Line data Source code
1 : // Copyright (C) 2020-2026 Free Software Foundation, Inc.
2 :
3 : // This file is part of GCC.
4 :
5 : // GCC is free software; you can redistribute it and/or modify it under
6 : // the terms of the GNU General Public License as published by the Free
7 : // Software Foundation; either version 3, or (at your option) any later
8 : // version.
9 :
10 : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : // for more details.
14 :
15 : // You should have received a copy of the GNU General Public License
16 : // along with GCC; see the file COPYING3. If not see
17 : // <http://www.gnu.org/licenses/>.
18 :
19 : #include "rust-rib.h"
20 : #include "rust-name-resolution-context.h"
21 :
22 : namespace Rust {
23 : namespace Resolver2_0 {
24 :
25 1486964 : Rib::Definition::Definition (NodeId id, Mode mode, bool enum_variant)
26 1486964 : : enum_variant (enum_variant)
27 : {
28 1486964 : switch (mode)
29 : {
30 47735 : case Mode::SHADOWABLE:
31 47735 : ids_shadowable.push_back (id);
32 47735 : return;
33 1439229 : case Mode::NON_SHADOWABLE:
34 1439229 : ids_non_shadowable.push_back (id);
35 1439229 : return;
36 0 : case Mode::GLOBBED:
37 0 : ids_globbed.push_back (id);
38 0 : return;
39 0 : default:
40 0 : gcc_unreachable ();
41 : }
42 : }
43 :
44 : bool
45 1657282 : Rib::Definition::is_ambiguous () const
46 : {
47 1657282 : if (!ids_shadowable.empty ())
48 : return false;
49 1508990 : else if (!ids_non_shadowable.empty ())
50 1242530 : return ids_non_shadowable.size () > 1;
51 : else
52 266460 : return ids_globbed.size () > 1;
53 : }
54 :
55 : bool
56 343818 : Rib::Definition::is_variant () const
57 : {
58 343818 : return enum_variant;
59 : }
60 :
61 : std::string
62 590126620 : Rib::Definition::to_string () const
63 : {
64 590126620 : std::stringstream out;
65 590126620 : const char *headers[3] = {"(S)[", "] (NS)[", "] (G)["};
66 590126620 : const std::vector<NodeId> *id_lists[3]
67 590126620 : = {&ids_shadowable, &ids_non_shadowable, &ids_globbed};
68 2360506480 : for (int i = 0; i < 3; i++)
69 : {
70 1770379860 : out << headers[i];
71 1770379860 : std::string sep;
72 2479342576 : for (auto id : *id_lists[i])
73 : {
74 1417925432 : out << sep << id;
75 708962716 : sep = ",";
76 : }
77 1770379860 : }
78 590126620 : out << "]";
79 590126620 : if (enum_variant)
80 39610 : out << "(enum variant)";
81 590126620 : return out.str ();
82 590126620 : }
83 :
84 : Rib::Definition
85 47735 : Rib::Definition::Shadowable (NodeId id)
86 : {
87 47735 : return Definition (id, Mode::SHADOWABLE, false);
88 : }
89 :
90 : Rib::Definition
91 1439229 : Rib::Definition::NonShadowable (NodeId id, bool enum_variant)
92 : {
93 1439229 : return Definition (id, Mode::NON_SHADOWABLE, enum_variant);
94 : }
95 :
96 : Rib::Definition
97 0 : Rib::Definition::Globbed (NodeId id)
98 : {
99 0 : return Definition (id, Mode::GLOBBED, false);
100 : }
101 :
102 1195771 : DuplicateNameError::DuplicateNameError (std::string name, NodeId existing)
103 1195771 : : name (name), existing (existing)
104 1195771 : {}
105 :
106 122964156 : Rib::Rib (Kind kind) : kind (kind) {}
107 :
108 0 : Rib::Rib (Kind kind, std::string identifier, NodeId id)
109 0 : : Rib (kind, {{identifier, id}})
110 0 : {}
111 :
112 0 : Rib::Rib (Kind kind, std::unordered_map<std::string, NodeId> to_insert)
113 0 : : kind (kind)
114 : {
115 0 : for (auto &value : to_insert)
116 0 : values.insert ({value.first, Definition::NonShadowable (value.second)});
117 0 : }
118 :
119 : tl::expected<NodeId, DuplicateNameError>
120 1429595 : Rib::insert (std::string name, Definition def)
121 : {
122 1429595 : auto it = values.find (name);
123 1429595 : if (it == values.end ())
124 : {
125 : /* No old value */
126 233380 : values[name] = def;
127 : }
128 1196215 : else if (it->second.ids_non_shadowable.empty ()
129 1196215 : || def.ids_non_shadowable.empty ())
130 : { /* No non-shadowable conflict */
131 2380 : auto ¤t = values[name];
132 2446 : for (auto id : def.ids_non_shadowable)
133 : {
134 132 : if (std::find (current.ids_non_shadowable.cbegin (),
135 : current.ids_non_shadowable.cend (), id)
136 132 : == current.ids_non_shadowable.cend ())
137 66 : current.ids_non_shadowable.push_back (id);
138 : else
139 : // TODO: should this produce an error?
140 0 : return tl::make_unexpected (DuplicateNameError (name, id));
141 : }
142 2758 : for (auto id : def.ids_shadowable)
143 : {
144 4628 : if (std::find (current.ids_shadowable.cbegin (),
145 : current.ids_shadowable.cend (), id)
146 4628 : == current.ids_shadowable.cend ())
147 378 : current.ids_shadowable.push_back (id);
148 : else
149 : // TODO: should this produce an error?
150 3872 : return tl::make_unexpected (DuplicateNameError (name, id));
151 : }
152 444 : for (auto id : def.ids_globbed)
153 : {
154 0 : if (std::find (current.ids_globbed.cbegin (),
155 : current.ids_globbed.cend (), id)
156 0 : == current.ids_globbed.cend ())
157 0 : current.ids_globbed.push_back (id);
158 : else
159 : // TODO: should this produce an error?
160 0 : return tl::make_unexpected (DuplicateNameError (name, id));
161 : }
162 : }
163 : else /* Multiple non-shadowable */
164 : {
165 3581505 : return tl::make_unexpected (
166 4775340 : DuplicateNameError (name, it->second.ids_non_shadowable.back ()));
167 : }
168 :
169 233824 : if (!def.ids_shadowable.empty ())
170 45799 : return def.ids_shadowable.back ();
171 188025 : else if (!def.ids_non_shadowable.empty ())
172 188025 : return def.ids_non_shadowable.back ();
173 0 : rust_assert (!def.ids_globbed.empty ());
174 0 : return def.ids_globbed.back ();
175 : }
176 :
177 : bool
178 4891458 : Rib::insert_globbed (std::string name, const Definition &def)
179 : {
180 4891458 : bool dirty = false;
181 :
182 4891458 : const std::vector<NodeId> *ids_src;
183 :
184 4891458 : if (!def.ids_shadowable.empty ())
185 315031 : ids_src = &def.ids_shadowable;
186 4576427 : else if (!def.ids_non_shadowable.empty ())
187 500528 : ids_src = &def.ids_non_shadowable;
188 : else
189 4075899 : ids_src = &def.ids_globbed;
190 :
191 4891458 : auto it = values.find (name);
192 4891458 : if (it == values.end ())
193 : {
194 77685 : values[name].ids_globbed = *ids_src;
195 77685 : return true;
196 : }
197 :
198 9704054 : for (NodeId id : *ids_src)
199 : {
200 4890281 : auto &ids_dst = it->second.ids_globbed;
201 9780562 : if (std::find (ids_dst.cbegin (), ids_dst.cend (), id) == ids_dst.cend ())
202 : {
203 3116 : dirty = true;
204 3116 : ids_dst.push_back (id);
205 : }
206 : }
207 :
208 4813773 : return dirty;
209 : }
210 :
211 : tl::optional<Rib::Definition>
212 3569250 : Rib::get (const std::string &name)
213 : {
214 3569250 : auto it = values.find (name);
215 :
216 3569250 : if (it == values.end ())
217 3134002 : return tl::nullopt;
218 :
219 435248 : return it->second;
220 : }
221 :
222 : const std::unordered_map<std::string, Rib::Definition> &
223 61540680 : Rib::get_values () const
224 : {
225 61540680 : return values;
226 : }
227 :
228 : } // namespace Resolver2_0
229 : } // namespace Rust
|
