// Copyright (C) 2020-2024 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_AST_RESOLVE_STMT_H #define RUST_AST_RESOLVE_STMT_H #include "rust-ast-resolve-base.h" #include "rust-ast-resolve-type.h" #include "rust-ast-resolve-pattern.h" #include "rust-ast-resolve-expr.h" #include "rust-item.h" namespace Rust { namespace Resolver { class ResolveStmt : public ResolverBase { using Rust::Resolver::ResolverBase::visit; public: static void go (AST::Stmt &stmt, const CanonicalPath &prefix, const CanonicalPath &canonical_prefix, const CanonicalPath &enum_prefix) { if (stmt.is_marked_for_strip ()) return; ResolveStmt resolver (prefix, canonical_prefix, enum_prefix); stmt.accept_vis (resolver); } void visit (AST::ExprStmt &stmt) override { ResolveExpr::go (stmt.get_expr (), prefix, canonical_prefix); } void visit (AST::ConstantItem &constant) override { auto decl = CanonicalPath::new_seg (constant.get_node_id (), constant.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (constant.get_node_id (), cpath); resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, Rib::ItemType::Const, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, constant.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); ResolveType::go (constant.get_type ()); ResolveExpr::go (constant.get_expr (), prefix, canonical_prefix); } void visit (AST::LetStmt &stmt) override { if (stmt.has_init_expr ()) { ResolveExpr::go (stmt.get_init_expr (), prefix, canonical_prefix); } PatternDeclaration::go (stmt.get_pattern (), Rib::ItemType::Var); if (stmt.has_type ()) ResolveType::go (stmt.get_type ()); } void visit (AST::TupleStruct &struct_decl) override { auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (), struct_decl.get_identifier ().as_string ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, struct_decl.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); NodeId scope_node_id = struct_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); if (struct_decl.has_generics ()) { for (auto &generic : struct_decl.get_generic_params ()) ResolveGenericParam::go (*generic, prefix, canonical_prefix); } for (AST::TupleField &field : struct_decl.get_fields ()) ResolveType::go (field.get_field_type ()); resolver->get_type_scope ().pop (); } void visit (AST::Enum &enum_decl) override { auto decl = CanonicalPath::new_seg (enum_decl.get_node_id (), enum_decl.get_identifier ().as_string ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (enum_decl.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, enum_decl.get_node_id (), enum_decl.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, enum_decl.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); NodeId scope_node_id = enum_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); if (enum_decl.has_generics ()) { for (auto &generic : enum_decl.get_generic_params ()) ResolveGenericParam::go (*generic, prefix, canonical_prefix); } for (auto &variant : enum_decl.get_variants ()) ResolveStmt::go (*variant, path, canonical_prefix, path); resolver->get_type_scope ().pop (); } void visit (AST::EnumItem &item) override { auto decl = enum_prefix.append ( CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ().as_string ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, item.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); // Done, no fields. } void visit (AST::EnumItemTuple &item) override { auto decl = enum_prefix.append ( CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ().as_string ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, item.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); for (auto &field : item.get_tuple_fields ()) { if (field.get_field_type ().is_marked_for_strip ()) continue; ResolveType::go (field.get_field_type ()); } } void visit (AST::EnumItemStruct &item) override { auto decl = enum_prefix.append ( CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ().as_string ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, item.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); for (auto &field : item.get_struct_fields ()) { if (field.get_field_type ().is_marked_for_strip ()) continue; ResolveType::go (field.get_field_type ()); } } void visit (AST::EnumItemDiscriminant &item) override { auto decl = enum_prefix.append ( CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ().as_string ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, item.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); // Done, no fields. } void visit (AST::StructStruct &struct_decl) override { auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (), struct_decl.get_identifier ().as_string ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, struct_decl.get_node_id (), struct_decl.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, struct_decl.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); NodeId scope_node_id = struct_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); if (struct_decl.has_generics ()) { for (auto &generic : struct_decl.get_generic_params ()) ResolveGenericParam::go (*generic, prefix, canonical_prefix); } for (AST::StructField &field : struct_decl.get_fields ()) { if (field.get_field_type ().is_marked_for_strip ()) continue; ResolveType::go (field.get_field_type ()); } resolver->get_type_scope ().pop (); } void visit (AST::Union &union_decl) override { auto decl = CanonicalPath::new_seg (union_decl.get_node_id (), union_decl.get_identifier ().as_string ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (union_decl.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, union_decl.get_node_id (), union_decl.get_locus (), false, Rib::ItemType::Type, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, union_decl.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); NodeId scope_node_id = union_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); if (union_decl.has_generics ()) for (auto &generic : union_decl.get_generic_params ()) ResolveGenericParam::go (*generic, prefix, canonical_prefix); for (AST::StructField &field : union_decl.get_variants ()) { if (field.get_field_type ().is_marked_for_strip ()) continue; ResolveType::go (field.get_field_type ()); } resolver->get_type_scope ().pop (); } void visit (AST::Function &function) override { auto decl = CanonicalPath::new_seg (function.get_node_id (), function.get_function_name ().as_string ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); mappings->insert_canonical_path (function.get_node_id (), cpath); resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, Rib::ItemType::Function, [&] (const CanonicalPath &, NodeId, location_t locus) -> void { rich_location r (line_table, function.get_locus ()); r.add_range (locus); rust_error_at (r, "redefined multiple times"); }); NodeId scope_node_id = function.get_node_id (); resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); resolver->get_label_scope ().push (scope_node_id); resolver->push_new_name_rib (resolver->get_name_scope ().peek ()); resolver->push_new_type_rib (resolver->get_type_scope ().peek ()); resolver->push_new_label_rib (resolver->get_type_scope ().peek ()); if (function.has_generics ()) for (auto &generic : function.get_generic_params ()) ResolveGenericParam::go (*generic, prefix, canonical_prefix); if (function.has_return_type ()) ResolveType::go (function.get_return_type ()); std::vector bindings = {PatternBinding (PatternBoundCtx::Product, std::set ())}; // we make a new scope so the names of parameters are resolved and shadowed // correctly for (auto &p : function.get_function_params ()) { if (p->is_variadic ()) { auto ¶m = static_cast (*p); PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param, bindings); } else if (p->is_self ()) { auto ¶m = static_cast (*p); ResolveType::go (param.get_type ()); } else { auto ¶m = static_cast (*p); ResolveType::go (param.get_type ()); PatternDeclaration::go (param.get_pattern (), Rib::ItemType::Param, bindings); } } // resolve the function body ResolveExpr::go (*function.get_definition ().value (), path, cpath); resolver->get_name_scope ().pop (); resolver->get_type_scope ().pop (); resolver->get_label_scope ().pop (); } void visit (AST::ExternBlock &extern_block) override; void visit (AST::Trait &trait) override; void visit (AST::InherentImpl &impl_block) override; void visit (AST::TraitImpl &impl_block) override; private: ResolveStmt (const CanonicalPath &prefix, const CanonicalPath &canonical_prefix, const CanonicalPath &enum_prefix) : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix), enum_prefix (enum_prefix) {} const CanonicalPath &prefix; const CanonicalPath &canonical_prefix; /* item declaration statements are not given a canonical path, but enum items * (variants) do inherit the enum path/identifier name. */ const CanonicalPath &enum_prefix; }; } // namespace Resolver } // namespace Rust #endif // RUST_AST_RESOLVE_STMT_H