From patchwork Tue Dec 6 10:14:05 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arthur Cohen X-Patchwork-Id: 61527 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 33F81396E83E for ; Tue, 6 Dec 2022 10:23:00 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-wr1-x42b.google.com (mail-wr1-x42b.google.com [IPv6:2a00:1450:4864:20::42b]) by sourceware.org (Postfix) with ESMTPS id 240EA3986418 for ; Tue, 6 Dec 2022 10:12:38 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 240EA3986418 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com Received: by mail-wr1-x42b.google.com with SMTP id o5so22766188wrm.1 for ; Tue, 06 Dec 2022 02:12:38 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=content-transfer-encoding:mime-version:reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:from:to:cc:subject :date:message-id:reply-to; bh=x6LRzMl4X61qK2B49HwyCYlrnVxV01WOI2TF4+pbrQY=; b=Ae0NiiskCU86C10V0QwtByrGD2wXmRXqtc8KoIGmlnuZ4sOha6my62SDS6CrnqeyD1 yHdLnjDtlTDw059jy1wc58OmxkiHlX1HMk9/6dobLeVSk2kSC+KFJgXUuAI5aB+3p62X QrLhI9M+hX5G1JwTzibdjHICMymqXJLnk0n/4zunqT1LY0GrZt1dPF58hlrmw0E6Y1Al bS0PPEfeUIUA/1VyJac18DcJxLFDjlAj4SfcdARKU5wg1nx9ce7h/4HNQnshIJampqMD obBQNj6NzMyCTZeA2EhIFStfxWugURXanNxed4wumUSl8yOWBSAHDLz5XNbzBCAVJTVN RcfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=x6LRzMl4X61qK2B49HwyCYlrnVxV01WOI2TF4+pbrQY=; b=miqTW8IrMwAsjJGsa/xhspT34TFK8BR8BI+TxpKSAf61ykrWSzeC4vWwZqo2YwBNME 6mmeVzPTH+qQyMJx7NU1uGjiV2AqtKC0obXNHDqEJRS917qlpKRfsuDjKgAcruuOIBJ4 5RtUips/1wuj8s+F4RlImm/MxV0QQNYzZwOVJin12prJJTeZ94tHU9b9fe5ex9PuS0OY nsXVQhqB8qxzGb/VESWOLSTJgVh0eOkL3y7yBS+zwPOsiQKtawaQEYiML6l15Hzaa/6c QtW5DAMHItTzLDTn/D3J1h2+udvhkZKXd1JNhoftSGxTJ7k0qo4g4LDDrsfRut4NGSvg M4/w== X-Gm-Message-State: ANoB5pmG4r8jt7QgPCD27kriRlUXFgVEDgzlaHaGHhmBlPUks1KDnEhR P3C9qnjwMg4IFfOTnhqSJfl4TCng+OlAVfjeqA== X-Google-Smtp-Source: AA0mqf5EGVx5bvqPMnuzaX0YDgVneiIsGKTc+SEUN7EJYJ88I3hZVGCPNIM6stn7fLNP9ku1ln7ZBA== X-Received: by 2002:a5d:53c4:0:b0:242:1f22:df3b with SMTP id a4-20020a5d53c4000000b002421f22df3bmr20544957wrw.679.1670321557133; Tue, 06 Dec 2022 02:12:37 -0800 (PST) Received: from platypus.lan ([2001:861:5e4c:3bb0:6424:328a:1734:3249]) by smtp.googlemail.com with ESMTPSA id r10-20020a05600c458a00b003cfd4a50d5asm27052699wmo.34.2022.12.06.02.12.36 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 06 Dec 2022 02:12:36 -0800 (PST) From: arthur.cohen@embecosm.com To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Thomas Young Subject: [PATCH Rust front-end v4 33/46] gccrs: Add dead code scan on HIR Date: Tue, 6 Dec 2022 11:14:05 +0100 Message-Id: <20221206101417.778807-34-arthur.cohen@embecosm.com> X-Mailer: git-send-email 2.38.1 In-Reply-To: <20221206101417.778807-1-arthur.cohen@embecosm.com> References: <20221206101417.778807-1-arthur.cohen@embecosm.com> MIME-Version: 1.0 X-Spam-Status: No, score=-18.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: arthur.cohen@embecosm.com Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org Sender: "Gcc-patches" From: Thomas Young In order to find dead code we use a depth first search and keep liveness variables, after type resolution. In this case, if a function is unused and it calls another function the 2nd function is now unused since the caller is not used etc. The algorithm is a depth first search. --- .../checks/lints/rust-lint-marklive-base.h | 45 +++ gcc/rust/checks/lints/rust-lint-marklive.cc | 282 ++++++++++++++++ gcc/rust/checks/lints/rust-lint-marklive.h | 308 ++++++++++++++++++ .../checks/lints/rust-lint-scan-deadcode.h | 154 +++++++++ 4 files changed, 789 insertions(+) create mode 100644 gcc/rust/checks/lints/rust-lint-marklive-base.h create mode 100644 gcc/rust/checks/lints/rust-lint-marklive.cc create mode 100644 gcc/rust/checks/lints/rust-lint-marklive.h create mode 100644 gcc/rust/checks/lints/rust-lint-scan-deadcode.h diff --git a/gcc/rust/checks/lints/rust-lint-marklive-base.h b/gcc/rust/checks/lints/rust-lint-marklive-base.h new file mode 100644 index 00000000000..97c068188b1 --- /dev/null +++ b/gcc/rust/checks/lints/rust-lint-marklive-base.h @@ -0,0 +1,45 @@ +// Copyright (C) 2021-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +#ifndef RUST_HIR_LIVENESS_BASE +#define RUST_HIR_LIVENESS_BASE + +#include "rust-diagnostics.h" +#include "rust-lint-marklive.h" +#include "rust-lint-marklive-base.h" +#include "rust-hir-visitor.h" +#include "rust-hir-map.h" + +namespace Rust { +namespace Analysis { + +class MarkLiveBase : public HIR::HIRFullVisitorBase +{ +public: + virtual ~MarkLiveBase () {} + +protected: + MarkLiveBase () : mappings (Analysis::Mappings::get ()) {} + + Analysis::Mappings *mappings; +}; + +} // namespace Analysis +} // namespace Rust + +#endif diff --git a/gcc/rust/checks/lints/rust-lint-marklive.cc b/gcc/rust/checks/lints/rust-lint-marklive.cc new file mode 100644 index 00000000000..245632b4b4c --- /dev/null +++ b/gcc/rust/checks/lints/rust-lint-marklive.cc @@ -0,0 +1,282 @@ +// Copyright (C) 2021-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +// The idea is that all reachable symbols are live, codes called +// from live codes are live, and everything else is dead. + +#include "rust-lint-marklive.h" +#include "rust-hir-full.h" +#include "rust-name-resolver.h" + +namespace Rust { +namespace Analysis { + +// This class trys to find the live symbols which can be used as +// seeds in MarkLive +// +// 1. TODO: explicit live +// - Attribute like #[allow(dead_code)] +// - Attribute like #[lang=".."], it's not a intra-crate item. +// 2. TODO: foreign item +class FindEntryPoint : public MarkLiveBase +{ + using Rust::Analysis::MarkLiveBase::visit; + +public: + static std::vector find (HIR::Crate &crate) + { + FindEntryPoint findEntryPoint; + for (auto it = crate.items.begin (); it != crate.items.end (); it++) + { + it->get ()->accept_vis (findEntryPoint); + } + return findEntryPoint.getEntryPoint (); + } + + // TODO not only fn main can be a entry point. + void visit (HIR::Function &function) override + { + if (function.get_function_name () == "main") + { + entryPoints.push_back (function.get_mappings ().get_hirid ()); + } + } + +private: + FindEntryPoint () : MarkLiveBase () {} + std::vector entryPoints; + std::vector getEntryPoint () { return entryPoints; } +}; + +std::set +MarkLive::Analysis (HIR::Crate &crate) +{ + MarkLive marklive (FindEntryPoint::find (crate)); + marklive.go (crate); + + return marklive.liveSymbols; +} + +// pop a live symbol from worklist every iteration, +// if it's a function then walk the function body, and +// 1. save all the live symbols in worklist which is +// visited first time +// 2. save all the live symbols in liveSymbols +void +MarkLive::go (HIR::Crate &crate) +{ + while (!worklist.empty ()) + { + HirId hirId = worklist.back (); + worklist.pop_back (); + scannedSymbols.emplace (hirId); + HIR::Item *item = mappings->lookup_hir_item (hirId); + liveSymbols.emplace (hirId); + if (item != nullptr) + { + item->accept_vis (*this); + } + else + { // the item maybe inside a trait impl + HirId parent_impl_id = UNKNOWN_HIRID; + HIR::ImplItem *implItem + = mappings->lookup_hir_implitem (hirId, &parent_impl_id); + if (implItem != nullptr) + implItem->accept_vis (*this); + } + } +} + +void +MarkLive::visit (HIR::PathInExpression &expr) +{ + // We should iterate every path segment in order to mark the struct which + // is used in expression like Foo::bar(), we should mark the Foo alive. + expr.iterate_path_segments ([&] (HIR::PathExprSegment &seg) -> bool { + return visit_path_segment (seg); + }); + + // after iterate the path segments, we should mark functions and associated + // functions alive. + NodeId ast_node_id = expr.get_mappings ().get_nodeid (); + NodeId ref_node_id = UNKNOWN_NODEID; + find_ref_node_id (ast_node_id, ref_node_id); + + // node back to HIR + HirId ref; + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); + rust_assert (ok); + + // it must resolve to some kind of HIR::Item or HIR::InheritImplItem + HIR::Item *resolved_item = mappings->lookup_hir_item (ref); + if (resolved_item != nullptr) + { + mark_hir_id (resolved_item->get_mappings ().get_hirid ()); + } + else + { + HirId parent_impl_id = UNKNOWN_HIRID; + HIR::ImplItem *resolved_item + = mappings->lookup_hir_implitem (ref, &parent_impl_id); + if (resolved_item != nullptr) + { + mark_hir_id (resolved_item->get_impl_mappings ().get_hirid ()); + } + } +} + +void +MarkLive::visit (HIR::MethodCallExpr &expr) +{ + expr.get_receiver ()->accept_vis (*this); + visit_path_segment (expr.get_method_name ()); + for (auto &argument : expr.get_arguments ()) + argument->accept_vis (*this); + + // Trying to find the method definition and mark it alive. + NodeId ast_node_id = expr.get_mappings ().get_nodeid (); + NodeId ref_node_id = UNKNOWN_NODEID; + find_ref_node_id (ast_node_id, ref_node_id); + + // node back to HIR + HirId ref; + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); + rust_assert (ok); + mark_hir_id (ref); +} + +bool +MarkLive::visit_path_segment (HIR::PathExprSegment seg) +{ + NodeId ast_node_id = seg.get_mappings ().get_nodeid (); + NodeId ref_node_id = UNKNOWN_NODEID; + + // There are two different kinds of segment for us. + // 1. function segment + // like the symbol "foo" in expression `foo()`. + // 2. type segment + // like the symbol "Foo" in expression `Foo{a: 1, b: 2}` + // + // We should mark them alive all and ignoring other kind of segments. + // If the segment we dont care then just return false is fine + if (!resolver->lookup_resolved_name (ast_node_id, &ref_node_id)) + { + if (!resolver->lookup_resolved_type (ast_node_id, &ref_node_id)) + return false; + } + HirId ref; + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); + rust_assert (ok); + mark_hir_id (ref); + return true; +} + +void +MarkLive::visit (HIR::FieldAccessExpr &expr) +{ + // visit receiver at first + expr.get_receiver_expr ()->accept_vis (*this); + + // resolve the receiver back to ADT type + TyTy::BaseType *receiver = nullptr; + if (!tyctx->lookup_type ( + expr.get_receiver_expr ()->get_mappings ().get_hirid (), &receiver)) + { + rust_error_at (expr.get_receiver_expr ()->get_locus (), + "unresolved type for receiver"); + } + + TyTy::ADTType *adt = nullptr; + if (receiver->get_kind () == TyTy::TypeKind::ADT) + { + adt = static_cast (receiver); + } + else if (receiver->get_kind () == TyTy::TypeKind::REF) + { + TyTy::ReferenceType *r = static_cast (receiver); + TyTy::BaseType *b = r->get_base (); + rust_assert (b->get_kind () == TyTy::TypeKind::ADT); + + adt = static_cast (b); + } + + rust_assert (adt != nullptr); + rust_assert (!adt->is_enum ()); + rust_assert (adt->number_of_variants () == 1); + + TyTy::VariantDef *variant = adt->get_variants ().at (0); + + // get the field index + size_t index; + TyTy::StructFieldType *field; + bool ok = variant->lookup_field (expr.get_field_name (), &field, &index); + rust_assert (ok); + if (index >= variant->num_fields ()) + { + rust_error_at (expr.get_receiver_expr ()->get_locus (), + "cannot access struct %s by index: %lu", + adt->get_name ().c_str (), (unsigned long) index); + return; + } + + // get the field hir id + HirId field_id = field->get_ref (); + mark_hir_id (field_id); +} + +void +MarkLive::visit (HIR::TupleIndexExpr &expr) +{ + // TODO: unused tuple field detection + expr.get_tuple_expr ()->accept_vis (*this); +} + +void +MarkLive::visit (HIR::TypeAlias &alias) +{ + NodeId ast_node_id; + resolver->lookup_resolved_type ( + alias.get_type_aliased ()->get_mappings ().get_nodeid (), &ast_node_id); + HirId hir_id; + bool ok = mappings->lookup_node_to_hir (ast_node_id, &hir_id); + rust_assert (ok); + mark_hir_id (hir_id); +} + +void +MarkLive::mark_hir_id (HirId id) +{ + if (scannedSymbols.find (id) == scannedSymbols.end ()) + { + worklist.push_back (id); + } + liveSymbols.emplace (id); +} + +void +MarkLive::find_ref_node_id (NodeId ast_node_id, NodeId &ref_node_id) +{ + if (!resolver->lookup_resolved_name (ast_node_id, &ref_node_id)) + { + bool ok = resolver->lookup_resolved_type (ast_node_id, &ref_node_id); + rust_assert (ok); + } +} + +} // namespace Analysis +} // namespace Rust diff --git a/gcc/rust/checks/lints/rust-lint-marklive.h b/gcc/rust/checks/lints/rust-lint-marklive.h new file mode 100644 index 00000000000..119af8b8c95 --- /dev/null +++ b/gcc/rust/checks/lints/rust-lint-marklive.h @@ -0,0 +1,308 @@ +// Copyright (C) 2021-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +#ifndef RUST_HIR_LIVENESS +#define RUST_HIR_LIVENESS + +#include "rust-hir-full-decls.h" +#include "rust-hir-map.h" +#include "rust-lint-marklive-base.h" +#include "rust-name-resolver.h" + +namespace Rust { +namespace Analysis { + +class MarkLive : public MarkLiveBase +{ + using Rust::Analysis::MarkLiveBase::visit; + +public: + static std::set Analysis (HIR::Crate &crate); + void go (HIR::Crate &crate); + + void visit (HIR::PathInExpression &expr) override; + void visit (HIR::FieldAccessExpr &expr) override; + void visit (HIR::TupleIndexExpr &expr) override; + void visit (HIR::MethodCallExpr &expr) override; + void visit (HIR::TypeAlias &alias) override; + + void visit (HIR::BorrowExpr &expr) override + { + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::DereferenceExpr &expr) override + { + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::NegationExpr &expr) override + { + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::LazyBooleanExpr &expr) override + { + expr.get_lhs ()->accept_vis (*this); + expr.get_rhs ()->accept_vis (*this); + } + + void visit (HIR::TypeCastExpr &expr) override + { + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::GroupedExpr &expr) override + { + expr.get_expr_in_parens ()->accept_vis (*this); + } + + void visit (HIR::ArrayExpr &expr) override + { + expr.get_internal_elements ()->accept_vis (*this); + } + + void visit (HIR::ArrayIndexExpr &expr) override + { + expr.get_array_expr ()->accept_vis (*this); + expr.get_index_expr ()->accept_vis (*this); + } + + void visit (HIR::ArrayElemsValues &expr) override + { + for (auto &elem : expr.get_values ()) + { + elem->accept_vis (*this); + } + } + + void visit (HIR::TupleExpr &expr) override + { + for (auto &elem : expr.get_tuple_elems ()) + { + elem->accept_vis (*this); + } + } + + void visit (HIR::BlockExpr &expr) override + { + for (auto &s : expr.get_statements ()) + { + s->accept_vis (*this); + } + if (expr.has_expr ()) + { + expr.get_final_expr ()->accept_vis (*this); + } + } + + void visit (HIR::UnsafeBlockExpr &expr) override + { + expr.get_block_expr ()->accept_vis (*this); + } + + void visit (HIR::LoopExpr &expr) override + { + expr.get_loop_block ()->accept_vis (*this); + } + + void visit (HIR::BreakExpr &expr) override + { + if (expr.has_break_expr ()) + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::WhileLoopExpr &expr) override + { + expr.get_loop_block ()->accept_vis (*this); + expr.get_predicate_expr ()->accept_vis (*this); + } + + void visit (HIR::Function &function) override + { + function.get_definition ()->accept_vis (*this); + } + + void visit (HIR::ReturnExpr &expr) override + { + if (expr.has_return_expr ()) + expr.get_expr ()->accept_vis (*this); + } + + void visit (HIR::WhileLetLoopExpr &expr) override + { + expr.get_loop_block ()->accept_vis (*this); + expr.get_cond ()->accept_vis (*this); + } + + void visit (HIR::ForLoopExpr &expr) override + { + expr.get_loop_block ()->accept_vis (*this); + expr.get_iterator_expr ()->accept_vis (*this); + } + + void visit (HIR::ExprStmtWithoutBlock &stmt) override + { + stmt.get_expr ()->accept_vis (*this); + } + + void visit (HIR::ExprStmtWithBlock &stmt) override + { + stmt.get_expr ()->accept_vis (*this); + } + + void visit (HIR::CallExpr &expr) override + { + expr.get_fnexpr ()->accept_vis (*this); + for (auto &argument : expr.get_arguments ()) + argument->accept_vis (*this); + } + + void visit (HIR::ArithmeticOrLogicalExpr &expr) override + { + expr.visit_lhs (*this); + expr.visit_rhs (*this); + } + void visit (HIR::ComparisonExpr &expr) override + { + expr.get_lhs ()->accept_vis (*this); + expr.get_rhs ()->accept_vis (*this); + } + + void visit (HIR::AssignmentExpr &expr) override + { + expr.visit_lhs (*this); + expr.visit_rhs (*this); + } + + void visit (HIR::CompoundAssignmentExpr &expr) override + { + expr.visit_lhs (*this); + expr.visit_rhs (*this); + } + + void visit (HIR::IfExpr &expr) override + { + expr.get_if_condition ()->accept_vis (*this); + expr.get_if_block ()->accept_vis (*this); + } + + void visit (HIR::IfExprConseqElse &expr) override + { + expr.get_if_condition ()->accept_vis (*this); + expr.get_if_block ()->accept_vis (*this); + expr.get_else_block ()->accept_vis (*this); + } + + void visit (HIR::MatchExpr &expr) override + { + expr.get_scrutinee_expr ()->accept_vis (*this); + std::vector &cases = expr.get_match_cases (); + for (auto &&caz : cases) + { + auto case_arm = caz.get_arm (); + if (case_arm.has_match_arm_guard ()) + case_arm.get_guard_expr ()->accept_vis (*this); + caz.get_expr ()->accept_vis (*this); + } + } + + void visit (HIR::IfExprConseqIf &expr) override + { + expr.get_if_condition ()->accept_vis (*this); + expr.get_if_block ()->accept_vis (*this); + expr.get_conseq_if_expr ()->accept_vis (*this); + } + + void visit (HIR::TraitItemFunc &item) override + { + item.get_block_expr ()->accept_vis (*this); + } + + void visit (HIR::ImplBlock &impl) override + { + for (auto &&item : impl.get_impl_items ()) + { + item->accept_vis (*this); + } + } + + void visit (HIR::LetStmt &stmt) override + { + if (stmt.has_init_expr ()) + { + stmt.get_init_expr ()->accept_vis (*this); + } + } + + void visit (HIR::StructExprStruct &stct) override + { + stct.get_struct_name ().accept_vis (*this); + } + + void visit (HIR::StructExprStructFields &stct) override + { + for (auto &field : stct.get_fields ()) + { + field->accept_vis (*this); + } + + stct.get_struct_name ().accept_vis (*this); + if (stct.has_struct_base ()) + { + stct.struct_base->base_struct->accept_vis (*this); + } + } + + virtual void visit (HIR::StructExprFieldIdentifierValue &field) override + { + field.get_value ()->accept_vis (*this); + } + + void visit (HIR::StructExprStructBase &stct) override + { + stct.get_struct_base ()->base_struct->accept_vis (*this); + } + + void visit (HIR::Module &module) override + { + for (auto &item : module.get_items ()) + item->accept_vis (*this); + } + +private: + std::vector worklist; + std::set liveSymbols; + std::set scannedSymbols; + Analysis::Mappings *mappings; + Resolver::Resolver *resolver; + Resolver::TypeCheckContext *tyctx; + MarkLive (std::vector worklist) + : worklist (worklist), mappings (Analysis::Mappings::get ()), + resolver (Resolver::Resolver::get ()), + tyctx (Resolver::TypeCheckContext::get ()){}; + + void mark_hir_id (HirId); + bool visit_path_segment (HIR::PathExprSegment); + void find_ref_node_id (NodeId ast_node_id, NodeId &ref_node_id); +}; + +} // namespace Analysis +} // namespace Rust + +#endif diff --git a/gcc/rust/checks/lints/rust-lint-scan-deadcode.h b/gcc/rust/checks/lints/rust-lint-scan-deadcode.h new file mode 100644 index 00000000000..591cb30bc24 --- /dev/null +++ b/gcc/rust/checks/lints/rust-lint-scan-deadcode.h @@ -0,0 +1,154 @@ +// Copyright (C) 2021-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// . + +#ifndef RUST_HIR_SCAN_DEADCODE +#define RUST_HIR_SCAN_DEADCODE + +#include "rust-hir-full-decls.h" +#include "rust-hir-map.h" +#include "rust-lint-marklive.h" +#include "rust-name-resolver.h" +#include "rust-diagnostics.h" + +namespace Rust { +namespace Analysis { + +// Scan item symbols and warn the symbol if it is not in the live_symbols set. +// There are three kinds of item we should handle in this pass. +// 1. Function item +// 2. The function item in the impl block without trait +// 3. StructStruct, e.g., `Struct Foo{one: 1, two: 2}`. Furthermore, the unused +// struct fields will be warned too. +// 4. TupleStruct, e.g., `Struct Foo(i32, i32)` +class ScanDeadcode : public MarkLiveBase +{ + using Rust::Analysis::MarkLiveBase::visit; + +public: + static void Scan (HIR::Crate &crate) + { + std::set live_symbols = Analysis::MarkLive::Analysis (crate); + ScanDeadcode sdc (live_symbols); + for (auto it = crate.items.begin (); it != crate.items.end (); it++) + { + it->get ()->accept_vis (sdc); + } + }; + + void visit (HIR::Function &function) override + { + HirId hirId = function.get_mappings ().get_hirid (); + if (should_warn (hirId)) + { + if (mappings->is_impl_item (hirId)) + { + HIR::ImplBlock *implBlock + = mappings->lookup_associated_impl (hirId); + if (!implBlock->has_trait_ref ()) + { + rust_warning_at (function.get_locus (), 0, + "associated function is never used: %<%s%>", + function.get_function_name ().c_str ()); + } + } + else + { + rust_warning_at (function.get_locus (), 0, + "function is never used: %<%s%>", + function.get_function_name ().c_str ()); + } + } + } + + void visit (HIR::StructStruct &stct) override + { + HirId hirId = stct.get_mappings ().get_hirid (); + if (should_warn (hirId)) + { + bool name_starts_underscore = stct.get_identifier ().at (0) == '_'; + if (!name_starts_underscore) + rust_warning_at (stct.get_locus (), 0, + "struct is never constructed: %<%s%>", + stct.get_identifier ().c_str ()); + } + else + { + // only warn the unused fields when in unwarned struct. + for (auto &field : stct.get_fields ()) + { + HirId field_hir_id = field.get_mappings ().get_hirid (); + if (should_warn (field_hir_id)) + { + rust_warning_at (field.get_locus (), 0, + "field is never read: %<%s%>", + field.get_field_name ().c_str ()); + } + } + } + } + + void visit (HIR::TupleStruct &stct) override + { + // only warn tuple struct unconstructed, and ignoring unused field + HirId hirId = stct.get_mappings ().get_hirid (); + if (should_warn (hirId)) + { + rust_warning_at (stct.get_locus (), 0, + "struct is never constructed: %<%s%>", + stct.get_identifier ().c_str ()); + } + } + + void visit (HIR::ImplBlock &blc) override + { + if (blc.has_impl_items ()) + { + for (auto &implItem : blc.get_impl_items ()) + { + implItem->accept_vis (*this); + } + } + } + + void visit (HIR::Module &mod) override + { + for (auto &item : mod.get_items ()) + item->accept_vis (*this); + } + +private: + std::set live_symbols; + Resolver::Resolver *resolver; + Analysis::Mappings *mappings; + + ScanDeadcode (std::set &live_symbols) + : live_symbols (live_symbols), resolver (Resolver::Resolver::get ()), + mappings (Analysis::Mappings::get ()){}; + + bool should_warn (HirId hirId) + { + // TODO: There are more condition to check if should warn, i.e visibility, + // attributes. + return live_symbols.find (hirId) == live_symbols.end (); + } +}; + +} // namespace Analysis +} // namespace Rust + +#endif