From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id 3DBE5385737D; Fri, 8 Jul 2022 13:47:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 3DBE5385737D Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Thomas Schwinge To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/rust/master] Refactor mappings class and HIR lowering to be consistent X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 31887c00fbdc7d607cf79b1042cb84d2c6db17e2 X-Git-Newrev: fb27d1452b31d5485b1fce692f14279472cf0baf Message-Id: <20220708134733.3DBE5385737D@sourceware.org> Date: Fri, 8 Jul 2022 13:47:33 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 08 Jul 2022 13:47:33 -0000 https://gcc.gnu.org/g:fb27d1452b31d5485b1fce692f14279472cf0baf commit fb27d1452b31d5485b1fce692f14279472cf0baf Author: Philip Herron Date: Mon Jul 4 16:56:46 2022 +0100 Refactor mappings class and HIR lowering to be consistent In order to support loading extern crates and use statements we needed to clarify the usage of NodeId and HirId within gccrs. Each of these id's were nested behind the CrateNum but the type resolution, linting and code-gen passes do not support that level of nesting. In order to get metadata exports and imports working lets focus on gccrs supporting compilation of a single crate at a time. This means the crate prefix only matters for imports and limits the complexity here. Down the line there might be a way to leverage DefId's for all Path resolution which could solve this problem but significant refactoring would be required here to do this properly and its not nessecary for a basic working rust compiler. Diff: --- gcc/rust/ast/rust-item.h | 3 + gcc/rust/backend/rust-compile-base.cc | 7 +- gcc/rust/backend/rust-compile-expr.cc | 19 +- gcc/rust/backend/rust-compile-expr.h | 6 +- gcc/rust/backend/rust-compile-implitem.cc | 4 +- gcc/rust/backend/rust-compile-item.cc | 5 +- gcc/rust/backend/rust-compile-resolve-path.cc | 18 +- gcc/rust/expand/rust-attribute-visitor.cc | 2 + gcc/rust/expand/rust-macro-expand.cc | 13 +- gcc/rust/hir/rust-ast-lower-base.cc | 20 +- gcc/rust/hir/rust-ast-lower-block.h | 24 +- gcc/rust/hir/rust-ast-lower-enumitem.h | 38 +- gcc/rust/hir/rust-ast-lower-expr.h | 5 +- gcc/rust/hir/rust-ast-lower-extern.h | 25 +- gcc/rust/hir/rust-ast-lower-implitem.h | 147 +++-- gcc/rust/hir/rust-ast-lower-item.cc | 113 +--- gcc/rust/hir/rust-ast-lower-pattern.cc | 5 +- gcc/rust/hir/rust-ast-lower-pattern.h | 6 +- gcc/rust/hir/rust-ast-lower-stmt.h | 85 +-- gcc/rust/hir/rust-ast-lower-struct-field-expr.h | 5 +- gcc/rust/hir/rust-ast-lower-type.h | 35 +- gcc/rust/hir/rust-ast-lower.cc | 15 +- gcc/rust/hir/rust-ast-lower.h | 4 +- gcc/rust/hir/tree/rust-hir-path.h | 2 + gcc/rust/lint/rust-lint-marklive.cc | 27 +- gcc/rust/parse/rust-parse-impl.h | 5 +- gcc/rust/parse/rust-parse.h | 2 +- gcc/rust/privacy/rust-privacy-reporter.cc | 4 +- gcc/rust/privacy/rust-visibility-resolver.cc | 9 +- gcc/rust/resolve/rust-ast-resolve-implitem.h | 12 +- gcc/rust/resolve/rust-ast-resolve-item.cc | 54 +- gcc/rust/resolve/rust-ast-resolve-stmt.h | 30 +- gcc/rust/resolve/rust-ast-resolve-toplevel.h | 93 +++- gcc/rust/resolve/rust-ast-resolve-type.cc | 3 +- gcc/rust/resolve/rust-ast-resolve-type.h | 3 +- gcc/rust/resolve/rust-name-resolver.cc | 23 +- gcc/rust/resolve/rust-name-resolver.h | 2 + gcc/rust/rust-session-manager.cc | 113 ++-- gcc/rust/rust-session-manager.h | 26 +- gcc/rust/typecheck/rust-hir-trait-resolve.cc | 12 +- gcc/rust/typecheck/rust-hir-type-check-enumitem.h | 12 +- gcc/rust/typecheck/rust-hir-type-check-expr.h | 3 +- gcc/rust/typecheck/rust-hir-type-check-implitem.h | 6 +- gcc/rust/typecheck/rust-hir-type-check-path.cc | 13 +- gcc/rust/typecheck/rust-hir-type-check-stmt.h | 10 +- gcc/rust/typecheck/rust-hir-type-check-toplevel.cc | 20 +- gcc/rust/typecheck/rust-hir-type-check-type.cc | 8 +- gcc/rust/typecheck/rust-hir-type-check-type.h | 4 +- gcc/rust/typecheck/rust-hir-type-check.cc | 6 +- gcc/rust/typecheck/rust-tyty.cc | 5 +- gcc/rust/util/rust-attributes.cc | 1 + gcc/rust/util/rust-hir-map.cc | 600 +++++++++------------ gcc/rust/util/rust-hir-map.h | 227 +++----- 53 files changed, 779 insertions(+), 1160 deletions(-) diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h index 94ffffba6fa..4987674cba1 100644 --- a/gcc/rust/ast/rust-item.h +++ b/gcc/rust/ast/rust-item.h @@ -1153,6 +1153,9 @@ public: void accept_vis (ASTVisitor &vis) override; + const std::string &get_referenced_crate () const { return referenced_crate; } + const std::string &get_as_clause () const { return as_clause_name; } + // Override that adds extern crate name in decl to passed list of names. void add_crate_name (std::vector &names) const override { diff --git a/gcc/rust/backend/rust-compile-base.cc b/gcc/rust/backend/rust-compile-base.cc index 066ef43ca23..3e6e370abe5 100644 --- a/gcc/rust/backend/rust-compile-base.cc +++ b/gcc/rust/backend/rust-compile-base.cc @@ -404,19 +404,16 @@ std::vector HIRCompileBase::compile_locals_for_block (Context *ctx, Resolver::Rib &rib, tree fndecl) { - CrateNum crate = ctx->get_mappings ()->get_current_crate (); - std::vector locals; for (auto it : rib.get_declarations ()) { NodeId node_id = it.first; HirId ref = UNKNOWN_HIRID; - if (!ctx->get_mappings ()->lookup_node_to_hir (crate, node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (node_id, &ref)) continue; // we only care about local patterns - HIR::Pattern *pattern - = ctx->get_mappings ()->lookup_hir_pattern (crate, ref); + HIR::Pattern *pattern = ctx->get_mappings ()->lookup_hir_pattern (ref); if (pattern == nullptr) continue; diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 3740c801d6f..7aa691e2506 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -985,8 +985,7 @@ CompileExpr::visit (HIR::MethodCallExpr &expr) // reverse lookup HirId ref; - if (!ctx->get_mappings ()->lookup_node_to_hir ( - expr.get_mappings ().get_crate_num (), resolved_node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref)) { rust_fatal_error (expr.get_locus (), "reverse lookup failure"); return; @@ -1188,8 +1187,7 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref, // declared function, generic function which has not be compiled yet or // its an not yet trait bound function HIR::ImplItem *resolved_item - = ctx->get_mappings ()->lookup_hir_implitem (expr_mappings.get_crate_num (), - ref, nullptr); + = ctx->get_mappings ()->lookup_hir_implitem (ref, nullptr); if (resolved_item != nullptr) { if (!fntype->has_subsititions_defined ()) @@ -1199,8 +1197,8 @@ CompileExpr::resolve_method_address (TyTy::FnType *fntype, HirId ref, } // it might be resolved to a trait item - HIR::TraitItem *trait_item = ctx->get_mappings ()->lookup_hir_trait_item ( - expr_mappings.get_crate_num (), ref); + HIR::TraitItem *trait_item + = ctx->get_mappings ()->lookup_hir_trait_item (ref); HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping ( trait_item->get_mappings ().get_hirid ()); @@ -1284,8 +1282,7 @@ CompileExpr::resolve_operator_overload ( // reverse lookup HirId ref; - ok = ctx->get_mappings ()->lookup_node_to_hir ( - expr.get_mappings ().get_crate_num (), resolved_node_id, &ref); + ok = ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref); rust_assert (ok); TyTy::BaseType *receiver = nullptr; @@ -1874,8 +1871,7 @@ CompileExpr::visit (HIR::IdentifierExpr &expr) // node back to HIR HirId ref; - if (!ctx->get_mappings ()->lookup_node_to_hir ( - expr.get_mappings ().get_crate_num (), ref_node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (ref_node_id, &ref)) { rust_error_at (expr.get_locus (), "reverse lookup failure"); return; @@ -1939,8 +1935,7 @@ CompileExpr::visit (HIR::IdentifierExpr &expr) else { // lets try and query compile it to an item/impl item - HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item ( - expr.get_mappings ().get_crate_num (), ref); + HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item (ref); bool is_hir_item = resolved_item != nullptr; if (!is_hir_item) { diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index 3b729c78b37..48a516ab419 100644 --- a/gcc/rust/backend/rust-compile-expr.h +++ b/gcc/rust/backend/rust-compile-expr.h @@ -715,8 +715,7 @@ public: } HirId ref = UNKNOWN_HIRID; - if (!ctx->get_mappings ()->lookup_node_to_hir ( - expr.get_mappings ().get_crate_num (), resolved_node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref)) { rust_fatal_error (expr.get_locus (), "reverse lookup label failure"); @@ -762,8 +761,7 @@ public: } HirId ref = UNKNOWN_HIRID; - if (!ctx->get_mappings ()->lookup_node_to_hir ( - expr.get_mappings ().get_crate_num (), resolved_node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (resolved_node_id, &ref)) { rust_fatal_error (expr.get_locus (), "reverse lookup label failure"); diff --git a/gcc/rust/backend/rust-compile-implitem.cc b/gcc/rust/backend/rust-compile-implitem.cc index c13556aaa91..735dede93c6 100644 --- a/gcc/rust/backend/rust-compile-implitem.cc +++ b/gcc/rust/backend/rust-compile-implitem.cc @@ -31,7 +31,6 @@ CompileTraitItem::visit (HIR::TraitItemConst &constant) const Resolver::CanonicalPath *canonical_path = nullptr; bool ok = ctx->get_mappings ()->lookup_canonical_path ( - constant.get_mappings ().get_crate_num (), constant.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); @@ -84,8 +83,7 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func) const Resolver::CanonicalPath *canonical_path = nullptr; bool ok = ctx->get_mappings ()->lookup_canonical_path ( - func.get_mappings ().get_crate_num (), func.get_mappings ().get_nodeid (), - &canonical_path); + func.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); // FIXME: How do we get the proper visibility here? diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc index 36fa78757ac..1f2e479e1f6 100644 --- a/gcc/rust/backend/rust-compile-item.cc +++ b/gcc/rust/backend/rust-compile-item.cc @@ -47,8 +47,7 @@ CompileItem::visit (HIR::StaticItem &var) const Resolver::CanonicalPath *canonical_path = nullptr; ok = ctx->get_mappings ()->lookup_canonical_path ( - var.get_mappings ().get_crate_num (), var.get_mappings ().get_nodeid (), - &canonical_path); + var.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); std::string name = canonical_path->get (); @@ -87,7 +86,6 @@ CompileItem::visit (HIR::ConstantItem &constant) // canonical path const Resolver::CanonicalPath *canonical_path = nullptr; ok = ctx->get_mappings ()->lookup_canonical_path ( - constant.get_mappings ().get_crate_num (), constant.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); @@ -162,7 +160,6 @@ CompileItem::visit (HIR::Function &function) const Resolver::CanonicalPath *canonical_path = nullptr; bool ok = ctx->get_mappings ()->lookup_canonical_path ( - function.get_mappings ().get_crate_num (), function.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index 2cf81e0f9d7..95d8841b5ab 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -99,8 +99,7 @@ ResolvePathRef::resolve (const HIR::PathIdentSegment &final_segment, } HirId ref; - if (!ctx->get_mappings ()->lookup_node_to_hir (mappings.get_crate_num (), - ref_node_id, &ref)) + if (!ctx->get_mappings ()->lookup_node_to_hir (ref_node_id, &ref)) { rust_error_at (expr_locus, "reverse call path lookup failure"); return error_mark_node; @@ -159,11 +158,9 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, const Analysis::NodeMapping &mappings, Location expr_locus, bool is_qualified_path) { - HIR::Item *resolved_item - = ctx->get_mappings ()->lookup_hir_item (mappings.get_crate_num (), ref); + HIR::Item *resolved_item = ctx->get_mappings ()->lookup_hir_item (ref); HIR::ExternalItem *resolved_extern_item - = ctx->get_mappings ()->lookup_hir_extern_item (mappings.get_crate_num (), - ref); + = ctx->get_mappings ()->lookup_hir_extern_item (ref); bool is_hir_item = resolved_item != nullptr; bool is_hir_extern_item = resolved_extern_item != nullptr; if (is_hir_item) @@ -188,15 +185,13 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, { HirId parent_impl_id = UNKNOWN_HIRID; HIR::ImplItem *resolved_item - = ctx->get_mappings ()->lookup_hir_implitem (mappings.get_crate_num (), - ref, &parent_impl_id); + = ctx->get_mappings ()->lookup_hir_implitem (ref, &parent_impl_id); bool is_impl_item = resolved_item != nullptr; if (is_impl_item) { rust_assert (parent_impl_id != UNKNOWN_HIRID); HIR::Item *impl_ref - = ctx->get_mappings ()->lookup_hir_item (mappings.get_crate_num (), - parent_impl_id); + = ctx->get_mappings ()->lookup_hir_item (parent_impl_id); rust_assert (impl_ref != nullptr); HIR::ImplBlock *impl = static_cast (impl_ref); @@ -216,8 +211,7 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, { // it might be resolved to a trait item HIR::TraitItem *trait_item - = ctx->get_mappings ()->lookup_hir_trait_item ( - mappings.get_crate_num (), ref); + = ctx->get_mappings ()->lookup_hir_trait_item (ref); HIR::Trait *trait = ctx->get_mappings ()->lookup_trait_item_mapping ( trait_item->get_mappings ().get_hirid ()); diff --git a/gcc/rust/expand/rust-attribute-visitor.cc b/gcc/rust/expand/rust-attribute-visitor.cc index bec6a9d138b..12d6f87182d 100644 --- a/gcc/rust/expand/rust-attribute-visitor.cc +++ b/gcc/rust/expand/rust-attribute-visitor.cc @@ -2864,6 +2864,8 @@ AttrVisitor::visit (AST::MacroRulesDefinition &rules_def) expander.resolver->get_macro_scope ().insert (path, rules_def.get_node_id (), rules_def.get_locus ()); expander.mappings->insert_macro_def (&rules_def); + rust_debug_loc (rules_def.get_locus (), "inserting macro def: [%s]", + path.get ().c_str ()); } void diff --git a/gcc/rust/expand/rust-macro-expand.cc b/gcc/rust/expand/rust-macro-expand.cc index d8684c83046..189d377ccc4 100644 --- a/gcc/rust/expand/rust-macro-expand.cc +++ b/gcc/rust/expand/rust-macro-expand.cc @@ -142,7 +142,7 @@ MacroExpander::expand_invoc (AST::MacroInvocation &invoc) &resolved_node); if (!found) { - rust_error_at (invoc.get_locus (), "unknown macro"); + rust_error_at (invoc.get_locus (), "unknown macro 1"); return; } @@ -177,13 +177,14 @@ MacroExpander::expand_invoc_semi (AST::MacroInvocation &invoc) // lookup the rules for this macro NodeId resolved_node = UNKNOWN_NODEID; - bool found = resolver->get_macro_scope ().lookup ( - Resolver::CanonicalPath::new_seg (invoc.get_macro_node_id (), - invoc_data.get_path ().as_string ()), - &resolved_node); + auto seg + = Resolver::CanonicalPath::new_seg (invoc.get_macro_node_id (), + invoc_data.get_path ().as_string ()); + bool found = resolver->get_macro_scope ().lookup (seg, &resolved_node); if (!found) { - rust_error_at (invoc.get_locus (), "unknown macro"); + rust_error_at (invoc.get_locus (), "unknown macro 2: [%s]", + seg.get ().c_str ()); return; } diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index 6afbbe2b828..3db7dc312eb 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -527,8 +527,7 @@ ASTLoweringBase::lower_lifetime (AST::Lifetime &lifetime) Analysis::NodeMapping mapping (crate_num, lifetime.get_node_id (), mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); - mappings->insert_node_to_hir (mapping.get_crate_num (), mapping.get_nodeid (), - mapping.get_hirid ()); + mappings->insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ()); return HIR::Lifetime (mapping, lifetime.get_lifetime_type (), lifetime.get_lifetime_name (), lifetime.get_locus ()); @@ -543,8 +542,7 @@ ASTLoweringBase::lower_loop_label (AST::LoopLabel &loop_label) Analysis::NodeMapping mapping (crate_num, loop_label.get_node_id (), mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); - mappings->insert_node_to_hir (mapping.get_crate_num (), mapping.get_nodeid (), - mapping.get_hirid ()); + mappings->insert_node_to_hir (mapping.get_nodeid (), mapping.get_hirid ()); return HIR::LoopLabel (mapping, std::move (life), loop_label.get_locus ()); } @@ -734,13 +732,11 @@ ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path) Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, mappings->get_next_localdef_id (crate_num)); - translated = new HIR::QualifiedPathInType (std::move (mapping), std::move (qual_path_type), std::move (associated_segment), std::move (translated_segments), path.get_locus ()); - mappings->insert_hir_type (crate_num, hirid, translated); } void @@ -758,9 +754,6 @@ ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type) translated = new HIR::TraitObjectType (mapping, std::move (bounds), type.get_locus (), type.is_dyn ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void @@ -783,9 +776,6 @@ ASTLoweringType::visit (AST::TraitObjectType &type) translated = new HIR::TraitObjectType (mapping, std::move (bounds), type.get_locus (), type.is_dyn ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } HIR::Type * @@ -1084,12 +1074,6 @@ ASTLoweringBase::lower_extern_block (AST::ExternBlock &extern_block) extern_block.get_outer_attrs (), extern_block.get_locus ()); - mappings->insert_defid_mapping (mapping.get_defid (), hir_extern_block); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - hir_extern_block); - mappings->insert_location (crate_num, mapping.get_hirid (), - extern_block.get_locus ()); - return hir_extern_block; } diff --git a/gcc/rust/hir/rust-ast-lower-block.h b/gcc/rust/hir/rust-ast-lower-block.h index b8f71750950..0d3c704c6f1 100644 --- a/gcc/rust/hir/rust-ast-lower-block.h +++ b/gcc/rust/hir/rust-ast-lower-block.h @@ -36,10 +36,7 @@ public: expr->accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings->insert_hir_expr ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), - resolver.translated); + resolver.mappings->insert_hir_expr (resolver.translated); } *terminated = resolver.terminated; @@ -65,9 +62,7 @@ public: std::unique_ptr (block), expr->get_outer_attrs (), expr->get_locus ()); - resolver.mappings->insert_hir_expr ( - translated->get_mappings ().get_crate_num (), - translated->get_mappings ().get_hirid (), translated); + resolver.mappings->insert_hir_expr (translated); return translated; } @@ -94,10 +89,7 @@ public: expr->accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings->insert_hir_expr ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), - resolver.translated); + resolver.mappings->insert_hir_expr (resolver.translated); } *terminated = resolver.terminated; return resolver.translated; @@ -131,10 +123,7 @@ public: expr->accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings->insert_hir_expr ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), - resolver.translated); + resolver.mappings->insert_hir_expr (resolver.translated); } return resolver.translated; } @@ -161,10 +150,7 @@ public: expr->accept_vis (resolver); if (resolver.translated != nullptr) { - resolver.mappings->insert_hir_expr ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), - resolver.translated); + resolver.mappings->insert_hir_expr (resolver.translated); } *terminated = resolver.terminated; diff --git a/gcc/rust/hir/rust-ast-lower-enumitem.h b/gcc/rust/hir/rust-ast-lower-enumitem.h index 1914ce64d09..b76658c78cc 100644 --- a/gcc/rust/hir/rust-ast-lower-enumitem.h +++ b/gcc/rust/hir/rust-ast-lower-enumitem.h @@ -39,6 +39,17 @@ public: { ASTLoweringEnumItem resolver; item->accept_vis (resolver); + + rust_assert (resolver.translated != nullptr); + + auto hirid = resolver.translated->get_mappings ().get_hirid (); + auto defid = resolver.translated->get_mappings ().get_defid (); + + resolver.mappings->insert_defid_mapping (defid, resolver.translated); + resolver.mappings->insert_hir_item (resolver.translated); + resolver.mappings->insert_location (hirid, + resolver.translated->get_locus ()); + return resolver.translated; } @@ -53,15 +64,8 @@ public: rust_error_at (item.get_locus (), "visibility qualifier %qs not allowed on enum item", item.get_visibility ().as_string ().c_str ()); - translated = new HIR::EnumItem (mapping, item.get_identifier (), item.get_outer_attrs (), item.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - item.get_locus ()); } void visit (AST::EnumItemTuple &item) override @@ -100,12 +104,6 @@ public: = new HIR::EnumItemTuple (mapping, item.get_identifier (), std::move (fields), item.get_outer_attrs (), item.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - item.get_locus ()); } void visit (AST::EnumItemStruct &item) override @@ -149,13 +147,8 @@ public: = new HIR::EnumItemStruct (mapping, item.get_identifier (), std::move (fields), item.get_outer_attrs (), item.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - item.get_locus ()); } + void visit (AST::EnumItemDiscriminant &item) override { auto crate_num = mappings->get_current_crate (); @@ -174,16 +167,11 @@ public: std::unique_ptr (expr), item.get_outer_attrs (), item.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - item.get_locus ()); } private: ASTLoweringEnumItem () : translated (nullptr) {} + HIR::EnumItem *translated; }; diff --git a/gcc/rust/hir/rust-ast-lower-expr.h b/gcc/rust/hir/rust-ast-lower-expr.h index a3f8d6e24a0..166a44b9096 100644 --- a/gcc/rust/hir/rust-ast-lower-expr.h +++ b/gcc/rust/hir/rust-ast-lower-expr.h @@ -87,11 +87,8 @@ public: return nullptr; } - resolver.mappings->insert_hir_expr ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), resolver.translated); + resolver.mappings->insert_hir_expr (resolver.translated); resolver.mappings->insert_location ( - resolver.translated->get_mappings ().get_crate_num (), resolver.translated->get_mappings ().get_hirid (), expr->get_locus ()); if (terminated != nullptr) diff --git a/gcc/rust/hir/rust-ast-lower-extern.h b/gcc/rust/hir/rust-ast-lower-extern.h index 1dfecb94fcc..28d160bb3e9 100644 --- a/gcc/rust/hir/rust-ast-lower-extern.h +++ b/gcc/rust/hir/rust-ast-lower-extern.h @@ -35,6 +35,13 @@ public: { ASTLoweringExternItem resolver; item->accept_vis (resolver); + + rust_assert (resolver.translated != nullptr); + resolver.mappings->insert_hir_extern_item (resolver.translated); + resolver.mappings->insert_location ( + resolver.translated->get_mappings ().get_hirid (), + resolver.translated->get_locus ()); + return resolver.translated; } @@ -49,17 +56,10 @@ public: mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - HIR::ExternalStaticItem *static_item = new HIR::ExternalStaticItem ( + translated = new HIR::ExternalStaticItem ( mapping, item.get_identifier (), std::unique_ptr (static_type), item.is_mut () ? Mutability::Mut : Mutability::Imm, std::move (vis), item.get_outer_attrs (), item.get_locus ()); - - translated = static_item; - - mappings->insert_hir_extern_item (crate_num, mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - item.get_locus ()); } void visit (AST::ExternalFunctionItem &function) override @@ -100,18 +100,11 @@ public: mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - HIR::ExternalFunctionItem *function_item = new HIR::ExternalFunctionItem ( + translated = new HIR::ExternalFunctionItem ( mapping, function.get_identifier (), std::move (generic_params), std::unique_ptr (return_type), std::move (where_clause), std::move (function_params), function.is_variadic (), std::move (vis), function.get_outer_attrs (), function.get_locus ()); - - translated = function_item; - - mappings->insert_hir_extern_item (crate_num, mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - function.get_locus ()); } private: diff --git a/gcc/rust/hir/rust-ast-lower-implitem.h b/gcc/rust/hir/rust-ast-lower-implitem.h index 64803f3056a..d5ca47587fc 100644 --- a/gcc/rust/hir/rust-ast-lower-implitem.h +++ b/gcc/rust/hir/rust-ast-lower-implitem.h @@ -37,18 +37,48 @@ public: static HIR::ImplItem *translate (AST::InherentImplItem *item, HirId parent_impl_id) { - ASTLowerImplItem resolver (parent_impl_id); + ASTLowerImplItem resolver; item->accept_vis (resolver); - rust_assert (resolver.translated != nullptr); + + if (resolver.translated != nullptr) + { + rust_assert (resolver.item_cast != nullptr); + + auto id = resolver.translated->get_impl_mappings ().get_hirid (); + auto defid = resolver.translated->get_impl_mappings ().get_defid (); + auto locus = resolver.translated->get_locus (); + + resolver.handle_outer_attributes (*resolver.item_cast); + resolver.mappings->insert_hir_implitem (parent_impl_id, + resolver.translated); + resolver.mappings->insert_location (id, locus); + resolver.mappings->insert_defid_mapping (defid, resolver.item_cast); + } + return resolver.translated; } static HIR::ImplItem *translate (AST::TraitImplItem *item, HirId parent_impl_id) { - ASTLowerImplItem resolver (parent_impl_id); + ASTLowerImplItem resolver; item->accept_vis (resolver); - rust_assert (resolver.translated != nullptr); + + if (resolver.translated != nullptr) + { + rust_assert (resolver.item_cast != nullptr); + + auto id = resolver.translated->get_impl_mappings ().get_hirid (); + auto defid = resolver.translated->get_impl_mappings ().get_defid (); + auto locus = resolver.translated->get_locus (); + + resolver.handle_outer_attributes (*resolver.item_cast); + resolver.mappings->insert_hir_implitem (parent_impl_id, + resolver.translated); + resolver.mappings->insert_location (id, locus); + resolver.mappings->insert_defid_mapping (defid, resolver.item_cast); + } + return resolver.translated; } @@ -76,13 +106,7 @@ public: std::move (vis), alias.get_outer_attrs (), alias.get_locus ()); translated = type_alias; - - mappings->insert_defid_mapping (mapping.get_defid (), type_alias); - mappings->insert_hir_implitem (mapping.get_crate_num (), - mapping.get_hirid (), parent_impl_id, - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - alias.get_locus ()); + item_cast = type_alias; } void visit (AST::ConstantItem &constant) override @@ -104,13 +128,7 @@ public: constant.get_outer_attrs (), constant.get_locus ()); translated = translated_constant; - - mappings->insert_defid_mapping (mapping.get_defid (), translated_constant); - mappings->insert_hir_implitem (mapping.get_crate_num (), - mapping.get_hirid (), parent_impl_id, - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - constant.get_locus ()); + item_cast = translated_constant; } void visit (AST::Function &function) override @@ -167,8 +185,7 @@ public: mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - mappings->insert_location (crate_num, - function_body->get_mappings ().get_hirid (), + mappings->insert_location (function_body->get_mappings ().get_hirid (), function.get_locus ()); auto fn @@ -179,22 +196,15 @@ public: std::move (vis), function.get_outer_attrs (), HIR::SelfParam::error (), locus); - mappings->insert_defid_mapping (mapping.get_defid (), fn); - mappings->insert_hir_implitem (mapping.get_crate_num (), - mapping.get_hirid (), parent_impl_id, fn); - mappings->insert_location (crate_num, mapping.get_hirid (), - function.get_locus ()); - // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } translated = fn; + item_cast = fn; } void visit (AST::Method &method) override @@ -260,39 +270,27 @@ public: std::move (vis), method.get_outer_attrs (), std::move (self_param), locus); - mappings->insert_defid_mapping (mapping.get_defid (), mth); - mappings->insert_hir_implitem (mapping.get_crate_num (), - mapping.get_hirid (), parent_impl_id, mth); - mappings->insert_location (crate_num, mapping.get_hirid (), - method.get_locus ()); - // insert mappings for self - mappings->insert_hir_self_param (crate_num, - self_param.get_mappings ().get_hirid (), - &self_param); - mappings->insert_location (crate_num, - self_param.get_mappings ().get_hirid (), + mappings->insert_hir_self_param (&self_param); + mappings->insert_location (self_param.get_mappings ().get_hirid (), self_param.get_locus ()); // add the mappings for the function params at the end for (auto ¶m : mth->get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } translated = mth; + item_cast = mth; } private: - ASTLowerImplItem (HirId parent_impl_id) - : translated (nullptr), parent_impl_id (parent_impl_id) - {} + ASTLowerImplItem () : translated (nullptr), item_cast (nullptr) {} HIR::ImplItem *translated; - HirId parent_impl_id; + HIR::Item *item_cast; }; class ASTLowerTraitItem : public ASTLoweringBase @@ -304,7 +302,21 @@ public: { ASTLowerTraitItem resolver; item->accept_vis (resolver); - rust_assert (resolver.translated != nullptr); + + if (resolver.translated != nullptr) + { + // FIXME + + // auto id = resolver.translated->get_mappings ().get_hirid (); + // auto defid = resolver.translated->get_mappings ().get_defid (); + // auto locus = resolver.translated->get_locus (); + + // resolver.handle_outer_attributes (*resolver.translated); + resolver.mappings->insert_hir_trait_item (resolver.translated); + // resolver.mappings->insert_location (id, locus); + // resolver.mappings->insert_defid_mapping (defid, resolver.item_cast); + } + return resolver.translated; } @@ -371,18 +383,12 @@ public: std::move (block_expr), func.get_outer_attrs (), func.get_locus ()); translated = trait_item; - mappings->insert_hir_trait_item (mapping.get_crate_num (), - mapping.get_hirid (), translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - trait_item->get_locus ()); // add the mappings for the function params at the end for (auto ¶m : trait_item->get_decl ().get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } } @@ -451,26 +457,17 @@ public: std::move (block_expr), method.get_outer_attrs (), method.get_locus ()); translated = trait_item; - mappings->insert_hir_trait_item (mapping.get_crate_num (), - mapping.get_hirid (), translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - trait_item->get_locus ()); // insert mappings for self - mappings->insert_hir_self_param (crate_num, - self_param.get_mappings ().get_hirid (), - &self_param); - mappings->insert_location (crate_num, - self_param.get_mappings ().get_hirid (), + mappings->insert_hir_self_param (&self_param); + mappings->insert_location (self_param.get_mappings ().get_hirid (), self_param.get_locus ()); // add the mappings for the function params at the end for (auto ¶m : trait_item->get_decl ().get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } } @@ -494,10 +491,6 @@ public: constant.get_outer_attrs (), constant.get_locus ()); translated = trait_item; - mappings->insert_hir_trait_item (mapping.get_crate_num (), - mapping.get_hirid (), translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - trait_item->get_locus ()); } void visit (AST::TraitItemType &type) override @@ -514,10 +507,6 @@ public: std::move (type_param_bounds), type.get_outer_attrs (), type.get_locus ()); translated = trait_item; - mappings->insert_hir_trait_item (mapping.get_crate_num (), - mapping.get_hirid (), translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - trait_item->get_locus ()); } private: diff --git a/gcc/rust/hir/rust-ast-lower-item.cc b/gcc/rust/hir/rust-ast-lower-item.cc index 5ab4dae5dab..fefc938b8e5 100644 --- a/gcc/rust/hir/rust-ast-lower-item.cc +++ b/gcc/rust/hir/rust-ast-lower-item.cc @@ -28,7 +28,17 @@ ASTLoweringItem::translate (AST::Item *item) item->accept_vis (resolver); if (resolver.translated != nullptr) - resolver.handle_outer_attributes (*resolver.translated); + { + auto id = resolver.translated->get_mappings ().get_hirid (); + auto defid = resolver.translated->get_mappings ().get_defid (); + auto locus = resolver.translated->get_locus (); + + resolver.handle_outer_attributes (*resolver.translated); + resolver.mappings->insert_ast_item (item); + resolver.mappings->insert_hir_item (resolver.translated); + resolver.mappings->insert_location (id, locus); + resolver.mappings->insert_defid_mapping (defid, resolver.translated); + } return resolver.translated; } @@ -53,21 +63,14 @@ ASTLoweringItem::visit (AST::Module &module) } // should be lowered/copied from module.get_in/outer_attrs() - AST::AttrVec inner_attrs; - AST::AttrVec outer_attrs; + AST::AttrVec inner_attrs = module.get_inner_attrs (); + AST::AttrVec outer_attrs = module.get_outer_attrs (); translated = new HIR::Module (mapping, module.get_name (), module.get_locus (), std::move (items), std::move (vis), std::move (inner_attrs), std::move (outer_attrs)); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_module (mapping.get_crate_num (), mapping.get_hirid (), - static_cast (translated)); - mappings->insert_location (crate_num, mapping.get_hirid (), - module.get_locus ()); + mappings->insert_module (static_cast (translated)); } void @@ -102,12 +105,6 @@ ASTLoweringItem::visit (AST::TypeAlias &alias) std::unique_ptr (existing_type), std::move (vis), alias.get_outer_attrs (), alias.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - alias.get_locus ()); } void @@ -165,12 +162,6 @@ ASTLoweringItem::visit (AST::TupleStruct &struct_decl) std::move (where_clause), vis, struct_decl.get_outer_attrs (), struct_decl.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - struct_decl.get_locus ()); } void @@ -233,12 +224,6 @@ ASTLoweringItem::visit (AST::StructStruct &struct_decl) std::move (where_clause), is_unit, vis, struct_decl.get_outer_attrs (), struct_decl.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - struct_decl.get_locus ()); } void @@ -282,12 +267,6 @@ ASTLoweringItem::visit (AST::Enum &enum_decl) std::move (where_clause), /* is_unit, */ std::move (items), enum_decl.get_outer_attrs (), enum_decl.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - enum_decl.get_locus ()); } void @@ -347,12 +326,6 @@ ASTLoweringItem::visit (AST::Union &union_decl) std::move (generic_params), std::move (where_clause), std::move (variants), union_decl.get_outer_attrs (), union_decl.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - union_decl.get_locus ()); } void @@ -374,11 +347,6 @@ ASTLoweringItem::visit (AST::StaticItem &var) std::unique_ptr (type), std::unique_ptr (expr), vis, var.get_outer_attrs (), var.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), var.get_locus ()); } void @@ -399,12 +367,6 @@ ASTLoweringItem::visit (AST::ConstantItem &constant) std::unique_ptr (expr), constant.get_outer_attrs (), constant.get_locus ()); - - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - constant.get_locus ()); } void @@ -470,8 +432,7 @@ ASTLoweringItem::visit (AST::Function &function) mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - mappings->insert_location (crate_num, - function_body->get_mappings ().get_hirid (), + mappings->insert_location (function_body->get_mappings ().get_hirid (), function.get_locus ()); auto fn @@ -482,19 +443,11 @@ ASTLoweringItem::visit (AST::Function &function) std::move (vis), function.get_outer_attrs (), HIR::SelfParam::error (), locus); - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - fn); - mappings->insert_location (crate_num, mapping.get_hirid (), - function.get_locus ()); - // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } translated = fn; @@ -573,14 +526,7 @@ ASTLoweringItem::visit (AST::InherentImpl &impl_block) impl_block.get_locus ()); translated = hir_impl_block; - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_hir_impl_block (mapping.get_crate_num (), - mapping.get_hirid (), hir_impl_block); - mappings->insert_location (crate_num, mapping.get_hirid (), - impl_block.get_locus ()); - + mappings->insert_hir_impl_block (hir_impl_block); for (auto &impl_item_id : impl_item_ids) { mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block); @@ -648,12 +594,6 @@ ASTLoweringItem::visit (AST::Trait &trait) trait.get_outer_attrs (), trait.get_locus ()); translated = hir_trait; - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - trait.get_locus ()); - for (auto trait_item_id : trait_item_ids) { mappings->insert_trait_item_mapping (trait_item_id, hir_trait); @@ -735,14 +675,7 @@ ASTLoweringItem::visit (AST::TraitImpl &impl_block) impl_block.get_locus ()); translated = hir_impl_block; - mappings->insert_defid_mapping (mapping.get_defid (), translated); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_hir_impl_block (mapping.get_crate_num (), - mapping.get_hirid (), hir_impl_block); - mappings->insert_location (crate_num, mapping.get_hirid (), - impl_block.get_locus ()); - + mappings->insert_hir_impl_block (hir_impl_block); for (auto &impl_item_id : impl_item_ids) { mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block); @@ -775,8 +708,8 @@ ASTLoweringSimplePath::lower (const AST::SimplePathSegment &segment) auto hir_seg = HIR::SimplePathSegment (mapping); - mappings->insert_node_to_hir (crate_num, node_id, mapping.get_hirid ()); - mappings->insert_simple_path_segment (crate_num, node_id, &segment); + mappings->insert_node_to_hir (node_id, mapping.get_hirid ()); + // mappings->insert_simple_path_segment (crate_num, node_id, &segment); return hir_seg; } @@ -798,8 +731,8 @@ ASTLoweringSimplePath::lower (const AST::SimplePath &path) auto lowered = HIR::SimplePath (std::move (segments), mapping, path.get_locus ()); - mappings->insert_node_to_hir (crate_num, node_id, mapping.get_hirid ()); - mappings->insert_simple_path (crate_num, node_id, &path); + mappings->insert_node_to_hir (node_id, mapping.get_hirid ()); + // mappings->insert_simple_path (crate_num, node_id, &path); return lowered; } diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc index 1c08bf1b197..2421ca84651 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.cc +++ b/gcc/rust/hir/rust-ast-lower-pattern.cc @@ -133,11 +133,10 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern) } // insert the reverse mappings and locations - auto crate_num = f->get_mappings ().get_crate_num (); auto field_id = f->get_mappings ().get_hirid (); auto field_node_id = f->get_mappings ().get_nodeid (); - mappings->insert_location (crate_num, field_id, f->get_locus ()); - mappings->insert_node_to_hir (crate_num, field_node_id, field_id); + mappings->insert_location (field_id, f->get_locus ()); + mappings->insert_node_to_hir (field_node_id, field_id); // add it to the lowered fields list fields.push_back (std::unique_ptr (f)); diff --git a/gcc/rust/hir/rust-ast-lower-pattern.h b/gcc/rust/hir/rust-ast-lower-pattern.h index dfd3dc07e69..aab99f602d5 100644 --- a/gcc/rust/hir/rust-ast-lower-pattern.h +++ b/gcc/rust/hir/rust-ast-lower-pattern.h @@ -36,12 +36,8 @@ public: rust_assert (resolver.translated != nullptr); - resolver.mappings->insert_hir_pattern ( - resolver.translated->get_pattern_mappings ().get_crate_num (), - resolver.translated->get_pattern_mappings ().get_hirid (), - resolver.translated); + resolver.mappings->insert_hir_pattern (resolver.translated); resolver.mappings->insert_location ( - resolver.translated->get_pattern_mappings ().get_crate_num (), resolver.translated->get_pattern_mappings ().get_hirid (), pattern->get_locus ()); diff --git a/gcc/rust/hir/rust-ast-lower-stmt.h b/gcc/rust/hir/rust-ast-lower-stmt.h index 199d146f5d5..2b26ae3835c 100644 --- a/gcc/rust/hir/rust-ast-lower-stmt.h +++ b/gcc/rust/hir/rust-ast-lower-stmt.h @@ -40,8 +40,24 @@ public: { ASTLoweringStmt resolver; stmt->accept_vis (resolver); + rust_assert (resolver.translated != nullptr); *terminated = resolver.terminated; + resolver.mappings->insert_location ( + resolver.translated->get_mappings ().get_hirid (), + resolver.translated->get_locus ()); + resolver.mappings->insert_hir_stmt (resolver.translated); + if (resolver.translated->is_item ()) + { + HIR::Item *i = static_cast (resolver.translated); + + auto defid = resolver.translated->get_mappings ().get_defid (); + + resolver.handle_outer_attributes (*i); + resolver.mappings->insert_hir_item (i); + resolver.mappings->insert_defid_mapping (defid, i); + } + return resolver.translated; } @@ -60,9 +76,6 @@ public: std::unique_ptr (expr), stmt.get_locus (), !stmt.is_semicolon_followed ()); - mappings->insert_location (crate_num, mapping.get_hirid (), - stmt.get_locus ()); - mappings->insert_hir_stmt (crate_num, mapping.get_hirid (), translated); } void visit (AST::ExprStmtWithoutBlock &stmt) override @@ -78,9 +91,6 @@ public: = new HIR::ExprStmtWithoutBlock (mapping, std::unique_ptr (expr), stmt.get_locus ()); - mappings->insert_location (crate_num, mapping.get_hirid (), - stmt.get_locus ()); - mappings->insert_hir_stmt (crate_num, mapping.get_hirid (), translated); } void visit (AST::ConstantItem &constant) override @@ -95,20 +105,11 @@ public: mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - HIR::ConstantItem *constant_item - = new HIR::ConstantItem (mapping, constant.get_identifier (), vis, - std::unique_ptr (type), - std::unique_ptr (expr), - constant.get_outer_attrs (), - constant.get_locus ()); - translated = constant_item; - - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - constant_item); - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - constant_item); - mappings->insert_location (crate_num, mapping.get_hirid (), - constant.get_locus ()); + translated = new HIR::ConstantItem (mapping, constant.get_identifier (), + vis, std::unique_ptr (type), + std::unique_ptr (expr), + constant.get_outer_attrs (), + constant.get_locus ()); } void visit (AST::LetStmt &stmt) override @@ -132,9 +133,6 @@ public: std::unique_ptr (init_expression), std::unique_ptr (type), stmt.get_outer_attrs (), stmt.get_locus ()); - mappings->insert_location (crate_num, mapping.get_hirid (), - stmt.get_locus ()); - mappings->insert_hir_stmt (crate_num, mapping.get_hirid (), translated); } void visit (AST::TupleStruct &struct_decl) override @@ -181,11 +179,6 @@ public: std::move (where_clause), vis, struct_decl.get_outer_attrs (), struct_decl.get_locus ()); - - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - struct_decl.get_locus ()); } void visit (AST::StructStruct &struct_decl) override @@ -237,11 +230,6 @@ public: std::move (where_clause), is_unit, vis, struct_decl.get_outer_attrs (), struct_decl.get_locus ()); - - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - struct_decl.get_locus ()); } void visit (AST::Union &union_decl) override @@ -291,11 +279,6 @@ public: std::move (generic_params), std::move (where_clause), std::move (variants), union_decl.get_outer_attrs (), union_decl.get_locus ()); - - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - union_decl.get_locus ()); } void visit (AST::Enum &enum_decl) override @@ -329,11 +312,6 @@ public: std::move (where_clause), /* is_unit, */ std::move (items), enum_decl.get_outer_attrs (), enum_decl.get_locus ()); - - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - enum_decl.get_locus ()); } void visit (AST::EmptyStmt &empty) override @@ -344,11 +322,6 @@ public: mappings->get_next_localdef_id (crate_num)); translated = new HIR::EmptyStmt (mapping, empty.get_locus ()); - - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - translated); - mappings->insert_location (crate_num, mapping.get_hirid (), - empty.get_locus ()); } void visit (AST::Function &function) override @@ -406,8 +379,7 @@ public: mappings->get_next_hir_id (crate_num), mappings->get_next_localdef_id (crate_num)); - mappings->insert_location (crate_num, - function_body->get_mappings ().get_hirid (), + mappings->insert_location (function_body->get_mappings ().get_hirid (), function.get_locus ()); auto fn @@ -418,20 +390,11 @@ public: std::move (vis), function.get_outer_attrs (), HIR::SelfParam::error (), locus); - mappings->insert_hir_item (mapping.get_crate_num (), mapping.get_hirid (), - fn); - mappings->insert_hir_stmt (mapping.get_crate_num (), mapping.get_hirid (), - fn); - mappings->insert_location (crate_num, mapping.get_hirid (), - function.get_locus ()); - // add the mappings for the function params at the end for (auto ¶m : fn->get_function_params ()) { - mappings->insert_hir_param (mapping.get_crate_num (), - param.get_mappings ().get_hirid (), ¶m); - mappings->insert_location (crate_num, mapping.get_hirid (), - param.get_locus ()); + mappings->insert_hir_param (¶m); + mappings->insert_location (mapping.get_hirid (), param.get_locus ()); } translated = fn; diff --git a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h index e89eed3ca3b..dadf3594904 100644 --- a/gcc/rust/hir/rust-ast-lower-struct-field-expr.h +++ b/gcc/rust/hir/rust-ast-lower-struct-field-expr.h @@ -36,11 +36,8 @@ public: field->accept_vis (compiler); rust_assert (compiler.translated != nullptr); - compiler.mappings->insert_hir_struct_field ( - compiler.translated->get_mappings ().get_crate_num (), - compiler.translated->get_mappings ().get_hirid (), compiler.translated); + compiler.mappings->insert_hir_struct_field (compiler.translated); compiler.mappings->insert_location ( - compiler.translated->get_mappings ().get_crate_num (), compiler.translated->get_mappings ().get_hirid (), field->get_locus ()); return compiler.translated; diff --git a/gcc/rust/hir/rust-ast-lower-type.h b/gcc/rust/hir/rust-ast-lower-type.h index a897c031444..317fe851a88 100644 --- a/gcc/rust/hir/rust-ast-lower-type.h +++ b/gcc/rust/hir/rust-ast-lower-type.h @@ -84,7 +84,6 @@ public: = new HIR::TypePath (std::move (mapping), std::move (translated_segments), path.get_locus (), path.has_opening_scope_resolution_op ()); - mappings->insert_hir_type (crate_num, hirid, translated); } protected: @@ -124,9 +123,10 @@ public: type->accept_vis (resolver); rust_assert (resolver.translated != nullptr); + resolver.mappings->insert_hir_type (resolver.translated); resolver.mappings->insert_location ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), type->get_locus ()); + resolver.translated->get_mappings ().get_hirid (), + resolver.translated->get_locus ()); return resolver.translated; } @@ -229,8 +229,6 @@ public: std::unique_ptr (translated_type), std::unique_ptr (array_size), type.get_locus ()); - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::ReferenceType &type) override @@ -250,9 +248,6 @@ public: : Mutability::Imm, std::unique_ptr (base_type), type.get_locus (), lifetime); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::RawPointerType &type) override @@ -273,9 +268,6 @@ public: : Mutability::Imm, std::unique_ptr (base_type), type.get_locus ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::SliceType &type) override @@ -291,9 +283,6 @@ public: translated = new HIR::SliceType (mapping, std::unique_ptr (base_type), type.get_locus ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::InferredType &type) override @@ -304,9 +293,6 @@ public: mappings->get_next_localdef_id (crate_num)); translated = new HIR::InferredType (mapping, type.get_locus ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::NeverType &type) override @@ -317,9 +303,6 @@ public: mappings->get_next_localdef_id (crate_num)); translated = new HIR::NeverType (mapping, type.get_locus ()); - - mappings->insert_hir_type (mapping.get_crate_num (), mapping.get_hirid (), - translated); } void visit (AST::TraitObjectTypeOneBound &type) override; @@ -344,11 +327,8 @@ public: rust_assert (resolver.translated != nullptr); resolver.mappings->insert_location ( - resolver.translated->get_mappings ().get_crate_num (), resolver.translated->get_mappings ().get_hirid (), param->get_locus ()); - resolver.mappings->insert_hir_generic_param ( - resolver.translated->get_mappings ().get_crate_num (), - resolver.translated->get_mappings ().get_hirid (), resolver.translated); + resolver.mappings->insert_hir_generic_param (resolver.translated); return resolver.translated; } @@ -440,7 +420,6 @@ public: rust_assert (resolver.translated != nullptr); resolver.mappings->insert_location ( - resolver.translated->get_mappings ().get_crate_num (), resolver.translated->get_mappings ().get_hirid (), resolver.translated->get_locus ()); @@ -486,7 +465,13 @@ public: { ASTLowerWhereClauseItem compiler; item.accept_vis (compiler); + rust_assert (compiler.translated != nullptr); + // FIXME + // compiler.mappings->insert_location ( + // compiler.translated->get_mappings ().get_hirid (), + // compiler.translated->get_locus ()); + return compiler.translated; } diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index 0072d30d858..0bec8b088af 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -58,14 +58,14 @@ ASTLowering::ASTLowering (AST::Crate &astCrate) : astCrate (astCrate) {} ASTLowering::~ASTLowering () {} -HIR::Crate +std::unique_ptr ASTLowering::Resolve (AST::Crate &astCrate) { ASTLowering resolver (astCrate); return resolver.go (); } -HIR::Crate +std::unique_ptr ASTLowering::go () { std::vector > items; @@ -83,7 +83,8 @@ ASTLowering::go () mappings->get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID); - return HIR::Crate (std::move (items), astCrate.get_inner_attrs (), mapping); + return std::unique_ptr ( + new HIR::Crate (std::move (items), astCrate.get_inner_attrs (), mapping)); } // rust-ast-lower-block.h @@ -413,9 +414,7 @@ ASTLowerPathInExpression::visit (AST::PathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings->insert_hir_path_expr_seg ( - lowered_seg->get_mappings ().get_crate_num (), - lowered_seg->get_mappings ().get_hirid (), lowered_seg); + mappings->insert_hir_path_expr_seg (lowered_seg); } auto crate_num = mappings->get_current_crate (); Analysis::NodeMapping mapping (crate_num, expr.get_node_id (), @@ -461,9 +460,7 @@ ASTLowerQualPathInExpression::visit (AST::QualifiedPathInExpression &expr) // insert the mappings for the segment HIR::PathExprSegment *lowered_seg = &path_segments.back (); - mappings->insert_hir_path_expr_seg ( - lowered_seg->get_mappings ().get_crate_num (), - lowered_seg->get_mappings ().get_hirid (), lowered_seg); + mappings->insert_hir_path_expr_seg (lowered_seg); } auto crate_num = mappings->get_current_crate (); diff --git a/gcc/rust/hir/rust-ast-lower.h b/gcc/rust/hir/rust-ast-lower.h index e1df5b24b33..e726b4b8282 100644 --- a/gcc/rust/hir/rust-ast-lower.h +++ b/gcc/rust/hir/rust-ast-lower.h @@ -43,12 +43,12 @@ translate_visibility (const AST::Visibility &vis); class ASTLowering { public: - static HIR::Crate Resolve (AST::Crate &astCrate); + static std::unique_ptr Resolve (AST::Crate &astCrate); ~ASTLowering (); private: ASTLowering (AST::Crate &astCrate); - HIR::Crate go (); + std::unique_ptr go (); AST::Crate &astCrate; }; diff --git a/gcc/rust/hir/tree/rust-hir-path.h b/gcc/rust/hir/tree/rust-hir-path.h index 64c6ddc9d54..03cf5f5d2e8 100644 --- a/gcc/rust/hir/tree/rust-hir-path.h +++ b/gcc/rust/hir/tree/rust-hir-path.h @@ -1001,6 +1001,8 @@ public: Location ()); } + bool is_error () const { return segments.empty (); } + const Analysis::NodeMapping &get_mappings () const { return mappings; } const Location &get_locus () const { return locus; } }; diff --git a/gcc/rust/lint/rust-lint-marklive.cc b/gcc/rust/lint/rust-lint-marklive.cc index f9850e80b31..edc4b718c1b 100644 --- a/gcc/rust/lint/rust-lint-marklive.cc +++ b/gcc/rust/lint/rust-lint-marklive.cc @@ -80,13 +80,12 @@ MarkLive::Analysis (HIR::Crate &crate) void MarkLive::go (HIR::Crate &crate) { - CrateNum crateNum = crate.get_mappings ().get_crate_num (); while (!worklist.empty ()) { HirId hirId = worklist.back (); worklist.pop_back (); scannedSymbols.emplace (hirId); - HIR::Item *item = mappings->lookup_hir_item (crateNum, hirId); + HIR::Item *item = mappings->lookup_hir_item (hirId); liveSymbols.emplace (hirId); if (item != nullptr) { @@ -96,7 +95,7 @@ MarkLive::go (HIR::Crate &crate) { // the item maybe inside a trait impl HirId parent_impl_id = UNKNOWN_HIRID; HIR::ImplItem *implItem - = mappings->lookup_hir_implitem (crateNum, hirId, &parent_impl_id); + = mappings->lookup_hir_implitem (hirId, &parent_impl_id); if (implItem != nullptr) implItem->accept_vis (*this); } @@ -120,13 +119,11 @@ MarkLive::visit (HIR::PathInExpression &expr) // node back to HIR HirId ref; - bool ok = mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - ref_node_id, &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 (expr.get_mappings ().get_crate_num (), ref); + HIR::Item *resolved_item = mappings->lookup_hir_item (ref); if (resolved_item != nullptr) { mark_hir_id (resolved_item->get_mappings ().get_hirid ()); @@ -135,8 +132,7 @@ MarkLive::visit (HIR::PathInExpression &expr) { HirId parent_impl_id = UNKNOWN_HIRID; HIR::ImplItem *resolved_item - = mappings->lookup_hir_implitem (expr.get_mappings ().get_crate_num (), - ref, &parent_impl_id); + = mappings->lookup_hir_implitem (ref, &parent_impl_id); if (resolved_item != nullptr) { mark_hir_id (resolved_item->get_impl_mappings ().get_hirid ()); @@ -159,8 +155,7 @@ MarkLive::visit (HIR::MethodCallExpr &expr) // node back to HIR HirId ref; - bool ok = mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - ref_node_id, &ref); + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); rust_assert (ok); mark_hir_id (ref); } @@ -185,8 +180,7 @@ MarkLive::visit_path_segment (HIR::PathExprSegment seg) return false; } HirId ref; - bool ok = mappings->lookup_node_to_hir (seg.get_mappings ().get_crate_num (), - ref_node_id, &ref); + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); rust_assert (ok); mark_hir_id (ref); return true; @@ -261,8 +255,7 @@ MarkLive::visit (HIR::IdentifierExpr &expr) // node back to HIR HirId ref; - bool ok = mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - ref_node_id, &ref); + bool ok = mappings->lookup_node_to_hir (ref_node_id, &ref); rust_assert (ok); mark_hir_id (ref); } @@ -274,9 +267,7 @@ MarkLive::visit (HIR::TypeAlias &alias) 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 (alias.get_mappings ().get_crate_num (), - ast_node_id, &hir_id); + bool ok = mappings->lookup_node_to_hir (ast_node_id, &hir_id); rust_assert (ok); mark_hir_id (hir_id); } diff --git a/gcc/rust/parse/rust-parse-impl.h b/gcc/rust/parse/rust-parse-impl.h index 446df13ab92..227564cb65a 100644 --- a/gcc/rust/parse/rust-parse-impl.h +++ b/gcc/rust/parse/rust-parse-impl.h @@ -424,7 +424,7 @@ Parser::parse_items () // Parses a crate (compilation unit) - entry point template -AST::Crate +std::unique_ptr Parser::parse_crate () { // parse inner attributes @@ -437,7 +437,8 @@ Parser::parse_crate () for (const auto &error : error_table) error.emit_error (); - return AST::Crate (std::move (items), std::move (inner_attrs)); + return std::unique_ptr ( + new AST::Crate (std::move (items), std::move (inner_attrs))); } // Parse a contiguous block of inner attributes. diff --git a/gcc/rust/parse/rust-parse.h b/gcc/rust/parse/rust-parse.h index c8faf499f59..4cae6ff809c 100644 --- a/gcc/rust/parse/rust-parse.h +++ b/gcc/rust/parse/rust-parse.h @@ -669,7 +669,7 @@ public: std::vector > parse_items (); // Main entry point for parser. - AST::Crate parse_crate (); + std::unique_ptr parse_crate (); // Dumps all lexer output. void debug_dump_lex_output (std::ostream &out); diff --git a/gcc/rust/privacy/rust-privacy-reporter.cc b/gcc/rust/privacy/rust-privacy-reporter.cc index 77f477b8303..00d993483bc 100644 --- a/gcc/rust/privacy/rust-privacy-reporter.cc +++ b/gcc/rust/privacy/rust-privacy-reporter.cc @@ -129,8 +129,8 @@ PrivacyReporter::check_base_type_privacy (Analysis::NodeMapping &node_mappings, auto ref_id = ty->get_ref (); NodeId lookup_id; - mappings.lookup_hir_to_node (node_mappings.get_crate_num (), ref_id, - &lookup_id); + bool ok = mappings.lookup_hir_to_node (ref_id, &lookup_id); + rust_assert (ok); return check_for_privacy_violation (lookup_id, locus); } diff --git a/gcc/rust/privacy/rust-visibility-resolver.cc b/gcc/rust/privacy/rust-visibility-resolver.cc index fdae5aa7a60..301182754a4 100644 --- a/gcc/rust/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/privacy/rust-visibility-resolver.cc @@ -72,14 +72,9 @@ VisibilityResolver::resolve_module_path (const HIR::SimplePath &restriction, // present? HirId ref; - rust_assert ( - mappings.lookup_node_to_hir (restriction.get_mappings ().get_crate_num (), - ref_node_id, &ref)); - - auto module - = mappings.lookup_module (restriction.get_mappings ().get_crate_num (), - ref); + rust_assert (mappings.lookup_node_to_hir (ref_node_id, &ref)); + auto module = mappings.lookup_module (ref); if (!module) { invalid_path.emit_error (); diff --git a/gcc/rust/resolve/rust-ast-resolve-implitem.h b/gcc/rust/resolve/rust-ast-resolve-implitem.h index 192ecaf42e6..29dbe3436f5 100644 --- a/gcc/rust/resolve/rust-ast-resolve-implitem.h +++ b/gcc/rust/resolve/rust-ast-resolve-implitem.h @@ -147,8 +147,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - function.get_node_id (), cpath); + mappings->insert_canonical_path (function.get_node_id (), cpath); } void visit (AST::TraitItemMethod &method) override @@ -166,8 +165,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - method.get_node_id (), cpath); + mappings->insert_canonical_path (method.get_node_id (), cpath); } void visit (AST::TraitItemConst &constant) override @@ -185,8 +183,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - constant.get_node_id (), cpath); + mappings->insert_canonical_path (constant.get_node_id (), cpath); } void visit (AST::TraitItemType &type) override @@ -204,8 +201,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - type.get_node_id (), cpath); + mappings->insert_canonical_path (type.get_node_id (), cpath); } private: diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc index 62518b6a403..244bf64d148 100644 --- a/gcc/rust/resolve/rust-ast-resolve-item.cc +++ b/gcc/rust/resolve/rust-ast-resolve-item.cc @@ -46,8 +46,7 @@ ResolveTraitItems::visit (AST::TraitItemType &type) = CanonicalPath::new_seg (type.get_node_id (), type.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - type.get_node_id (), cpath); + mappings->insert_canonical_path (type.get_node_id (), cpath); for (auto &bound : type.get_type_param_bounds ()) ResolveTypeBound::go (bound.get ()); @@ -60,8 +59,7 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func) func.get_node_id (), func.get_trait_function_decl ().get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - func.get_node_id (), cpath); + mappings->insert_canonical_path (func.get_node_id (), cpath); NodeId scope_node_id = func.get_node_id (); resolver->get_name_scope ().push (scope_node_id); @@ -107,8 +105,7 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func) func.get_trait_method_decl ().get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - func.get_node_id (), cpath); + mappings->insert_canonical_path (func.get_node_id (), cpath); NodeId scope_node_id = func.get_node_id (); resolver->get_name_scope ().push (scope_node_id); @@ -170,8 +167,7 @@ ResolveTraitItems::visit (AST::TraitItemConst &constant) constant.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - constant.get_node_id (), cpath); + mappings->insert_canonical_path (constant.get_node_id (), cpath); ResolveType::go (constant.get_type ().get ()); @@ -199,8 +195,7 @@ ResolveItem::visit (AST::TypeAlias &alias) = CanonicalPath::new_seg (alias.get_node_id (), alias.get_new_type_name ()); auto path = prefix.append (talias); auto cpath = canonical_prefix.append (talias); - mappings->insert_canonical_path (mappings->get_current_crate (), - alias.get_node_id (), cpath); + mappings->insert_canonical_path (alias.get_node_id (), cpath); NodeId scope_node_id = alias.get_node_id (); resolver->get_type_scope ().push (scope_node_id); @@ -223,8 +218,7 @@ ResolveItem::visit (AST::Module &module) auto mod = CanonicalPath::new_seg (module.get_node_id (), module.get_name ()); auto path = prefix.append (mod); auto cpath = canonical_prefix.append (mod); - mappings->insert_canonical_path (mappings->get_current_crate (), - module.get_node_id (), cpath); + mappings->insert_canonical_path (module.get_node_id (), cpath); resolve_visibility (module.get_visibility ()); @@ -259,8 +253,7 @@ ResolveItem::visit (AST::TupleStruct &struct_decl) struct_decl.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); resolve_visibility (struct_decl.get_visibility ()); @@ -294,8 +287,7 @@ ResolveItem::visit (AST::Enum &enum_decl) enum_decl.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - enum_decl.get_node_id (), cpath); + mappings->insert_canonical_path (enum_decl.get_node_id (), cpath); resolve_visibility (enum_decl.get_visibility ()); @@ -327,8 +319,7 @@ ResolveItem::visit (AST::EnumItem &item) = CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void @@ -338,8 +329,7 @@ ResolveItem::visit (AST::EnumItemTuple &item) = CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); for (auto &field : item.get_tuple_fields ()) { @@ -357,8 +347,7 @@ ResolveItem::visit (AST::EnumItemStruct &item) = CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); for (auto &field : item.get_struct_fields ()) { @@ -377,8 +366,7 @@ ResolveItem::visit (AST::EnumItemDiscriminant &item) auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void @@ -388,8 +376,7 @@ ResolveItem::visit (AST::StructStruct &struct_decl) struct_decl.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); resolve_visibility (struct_decl.get_visibility ()); @@ -423,8 +410,7 @@ ResolveItem::visit (AST::Union &union_decl) union_decl.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - union_decl.get_node_id (), cpath); + mappings->insert_canonical_path (union_decl.get_node_id (), cpath); resolve_visibility (union_decl.get_visibility ()); @@ -456,8 +442,7 @@ ResolveItem::visit (AST::StaticItem &var) = CanonicalPath::new_seg (var.get_node_id (), var.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - var.get_node_id (), cpath); + mappings->insert_canonical_path (var.get_node_id (), cpath); ResolveType::go (var.get_type ().get ()); ResolveExpr::go (var.get_expr ().get (), path, cpath); @@ -470,8 +455,7 @@ ResolveItem::visit (AST::ConstantItem &constant) constant.get_identifier ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - constant.get_node_id (), cpath); + mappings->insert_canonical_path (constant.get_node_id (), cpath); resolve_visibility (constant.get_visibility ()); @@ -487,8 +471,7 @@ ResolveItem::visit (AST::Function &function) auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - function.get_node_id (), cpath); + mappings->insert_canonical_path (function.get_node_id (), cpath); resolve_visibility (function.get_visibility ()); @@ -614,8 +597,7 @@ ResolveItem::visit (AST::Method &method) = CanonicalPath::new_seg (method.get_node_id (), method.get_method_name ()); auto path = prefix.append (decl); auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - method.get_node_id (), cpath); + mappings->insert_canonical_path (method.get_node_id (), cpath); NodeId scope_node_id = method.get_node_id (); diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h index 88678455211..6f21bc35a33 100644 --- a/gcc/rust/resolve/rust-ast-resolve-stmt.h +++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h @@ -60,8 +60,7 @@ public: constant.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - constant.get_node_id (), cpath); + mappings->insert_canonical_path (constant.get_node_id (), cpath); resolver->get_name_scope ().insert ( path, constant.get_node_id (), constant.get_locus (), false, @@ -94,8 +93,7 @@ public: struct_decl.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + 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, @@ -126,8 +124,7 @@ public: enum_decl.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - enum_decl.get_node_id (), cpath); + 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, @@ -158,8 +155,7 @@ public: CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, @@ -178,8 +174,7 @@ public: CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, @@ -204,8 +199,7 @@ public: CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, @@ -230,8 +224,7 @@ public: CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ())); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); resolver->get_type_scope ().insert ( path, item.get_node_id (), item.get_locus (), false, @@ -250,8 +243,7 @@ public: struct_decl.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + 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, @@ -287,8 +279,7 @@ public: union_decl.get_identifier ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - union_decl.get_node_id (), cpath); + 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, @@ -322,8 +313,7 @@ public: function.get_function_name ()); auto path = decl; // this ensures we have the correct relative resolution auto cpath = canonical_prefix.append (decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - function.get_node_id (), cpath); + mappings->insert_canonical_path (function.get_node_id (), cpath); resolver->get_name_scope ().insert ( path, function.get_node_id (), function.get_locus (), false, diff --git a/gcc/rust/resolve/rust-ast-resolve-toplevel.h b/gcc/rust/resolve/rust-ast-resolve-toplevel.h index 7aacc0a5590..352faac0c46 100644 --- a/gcc/rust/resolve/rust-ast-resolve-toplevel.h +++ b/gcc/rust/resolve/rust-ast-resolve-toplevel.h @@ -24,6 +24,7 @@ #include "rust-ast-resolve-implitem.h" #include "rust-ast-full.h" #include "rust-name-resolver.h" +#include "rust-session-manager.h" namespace Rust { namespace Resolver { @@ -72,8 +73,7 @@ public: resolver->pop_module_scope (); - mappings->insert_canonical_path (mappings->get_current_crate (), - module.get_node_id (), cpath); + mappings->insert_canonical_path (module.get_node_id (), cpath); } void visit (AST::TypeAlias &alias) override @@ -93,8 +93,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, talias); - mappings->insert_canonical_path (mappings->get_current_crate (), - alias.get_node_id (), cpath); + mappings->insert_canonical_path (alias.get_node_id (), cpath); } void visit (AST::TupleStruct &struct_decl) override @@ -114,8 +113,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); } void visit (AST::Enum &enum_decl) override @@ -138,8 +136,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - enum_decl.get_node_id (), cpath); + mappings->insert_canonical_path (enum_decl.get_node_id (), cpath); } void visit (AST::EnumItem &item) override @@ -157,8 +154,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void visit (AST::EnumItemTuple &item) override @@ -176,8 +172,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void visit (AST::EnumItemStruct &item) override @@ -195,8 +190,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void visit (AST::EnumItemDiscriminant &item) override @@ -214,8 +208,7 @@ public: rust_error_at (r, "redefined multiple times"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - item.get_node_id (), cpath); + mappings->insert_canonical_path (item.get_node_id (), cpath); } void visit (AST::StructStruct &struct_decl) override @@ -235,8 +228,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - struct_decl.get_node_id (), cpath); + mappings->insert_canonical_path (struct_decl.get_node_id (), cpath); } void visit (AST::Union &union_decl) override @@ -256,8 +248,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - union_decl.get_node_id (), cpath); + mappings->insert_canonical_path (union_decl.get_node_id (), cpath); } void visit (AST::StaticItem &var) override @@ -277,8 +268,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - var.get_node_id (), cpath); + mappings->insert_canonical_path (var.get_node_id (), cpath); } void visit (AST::ConstantItem &constant) override @@ -298,8 +288,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - constant.get_node_id (), cpath); + mappings->insert_canonical_path (constant.get_node_id (), cpath); } void visit (AST::Function &function) override @@ -319,8 +308,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - function.get_node_id (), cpath); + mappings->insert_canonical_path (function.get_node_id (), cpath); } void visit (AST::InherentImpl &impl_block) override @@ -385,8 +373,7 @@ public: NodeId current_module = resolver->peek_current_module_scope (); mappings->insert_module_child_item (current_module, decl); - mappings->insert_canonical_path (mappings->get_current_crate (), - trait.get_node_id (), cpath); + mappings->insert_canonical_path (trait.get_node_id (), cpath); } void visit (AST::ExternBlock &extern_block) override @@ -397,6 +384,56 @@ public: } } + void visit (AST::ExternCrate &extern_crate) override + { + if (extern_crate.is_marked_for_strip ()) + return; + + NodeId resolved_crate = UNKNOWN_NODEID; + if (extern_crate.references_self ()) + { + // FIXME + // then this resolves to current crate_node_id + // need to expose on the session object a reference to the current + // AST::Crate& to get node_id + gcc_unreachable (); + return; + } + else + { + rust_debug_loc (extern_crate.get_locus (), "load extern crate: [%s]", + extern_crate.as_string ().c_str ()); + + Session &session = Session::get_instance (); + resolved_crate + = session.load_extern_crate (extern_crate.get_referenced_crate ()); + } + + if (resolved_crate == UNKNOWN_NODEID) + { + rust_error_at (extern_crate.get_locus (), "failed to resolve crate"); + return; + } + + // mark the node as resolved + resolver->insert_resolved_name (extern_crate.get_node_id (), + resolved_crate); + + // does it has an as clause + if (extern_crate.has_as_clause ()) + { + auto decl = CanonicalPath::new_seg (extern_crate.get_node_id (), + extern_crate.get_as_clause ()); + resolver->get_type_scope ().insert ( + decl, extern_crate.get_node_id (), extern_crate.get_locus (), false, + [&] (const CanonicalPath &, NodeId, Location locus) -> void { + RichLocation r (extern_crate.get_locus ()); + r.add_range (locus); + rust_error_at (r, "redefined multiple times"); + }); + } + } + private: ResolveTopLevel (const CanonicalPath &prefix, const CanonicalPath &canonical_prefix) diff --git a/gcc/rust/resolve/rust-ast-resolve-type.cc b/gcc/rust/resolve/rust-ast-resolve-type.cc index e875688dc28..8e85889ffd1 100644 --- a/gcc/rust/resolve/rust-ast-resolve-type.cc +++ b/gcc/rust/resolve/rust-ast-resolve-type.cc @@ -371,8 +371,7 @@ ResolveTypeToCanonicalPath::visit (AST::TypePath &path) return; const CanonicalPath *type_path = nullptr; - if (mappings->lookup_canonical_path (mappings->get_current_crate (), - resolved_node, &type_path)) + if (mappings->lookup_canonical_path (resolved_node, &type_path)) { auto &final_seg = path.get_segments ().back (); switch (final_seg->get_type ()) diff --git a/gcc/rust/resolve/rust-ast-resolve-type.h b/gcc/rust/resolve/rust-ast-resolve-type.h index f933d1ec917..16798318227 100644 --- a/gcc/rust/resolve/rust-ast-resolve-type.h +++ b/gcc/rust/resolve/rust-ast-resolve-type.h @@ -184,8 +184,7 @@ public: rust_error_at (locus, "was defined here"); }); - mappings->insert_canonical_path (mappings->get_current_crate (), - param.get_node_id (), seg); + mappings->insert_canonical_path (param.get_node_id (), seg); } private: diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc index a788914da0d..fb7087425c1 100644 --- a/gcc/rust/resolve/rust-name-resolver.cc +++ b/gcc/rust/resolve/rust-name-resolver.cc @@ -34,11 +34,10 @@ _R.push_back (builtin_type); \ tyctx->insert_builtin (_TY->get_ref (), builtin_type->get_node_id (), \ _TY); \ - mappings->insert_node_to_hir (mappings->get_current_crate (), \ - builtin_type->get_node_id (), \ + mappings->insert_node_to_hir (builtin_type->get_node_id (), \ _TY->get_ref ()); \ mappings->insert_canonical_path ( \ - mappings->get_current_crate (), builtin_type->get_node_id (), \ + builtin_type->get_node_id (), \ CanonicalPath::new_seg (builtin_type->get_node_id (), _X)); \ } \ while (0) @@ -129,6 +128,24 @@ Rib::decl_was_declared_here (NodeId def) const return false; } +void +Rib::debug () const +{ + fprintf (stderr, "%s\n", debug_str ().c_str ()); +} + +std::string +Rib::debug_str () const +{ + std::string buffer; + for (const auto &it : path_mappings) + { + buffer += it.first.get () + "=" + std::to_string (it.second); + buffer += ","; + } + return "{" + buffer + "}"; +} + Scope::Scope (CrateNum crate_num) : crate_num (crate_num) {} void diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h index e9f7c621a47..014628a87c9 100644 --- a/gcc/rust/resolve/rust-name-resolver.h +++ b/gcc/rust/resolve/rust-name-resolver.h @@ -45,6 +45,8 @@ public: void append_reference_for_def (NodeId def, NodeId ref); bool have_references_for_node (NodeId def) const; bool decl_was_declared_here (NodeId def) const; + void debug () const; + std::string debug_str () const; CrateNum get_crate_num () const { return crate_num; } NodeId get_node_id () const { return node_id; } diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index 11076089de3..febd0096557 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -62,6 +62,13 @@ const char *kTargetOptionsDumpFile = "gccrs.target-options.dump"; const std::string kDefaultCrateName = "rust_out"; const size_t kMaxNameLength = 64; +Session & +Session::get_instance () +{ + static Session instance; + return instance; +} + static std::string infer_crate_name (const std::string &filename) { @@ -374,6 +381,9 @@ Session::init () // setup backend to GCC GIMPLE backend = rust_get_backend (); + + // setup mappings class + mappings = Analysis::Mappings::get (); } /* Initialise default options. Actually called before handle_option, unlike init @@ -574,10 +584,8 @@ Session::parse_files (int num_files, const char **files) options.set_crate_name (crate_name); } - auto mappings = Analysis::Mappings::get (); - CrateNum crate_num = mappings->setup_crate_mappings (options.crate_name); + CrateNum crate_num = mappings->get_next_crate_num (options.get_crate_name ()); mappings->set_current_crate (crate_num); - for (int i = 0; i < num_files; i++) { rust_debug ("Attempting to parse file: %s", files[i]); @@ -588,7 +596,7 @@ Session::parse_files (int num_files, const char **files) } void -Session::handle_crate_name (AST::Crate parsed_crate) +Session::handle_crate_name (const AST::Crate &parsed_crate) { auto mappings = Analysis::Mappings::get (); auto crate_name_changed = false; @@ -656,26 +664,23 @@ Session::parse_file (const char *filename) Parser parser (lex); // generate crate from parser - auto parsed_crate = parser.parse_crate (); - - // setup the mappings for this AST - auto mappings = Analysis::Mappings::get (); - mappings->insert_ast_crate (&parsed_crate); + std::unique_ptr ast_crate = parser.parse_crate (); // handle crate name - handle_crate_name (parsed_crate); + handle_crate_name (*ast_crate.get ()); + // dump options if (options.dump_option_enabled (CompileOptions::LEXER_DUMP)) { dump_lex (parser); } if (options.dump_option_enabled (CompileOptions::PARSER_AST_DUMP)) { - dump_ast (parser, parsed_crate); + dump_ast (parser, *ast_crate.get ()); } if (options.dump_option_enabled (CompileOptions::AST_DUMP_PRETTY)) { - dump_ast_pretty (parsed_crate); + dump_ast_pretty (*ast_crate.get ()); } if (options.dump_option_enabled (CompileOptions::TARGET_OPTION_DUMP)) { @@ -685,6 +690,11 @@ Session::parse_file (const char *filename) if (saw_errors ()) return; + // setup the mappings for this AST + CrateNum current_crate = mappings->get_current_crate (); + AST::Crate &parsed_crate + = mappings->insert_ast_crate (std::move (ast_crate), current_crate); + /* basic pipeline: * - lex * - parse @@ -744,23 +754,22 @@ Session::parse_file (const char *filename) return; // lower AST to HIR - HIR::Crate hir = HIR::ASTLowering::Resolve (parsed_crate); + std::unique_ptr lowered + = HIR::ASTLowering::Resolve (parsed_crate); + if (saw_errors ()) + return; + + // add the mappings to it + HIR::Crate &hir = mappings->insert_hir_crate (std::move (lowered)); if (options.dump_option_enabled (CompileOptions::HIR_DUMP)) { dump_hir (hir); } - if (options.dump_option_enabled (CompileOptions::HIR_DUMP_PRETTY)) { dump_hir_pretty (hir); } - if (saw_errors ()) - return; - - // add the mappings to it - mappings->insert_hir_crate (&hir); - // type resolve Resolver::TypeResolution::Resolve (hir); if (options.dump_option_enabled (CompileOptions::TYPE_RESOLUTION_DUMP)) @@ -781,6 +790,7 @@ Session::parse_file (const char *filename) // we can't do static analysis if there are errors to worry about if (!saw_errors ()) { + // lints Analysis::ScanDeadcode::Scan (hir); Analysis::UnusedVariables::Lint (ctx); } @@ -789,52 +799,6 @@ Session::parse_file (const char *filename) ctx.write_to_backend (); } -// TODO: actually implement method -void -load_extern_crate (std::string crate_name ATTRIBUTE_UNUSED) -{} -// TODO: deprecated - don't use - -// Parses up to the "load (external) crates" part of the frontend. -// TODO: lots of this code is probably actually useful outside of dumping, so -// maybe split off function -void -Session::debug_dump_load_crates (Parser &parser) -{ - // parse crate as AST - AST::Crate crate = parser.parse_crate (); - - /* TODO: search through inner attrs and see whether any of those attr paths - * contain "no_core", "no_std", "compiler_builtins". If so/not, save certain - * crate names. In these names, insert items at beginning of crate items. - * This is crate injection. Also, inject prelude use decl at beginning - * (first name is assumed to be prelude - prelude is a use decl - * automatically generated to enable using Option and Copy without - * qualifying it or importing it via 'use' manually) */ - - std::vector crate_names; - for (const auto &item : crate.items) - { - // if item is extern crate, add name? to list of stuff ONLY IF config is - // checked if item is module, iterate this loop inside it as well - // (recursive?) ONLY IF config is checked - - // TODO: actually do the checks somewhere - probably in the items - - item->add_crate_name (crate_names); - } - - /* loop through list of crate names/paths/whatever, attempting to load each - * one. save loaded crates to a Session variable? Or save to current - * AST::Crate? */ - for (const auto &name : crate_names) - { - load_extern_crate (name /*, basename = ""?*/); - } - // for each loaded crate, load dependencies of it as well -} -// TODO: deprecated - don't use - void Session::register_plugins (AST::Crate &crate ATTRIBUTE_UNUSED) { @@ -951,7 +915,7 @@ Session::injection (AST::Crate &crate) Linemap::unknown_location ())); // insert at beginning - crate.items.insert (crate.items.begin (), std::move (extern_crate)); + // crate.items.insert (crate.items.begin (), std::move (extern_crate)); } // create use tree path @@ -1130,6 +1094,21 @@ Session::dump_type_resolution (HIR::Crate &hir) const out.close (); } +// imports + +NodeId +Session::load_extern_crate (const std::string &crate_name) +{ + // check if it was already loaded + // .... + + rust_debug ("load_extern_crate: %s", crate_name.c_str ()); + gcc_unreachable (); + + return UNKNOWN_NODEID; +} +// + void TargetOptions::dump_target_options () const { diff --git a/gcc/rust/rust-session-manager.h b/gcc/rust/rust-session-manager.h index b0e8bf8c991..dd696411db6 100644 --- a/gcc/rust/rust-session-manager.h +++ b/gcc/rust/rust-session-manager.h @@ -22,6 +22,7 @@ #include "rust-linemap.h" #include "rust-backend.h" +#include "rust-hir-map.h" #include "safe-ctype.h" #include "config.h" @@ -225,6 +226,12 @@ struct CompileOptions crate_name = std::move (name); } + const std::string &get_crate_name () const + { + rust_assert (!crate_name.empty ()); + return crate_name; + } + void set_edition (int raw_edition) { edition = static_cast (raw_edition); @@ -250,15 +257,14 @@ struct Session // backend linemap Linemap *linemap; + // mappings + Analysis::Mappings *mappings; + public: /* Get a reference to the static session instance */ - static Session &get_instance () - { - static Session instance; - - return instance; - } + static Session &get_instance (); + Session () = default; ~Session () = default; /* This initializes the compiler session. Corresponds to langhook @@ -275,7 +281,7 @@ public: const struct cl_option_handlers *handlers); void parse_files (int num_files, const char **files); void init_options (); - void handle_crate_name (AST::Crate parsed_crate); + void handle_crate_name (const AST::Crate &parsed_crate); /* This function saves the filename data into the session manager using the * `move` semantics, and returns a C-style string referencing the input @@ -286,8 +292,9 @@ public: return extra_files.back ().c_str (); } + NodeId load_extern_crate (const std::string &crate_name); + private: - Session () = default; void parse_file (const char *filename); bool enable_dump (std::string arg); @@ -299,8 +306,6 @@ private: void dump_hir_pretty (HIR::Crate &crate) const; void dump_type_resolution (HIR::Crate &crate) const; - void debug_dump_load_crates (Parser &parser); - void implicitly_enable_feature (std::string feature_name); void enable_features (); @@ -324,6 +329,7 @@ private: // handle cfg_option bool handle_cfg_option (std::string &data); }; + } // namespace Rust #if CHECKING_P diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index c0087636aea..5ad9540868c 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -107,15 +107,13 @@ TraitResolver::resolve_path (HIR::TypePath &path) } HirId hir_node = UNKNOWN_HIRID; - if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, - &hir_node)) + if (!mappings->lookup_node_to_hir (ref, &hir_node)) { rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); return &TraitReference::error_node (); } - HIR::Item *resolved_item - = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); + HIR::Item *resolved_item = mappings->lookup_hir_item (hir_node); rust_assert (resolved_item != nullptr); resolved_item->accept_vis (*this); @@ -248,15 +246,13 @@ TraitResolver::lookup_path (HIR::TypePath &path) } HirId hir_node = UNKNOWN_HIRID; - if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, - &hir_node)) + if (!mappings->lookup_node_to_hir (ref, &hir_node)) { rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); return &TraitReference::error_node (); } - HIR::Item *resolved_item - = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); + HIR::Item *resolved_item = mappings->lookup_hir_item (hir_node); rust_assert (resolved_item != nullptr); resolved_item->accept_vis (*this); diff --git a/gcc/rust/typecheck/rust-hir-type-check-enumitem.h b/gcc/rust/typecheck/rust-hir-type-check-enumitem.h index 16cae9c38b2..bc91f458b72 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-enumitem.h +++ b/gcc/rust/typecheck/rust-hir-type-check-enumitem.h @@ -65,8 +65,7 @@ public: context->insert_type (mapping, isize); const CanonicalPath *canonical_path = nullptr; - ok = mappings->lookup_canonical_path (item.get_mappings ().get_crate_num (), - item.get_mappings ().get_nodeid (), + ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); @@ -95,8 +94,7 @@ public: const CanonicalPath *canonical_path = nullptr; bool ok - = mappings->lookup_canonical_path (item.get_mappings ().get_crate_num (), - item.get_mappings ().get_nodeid (), + = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); @@ -143,8 +141,7 @@ public: context->insert_type (mapping, isize); const CanonicalPath *canonical_path = nullptr; - ok = mappings->lookup_canonical_path (item.get_mappings ().get_crate_num (), - item.get_mappings ().get_nodeid (), + ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); @@ -190,8 +187,7 @@ public: context->insert_type (mapping, isize); const CanonicalPath *canonical_path = nullptr; - ok = mappings->lookup_canonical_path (item.get_mappings ().get_crate_num (), - item.get_mappings ().get_nodeid (), + ok = mappings->lookup_canonical_path (item.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h index e84f5e899e3..a5f0a849b91 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.h +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h @@ -438,8 +438,7 @@ public: // node back to HIR HirId ref; - if (!mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - ref_node_id, &ref)) + if (!mappings->lookup_node_to_hir (ref_node_id, &ref)) { // FIXME // this is an internal error diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h index 0bca9b467da..294dffdead2 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h +++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h @@ -307,9 +307,9 @@ public: } const CanonicalPath *canonical_path = nullptr; - bool ok = mappings->lookup_canonical_path ( - function.get_mappings ().get_crate_num (), - function.get_mappings ().get_nodeid (), &canonical_path); + bool ok + = mappings->lookup_canonical_path (function.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, function.get_locus ()}; diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index a0596116571..ac1ebfd6c95 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -205,8 +205,7 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset, // node back to HIR HirId ref; - if (!mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - ref_node_id, &ref)) + if (!mappings->lookup_node_to_hir (ref_node_id, &ref)) { rust_error_at (seg.get_locus (), "456 reverse lookup failure"); rust_debug_loc (seg.get_locus (), @@ -218,10 +217,7 @@ TypeCheckExpr::resolve_root_path (HIR::PathInExpression &expr, size_t *offset, return new TyTy::ErrorType (expr.get_mappings ().get_hirid ()); } - auto seg_is_module - = (nullptr - != mappings->lookup_module (expr.get_mappings ().get_crate_num (), - ref)); + auto seg_is_module = (nullptr != mappings->lookup_module (ref)); auto seg_is_crate = mappings->is_local_hirid_crate (ref); if (seg_is_module || seg_is_crate) { @@ -354,11 +350,8 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id, { const TyTy::VariantDef *variant = candidate.item.enum_field.variant; - CrateNum crate_num = mappings->get_current_crate (); HirId variant_id = variant->get_id (); - - HIR::Item *enum_item - = mappings->lookup_hir_item (crate_num, variant_id); + HIR::Item *enum_item = mappings->lookup_hir_item (variant_id); rust_assert (enum_item != nullptr); resolved_node_id = enum_item->get_mappings ().get_nodeid (); diff --git a/gcc/rust/typecheck/rust-hir-type-check-stmt.h b/gcc/rust/typecheck/rust-hir-type-check-stmt.h index 67eddb55c95..b2b68c05494 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-stmt.h +++ b/gcc/rust/typecheck/rust-hir-type-check-stmt.h @@ -177,7 +177,6 @@ public: // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - struct_decl.get_mappings ().get_crate_num (), struct_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, struct_decl.get_locus ()}; @@ -251,7 +250,6 @@ public: // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - enum_decl.get_mappings ().get_crate_num (), enum_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, enum_decl.get_locus ()}; @@ -313,7 +311,6 @@ public: // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - struct_decl.get_mappings ().get_crate_num (), struct_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, struct_decl.get_locus ()}; @@ -389,7 +386,6 @@ public: // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - union_decl.get_mappings ().get_crate_num (), union_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, union_decl.get_locus ()}; @@ -478,9 +474,9 @@ public: // get the path const CanonicalPath *canonical_path = nullptr; - bool ok = mappings->lookup_canonical_path ( - function.get_mappings ().get_crate_num (), - function.get_mappings ().get_nodeid (), &canonical_path); + bool ok + = mappings->lookup_canonical_path (function.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, function.get_locus ()}; diff --git a/gcc/rust/typecheck/rust-hir-type-check-toplevel.cc b/gcc/rust/typecheck/rust-hir-type-check-toplevel.cc index e46d312fa32..78188cc17ad 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-toplevel.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-toplevel.cc @@ -99,7 +99,6 @@ TypeCheckTopLevel::visit (HIR::TupleStruct &struct_decl) // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - struct_decl.get_mappings ().get_crate_num (), struct_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, struct_decl.get_locus ()}; @@ -159,7 +158,6 @@ TypeCheckTopLevel::visit (HIR::StructStruct &struct_decl) // get the path const CanonicalPath *canonical_path = nullptr; bool ok = mappings->lookup_canonical_path ( - struct_decl.get_mappings ().get_crate_num (), struct_decl.get_mappings ().get_nodeid (), &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, struct_decl.get_locus ()}; @@ -205,9 +203,9 @@ TypeCheckTopLevel::visit (HIR::Enum &enum_decl) // get the path const CanonicalPath *canonical_path = nullptr; - bool ok = mappings->lookup_canonical_path ( - enum_decl.get_mappings ().get_crate_num (), - enum_decl.get_mappings ().get_nodeid (), &canonical_path); + bool ok + = mappings->lookup_canonical_path (enum_decl.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, enum_decl.get_locus ()}; @@ -249,9 +247,9 @@ TypeCheckTopLevel::visit (HIR::Union &union_decl) // get the path const CanonicalPath *canonical_path = nullptr; - bool ok = mappings->lookup_canonical_path ( - union_decl.get_mappings ().get_crate_num (), - union_decl.get_mappings ().get_nodeid (), &canonical_path); + bool ok + = mappings->lookup_canonical_path (union_decl.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, union_decl.get_locus ()}; @@ -335,9 +333,9 @@ TypeCheckTopLevel::visit (HIR::Function &function) } const CanonicalPath *canonical_path = nullptr; - bool ok = mappings->lookup_canonical_path ( - function.get_mappings ().get_crate_num (), - function.get_mappings ().get_nodeid (), &canonical_path); + bool ok + = mappings->lookup_canonical_path (function.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, function.get_locus ()}; diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index a5597beb185..9291a18d598 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -273,8 +273,7 @@ TypeCheckType::resolve_root_path (HIR::TypePath &path, size_t *offset, // node back to HIR HirId ref = UNKNOWN_HIRID; - if (!mappings->lookup_node_to_hir (path.get_mappings ().get_crate_num (), - ref_node_id, &ref)) + if (!mappings->lookup_node_to_hir (ref_node_id, &ref)) { if (is_root) { @@ -291,10 +290,7 @@ TypeCheckType::resolve_root_path (HIR::TypePath &path, size_t *offset, return root_tyty; } - auto seg_is_module - = (nullptr - != mappings->lookup_module (path.get_mappings ().get_crate_num (), - ref)); + auto seg_is_module = (nullptr != mappings->lookup_module (ref)); auto seg_is_crate = mappings->is_local_hirid_crate (ref); if (seg_is_module || seg_is_crate) { diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.h b/gcc/rust/typecheck/rust-hir-type-check-type.h index 127502f1494..82ca221545c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.h +++ b/gcc/rust/typecheck/rust-hir-type-check-type.h @@ -291,9 +291,7 @@ public: // node back to HIR HirId ref; - if (!mappings->lookup_node_to_hir ( - binding_type_path->get_mappings ().get_crate_num (), ref_node_id, - &ref)) + if (!mappings->lookup_node_to_hir (ref_node_id, &ref)) { // FIXME rust_error_at (Location (), "where-clause reverse lookup failure"); diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc index 7cfb952152f..37a085f521b 100644 --- a/gcc/rust/typecheck/rust-hir-type-check.cc +++ b/gcc/rust/typecheck/rust-hir-type-check.cc @@ -313,10 +313,8 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const auto mappings = Analysis::Mappings::get (); const CanonicalPath *canonical_path = nullptr; - bool ok - = mappings->lookup_canonical_path (fn.get_mappings ().get_crate_num (), - fn.get_mappings ().get_nodeid (), - &canonical_path); + bool ok = mappings->lookup_canonical_path (fn.get_mappings ().get_nodeid (), + &canonical_path); rust_assert (ok); RustIdent ident{*canonical_path, fn.get_locus ()}; diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 60407a70b15..05cd8ce971a 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -329,8 +329,7 @@ TyVar::get_implicit_infer_var (Location locus) infer->get_ref (), UNKNOWN_LOCAL_DEFID), infer); - mappings->insert_location (mappings->get_current_crate (), infer->get_ref (), - locus); + mappings->insert_location (infer->get_ref (), locus); return TyVar (infer->get_ref ()); } @@ -457,7 +456,7 @@ InferType::clone () const clone->get_ref (), UNKNOWN_LOCAL_DEFID), clone); - mappings->insert_location (mappings->get_current_crate (), clone->get_ref (), + mappings->insert_location (clone->get_ref (), mappings->lookup_location (get_ref ())); // setup the chain to reference this diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc index 870ca21f87c..b5989fba676 100644 --- a/gcc/rust/util/rust-attributes.cc +++ b/gcc/rust/util/rust-attributes.cc @@ -35,6 +35,7 @@ static const BuiltinAttrDefinition __definitions[] = { {"link_section", CODE_GENERATION}, {"no_mangle", CODE_GENERATION}, {"repr", CODE_GENERATION}, + {"path", EXPANSION}, }; BuiltinAttributeMappings * diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 8b3be5c9e8d..353b7cb16ed 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -20,6 +20,7 @@ #include "rust-ast-full.h" #include "rust-hir-full.h" #include "rust-macro-builtins.h" +#include "rust-mapping-common.h" namespace Rust { namespace Analysis { @@ -87,8 +88,14 @@ NodeMapping::as_string () const } // Mappings Class now +static const HirId kDefaultNodeIdBegin = 1; +static const HirId kDefaultHirIdBegin = 1; +static const HirId kDefaultCrateNumBegin = 0; -Mappings::Mappings () {} +Mappings::Mappings () + : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CREATENUM), + hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin) +{} Mappings::~Mappings () {} @@ -103,9 +110,12 @@ Mappings::get () } CrateNum -Mappings::get_next_crate_num () +Mappings::get_next_crate_num (const std::string &name) { - return crateNumItr++; + auto id = crateNumItr; + crateNumItr++; + set_crate_name (id, name); + return id; } void @@ -114,21 +124,6 @@ Mappings::set_current_crate (CrateNum crateNum) currentCrateNum = crateNum; } -CrateNum -Mappings::setup_crate_mappings (std::string crate_name) -{ - CrateNum crate_num = get_next_crate_num (); - - hirIdIter[crate_num] = UNKNOWN_HIRID; - nodeIdIter[crate_num] = UNKNOWN_NODEID; - localIdIter[crate_num] = UNKNOWN_LOCAL_DEFID; - nodeIdToHirMappings[crate_num] = {}; - locations[crate_num] = {}; - crate_names[crate_num] = crate_name; - - return crate_num; -} - CrateNum Mappings::get_current_crate () const { @@ -136,27 +131,25 @@ Mappings::get_current_crate () const } NodeId -Mappings::get_next_node_id (CrateNum crateNum) +Mappings::get_next_node_id () { - auto it = nodeIdIter.find (crateNum); - // We're probably *not* parsing actual rust code... but mostly reusing - // the parser in another way. Return 0 - if (it == nodeIdIter.end ()) - return 0; - - auto id = it->second + 1; - nodeIdIter[crateNum] = id; - return id; + auto it = nodeIdIter; + nodeIdIter++; + return it; } HirId Mappings::get_next_hir_id (CrateNum crateNum) { - auto it = hirIdIter.find (crateNum); - rust_assert (it != hirIdIter.end ()); + auto id = hirIdIter; + hirIdIter++; + + auto it = hirNodesWithinCrate.find (crateNum); + if (it == hirNodesWithinCrate.end ()) + { + hirNodesWithinCrate.insert ({crateNum, {}}); + } - auto id = it->second + 1; - hirIdIter[crateNum] = id; hirNodesWithinCrate[crateNum].insert (id); return id; } @@ -165,64 +158,89 @@ LocalDefId Mappings::get_next_localdef_id (CrateNum crateNum) { auto it = localIdIter.find (crateNum); + if (it == localIdIter.end ()) + { + localIdIter.insert ({crateNum, 1}); + } + + it = localIdIter.find (crateNum); rust_assert (it != localIdIter.end ()); - auto id = it->second + 1; - localIdIter[crateNum] = id; + LocalDefId id = it->second; + localIdIter[crateNum] = id + 1; return id; } -AST::Crate * +AST::Crate & Mappings::get_ast_crate (CrateNum crateNum) { - auto it = astCrateMappings.find (crateNum); - if (it == astCrateMappings.end ()) - return nullptr; + auto it = ast_crate_mappings.find (crateNum); + rust_assert (it != ast_crate_mappings.end ()); + return *it->second; +} - return it->second; +AST::Crate & +Mappings::get_ast_crate_by_node_id (NodeId id) +{ + auto i = crate_node_to_crate_num.find (id); + rust_assert (i != crate_node_to_crate_num.end ()); + + CrateNum crateNum = i->second; + auto it = ast_crate_mappings.find (crateNum); + rust_assert (it != ast_crate_mappings.end ()); + return *it->second; } -void -Mappings::insert_ast_crate (AST::Crate *crate) +AST::Crate & +Mappings::insert_ast_crate (std::unique_ptr &&crate, + CrateNum crate_num) { - CrateNum crateNum = get_current_crate (); - rust_assert (get_ast_crate (crateNum) == nullptr); + auto it = ast_crate_mappings.find (crate_num); + rust_assert (it == ast_crate_mappings.end ()); - astCrateMappings[crateNum] = crate; + // store it + ast_crate_mappings.insert ({crate_num, crate.get ()}); + + // return the reference to it + it = ast_crate_mappings.find (crate_num); + rust_assert (it != ast_crate_mappings.end ()); + return *it->second; } -HIR::Crate * +HIR::Crate & Mappings::get_hir_crate (CrateNum crateNum) { - auto it = hirCrateMappings.find (crateNum); - if (it == hirCrateMappings.end ()) - return nullptr; - - return it->second; + auto it = hir_crate_mappings.find (crateNum); + rust_assert (it != hir_crate_mappings.end ()); + return *it->second; } bool Mappings::is_local_hirid_crate (HirId crateNum) { - for (const auto &it : hirCrateMappings) + for (const auto &it : hir_crate_mappings) { - const HIR::Crate *crate = it.second; + const auto &crate = it.second; if (crate->get_mappings ().get_hirid () == crateNum) return true; } return false; } -void -Mappings::insert_hir_crate (HIR::Crate *crate) +HIR::Crate & +Mappings::insert_hir_crate (std::unique_ptr &&crate) { CrateNum crateNum = crate->get_mappings ().get_crate_num (); - rust_assert (get_hir_crate (crateNum) == nullptr); + auto it = hir_crate_mappings.find (crateNum); + rust_assert (it == hir_crate_mappings.end ()); - hirCrateMappings[crateNum] = crate; - insert_node_to_hir (crate->get_mappings ().get_crate_num (), - crate->get_mappings ().get_nodeid (), + insert_node_to_hir (crate->get_mappings ().get_nodeid (), crate->get_mappings ().get_hirid ()); + hir_crate_mappings.insert ({crateNum, crate.get ()}); + + it = hir_crate_mappings.find (crateNum); + rust_assert (it != hir_crate_mappings.end ()); + return *it->second; } void @@ -249,145 +267,124 @@ Mappings::lookup_defid (DefId id) } void -Mappings::insert_hir_item (CrateNum crateNum, HirId id, HIR::Item *item) +Mappings::insert_hir_item (HIR::Item *item) { - rust_assert (lookup_hir_item (crateNum, id) == nullptr); + auto id = item->get_mappings ().get_hirid (); + rust_assert (lookup_hir_item (id) == nullptr); - hirItemMappings[crateNum][id] = item; - insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id); + hirItemMappings[id] = item; + insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } HIR::Item * -Mappings::lookup_hir_item (CrateNum crateNum, HirId id) +Mappings::lookup_hir_item (HirId id) { - auto it = hirItemMappings.find (crateNum); + auto it = hirItemMappings.find (id); if (it == hirItemMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_trait_item (CrateNum crateNum, HirId id, - HIR::TraitItem *item) +Mappings::insert_hir_trait_item (HIR::TraitItem *item) { - rust_assert (lookup_hir_trait_item (crateNum, id) == nullptr); + auto id = item->get_mappings ().get_hirid (); + rust_assert (lookup_hir_trait_item (id) == nullptr); - hirTraitItemMappings[crateNum][id] = item; - insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id); + hirTraitItemMappings[id] = item; + insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } HIR::TraitItem * -Mappings::lookup_hir_trait_item (CrateNum crateNum, HirId id) +Mappings::lookup_hir_trait_item (HirId id) { - auto it = hirTraitItemMappings.find (crateNum); + auto it = hirTraitItemMappings.find (id); if (it == hirTraitItemMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_extern_item (CrateNum crateNum, HirId id, - HIR::ExternalItem *item) +Mappings::insert_hir_extern_item (HIR::ExternalItem *item) { - rust_assert (lookup_hir_extern_item (crateNum, id) == nullptr); + auto id = item->get_mappings ().get_hirid (); + rust_assert (lookup_hir_extern_item (id) == nullptr); - hirExternItemMappings[crateNum][id] = item; - insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id); + hirExternItemMappings[id] = item; + insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } HIR::ExternalItem * -Mappings::lookup_hir_extern_item (CrateNum crateNum, HirId id) +Mappings::lookup_hir_extern_item (HirId id) { - auto it = hirExternItemMappings.find (crateNum); + auto it = hirExternItemMappings.find (id); if (it == hirExternItemMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_impl_block (CrateNum crateNum, HirId id, - HIR::ImplBlock *item) +Mappings::insert_hir_impl_block (HIR::ImplBlock *item) { - rust_assert (lookup_hir_impl_block (crateNum, id) == nullptr); + auto id = item->get_mappings ().get_hirid (); + rust_assert (lookup_hir_impl_block (id) == nullptr); - hirImplBlockMappings[crateNum][id] = item; - insert_node_to_hir (crateNum, item->get_mappings ().get_nodeid (), id); + hirImplBlockMappings[id] = item; + insert_node_to_hir (item->get_mappings ().get_nodeid (), id); } HIR::ImplBlock * -Mappings::lookup_hir_impl_block (CrateNum crateNum, HirId id) +Mappings::lookup_hir_impl_block (HirId id) { - auto it = hirImplBlockMappings.find (crateNum); + auto it = hirImplBlockMappings.find (id); if (it == hirImplBlockMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_module (CrateNum crateNum, HirId id, HIR::Module *module) +Mappings::insert_module (HIR::Module *module) { - rust_assert (lookup_module (crateNum, id) == nullptr); + auto id = module->get_mappings ().get_hirid (); + rust_assert (lookup_module (id) == nullptr); - hirModuleMappings[crateNum][id] = module; + hirModuleMappings[id] = module; + insert_node_to_hir (module->get_mappings ().get_nodeid (), id); } HIR::Module * -Mappings::lookup_module (CrateNum crateNum, HirId id) +Mappings::lookup_module (HirId id) { - auto it = hirModuleMappings.find (crateNum); + auto it = hirModuleMappings.find (id); if (it == hirModuleMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_implitem (CrateNum crateNum, HirId id, - HirId parent_impl_id, HIR::ImplItem *item) +Mappings::insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item) { - rust_assert (lookup_hir_implitem (crateNum, id, nullptr) == nullptr); - hirImplItemMappings[crateNum][id] + auto id = item->get_impl_mappings ().get_hirid (); + rust_assert (lookup_hir_implitem (id, nullptr) == nullptr); + + hirImplItemMappings[id] = std::pair (parent_impl_id, item); - insert_node_to_hir (crateNum, item->get_impl_mappings ().get_nodeid (), id); + insert_node_to_hir (item->get_impl_mappings ().get_nodeid (), id); } HIR::ImplItem * -Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id, - HirId *parent_impl_id) +Mappings::lookup_hir_implitem (HirId id, HirId *parent_impl_id) { - auto it = hirImplItemMappings.find (crateNum); + auto it = hirImplItemMappings.find (id); if (it == hirImplItemMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - std::pair &ref = iy->second; + std::pair &ref = it->second; if (parent_impl_id != nullptr) *parent_impl_id = ref.first; @@ -395,266 +392,185 @@ Mappings::lookup_hir_implitem (CrateNum crateNum, HirId id, } void -Mappings::insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr) +Mappings::insert_hir_expr (HIR::Expr *expr) { - hirExprMappings[crateNum][id] = expr; - insert_node_to_hir (crateNum, expr->get_mappings ().get_nodeid (), id); - insert_location (crateNum, id, expr->get_locus ()); + auto id = expr->get_mappings ().get_hirid (); + hirExprMappings[id] = expr; + + insert_node_to_hir (expr->get_mappings ().get_nodeid (), id); + insert_location (id, expr->get_locus ()); } HIR::Expr * -Mappings::lookup_hir_expr (CrateNum crateNum, HirId id) +Mappings::lookup_hir_expr (HirId id) { - auto it = hirExprMappings.find (crateNum); + auto it = hirExprMappings.find (id); if (it == hirExprMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_path_expr_seg (CrateNum crateNum, HirId id, - HIR::PathExprSegment *expr) +Mappings::insert_hir_path_expr_seg (HIR::PathExprSegment *expr) { - rust_assert (lookup_hir_path_expr_seg (crateNum, id) == nullptr); + auto id = expr->get_mappings ().get_hirid (); + rust_assert (lookup_hir_path_expr_seg (id) == nullptr); - hirPathSegMappings[crateNum][id] = expr; - insert_node_to_hir (crateNum, expr->get_mappings ().get_nodeid (), id); - insert_location (crateNum, id, expr->get_locus ()); + hirPathSegMappings[id] = expr; + insert_node_to_hir (expr->get_mappings ().get_nodeid (), id); + insert_location (id, expr->get_locus ()); } HIR::PathExprSegment * -Mappings::lookup_hir_path_expr_seg (CrateNum crateNum, HirId id) +Mappings::lookup_hir_path_expr_seg (HirId id) { - auto it = hirPathSegMappings.find (crateNum); + auto it = hirPathSegMappings.find (id); if (it == hirPathSegMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; -} - -void -Mappings::insert_simple_path_segment (CrateNum crateNum, HirId id, - const AST::SimplePathSegment *path) -{ - rust_assert (lookup_simple_path_segment (crateNum, id) == nullptr); - - astSimplePathSegmentMappings[crateNum][id] = path; - insert_node_to_hir (crateNum, path->get_node_id (), id); - insert_location (crateNum, id, path->get_locus ()); -} - -const AST::SimplePathSegment * -Mappings::lookup_simple_path_segment (CrateNum crateNum, HirId id) -{ - auto it = astSimplePathSegmentMappings.find (crateNum); - if (it == astSimplePathSegmentMappings.end ()) - return nullptr; - - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; -} - -void -Mappings::insert_simple_path (CrateNum crateNum, HirId id, - const AST::SimplePath *path) -{ - rust_assert (lookup_simple_path (crateNum, id) == nullptr); - - astSimplePathMappings[crateNum][id] = path; - insert_node_to_hir (crateNum, path->get_node_id (), id); - insert_location (crateNum, id, path->get_locus ()); -} - -const AST::SimplePath * -Mappings::lookup_simple_path (CrateNum crateNum, HirId id) -{ - auto it = astSimplePathMappings.find (crateNum); - if (it == astSimplePathMappings.end ()) - return nullptr; - - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_generic_param (CrateNum crateNum, HirId id, - HIR::GenericParam *param) +Mappings::insert_hir_generic_param (HIR::GenericParam *param) { - rust_assert (lookup_hir_generic_param (crateNum, id) == nullptr); + auto id = param->get_mappings ().get_hirid (); + rust_assert (lookup_hir_generic_param (id) == nullptr); - hirGenericParamMappings[crateNum][id] = param; - insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id); - insert_location (crateNum, id, param->get_locus ()); + hirGenericParamMappings[id] = param; + insert_node_to_hir (param->get_mappings ().get_nodeid (), id); + insert_location (id, param->get_locus ()); } HIR::GenericParam * -Mappings::lookup_hir_generic_param (CrateNum crateNum, HirId id) +Mappings::lookup_hir_generic_param (HirId id) { - auto it = hirGenericParamMappings.find (crateNum); + auto it = hirGenericParamMappings.find (id); if (it == hirGenericParamMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_type (CrateNum crateNum, HirId id, HIR::Type *type) +Mappings::insert_hir_type (HIR::Type *type) { - rust_assert (lookup_hir_type (crateNum, id) == nullptr); + auto id = type->get_mappings ().get_hirid (); + rust_assert (lookup_hir_type (id) == nullptr); - hirTypeMappings[crateNum][id] = type; - insert_node_to_hir (crateNum, type->get_mappings ().get_nodeid (), id); + hirTypeMappings[id] = type; + insert_node_to_hir (type->get_mappings ().get_nodeid (), id); } HIR::Type * -Mappings::lookup_hir_type (CrateNum crateNum, HirId id) +Mappings::lookup_hir_type (HirId id) { - auto it = hirTypeMappings.find (crateNum); + auto it = hirTypeMappings.find (id); if (it == hirTypeMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_stmt (CrateNum crateNum, HirId id, HIR::Stmt *stmt) +Mappings::insert_hir_stmt (HIR::Stmt *stmt) { - rust_assert (lookup_hir_stmt (crateNum, id) == nullptr); + auto id = stmt->get_mappings ().get_hirid (); + rust_assert (lookup_hir_stmt (id) == nullptr); - hirStmtMappings[crateNum][id] = stmt; - insert_node_to_hir (crateNum, stmt->get_mappings ().get_nodeid (), id); + hirStmtMappings[id] = stmt; + insert_node_to_hir (stmt->get_mappings ().get_nodeid (), id); } HIR::Stmt * -Mappings::lookup_hir_stmt (CrateNum crateNum, HirId id) +Mappings::lookup_hir_stmt (HirId id) { - auto it = hirStmtMappings.find (crateNum); + auto it = hirStmtMappings.find (id); if (it == hirStmtMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_param (CrateNum crateNum, HirId id, - HIR::FunctionParam *param) +Mappings::insert_hir_param (HIR::FunctionParam *param) { - rust_assert (lookup_hir_stmt (crateNum, id) == nullptr); + auto id = param->get_mappings ().get_hirid (); + rust_assert (lookup_hir_param (id) == nullptr); - hirParamMappings[crateNum][id] = param; - insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id); + hirParamMappings[id] = param; + insert_node_to_hir (param->get_mappings ().get_nodeid (), id); } HIR::FunctionParam * -Mappings::lookup_hir_param (CrateNum crateNum, HirId id) +Mappings::lookup_hir_param (HirId id) { - auto it = hirParamMappings.find (crateNum); + auto it = hirParamMappings.find (id); if (it == hirParamMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_self_param (CrateNum crateNum, HirId id, - HIR::SelfParam *param) +Mappings::insert_hir_self_param (HIR::SelfParam *param) { - rust_assert (lookup_hir_stmt (crateNum, id) == nullptr); + auto id = param->get_mappings ().get_hirid (); + rust_assert (lookup_hir_self_param (id) == nullptr); - hirSelfParamMappings[crateNum][id] = param; - insert_node_to_hir (crateNum, param->get_mappings ().get_nodeid (), id); + hirSelfParamMappings[id] = param; + insert_node_to_hir (param->get_mappings ().get_nodeid (), id); } HIR::SelfParam * -Mappings::lookup_hir_self_param (CrateNum crateNum, HirId id) +Mappings::lookup_hir_self_param (HirId id) { - auto it = hirSelfParamMappings.find (crateNum); + auto it = hirSelfParamMappings.find (id); if (it == hirSelfParamMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_struct_field (CrateNum crateNum, HirId id, - HIR::StructExprField *field) +Mappings::insert_hir_struct_field (HIR::StructExprField *field) { - rust_assert (lookup_hir_stmt (crateNum, id) == nullptr); + auto id = field->get_mappings ().get_hirid (); + rust_assert (lookup_hir_struct_field (id) == nullptr); - hirStructFieldMappings[crateNum][id] = field; - insert_node_to_hir (crateNum, field->get_mappings ().get_nodeid (), id); + hirStructFieldMappings[id] = field; + insert_node_to_hir (field->get_mappings ().get_nodeid (), id); } HIR::StructExprField * -Mappings::lookup_hir_struct_field (CrateNum crateNum, HirId id) +Mappings::lookup_hir_struct_field (HirId id) { - auto it = hirStructFieldMappings.find (crateNum); + auto it = hirStructFieldMappings.find (id); if (it == hirStructFieldMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void -Mappings::insert_hir_pattern (CrateNum crateNum, HirId id, - HIR::Pattern *pattern) +Mappings::insert_hir_pattern (HIR::Pattern *pattern) { - hirPatternMappings[crateNum][id] = pattern; - insert_node_to_hir (crateNum, pattern->get_pattern_mappings ().get_nodeid (), - id); + auto id = pattern->get_pattern_mappings ().get_hirid (); + rust_assert (lookup_hir_pattern (id) == nullptr); + + hirPatternMappings[id] = pattern; + insert_node_to_hir (pattern->get_pattern_mappings ().get_nodeid (), id); } HIR::Pattern * -Mappings::lookup_hir_pattern (CrateNum crateNum, HirId id) +Mappings::lookup_hir_pattern (HirId id) { - auto it = hirPatternMappings.find (crateNum); + auto it = hirPatternMappings.find (id); if (it == hirPatternMappings.end ()) return nullptr; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return nullptr; - - return iy->second; + return it->second; } void @@ -662,7 +578,6 @@ Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id, HIR::Item *item) { rust_assert (lookup_local_defid (crateNum, id) == nullptr); - localDefIdMappings[crateNum][id] = item; } @@ -696,75 +611,59 @@ Mappings::walk_local_defids_for_crate (CrateNum crateNum, } void -Mappings::insert_node_to_hir (CrateNum crate, NodeId id, HirId ref) +Mappings::insert_node_to_hir (NodeId id, HirId ref) { - nodeIdToHirMappings[crate][id] = ref; - hirIdToNodeMappings[crate][ref] = id; + nodeIdToHirMappings[id] = ref; + hirIdToNodeMappings[ref] = id; } bool -Mappings::lookup_node_to_hir (CrateNum crate, NodeId id, HirId *ref) +Mappings::lookup_node_to_hir (NodeId id, HirId *ref) { - auto it = nodeIdToHirMappings.find (crate); + auto it = nodeIdToHirMappings.find (id); if (it == nodeIdToHirMappings.end ()) return false; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return false; - - *ref = iy->second; + *ref = it->second; return true; } bool -Mappings::lookup_hir_to_node (CrateNum crate, HirId id, NodeId *ref) +Mappings::lookup_hir_to_node (HirId id, NodeId *ref) { - auto it = hirIdToNodeMappings.find (crate); + auto it = hirIdToNodeMappings.find (id); if (it == hirIdToNodeMappings.end ()) return false; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return false; - - *ref = iy->second; + *ref = it->second; return true; } void -Mappings::insert_location (CrateNum crate, HirId id, Location locus) +Mappings::insert_location (HirId id, Location locus) { - locations[crate][id] = locus; + locations[id] = locus; } Location -Mappings::lookup_location (CrateNum crate, HirId id) +Mappings::lookup_location (HirId id) { - auto it = locations.find (crate); + auto it = locations.find (id); if (it == locations.end ()) return Location (); - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return Location (); - - return iy->second; + return it->second; } bool -Mappings::resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt) +Mappings::resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt) { - auto it = nodeIdToHirMappings.find (crate); + auto it = nodeIdToHirMappings.find (id); if (it == nodeIdToHirMappings.end ()) return false; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return false; - - HirId resolved = iy->second; - auto resolved_stmt = lookup_hir_stmt (crate, resolved); + HirId resolved = it->second; + auto resolved_stmt = lookup_hir_stmt (resolved); *stmt = resolved_stmt; return resolved_stmt != nullptr; } @@ -776,15 +675,12 @@ Mappings::iterate_impl_items ( for (auto it = hirImplItemMappings.begin (); it != hirImplItemMappings.end (); it++) { - for (auto iy = it->second.begin (); iy != it->second.end (); iy++) - { - auto id = iy->first; - auto impl_item = iy->second.second; - auto impl = lookup_associated_impl ( - impl_item->get_impl_mappings ().get_hirid ()); - if (!cb (id, impl_item, impl)) - return; - } + auto id = it->first; + auto impl_item = it->second.second; + auto impl + = lookup_associated_impl (impl_item->get_impl_mappings ().get_hirid ()); + if (!cb (id, impl_item, impl)) + return; } } @@ -794,13 +690,10 @@ Mappings::iterate_impl_blocks (std::function cb) for (auto it = hirImplBlockMappings.begin (); it != hirImplBlockMappings.end (); it++) { - for (auto iy = it->second.begin (); iy != it->second.end (); iy++) - { - HirId id = iy->first; - HIR::ImplBlock *impl_block = iy->second; - if (!cb (id, impl_block)) - return; - } + HirId id = it->first; + HIR::ImplBlock *impl_block = it->second; + if (!cb (id, impl_block)) + return; } } @@ -811,15 +704,12 @@ Mappings::iterate_trait_items ( for (auto it = hirTraitItemMappings.begin (); it != hirTraitItemMappings.end (); it++) { - for (auto iy = it->second.begin (); iy != it->second.end (); iy++) - { - HirId trait_item_id = iy->first; - HIR::TraitItem *trait_item = iy->second; - HIR::Trait *trait = lookup_trait_item_mapping (trait_item_id); - - if (!cb (trait_item, trait)) - return; - } + HirId trait_item_id = it->first; + HIR::TraitItem *trait_item = it->second; + HIR::Trait *trait = lookup_trait_item_mapping (trait_item_id); + + if (!cb (trait_item, trait)) + return; } } @@ -966,5 +856,25 @@ Mappings::node_is_module (NodeId query) return module_child_items.find (query) != module_child_items.end (); } +void +Mappings::insert_ast_item (AST::Item *item) +{ + auto it = ast_item_mappings.find (item->get_node_id ()); + rust_assert (it == ast_item_mappings.end ()); + + ast_item_mappings[item->get_node_id ()] = item; +} + +bool +Mappings::lookup_ast_item (NodeId id, AST::Item **result) +{ + auto it = ast_item_mappings.find (id); + if (it == ast_item_mappings.end ()) + return false; + + *result = it->second; + return true; +} + } // namespace Analysis } // namespace Rust diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 4360ae2e2a9..804242e99bb 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -74,10 +74,9 @@ public: static Mappings *get (); ~Mappings (); - CrateNum get_next_crate_num (); + CrateNum get_next_crate_num (const std::string &name); void set_current_crate (CrateNum crateNum); CrateNum get_current_crate () const; - CrateNum setup_crate_mappings (std::string crate_name); bool get_crate_name (CrateNum crate_num, std::string &name) const { @@ -90,16 +89,9 @@ public: } // set crate name mid-compilation - // don't use this if setting crate name before Session::parse_files - bool set_crate_name (CrateNum crate_num, std::string name) + void set_crate_name (CrateNum crate_num, const std::string &name) { - rust_assert (!name.empty ()); - auto it = crate_names.find (crate_num); - if (it == crate_names.end ()) - return false; - - it->second.assign (name); - return true; + crate_names[crate_num] = name; } std::string get_current_crate_name () const @@ -110,20 +102,22 @@ public: return name; } - NodeId get_next_node_id () { return get_next_node_id (get_current_crate ()); } - NodeId get_next_node_id (CrateNum crateNum); - + NodeId get_next_node_id (); HirId get_next_hir_id () { return get_next_hir_id (get_current_crate ()); } HirId get_next_hir_id (CrateNum crateNum); - + LocalDefId get_next_localdef_id () + { + return get_next_localdef_id (get_current_crate ()); + } LocalDefId get_next_localdef_id (CrateNum crateNum); - AST::Crate *get_ast_crate (CrateNum crateNum); - void insert_ast_crate (AST::Crate *crate); - - HIR::Crate *get_hir_crate (CrateNum crateNum); + AST::Crate &get_ast_crate (CrateNum crateNum); + AST::Crate &get_ast_crate_by_node_id (NodeId id); + AST::Crate &insert_ast_crate (std::unique_ptr &&crate, + CrateNum crate_num); + HIR::Crate &insert_hir_crate (std::unique_ptr &&crate); + HIR::Crate &get_hir_crate (CrateNum crateNum); bool is_local_hirid_crate (HirId crateNum); - void insert_hir_crate (HIR::Crate *crate); void insert_defid_mapping (DefId id, HIR::Item *item); HIR::Item *lookup_defid (DefId id); @@ -132,88 +126,62 @@ public: HIR::Item *item); HIR::Item *lookup_local_defid (CrateNum crateNum, LocalDefId id); - void insert_hir_item (CrateNum crateNum, HirId id, HIR::Item *item); - HIR::Item *lookup_hir_item (CrateNum crateNum, HirId id); - - void insert_hir_trait_item (CrateNum crateNum, HirId id, - HIR::TraitItem *item); - HIR::TraitItem *lookup_hir_trait_item (CrateNum crateNum, HirId id); + void insert_hir_item (HIR::Item *item); + HIR::Item *lookup_hir_item (HirId id); - void insert_hir_extern_item (CrateNum crateNum, HirId id, - HIR::ExternalItem *item); - HIR::ExternalItem *lookup_hir_extern_item (CrateNum crateNum, HirId id); + void insert_hir_trait_item (HIR::TraitItem *item); + HIR::TraitItem *lookup_hir_trait_item (HirId id); - void insert_hir_impl_block (CrateNum crateNum, HirId id, - HIR::ImplBlock *item); - HIR::ImplBlock *lookup_hir_impl_block (CrateNum crateNum, HirId id); + void insert_hir_extern_item (HIR::ExternalItem *item); + HIR::ExternalItem *lookup_hir_extern_item (HirId id); - void insert_module (CrateNum crateNum, HirId id, HIR::Module *module); - HIR::Module *lookup_module (CrateNum crateNum, HirId id); + void insert_hir_impl_block (HIR::ImplBlock *item); + HIR::ImplBlock *lookup_hir_impl_block (HirId id); - void insert_hir_implitem (CrateNum crateNum, HirId id, HirId parent_impl_id, - HIR::ImplItem *item); - HIR::ImplItem *lookup_hir_implitem (CrateNum crateNum, HirId id, - HirId *parent_impl_id); + void insert_module (HIR::Module *module); + HIR::Module *lookup_module (HirId id); - void insert_hir_expr (CrateNum crateNum, HirId id, HIR::Expr *expr); - HIR::Expr *lookup_hir_expr (CrateNum crateNum, HirId id); + void insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item); + HIR::ImplItem *lookup_hir_implitem (HirId id, HirId *parent_impl_id); - void insert_hir_path_expr_seg (CrateNum crateNum, HirId id, - HIR::PathExprSegment *expr); - HIR::PathExprSegment *lookup_hir_path_expr_seg (CrateNum crateNum, HirId id); + void insert_hir_expr (HIR::Expr *expr); + HIR::Expr *lookup_hir_expr (HirId id); - void insert_simple_path_segment (CrateNum crateNum, HirId id, - const AST::SimplePathSegment *path); - const AST::SimplePathSegment *lookup_simple_path_segment (CrateNum crateNum, - HirId id); + void insert_hir_path_expr_seg (HIR::PathExprSegment *expr); + HIR::PathExprSegment *lookup_hir_path_expr_seg (HirId id); - void insert_simple_path (CrateNum crateNum, HirId id, - const AST::SimplePath *path); - const AST::SimplePath *lookup_simple_path (CrateNum crateNum, HirId id); + void insert_hir_generic_param (HIR::GenericParam *expr); + HIR::GenericParam *lookup_hir_generic_param (HirId id); - void insert_hir_generic_param (CrateNum crateNum, HirId id, - HIR::GenericParam *expr); - HIR::GenericParam *lookup_hir_generic_param (CrateNum crateNum, HirId id); + void insert_hir_type (HIR::Type *type); + HIR::Type *lookup_hir_type (HirId id); - void insert_hir_type (CrateNum crateNum, HirId id, HIR::Type *type); - HIR::Type *lookup_hir_type (CrateNum crateNum, HirId id); + void insert_hir_stmt (HIR::Stmt *stmt); + HIR::Stmt *lookup_hir_stmt (HirId id); - void insert_hir_stmt (CrateNum crateNum, HirId id, HIR::Stmt *stmt); - HIR::Stmt *lookup_hir_stmt (CrateNum crateNum, HirId id); + void insert_hir_param (HIR::FunctionParam *type); + HIR::FunctionParam *lookup_hir_param (HirId id); - void insert_hir_param (CrateNum crateNum, HirId id, HIR::FunctionParam *type); - HIR::FunctionParam *lookup_hir_param (CrateNum crateNum, HirId id); + void insert_hir_self_param (HIR::SelfParam *type); + HIR::SelfParam *lookup_hir_self_param (HirId id); - void insert_hir_self_param (CrateNum crateNum, HirId id, - HIR::SelfParam *type); - HIR::SelfParam *lookup_hir_self_param (CrateNum crateNum, HirId id); + void insert_hir_struct_field (HIR::StructExprField *type); + HIR::StructExprField *lookup_hir_struct_field (HirId id); - void insert_hir_struct_field (CrateNum crateNum, HirId id, - HIR::StructExprField *type); - HIR::StructExprField *lookup_hir_struct_field (CrateNum crateNum, HirId id); - - void insert_hir_pattern (CrateNum crateNum, HirId id, HIR::Pattern *pattern); - HIR::Pattern *lookup_hir_pattern (CrateNum crateNum, HirId id); + void insert_hir_pattern (HIR::Pattern *pattern); + HIR::Pattern *lookup_hir_pattern (HirId id); void walk_local_defids_for_crate (CrateNum crateNum, std::function cb); - void insert_node_to_hir (CrateNum crate, NodeId id, HirId ref); - bool lookup_node_to_hir (CrateNum crate, NodeId id, HirId *ref); - bool lookup_hir_to_node (CrateNum crate, HirId id, NodeId *ref); + void insert_node_to_hir (NodeId id, HirId ref); + bool lookup_node_to_hir (NodeId id, HirId *ref); + bool lookup_hir_to_node (HirId id, NodeId *ref); - void insert_location (CrateNum crate, HirId id, Location locus); - Location lookup_location (CrateNum crate, HirId id); - Location lookup_location (HirId id) - { - return lookup_location (get_current_crate (), id); - } + void insert_location (HirId id, Location locus); + Location lookup_location (HirId id); - bool resolve_nodeid_to_stmt (CrateNum crate, NodeId id, HIR::Stmt **stmt); - bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt) - { - return resolve_nodeid_to_stmt (get_current_crate (), id, stmt); - } + bool resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt); std::set &get_hirids_within_crate (CrateNum crate) { @@ -245,8 +213,7 @@ public: bool is_impl_item (HirId id) { HirId parent_impl_block_id = UNKNOWN_HIRID; - return lookup_hir_implitem (get_current_crate (), id, &parent_impl_block_id) - != nullptr; + return lookup_hir_implitem (id, &parent_impl_block_id) != nullptr; } void insert_trait_item_mapping (HirId trait_item_id, HIR::Trait *trait) @@ -263,11 +230,10 @@ public: return lookup->second; } - void insert_canonical_path (CrateNum crate, NodeId id, - const Resolver::CanonicalPath path) + void insert_canonical_path (NodeId id, const Resolver::CanonicalPath path) { const Resolver::CanonicalPath *p = nullptr; - if (lookup_canonical_path (crate, id, &p)) + if (lookup_canonical_path (id, &p)) { // if we have already stored a canonical path this is ok so long as // this new path is equal or is smaller that the existing one but in @@ -281,21 +247,16 @@ public: } } - paths[crate].emplace (id, std::move (path)); + paths.emplace (id, std::move (path)); } - bool lookup_canonical_path (CrateNum crate, NodeId id, - const Resolver::CanonicalPath **path) + bool lookup_canonical_path (NodeId id, const Resolver::CanonicalPath **path) { - auto it = paths.find (crate); + auto it = paths.find (id); if (it == paths.end ()) return false; - auto iy = it->second.find (id); - if (iy == it->second.end ()) - return false; - - *path = &iy->second; + *path = &it->second; return true; } @@ -338,59 +299,46 @@ public: Optional lookup_parent_module (NodeId child_item); bool node_is_module (NodeId query); + void insert_ast_item (AST::Item *item); + bool lookup_ast_item (NodeId id, AST::Item **result); + private: Mappings (); - CrateNum crateNumItr = 0; + CrateNum crateNumItr; CrateNum currentCrateNum; - - std::map hirIdIter; - std::map nodeIdIter; + HirId hirIdIter; + NodeId nodeIdIter; std::map localIdIter; - std::map astCrateMappings; - std::map hirCrateMappings; - + std::map crate_node_to_crate_num; + std::map ast_crate_mappings; + std::map hir_crate_mappings; std::map defIdMappings; std::map> localDefIdMappings; - std::map> hirModuleMappings; - std::map> hirItemMappings; - std::map> hirTypeMappings; - std::map> hirExprMappings; - std::map> hirStmtMappings; - std::map> hirParamMappings; - std::map> - hirStructFieldMappings; - std::map>> - hirImplItemMappings; - std::map> hirSelfParamMappings; + + std::map hirModuleMappings; + std::map hirItemMappings; + std::map hirTypeMappings; + std::map hirExprMappings; + std::map hirStmtMappings; + std::map hirParamMappings; + std::map hirStructFieldMappings; + std::map> hirImplItemMappings; + std::map hirSelfParamMappings; std::map hirImplItemsToImplMappings; - std::map> hirImplBlockMappings; - std::map> hirTraitItemMappings; - std::map> - hirExternItemMappings; - std::map> - astSimplePathMappings; - std::map> - astSimplePathSegmentMappings; - std::map> - hirPathSegMappings; - std::map> - hirGenericParamMappings; + std::map hirImplBlockMappings; + std::map hirTraitItemMappings; + std::map hirExternItemMappings; + std::map hirPathSegMappings; + std::map hirGenericParamMappings; std::map hirTraitItemsToTraitMappings; - std::map> hirPatternMappings; - - // this maps the lang= to DefId mappings + std::map hirPatternMappings; std::map lang_item_mappings; - - // canonical paths - std::map> paths; - - // location info - std::map> locations; - - std::map> nodeIdToHirMappings; - std::map> hirIdToNodeMappings; + std::map paths; + std::map locations; + std::map nodeIdToHirMappings; + std::map hirIdToNodeMappings; // all hirid nodes std::map> hirNodesWithinCrate; @@ -410,6 +358,9 @@ private: std::map> module_child_map; std::map> module_child_items; std::map child_to_parent_module_map; + + // AST mappings + std::map ast_item_mappings; }; } // namespace Analysis