https://gcc.gnu.org/g:bbd898585a4124f18cf3005cb49c9b3882aac35f
commit r17-5165-gbbd898585a4124f18cf3005cb49c9b3882aac35f Author: Pierre-Emmanuel Patry <[email protected]> Date: Thu Sep 24 02:24:00 2026 +0200 gccrs: Move proc macro crate mapping to crate mappings Some mapping getters were using the crate num for their key, just like any other mapping within the CrateMappings. Move them over there for consistency. Also modifies the crate mapping name to make use of the Mapping class instead of relying on separate insert/lookup function implementation. gcc/rust/ChangeLog: * checks/errors/borrowck/rust-borrow-checker.cc (BorrowChecker::go): Update function call name. * expand/rust-macro-substitute-ctx.cc: Likewise. * resolve/rust-default-resolver.cc (DefaultResolver::visit): Likewise. * resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit_extern_crate): Likewise. * rust-session-manager.cc (Session::load_extern_crate): Likewise. * util/rust-hir-map.cc (CrateMappings::get_next_crate_num): Likewise. (CrateMappings::get_crate_name): Remove. (CrateMappings::set_crate_name): Remove. (CrateMappings::get_current_crate_name): Update with new lookup function. (CrateMappings::lookup_crate_name): Use internal storage getter. (ProcMacroMappings::insert_bang_proc_macros): Remove. (ProcMacroMappings::lookup_derive_proc_macros): Remove. (ProcMacroMappings::lookup_bang_proc_macros): Remove. (ProcMacroMappings::lookup_attribute_proc_macros): Remove. * util/rust-hir-map.h (enum class): Move enum. (class Mapping): Add a getter to const storage in order to allow iteration on existing mappings. Also add a const getter. (class CrateMappings): Add proc macro crate mappings. Convert crate_name getter/setter to Mapping. (class ProcMacroMappings): Remove crate related mappings. Signed-off-by: Pierre-Emmanuel Patry <[email protected]> Diff: --- .../checks/errors/borrowck/rust-borrow-checker.cc | 2 +- gcc/rust/expand/rust-macro-substitute-ctx.cc | 2 +- gcc/rust/resolve/rust-default-resolver.cc | 2 +- .../resolve/rust-toplevel-name-resolver-2.0.cc | 6 +- gcc/rust/rust-session-manager.cc | 6 +- gcc/rust/util/rust-hir-map.cc | 82 +--------------- gcc/rust/util/rust-hir-map.h | 103 ++++++++++++--------- 7 files changed, 71 insertions(+), 132 deletions(-) diff --git a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc index 16b8f76a8a1c..d04699fc244d 100644 --- a/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc +++ b/gcc/rust/checks/errors/borrowck/rust-borrow-checker.cc @@ -55,7 +55,7 @@ BorrowChecker::go (HIR::Crate &crate) { mkdir ("bir_dump", 0755); auto &mappings = Analysis::Mappings::get (); - crate_name = *mappings.crate.get_crate_name ( + crate_name = *mappings.crate.crate_names.lookup ( crate.get_mappings ().get_crate_num ()); mkdir ("nll_facts_gccrs", 0755); } diff --git a/gcc/rust/expand/rust-macro-substitute-ctx.cc b/gcc/rust/expand/rust-macro-substitute-ctx.cc index 5fa21e64f231..b199860413c5 100644 --- a/gcc/rust/expand/rust-macro-substitute-ctx.cc +++ b/gcc/rust/expand/rust-macro-substitute-ctx.cc @@ -44,7 +44,7 @@ SubstituteCtx::substitute_dollar_crate ( } else { - auto name = mappings.crate.get_crate_name (*def_crate); + auto name = mappings.crate.crate_names.lookup (*def_crate); rust_assert (name); diff --git a/gcc/rust/resolve/rust-default-resolver.cc b/gcc/rust/resolve/rust-default-resolver.cc index 585df8979f6c..cbfd84ac2eb7 100644 --- a/gcc/rust/resolve/rust-default-resolver.cc +++ b/gcc/rust/resolve/rust-default-resolver.cc @@ -45,7 +45,7 @@ DefaultResolver::visit (AST::Crate &crate) auto crate_num = crate_mappings.lookup_crate_num (crate.get_node_id ()); rust_assert (crate_num.has_value ()); - auto crate_name = crate_mappings.get_crate_name (*crate_num); + auto crate_name = crate_mappings.crate_names.lookup (*crate_num); rust_assert (crate_name.has_value ()); ctx.canonical_ctx.scope_crate (crate.get_node_id (), *crate_name, inner_fn); diff --git a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc index 0e4172239435..d92e5e2a4b48 100644 --- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc +++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc @@ -187,11 +187,11 @@ TopLevel::visit_extern_crate (AST::ExternCrate &extern_crate, AST::Crate &crate, { auto &mappings = Analysis::Mappings::get (); - auto attribute_macros = mappings.pmacro.lookup_attribute_proc_macros (num); + auto attribute_macros = mappings.crate.attributes.lookup (num); - auto bang_macros = mappings.pmacro.lookup_bang_proc_macros (num); + auto bang_macros = mappings.crate.bangs.lookup (num); - auto derive_macros = mappings.pmacro.lookup_derive_proc_macros (num); + auto derive_macros = mappings.crate.derives.lookup (num); // TODO: Find a way to keep this part clean without the double dispatch. if (derive_macros.has_value ()) diff --git a/gcc/rust/rust-session-manager.cc b/gcc/rust/rust-session-manager.cc index e12147700ce9..8d7dde39b90f 100644 --- a/gcc/rust/rust-session-manager.cc +++ b/gcc/rust/rust-session-manager.cc @@ -1364,9 +1364,9 @@ Session::load_extern_crate (const std::string &crate_name, location_t locus) } } - mappings.pmacro.insert_attribute_proc_macros (crate_num, attribute_macros); - mappings.pmacro.insert_bang_proc_macros (crate_num, bang_macros); - mappings.pmacro.insert_derive_proc_macros (crate_num, derive_macros); + mappings.crate.attributes.insert (crate_num, attribute_macros); + mappings.crate.bangs.insert (crate_num, bang_macros); + mappings.crate.derives.insert (crate_num, derive_macros); // always restore the crate_num crate_mapping.set_current_crate (saved_crate_num); diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 2b4ee2731298..59c8bed8ff07 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -128,7 +128,7 @@ CrateMappings::get_next_crate_num (const std::string &name) { auto id = crateNumItr; crateNumItr++; - set_crate_name (id, name); + crate_names.insert (id, name); return id; } @@ -144,16 +144,6 @@ CrateMappings::get_current_crate () const return currentCrateNum; } -tl::optional<const std::string &> -CrateMappings::get_crate_name (CrateNum crate_num) const -{ - auto it = crate_names.find (crate_num); - if (it == crate_names.end ()) - return tl::nullopt; - - return it->second; -} - tl::optional<CrateNum> CrateMappings::lookup_crate_num (NodeId node_id) const { @@ -164,22 +154,16 @@ CrateMappings::lookup_crate_num (NodeId node_id) const return it->second; } -void -CrateMappings::set_crate_name (CrateNum crate_num, const std::string &name) -{ - crate_names[crate_num] = name; -} - const std::string & CrateMappings::get_current_crate_name () const { - return get_crate_name (get_current_crate ()).value (); + return crate_names.lookup (get_current_crate ()).value (); } tl::optional<CrateNum> CrateMappings::lookup_crate_name (const std::string &crate_name) const { - for (const auto &it : crate_names) + for (const auto &it : crate_names.get_storage ()) { if (it.second.compare (crate_name) == 0) return it.first; @@ -871,66 +855,6 @@ Mappings::get_exported_macros () return exportedMacros; } -void -ProcMacroMappings::insert_derive_proc_macros ( - CrateNum num, std::vector<CustomDeriveProcMacro> macros) -{ - auto it = deriveMappings.find (num); - rust_assert (it == deriveMappings.end ()); - - deriveMappings[num] = macros; -} - -void -ProcMacroMappings::insert_bang_proc_macros (CrateNum num, - std::vector<BangProcMacro> macros) -{ - auto it = bangMappings.find (num); - rust_assert (it == bangMappings.end ()); - - bangMappings[num] = macros; -} - -void -ProcMacroMappings::insert_attribute_proc_macros ( - CrateNum num, std::vector<AttributeProcMacro> macros) -{ - auto it = attributeMappings.find (num); - rust_assert (it == attributeMappings.end ()); - - attributeMappings[num] = macros; -} - -tl::optional<std::vector<CustomDeriveProcMacro> &> -ProcMacroMappings::lookup_derive_proc_macros (CrateNum num) -{ - auto it = deriveMappings.find (num); - if (it == deriveMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional<std::vector<BangProcMacro> &> -ProcMacroMappings::lookup_bang_proc_macros (CrateNum num) -{ - auto it = bangMappings.find (num); - if (it == bangMappings.end ()) - return tl::nullopt; - - return it->second; -} - -tl::optional<std::vector<AttributeProcMacro> &> -ProcMacroMappings::lookup_attribute_proc_macros (CrateNum num) -{ - auto it = attributeMappings.find (num); - if (it == attributeMappings.end ()) - return tl::nullopt; - - return it->second; -} - void ProcMacroMappings::insert_derive_def (CustomDeriveProcMacro macro) { diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 638b16155f24..e22a067dde52 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -71,13 +71,56 @@ private: LocalDefId localDefId; }; +enum class InsertionPolicy +{ + FORBID_DUPLICATES, + ALLOW_DUPLICATES, +}; + +template <typename Id, typename Item, + const InsertionPolicy insertion_policy + = InsertionPolicy::ALLOW_DUPLICATES> +class Mapping +{ + std::unordered_map<Id, Item> storage; + +public: + tl::optional<Item &> lookup (Id id) + { + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; + } + + tl::optional<const Item &> lookup (Id id) const + { + auto it = storage.find (id); + if (it == storage.cend ()) + return tl::nullopt; + return it->second; + } + + void insert (Id id, Item item) + { + if (insertion_policy == InsertionPolicy::FORBID_DUPLICATES) + { + auto it = storage.find (id); + rust_assert (it == storage.end ()); + } + + storage.insert ({id, item}); + } + + // Required for CrateMappings::lookup_crate_name. Should we make mappings a + // bimap instead ? + const decltype (storage) &get_storage () const { return storage; } +}; + class CrateMappings { std::map<CrateNum, AST::Crate *> ast_crate_mappings; - // crate names - std::map<CrateNum, std::string> crate_names; - CrateNum crateNumItr; CrateNum currentCrateNum; @@ -90,10 +133,8 @@ public: CrateNum get_next_crate_num (const std::string &name); void set_current_crate (CrateNum crateNum); CrateNum get_current_crate () const; - tl::optional<const std::string &> get_crate_name (CrateNum crate_num) const; tl::optional<CrateNum> lookup_crate_num (NodeId node_id) const; - void set_crate_name (CrateNum crate_num, const std::string &name); const std::string &get_current_crate_name () const; tl::optional<CrateNum> lookup_crate_name (const std::string &crate_name) const; @@ -106,14 +147,23 @@ public: AST::Crate &get_ast_crate (CrateNum crateNum); AST::Crate *get_ast_crate_by_node_id_raw (NodeId id); + + Mapping<CrateNum, std::vector<CustomDeriveProcMacro>, + InsertionPolicy::FORBID_DUPLICATES> + derives; + Mapping<CrateNum, std::vector<BangProcMacro>, + InsertionPolicy::FORBID_DUPLICATES> + bangs; + Mapping<CrateNum, std::vector<AttributeProcMacro>, + InsertionPolicy::FORBID_DUPLICATES> + attributes; + + Mapping<CrateNum, std::string, InsertionPolicy::FORBID_DUPLICATES> + crate_names; }; class ProcMacroMappings { - std::map<CrateNum, std::vector<CustomDeriveProcMacro>> deriveMappings; - std::map<CrateNum, std::vector<BangProcMacro>> bangMappings; - std::map<CrateNum, std::vector<AttributeProcMacro>> attributeMappings; - std::map<NodeId, CustomDeriveProcMacro> procmacroDeriveMappings; std::map<NodeId, BangProcMacro> procmacroBangMappings; std::map<NodeId, AttributeProcMacro> procmacroAttributeMappings; @@ -122,20 +172,6 @@ class ProcMacroMappings std::map<NodeId, AttributeProcMacro> procmacroAttributeInvocations; public: - void insert_derive_proc_macros (CrateNum num, - std::vector<CustomDeriveProcMacro> macros); - void insert_bang_proc_macros (CrateNum num, - std::vector<BangProcMacro> macros); - void insert_attribute_proc_macros (CrateNum num, - std::vector<AttributeProcMacro> macros); - - tl::optional<std::vector<CustomDeriveProcMacro> &> - lookup_derive_proc_macros (CrateNum num); - tl::optional<std::vector<BangProcMacro> &> - lookup_bang_proc_macros (CrateNum num); - tl::optional<std::vector<AttributeProcMacro> &> - lookup_attribute_proc_macros (CrateNum num); - void insert_derive_def (CustomDeriveProcMacro macro); void insert_bang_def (BangProcMacro macro); void insert_attribute_def (AttributeProcMacro macro); @@ -157,27 +193,6 @@ public: AttributeProcMacro def); }; -template <typename Id, typename Item> class Mapping -{ - std::unordered_map<Id, Item> storage; - -public: - tl::optional<Item &> lookup (Id id) - { - auto it = storage.find (id); - if (it == storage.cend ()) - return tl::nullopt; - return it->second; - } - void insert (Id id, Item item) { storage.insert ({id, item}); } -}; - -enum class InsertionPolicy -{ - FORBID_DUPLICATES, - ALLOW_DUPLICATES, -}; - enum class InsertLocation { YES,
