1 // Copyright (C) 2020-2023 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 #ifndef RUST_AST_RESOLVE_STMT_H
20 #define RUST_AST_RESOLVE_STMT_H
21
22 #include "rust-ast-resolve-base.h"
23 #include "rust-ast-full.h"
24 #include "rust-ast-resolve-type.h"
25 #include "rust-ast-resolve-pattern.h"
26 #include "rust-ast-resolve-expr.h"
27
28 namespace Rust {
29 namespace Resolver {
30
31 class ResolveStmt : public ResolverBase
32 {
33 using Rust::Resolver::ResolverBase::visit;
34
35 public:
36 static void go (AST::Stmt *stmt, const CanonicalPath &prefix,
37 const CanonicalPath &canonical_prefix,
38 const CanonicalPath &enum_prefix)
39 {
40 if (stmt->is_marked_for_strip ())
41 return;
42
43 ResolveStmt resolver (prefix, canonical_prefix, enum_prefix);
44 stmt->accept_vis (resolver);
45 }
46
47 void visit (AST::ExprStmtWithBlock &stmt) override
48 {
49 ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
50 }
51
52 void visit (AST::ExprStmtWithoutBlock &stmt) override
53 {
54 ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
55 }
56
57 void visit (AST::ConstantItem &constant) override
58 {
59 auto decl = CanonicalPath::new_seg (constant.get_node_id (),
60 constant.get_identifier ());
61 auto path = decl; // this ensures we have the correct relative resolution
62 auto cpath = canonical_prefix.append (decl);
63 mappings->insert_canonical_path (constant.get_node_id (), cpath);
64
65 resolver->get_name_scope ().insert (
66 path, constant.get_node_id (), constant.get_locus (), false,
67 Rib::ItemType::Const,
68 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
69 RichLocation r (constant.get_locus ());
70 r.add_range (locus);
71 rust_error_at (r, "redefined multiple times");
72 });
73
74 ResolveType::go (constant.get_type ().get ());
75 ResolveExpr::go (constant.get_expr ().get (), prefix, canonical_prefix);
76 }
77
78 void visit (AST::LetStmt &stmt) override
79 {
80 if (stmt.has_init_expr ())
81 {
82 ResolveExpr::go (stmt.get_init_expr ().get (), prefix,
83 canonical_prefix);
84 }
85
86 PatternDeclaration::go (stmt.get_pattern ().get (), Rib::ItemType::Var);
87 if (stmt.has_type ())
88 ResolveType::go (stmt.get_type ().get ());
89 }
90
91 void visit (AST::TupleStruct &struct_decl) override
92 {
93 auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (),
94 struct_decl.get_identifier ());
95 auto path = decl; // this ensures we have the correct relative resolution
96 auto cpath = canonical_prefix.append (decl);
97 mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
98
99 resolver->get_type_scope ().insert (
100 path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
101 Rib::ItemType::Type,
102 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
103 RichLocation r (struct_decl.get_locus ());
104 r.add_range (locus);
105 rust_error_at (r, "redefined multiple times");
106 });
107
108 NodeId scope_node_id = struct_decl.get_node_id ();
109 resolver->get_type_scope ().push (scope_node_id);
110
111 if (struct_decl.has_generics ())
112 {
113 for (auto &generic : struct_decl.get_generic_params ())
114 ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
115 }
116
117 for (AST::TupleField &field : struct_decl.get_fields ())
118 ResolveType::go (field.get_field_type ().get ());
119
120 resolver->get_type_scope ().pop ();
121 }
122
123 void visit (AST::Enum &enum_decl) override
124 {
125 auto decl = CanonicalPath::new_seg (enum_decl.get_node_id (),
126 enum_decl.get_identifier ());
127 auto path = decl; // this ensures we have the correct relative resolution
128 auto cpath = canonical_prefix.append (decl);
129 mappings->insert_canonical_path (enum_decl.get_node_id (), cpath);
130
131 resolver->get_type_scope ().insert (
132 path, enum_decl.get_node_id (), enum_decl.get_locus (), false,
133 Rib::ItemType::Type,
134 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
135 RichLocation r (enum_decl.get_locus ());
136 r.add_range (locus);
137 rust_error_at (r, "redefined multiple times");
138 });
139
140 NodeId scope_node_id = enum_decl.get_node_id ();
141 resolver->get_type_scope ().push (scope_node_id);
142
143 if (enum_decl.has_generics ())
144 {
145 for (auto &generic : enum_decl.get_generic_params ())
146 ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
147 }
148
149 for (auto &variant : enum_decl.get_variants ())
150 ResolveStmt::go (variant.get (), path, canonical_prefix, path);
151
152 resolver->get_type_scope ().pop ();
153 }
154
155 void visit (AST::EnumItem &item) override
156 {
157 auto decl = enum_prefix.append (
158 CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
159 auto path = decl; // this ensures we have the correct relative resolution
160 auto cpath = canonical_prefix.append (decl);
161 mappings->insert_canonical_path (item.get_node_id (), cpath);
162
163 resolver->get_type_scope ().insert (
164 path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
165 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
166 RichLocation r (item.get_locus ());
167 r.add_range (locus);
168 rust_error_at (r, "redefined multiple times");
169 });
170
171 // Done, no fields.
172 }
173
174 void visit (AST::EnumItemTuple &item) override
175 {
176 auto decl = enum_prefix.append (
177 CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
178 auto path = decl; // this ensures we have the correct relative resolution
179 auto cpath = canonical_prefix.append (decl);
180 mappings->insert_canonical_path (item.get_node_id (), cpath);
181
182 resolver->get_type_scope ().insert (
183 path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
184 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
185 RichLocation r (item.get_locus ());
186 r.add_range (locus);
187 rust_error_at (r, "redefined multiple times");
188 });
189
190 for (auto &field : item.get_tuple_fields ())
191 {
192 if (field.get_field_type ()->is_marked_for_strip ())
193 continue;
194
195 ResolveType::go (field.get_field_type ().get ());
196 }
197 }
198
199 void visit (AST::EnumItemStruct &item) override
200 {
201 auto decl = enum_prefix.append (
202 CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
203 auto path = decl; // this ensures we have the correct relative resolution
204 auto cpath = canonical_prefix.append (decl);
205 mappings->insert_canonical_path (item.get_node_id (), cpath);
206
207 resolver->get_type_scope ().insert (
208 path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
209 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
210 RichLocation r (item.get_locus ());
211 r.add_range (locus);
212 rust_error_at (r, "redefined multiple times");
213 });
214
215 for (auto &field : item.get_struct_fields ())
216 {
217 if (field.get_field_type ()->is_marked_for_strip ())
218 continue;
219
220 ResolveType::go (field.get_field_type ().get ());
221 }
222 }
223
224 void visit (AST::EnumItemDiscriminant &item) override
225 {
226 auto decl = enum_prefix.append (
227 CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
228 auto path = decl; // this ensures we have the correct relative resolution
229 auto cpath = canonical_prefix.append (decl);
230 mappings->insert_canonical_path (item.get_node_id (), cpath);
231
232 resolver->get_type_scope ().insert (
233 path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
234 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
235 RichLocation r (item.get_locus ());
236 r.add_range (locus);
237 rust_error_at (r, "redefined multiple times");
238 });
239
240 // Done, no fields.
241 }
242
243 void visit (AST::StructStruct &struct_decl) override
244 {
245 auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (),
246 struct_decl.get_identifier ());
247 auto path = decl; // this ensures we have the correct relative resolution
248 auto cpath = canonical_prefix.append (decl);
249 mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
250
251 resolver->get_type_scope ().insert (
252 path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
253 Rib::ItemType::Type,
254 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
255 RichLocation r (struct_decl.get_locus ());
256 r.add_range (locus);
257 rust_error_at (r, "redefined multiple times");
258 });
259
260 NodeId scope_node_id = struct_decl.get_node_id ();
261 resolver->get_type_scope ().push (scope_node_id);
262
263 if (struct_decl.has_generics ())
264 {
265 for (auto &generic : struct_decl.get_generic_params ())
266 ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
267 }
268
269 for (AST::StructField &field : struct_decl.get_fields ())
270 {
271 if (field.get_field_type ()->is_marked_for_strip ())
272 continue;
273
274 ResolveType::go (field.get_field_type ().get ());
275 }
276
277 resolver->get_type_scope ().pop ();
278 }
279
280 void visit (AST::Union &union_decl) override
281 {
282 auto decl = CanonicalPath::new_seg (union_decl.get_node_id (),
283 union_decl.get_identifier ());
284 auto path = decl; // this ensures we have the correct relative resolution
285 auto cpath = canonical_prefix.append (decl);
286 mappings->insert_canonical_path (union_decl.get_node_id (), cpath);
287
288 resolver->get_type_scope ().insert (
289 path, union_decl.get_node_id (), union_decl.get_locus (), false,
290 Rib::ItemType::Type,
291 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
292 RichLocation r (union_decl.get_locus ());
293 r.add_range (locus);
294 rust_error_at (r, "redefined multiple times");
295 });
296
297 NodeId scope_node_id = union_decl.get_node_id ();
298 resolver->get_type_scope ().push (scope_node_id);
299
300 if (union_decl.has_generics ())
301 for (auto &generic : union_decl.get_generic_params ())
302 ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
303
304 for (AST::StructField &field : union_decl.get_variants ())
305 {
306 if (field.get_field_type ()->is_marked_for_strip ())
307 continue;
308
309 ResolveType::go (field.get_field_type ().get ());
310 }
311
312 resolver->get_type_scope ().pop ();
313 }
314
315 void visit (AST::Function &function) override
316 {
317 auto decl = CanonicalPath::new_seg (function.get_node_id (),
318 function.get_function_name ());
319 auto path = decl; // this ensures we have the correct relative resolution
320 auto cpath = canonical_prefix.append (decl);
321 mappings->insert_canonical_path (function.get_node_id (), cpath);
322
323 resolver->get_name_scope ().insert (
324 path, function.get_node_id (), function.get_locus (), false,
325 Rib::ItemType::Function,
326 [&] (const CanonicalPath &, NodeId, Location locus) -> void {
327 RichLocation r (function.get_locus ());
328 r.add_range (locus);
329 rust_error_at (r, "redefined multiple times");
330 });
331
332 NodeId scope_node_id = function.get_node_id ();
333 resolver->get_name_scope ().push (scope_node_id);
334 resolver->get_type_scope ().push (scope_node_id);
335 resolver->get_label_scope ().push (scope_node_id);
336 resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
337 resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
338 resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
339
340 if (function.has_generics ())
341 for (auto &generic : function.get_generic_params ())
342 ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
343
344 if (function.has_return_type ())
345 ResolveType::go (function.get_return_type ().get ());
346
347 // we make a new scope so the names of parameters are resolved and shadowed
348 // correctly
349 for (auto ¶m : function.get_function_params ())
350 {
351 ResolveType::go (param.get_type ().get ());
352 PatternDeclaration::go (param.get_pattern ().get (),
353 Rib::ItemType::Param);
354 }
355
356 // resolve the function body
357 ResolveExpr::go (function.get_definition ().get (), path, cpath);
358
359 resolver->get_name_scope ().pop ();
360 resolver->get_type_scope ().pop ();
361 resolver->get_label_scope ().pop ();
362 }
363
364 void visit (AST::ExternBlock &extern_block) override;
365
366 private:
367 ResolveStmt (const CanonicalPath &prefix,
368 const CanonicalPath &canonical_prefix,
369 const CanonicalPath &enum_prefix)
370 : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix),
371 enum_prefix (enum_prefix)
372 {}
373
374 const CanonicalPath &prefix;
375 const CanonicalPath &canonical_prefix;
376
377 /* item declaration statements are not given a canonical path, but enum items
378 * (variants) do inherit the enum path/identifier name. */
379 const CanonicalPath &enum_prefix;
380 };
381
382 } // namespace Resolver
383 } // namespace Rust
384
385 #endif // RUST_AST_RESOLVE_STMT_H