| // Copyright (C) 2020-2026 Free Software Foundation, Inc. | |
| // This file is part of GCC. | |
| // GCC is free software; you can redistribute it and/or modify it under | |
| // the terms of the GNU General Public License as published by the Free | |
| // Software Foundation; either version 3, or (at your option) any later | |
| // version. | |
| // GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| // WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| // for more details. | |
| // You should have received a copy of the GNU General Public License | |
| // along with GCC; see the file COPYING3. If not see | |
| // <http://www.gnu.org/licenses/>. | |
| #include "rust-rib.h" | |
| #include "rust-name-resolution-context.h" | |
| namespace Rust { | |
| namespace Resolver2_0 { | |
| Rib::Definition::Definition (NodeId id, Mode mode, bool enum_variant) | |
| : enum_variant (enum_variant) | |
| { | |
| switch (mode) | |
| { | |
| case Mode::SHADOWABLE: | |
| ids_shadowable.push_back (id); | |
| return; | |
| case Mode::NON_SHADOWABLE: | |
| ids_non_shadowable.push_back (id); | |
| return; | |
| case Mode::GLOBBED: | |
| ids_globbed.push_back (id); | |
| return; | |
| default: | |
| gcc_unreachable (); | |
| } | |
| } | |
| bool | |
| Rib::Definition::is_ambiguous () const | |
| { | |
| if (!ids_shadowable.empty ()) | |
| return false; | |
| else if (!ids_non_shadowable.empty ()) | |
| return ids_non_shadowable.size () > 1; | |
| else | |
| return ids_globbed.size () > 1; | |
| } | |
| bool | |
| Rib::Definition::is_variant () const | |
| { | |
| return enum_variant; | |
| } | |
| std::string | |
| Rib::Definition::to_string () const | |
| { | |
| std::stringstream out; | |
| const char *headers[3] = {"(S)[", "] (NS)[", "] (G)["}; | |
| const std::vector<NodeId> *id_lists[3] | |
| = {&ids_shadowable, &ids_non_shadowable, &ids_globbed}; | |
| for (int i = 0; i < 3; i++) | |
| { | |
| out << headers[i]; | |
| std::string sep; | |
| for (auto id : *id_lists[i]) | |
| { | |
| out << sep << id; | |
| sep = ","; | |
| } | |
| } | |
| out << "]"; | |
| if (enum_variant) | |
| out << "(enum variant)"; | |
| return out.str (); | |
| } | |
| Rib::Definition | |
| Rib::Definition::Shadowable (NodeId id) | |
| { | |
| return Definition (id, Mode::SHADOWABLE, false); | |
| } | |
| Rib::Definition | |
| Rib::Definition::NonShadowable (NodeId id, bool enum_variant) | |
| { | |
| return Definition (id, Mode::NON_SHADOWABLE, enum_variant); | |
| } | |
| Rib::Definition | |
| Rib::Definition::Globbed (NodeId id) | |
| { | |
| return Definition (id, Mode::GLOBBED, false); | |
| } | |
| DuplicateNameError::DuplicateNameError (std::string name, NodeId existing) | |
| : name (name), existing (existing) | |
| {} | |
| Rib::Rib (Kind kind) : kind (kind) {} | |
| Rib::Rib (Kind kind, std::string identifier, NodeId id) | |
| : Rib (kind, {{identifier, id}}) | |
| {} | |
| Rib::Rib (Kind kind, std::unordered_map<std::string, NodeId> to_insert) | |
| : kind (kind) | |
| { | |
| for (auto &value : to_insert) | |
| values.insert ({value.first, Definition::NonShadowable (value.second)}); | |
| } | |
| tl::expected<NodeId, DuplicateNameError> | |
| Rib::insert (std::string name, Definition def) | |
| { | |
| auto it = values.find (name); | |
| if (it == values.end ()) | |
| { | |
| /* No old value */ | |
| values[name] = def; | |
| } | |
| else if (it->second.ids_non_shadowable.empty () | |
| || def.ids_non_shadowable.empty ()) | |
| { /* No non-shadowable conflict */ | |
| auto ¤t = values[name]; | |
| for (auto id : def.ids_non_shadowable) | |
| { | |
| if (std::find (current.ids_non_shadowable.cbegin (), | |
| current.ids_non_shadowable.cend (), id) | |
| == current.ids_non_shadowable.cend ()) | |
| current.ids_non_shadowable.push_back (id); | |
| else | |
| // TODO: should this produce an error? | |
| return tl::make_unexpected (DuplicateNameError (name, id)); | |
| } | |
| for (auto id : def.ids_shadowable) | |
| { | |
| if (std::find (current.ids_shadowable.cbegin (), | |
| current.ids_shadowable.cend (), id) | |
| == current.ids_shadowable.cend ()) | |
| current.ids_shadowable.push_back (id); | |
| else | |
| // TODO: should this produce an error? | |
| return tl::make_unexpected (DuplicateNameError (name, id)); | |
| } | |
| for (auto id : def.ids_globbed) | |
| { | |
| if (std::find (current.ids_globbed.cbegin (), | |
| current.ids_globbed.cend (), id) | |
| == current.ids_globbed.cend ()) | |
| current.ids_globbed.push_back (id); | |
| else | |
| // TODO: should this produce an error? | |
| return tl::make_unexpected (DuplicateNameError (name, id)); | |
| } | |
| } | |
| else /* Multiple non-shadowable */ | |
| { | |
| return tl::make_unexpected ( | |
| DuplicateNameError (name, it->second.ids_non_shadowable.back ())); | |
| } | |
| if (!def.ids_shadowable.empty ()) | |
| return def.ids_shadowable.back (); | |
| else if (!def.ids_non_shadowable.empty ()) | |
| return def.ids_non_shadowable.back (); | |
| rust_assert (!def.ids_globbed.empty ()); | |
| return def.ids_globbed.back (); | |
| } | |
| bool | |
| Rib::insert_globbed (std::string name, const Definition &def) | |
| { | |
| bool dirty = false; | |
| const std::vector<NodeId> *ids_src; | |
| if (!def.ids_shadowable.empty ()) | |
| ids_src = &def.ids_shadowable; | |
| else if (!def.ids_non_shadowable.empty ()) | |
| ids_src = &def.ids_non_shadowable; | |
| else | |
| ids_src = &def.ids_globbed; | |
| auto it = values.find (name); | |
| if (it == values.end ()) | |
| { | |
| values[name].ids_globbed = *ids_src; | |
| return true; | |
| } | |
| for (NodeId id : *ids_src) | |
| { | |
| auto &ids_dst = it->second.ids_globbed; | |
| if (std::find (ids_dst.cbegin (), ids_dst.cend (), id) == ids_dst.cend ()) | |
| { | |
| dirty = true; | |
| ids_dst.push_back (id); | |
| } | |
| } | |
| return dirty; | |
| } | |
| tl::optional<Rib::Definition> | |
| Rib::get (const std::string &name) | |
| { | |
| auto it = values.find (name); | |
| if (it == values.end ()) | |
| return tl::nullopt; | |
| return it->second; | |
| } | |
| const std::unordered_map<std::string, Rib::Definition> & | |
| Rib::get_values () const | |
| { | |
| return values; | |
| } | |
| } // namespace Resolver2_0 | |
| } // namespace Rust |