Branch data Line data Source code
1 : : // Copyright (C) 2020-2024 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-ast-lower-item.h"
20 : : #include "rust-diagnostics.h"
21 : : #include "rust-ast-lower.h"
22 : : #include "rust-ast-lower-base.h"
23 : : #include "rust-ast-lower-enumitem.h"
24 : : #include "rust-ast-lower-type.h"
25 : : #include "rust-ast-lower-implitem.h"
26 : : #include "rust-ast-lower-expr.h"
27 : : #include "rust-ast-lower-pattern.h"
28 : : #include "rust-ast-lower-block.h"
29 : : #include "rust-item.h"
30 : :
31 : : namespace Rust {
32 : : namespace HIR {
33 : :
34 : : HIR::Item *
35 : 14653 : ASTLoweringItem::translate (AST::Item &item)
36 : : {
37 : 14653 : ASTLoweringItem resolver;
38 : 14653 : item.accept_vis (resolver);
39 : :
40 : 14653 : if (resolver.translated != nullptr)
41 : : {
42 : 14012 : auto id = resolver.translated->get_mappings ().get_hirid ();
43 : 14012 : auto defid = resolver.translated->get_mappings ().get_defid ();
44 : 14012 : auto locus = resolver.translated->get_locus ();
45 : :
46 : 14012 : resolver.handle_outer_attributes (*resolver.translated);
47 : 14012 : resolver.mappings->insert_ast_item (&item);
48 : 14012 : resolver.mappings->insert_hir_item (resolver.translated);
49 : 14012 : resolver.mappings->insert_location (id, locus);
50 : 14012 : resolver.mappings->insert_defid_mapping (defid, resolver.translated);
51 : : }
52 : :
53 : 14653 : return resolver.translated;
54 : 14653 : }
55 : :
56 : : void
57 : 440 : ASTLoweringItem::visit (AST::Module &module)
58 : : {
59 : 440 : auto crate_num = mappings->get_current_crate ();
60 : 440 : Analysis::NodeMapping mapping (crate_num, module.get_node_id (),
61 : 440 : mappings->get_next_hir_id (crate_num),
62 : 440 : mappings->get_next_localdef_id (crate_num));
63 : :
64 : : // should be lowered from module.get_vis()
65 : 440 : HIR::Visibility vis = translate_visibility (module.get_visibility ());
66 : :
67 : 440 : auto items = std::vector<std::unique_ptr<Item>> ();
68 : :
69 : 1027 : for (auto &item : module.get_items ())
70 : : {
71 : 587 : auto transitem = translate (*item);
72 : : // The item may be null if it doesn't need to live in the HIR - for
73 : : // example, macro rules definitions
74 : 587 : if (transitem)
75 : 555 : items.push_back (std::unique_ptr<Item> (transitem));
76 : : }
77 : :
78 : : // should be lowered/copied from module.get_in/outer_attrs()
79 : 440 : AST::AttrVec inner_attrs = module.get_inner_attrs ();
80 : 440 : AST::AttrVec outer_attrs = module.get_outer_attrs ();
81 : :
82 : 440 : translated
83 : 440 : = new HIR::Module (mapping, module.get_name (), module.get_locus (),
84 : : std::move (items), std::move (vis),
85 : 880 : std::move (inner_attrs), std::move (outer_attrs));
86 : 440 : mappings->insert_module (static_cast<Module *> (translated));
87 : 440 : }
88 : :
89 : : void
90 : 33 : ASTLoweringItem::visit (AST::TypeAlias &alias)
91 : : {
92 : 33 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
93 : 33 : for (auto &item : alias.get_where_clause ().get_items ())
94 : : {
95 : 0 : HIR::WhereClauseItem *i
96 : 0 : = ASTLowerWhereClauseItem::translate (*item.get ());
97 : 0 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
98 : : }
99 : :
100 : 33 : HIR::WhereClause where_clause (std::move (where_clause_items));
101 : 33 : HIR::Visibility vis = translate_visibility (alias.get_visibility ());
102 : :
103 : 33 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
104 : 33 : if (alias.has_generics ())
105 : 8 : generic_params = lower_generic_params (alias.get_generic_params ());
106 : :
107 : 33 : HIR::Type *existing_type
108 : 33 : = ASTLoweringType::translate (alias.get_type_aliased ());
109 : :
110 : 33 : auto crate_num = mappings->get_current_crate ();
111 : 33 : Analysis::NodeMapping mapping (crate_num, alias.get_node_id (),
112 : 33 : mappings->get_next_hir_id (crate_num),
113 : 33 : mappings->get_next_localdef_id (crate_num));
114 : :
115 : 33 : translated
116 : 33 : = new HIR::TypeAlias (mapping, alias.get_new_type_name (),
117 : : std::move (generic_params), std::move (where_clause),
118 : 66 : std::unique_ptr<HIR::Type> (existing_type),
119 : 33 : std::move (vis), alias.get_outer_attrs (),
120 : 99 : alias.get_locus ());
121 : 33 : }
122 : :
123 : : void
124 : 756 : ASTLoweringItem::visit (AST::TupleStruct &struct_decl)
125 : : {
126 : 756 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
127 : 756 : if (struct_decl.has_generics ())
128 : : {
129 : 280 : generic_params = lower_generic_params (struct_decl.get_generic_params ());
130 : : }
131 : :
132 : 756 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
133 : 756 : for (auto &item : struct_decl.get_where_clause ().get_items ())
134 : : {
135 : 0 : HIR::WhereClauseItem *i
136 : 0 : = ASTLowerWhereClauseItem::translate (*item.get ());
137 : 0 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
138 : : }
139 : :
140 : 756 : HIR::WhereClause where_clause (std::move (where_clause_items));
141 : 756 : HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());
142 : :
143 : 756 : std::vector<HIR::TupleField> fields;
144 : 2029 : for (AST::TupleField &field : struct_decl.get_fields ())
145 : : {
146 : 1273 : if (field.get_field_type ().is_marked_for_strip ())
147 : 0 : continue;
148 : :
149 : : // FIXME: How do we get the visibility from here?
150 : 1273 : HIR::Visibility vis = translate_visibility (field.get_visibility ());
151 : 1273 : HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
152 : :
153 : 1273 : auto crate_num = mappings->get_current_crate ();
154 : 1273 : Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
155 : 1273 : mappings->get_next_hir_id (crate_num),
156 : 1273 : mappings->get_next_localdef_id (
157 : 1273 : crate_num));
158 : :
159 : 1273 : HIR::TupleField translated_field (mapping,
160 : 1273 : std::unique_ptr<HIR::Type> (type), vis,
161 : : field.get_locus (),
162 : 2546 : field.get_outer_attrs ());
163 : 1273 : fields.push_back (std::move (translated_field));
164 : 1273 : }
165 : :
166 : 756 : auto crate_num = mappings->get_current_crate ();
167 : 756 : Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
168 : 756 : mappings->get_next_hir_id (crate_num),
169 : 756 : mappings->get_next_localdef_id (crate_num));
170 : :
171 : 1512 : translated = new HIR::TupleStruct (mapping, std::move (fields),
172 : 756 : struct_decl.get_identifier (),
173 : : std::move (generic_params),
174 : : std::move (where_clause), vis,
175 : 756 : struct_decl.get_outer_attrs (),
176 : 756 : struct_decl.get_locus ());
177 : 756 : }
178 : :
179 : : void
180 : 922 : ASTLoweringItem::visit (AST::StructStruct &struct_decl)
181 : : {
182 : 922 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
183 : 922 : if (struct_decl.has_generics ())
184 : : {
185 : 242 : generic_params = lower_generic_params (struct_decl.get_generic_params ());
186 : : }
187 : :
188 : 922 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
189 : 926 : for (auto &item : struct_decl.get_where_clause ().get_items ())
190 : : {
191 : 4 : HIR::WhereClauseItem *i
192 : 4 : = ASTLowerWhereClauseItem::translate (*item.get ());
193 : 4 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
194 : : }
195 : :
196 : 922 : HIR::WhereClause where_clause (std::move (where_clause_items));
197 : :
198 : 922 : HIR::Visibility vis = translate_visibility (struct_decl.get_visibility ());
199 : :
200 : 922 : bool is_unit = struct_decl.is_unit_struct ();
201 : 922 : std::vector<HIR::StructField> fields;
202 : 2221 : for (AST::StructField &field : struct_decl.get_fields ())
203 : : {
204 : 1301 : if (field.get_field_type ().is_marked_for_strip ())
205 : 0 : continue;
206 : :
207 : 1301 : HIR::Visibility vis = translate_visibility (field.get_visibility ());
208 : 1301 : HIR::Type *type = ASTLoweringType::translate (field.get_field_type ());
209 : :
210 : 1301 : auto crate_num = mappings->get_current_crate ();
211 : 1301 : Analysis::NodeMapping mapping (crate_num, field.get_node_id (),
212 : 1301 : mappings->get_next_hir_id (crate_num),
213 : 1301 : mappings->get_next_localdef_id (
214 : 1301 : crate_num));
215 : :
216 : 1301 : HIR::StructField translated_field (mapping, field.get_field_name (),
217 : 2602 : std::unique_ptr<HIR::Type> (type), vis,
218 : : field.get_locus (),
219 : 2602 : field.get_outer_attrs ());
220 : :
221 : 1301 : if (struct_field_name_exists (fields, translated_field))
222 : : break;
223 : :
224 : 1299 : fields.push_back (std::move (translated_field));
225 : 1301 : }
226 : :
227 : 922 : auto crate_num = mappings->get_current_crate ();
228 : 922 : Analysis::NodeMapping mapping (crate_num, struct_decl.get_node_id (),
229 : 922 : mappings->get_next_hir_id (crate_num),
230 : 922 : mappings->get_next_localdef_id (crate_num));
231 : :
232 : 1844 : translated = new HIR::StructStruct (mapping, std::move (fields),
233 : 922 : struct_decl.get_identifier (),
234 : : std::move (generic_params),
235 : : std::move (where_clause), is_unit, vis,
236 : 922 : struct_decl.get_outer_attrs (),
237 : 922 : struct_decl.get_locus ());
238 : 922 : }
239 : :
240 : : void
241 : 172 : ASTLoweringItem::visit (AST::Enum &enum_decl)
242 : : {
243 : 172 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
244 : 172 : if (enum_decl.has_generics ())
245 : : {
246 : 81 : generic_params = lower_generic_params (enum_decl.get_generic_params ());
247 : : }
248 : :
249 : 172 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
250 : 172 : for (auto &item : enum_decl.get_where_clause ().get_items ())
251 : : {
252 : 0 : HIR::WhereClauseItem *i
253 : 0 : = ASTLowerWhereClauseItem::translate (*item.get ());
254 : 0 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
255 : : }
256 : :
257 : 172 : HIR::WhereClause where_clause (std::move (where_clause_items));
258 : 172 : HIR::Visibility vis = translate_visibility (enum_decl.get_visibility ());
259 : :
260 : : // bool is_unit = enum_decl.is_zero_variant ();
261 : 172 : std::vector<std::unique_ptr<HIR::EnumItem>> items;
262 : 600 : for (auto &variant : enum_decl.get_variants ())
263 : : {
264 : 428 : if (variant->is_marked_for_strip ())
265 : 0 : continue;
266 : :
267 : 428 : HIR::EnumItem *hir_item = ASTLoweringEnumItem::translate (variant.get ());
268 : 428 : items.push_back (std::unique_ptr<HIR::EnumItem> (hir_item));
269 : : }
270 : :
271 : 172 : auto crate_num = mappings->get_current_crate ();
272 : 172 : Analysis::NodeMapping mapping (crate_num, enum_decl.get_node_id (),
273 : 172 : mappings->get_next_hir_id (crate_num),
274 : 172 : mappings->get_next_localdef_id (crate_num));
275 : :
276 : 172 : HIR::Enum *hir_enum
277 : 172 : = new HIR::Enum (mapping, enum_decl.get_identifier (), vis,
278 : : std::move (generic_params), std::move (where_clause),
279 : 172 : std::move (items), enum_decl.get_outer_attrs (),
280 : 344 : enum_decl.get_locus ());
281 : 172 : translated = hir_enum;
282 : 600 : for (auto &variant : hir_enum->get_variants ())
283 : : {
284 : 428 : mappings->insert_hir_enumitem (hir_enum, variant.get ());
285 : : }
286 : 172 : }
287 : :
288 : : void
289 : 92 : ASTLoweringItem::visit (AST::Union &union_decl)
290 : : {
291 : 92 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
292 : 92 : if (union_decl.has_generics ())
293 : : {
294 : 65 : generic_params = lower_generic_params (union_decl.get_generic_params ());
295 : : }
296 : :
297 : 92 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
298 : 92 : for (auto &item : union_decl.get_where_clause ().get_items ())
299 : : {
300 : 0 : HIR::WhereClauseItem *i
301 : 0 : = ASTLowerWhereClauseItem::translate (*item.get ());
302 : 0 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
303 : : }
304 : 92 : HIR::WhereClause where_clause (std::move (where_clause_items));
305 : 92 : HIR::Visibility vis = translate_visibility (union_decl.get_visibility ());
306 : :
307 : 92 : std::vector<HIR::StructField> variants;
308 : 364 : for (AST::StructField &variant : union_decl.get_variants ())
309 : : {
310 : 274 : if (variant.get_field_type ().is_marked_for_strip ())
311 : 0 : continue;
312 : :
313 : : // FIXME: Does visibility apply here?
314 : 274 : HIR::Visibility vis = translate_visibility (variant.get_visibility ());
315 : 274 : HIR::Type *type = ASTLoweringType::translate (variant.get_field_type ());
316 : :
317 : 274 : auto crate_num = mappings->get_current_crate ();
318 : 274 : Analysis::NodeMapping mapping (crate_num, variant.get_node_id (),
319 : 274 : mappings->get_next_hir_id (crate_num),
320 : 274 : mappings->get_next_localdef_id (
321 : 274 : crate_num));
322 : :
323 : 274 : HIR::StructField translated_variant (mapping, variant.get_field_name (),
324 : 548 : std::unique_ptr<HIR::Type> (type),
325 : : vis, variant.get_locus (),
326 : 548 : variant.get_outer_attrs ());
327 : :
328 : 274 : if (struct_field_name_exists (variants, translated_variant))
329 : : break;
330 : :
331 : 272 : variants.push_back (std::move (translated_variant));
332 : 274 : }
333 : :
334 : 92 : auto crate_num = mappings->get_current_crate ();
335 : 92 : Analysis::NodeMapping mapping (crate_num, union_decl.get_node_id (),
336 : 92 : mappings->get_next_hir_id (crate_num),
337 : 92 : mappings->get_next_localdef_id (crate_num));
338 : :
339 : 92 : translated
340 : 92 : = new HIR::Union (mapping, union_decl.get_identifier (), vis,
341 : : std::move (generic_params), std::move (where_clause),
342 : 92 : std::move (variants), union_decl.get_outer_attrs (),
343 : 184 : union_decl.get_locus ());
344 : 92 : }
345 : :
346 : : void
347 : 41 : ASTLoweringItem::visit (AST::StaticItem &var)
348 : : {
349 : 41 : HIR::Visibility vis = translate_visibility (var.get_visibility ());
350 : :
351 : 41 : HIR::Type *type = ASTLoweringType::translate (var.get_type (), true);
352 : 41 : HIR::Expr *expr = ASTLoweringExpr::translate (var.get_expr ());
353 : :
354 : 41 : auto crate_num = mappings->get_current_crate ();
355 : 41 : Analysis::NodeMapping mapping (crate_num, var.get_node_id (),
356 : 41 : mappings->get_next_hir_id (crate_num),
357 : 41 : mappings->get_next_localdef_id (crate_num));
358 : :
359 : 41 : translated = new HIR::StaticItem (mapping, var.get_identifier (),
360 : 41 : var.is_mutable () ? Mutability::Mut
361 : : : Mutability::Imm,
362 : 41 : std::unique_ptr<HIR::Type> (type),
363 : 82 : std::unique_ptr<HIR::Expr> (expr), vis,
364 : 123 : var.get_outer_attrs (), var.get_locus ());
365 : 41 : }
366 : :
367 : : void
368 : 423 : ASTLoweringItem::visit (AST::ConstantItem &constant)
369 : : {
370 : 423 : HIR::Visibility vis = translate_visibility (constant.get_visibility ());
371 : :
372 : 423 : HIR::Type *type = ASTLoweringType::translate (constant.get_type (), true);
373 : 423 : HIR::Expr *expr = ASTLoweringExpr::translate (constant.get_expr ());
374 : :
375 : 423 : auto crate_num = mappings->get_current_crate ();
376 : 423 : Analysis::NodeMapping mapping (crate_num, constant.get_node_id (),
377 : 423 : mappings->get_next_hir_id (crate_num),
378 : 423 : mappings->get_next_localdef_id (crate_num));
379 : :
380 : 846 : translated = new HIR::ConstantItem (mapping, constant.get_identifier (), vis,
381 : 1269 : std::unique_ptr<HIR::Type> (type),
382 : 846 : std::unique_ptr<HIR::Expr> (expr),
383 : 423 : constant.get_outer_attrs (),
384 : 1692 : constant.get_locus ());
385 : 423 : }
386 : :
387 : : void
388 : 5027 : ASTLoweringItem::visit (AST::Function &function)
389 : : {
390 : 5027 : if (function.is_marked_for_strip ())
391 : 0 : return;
392 : :
393 : 5027 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
394 : 5037 : for (auto &item : function.get_where_clause ().get_items ())
395 : : {
396 : 10 : HIR::WhereClauseItem *i
397 : 10 : = ASTLowerWhereClauseItem::translate (*item.get ());
398 : 10 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
399 : : }
400 : :
401 : 5027 : HIR::WhereClause where_clause (std::move (where_clause_items));
402 : 5027 : HIR::FunctionQualifiers qualifiers
403 : 5027 : = lower_qualifiers (function.get_qualifiers ());
404 : 5027 : HIR::Visibility vis = translate_visibility (function.get_visibility ());
405 : :
406 : : // need
407 : 5027 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
408 : 5027 : if (function.has_generics ())
409 : : {
410 : 395 : generic_params = lower_generic_params (function.get_generic_params ());
411 : : }
412 : 5027 : Identifier function_name = function.get_function_name ();
413 : 5027 : location_t locus = function.get_locus ();
414 : :
415 : 5027 : std::unique_ptr<HIR::Type> return_type
416 : 5027 : = function.has_return_type () ? std::unique_ptr<HIR::Type> (
417 : : ASTLoweringType::translate (function.get_return_type ()))
418 : 5027 : : nullptr;
419 : :
420 : 5027 : std::vector<HIR::FunctionParam> function_params;
421 : 6258 : for (auto &p : function.get_function_params ())
422 : : {
423 : 1231 : if (p->is_variadic () || p->is_self ())
424 : 0 : continue;
425 : 1231 : auto param = static_cast<AST::FunctionParam &> (*p);
426 : :
427 : 1231 : auto translated_pattern = std::unique_ptr<HIR::Pattern> (
428 : 1231 : ASTLoweringPattern::translate (param.get_pattern ()));
429 : 1231 : auto translated_type = std::unique_ptr<HIR::Type> (
430 : 1231 : ASTLoweringType::translate (param.get_type ()));
431 : :
432 : 1231 : auto crate_num = mappings->get_current_crate ();
433 : 1231 : Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
434 : 1231 : mappings->get_next_hir_id (crate_num),
435 : 1231 : UNKNOWN_LOCAL_DEFID);
436 : :
437 : 1231 : auto hir_param
438 : : = HIR::FunctionParam (mapping, std::move (translated_pattern),
439 : 1231 : std::move (translated_type), param.get_locus ());
440 : 1231 : function_params.push_back (std::move (hir_param));
441 : 1231 : }
442 : :
443 : 5027 : bool terminated = false;
444 : 5027 : std::unique_ptr<HIR::BlockExpr> function_body
445 : : = std::unique_ptr<HIR::BlockExpr> (
446 : 5027 : ASTLoweringBlock::translate (*function.get_definition ().value (),
447 : 5027 : &terminated));
448 : :
449 : 5027 : auto crate_num = mappings->get_current_crate ();
450 : 10054 : Analysis::NodeMapping mapping (crate_num, function.get_node_id (),
451 : 5027 : mappings->get_next_hir_id (crate_num),
452 : 5027 : mappings->get_next_localdef_id (crate_num));
453 : :
454 : 5027 : mappings->insert_location (function_body->get_mappings ().get_hirid (),
455 : : function.get_locus ());
456 : :
457 : 5027 : auto fn
458 : : = new HIR::Function (mapping, std::move (function_name),
459 : : std::move (qualifiers), std::move (generic_params),
460 : : std::move (function_params), std::move (return_type),
461 : : std::move (where_clause), std::move (function_body),
462 : 5027 : std::move (vis), function.get_outer_attrs (),
463 : 5027 : HIR::SelfParam::error (), locus);
464 : :
465 : : // add the mappings for the function params at the end
466 : 6258 : for (auto ¶m : fn->get_function_params ())
467 : : {
468 : 1231 : mappings->insert_hir_param (¶m);
469 : 1231 : mappings->insert_location (mapping.get_hirid (), param.get_locus ());
470 : : }
471 : :
472 : 5027 : translated = fn;
473 : 5027 : }
474 : :
475 : : void
476 : 689 : ASTLoweringItem::visit (AST::InherentImpl &impl_block)
477 : : {
478 : 689 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
479 : 689 : for (auto &item : impl_block.get_where_clause ().get_items ())
480 : : {
481 : 0 : HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
482 : 0 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
483 : : }
484 : :
485 : 689 : HIR::WhereClause where_clause (std::move (where_clause_items));
486 : 689 : HIR::Visibility vis = translate_visibility (impl_block.get_visibility ());
487 : :
488 : 689 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
489 : 689 : if (impl_block.has_generics ())
490 : : {
491 : 232 : generic_params = lower_generic_params (impl_block.get_generic_params ());
492 : :
493 : 465 : for (auto &generic_param : generic_params)
494 : : {
495 : 233 : switch (generic_param->get_kind ())
496 : : {
497 : 227 : case HIR::GenericParam::GenericKind::TYPE: {
498 : 227 : const HIR::TypeParam &t
499 : 227 : = static_cast<const HIR::TypeParam &> (*generic_param);
500 : :
501 : 227 : if (t.has_type ())
502 : : {
503 : 1 : rich_location rich_locus (line_table, t.get_locus ());
504 : 1 : rich_locus.add_fixit_replace (
505 : : t.get_locus (),
506 : : "for more information, see issue #36887 "
507 : : "<https://github.com/rust-lang/rust/issues/36887>");
508 : 1 : rust_error_at (rich_locus,
509 : : "defaults for type parameters are only "
510 : : "allowed in %<struct%>, %<enum%>, %<type%>, "
511 : : "or %<trait%> definitions");
512 : 1 : }
513 : : }
514 : : break;
515 : :
516 : : default:
517 : : break;
518 : : }
519 : : }
520 : : }
521 : :
522 : 689 : HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ());
523 : :
524 : 689 : auto crate_num = mappings->get_current_crate ();
525 : 689 : Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (),
526 : 689 : mappings->get_next_hir_id (crate_num),
527 : 689 : mappings->get_next_localdef_id (crate_num));
528 : :
529 : 689 : std::vector<std::unique_ptr<HIR::ImplItem>> impl_items;
530 : 689 : std::vector<HirId> impl_item_ids;
531 : 2326 : for (auto &impl_item : impl_block.get_impl_items ())
532 : : {
533 : 1637 : if (impl_item->is_marked_for_strip ())
534 : 0 : continue;
535 : :
536 : 1637 : HIR::ImplItem *lowered
537 : 1637 : = ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
538 : 1637 : rust_assert (lowered != nullptr);
539 : 1637 : impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
540 : 1637 : impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
541 : : }
542 : :
543 : 689 : BoundPolarity polarity = BoundPolarity::RegularBound;
544 : 689 : HIR::ImplBlock *hir_impl_block = new HIR::ImplBlock (
545 : : mapping, std::move (impl_items), std::move (generic_params),
546 : 689 : std::unique_ptr<HIR::Type> (impl_type), nullptr, where_clause, polarity,
547 : 1378 : vis, impl_block.get_inner_attrs (), impl_block.get_outer_attrs (),
548 : 689 : impl_block.get_locus ());
549 : 689 : translated = hir_impl_block;
550 : :
551 : 689 : mappings->insert_hir_impl_block (hir_impl_block);
552 : 2326 : for (auto &impl_item_id : impl_item_ids)
553 : : {
554 : 1637 : mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
555 : : }
556 : 689 : }
557 : :
558 : : void
559 : 2081 : ASTLoweringItem::visit (AST::Trait &trait)
560 : : {
561 : 2081 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
562 : 2088 : for (auto &item : trait.get_where_clause ().get_items ())
563 : : {
564 : 7 : HIR::WhereClauseItem *i
565 : 7 : = ASTLowerWhereClauseItem::translate (*item.get ());
566 : 7 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
567 : : }
568 : 2081 : HIR::WhereClause where_clause (std::move (where_clause_items));
569 : :
570 : 2081 : HIR::Visibility vis = translate_visibility (trait.get_visibility ());
571 : :
572 : 2081 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
573 : 2081 : if (trait.has_generics ())
574 : : {
575 : 2081 : generic_params = lower_generic_params (trait.get_generic_params ());
576 : : }
577 : :
578 : 2081 : std::vector<std::unique_ptr<HIR::TypeParamBound>> type_param_bounds;
579 : 2081 : if (trait.has_type_param_bounds ())
580 : : {
581 : 294 : for (auto &bound : trait.get_type_param_bounds ())
582 : : {
583 : 147 : HIR::TypeParamBound *b = lower_bound (*bound);
584 : 147 : type_param_bounds.push_back (
585 : 147 : std::unique_ptr<HIR::TypeParamBound> (b));
586 : : }
587 : : }
588 : :
589 : 2081 : std::vector<std::unique_ptr<HIR::TraitItem>> trait_items;
590 : 2081 : std::vector<HirId> trait_item_ids;
591 : 3604 : for (auto &item : trait.get_trait_items ())
592 : : {
593 : 1523 : if (item->is_marked_for_strip ())
594 : 0 : continue;
595 : :
596 : 1523 : HIR::TraitItem *lowered = ASTLowerTraitItem::translate (*item);
597 : 1523 : trait_items.push_back (std::unique_ptr<HIR::TraitItem> (lowered));
598 : 1523 : trait_item_ids.push_back (lowered->get_mappings ().get_hirid ());
599 : : }
600 : :
601 : 2081 : auto crate_num = mappings->get_current_crate ();
602 : 2081 : Analysis::NodeMapping mapping (crate_num, trait.get_node_id (),
603 : 2081 : mappings->get_next_hir_id (crate_num),
604 : 2081 : mappings->get_next_localdef_id (crate_num));
605 : :
606 : 2081 : auto trait_unsafety = Unsafety::Normal;
607 : 2081 : if (trait.is_unsafe ())
608 : : {
609 : 44 : trait_unsafety = Unsafety::Unsafe;
610 : : }
611 : :
612 : 2081 : HIR::Trait *hir_trait
613 : 4162 : = new HIR::Trait (mapping, trait.get_identifier (), trait_unsafety,
614 : : std::move (generic_params), std::move (type_param_bounds),
615 : : where_clause, std::move (trait_items), vis,
616 : 2081 : trait.get_outer_attrs (), trait.get_locus ());
617 : 2081 : translated = hir_trait;
618 : :
619 : 3604 : for (auto trait_item_id : trait_item_ids)
620 : : {
621 : 1523 : mappings->insert_trait_item_mapping (trait_item_id, hir_trait);
622 : : }
623 : 2081 : }
624 : :
625 : : void
626 : 2320 : ASTLoweringItem::visit (AST::TraitImpl &impl_block)
627 : : {
628 : 2320 : std::vector<std::unique_ptr<HIR::WhereClauseItem>> where_clause_items;
629 : 2379 : for (auto &item : impl_block.get_where_clause ().get_items ())
630 : : {
631 : 59 : HIR::WhereClauseItem *i = ASTLowerWhereClauseItem::translate (*item);
632 : 59 : where_clause_items.push_back (std::unique_ptr<HIR::WhereClauseItem> (i));
633 : : }
634 : 2320 : HIR::WhereClause where_clause (std::move (where_clause_items));
635 : 2320 : HIR::Visibility vis = translate_visibility (impl_block.get_visibility ());
636 : :
637 : 2320 : std::vector<std::unique_ptr<HIR::GenericParam>> generic_params;
638 : 2320 : if (impl_block.has_generics ())
639 : : {
640 : 467 : generic_params = lower_generic_params (impl_block.get_generic_params ());
641 : :
642 : 1012 : for (auto &generic_param : generic_params)
643 : : {
644 : 545 : switch (generic_param->get_kind ())
645 : : {
646 : 478 : case HIR::GenericParam::GenericKind::TYPE: {
647 : 478 : const HIR::TypeParam &t
648 : 478 : = static_cast<const HIR::TypeParam &> (*generic_param);
649 : :
650 : 478 : if (t.has_type ())
651 : : {
652 : 0 : rich_location rich_locus (line_table, t.get_locus ());
653 : 0 : rich_locus.add_fixit_replace (
654 : : t.get_locus (), "for more information, see issue #36887 "
655 : : "<https://github.com/rust-lang/rust/"
656 : : "issues/36887>");
657 : 0 : rust_error_at (rich_locus,
658 : : "defaults for type parameters are only "
659 : : "allowed in %<struct%>, %<enum%>, %<type%>, "
660 : : "or %<trait%> definitions");
661 : 0 : }
662 : : }
663 : : break;
664 : :
665 : : default:
666 : : break;
667 : : }
668 : : }
669 : : }
670 : :
671 : 2320 : HIR::Type *impl_type = ASTLoweringType::translate (impl_block.get_type ());
672 : 2320 : HIR::TypePath *trait_ref
673 : 2320 : = ASTLowerTypePath::translate (impl_block.get_trait_path ());
674 : :
675 : 2320 : auto crate_num = mappings->get_current_crate ();
676 : 2320 : Analysis::NodeMapping mapping (crate_num, impl_block.get_node_id (),
677 : 2320 : mappings->get_next_hir_id (crate_num),
678 : 2320 : mappings->get_next_localdef_id (crate_num));
679 : :
680 : 2320 : std::vector<std::unique_ptr<HIR::ImplItem>> impl_items;
681 : 2320 : std::vector<HirId> impl_item_ids;
682 : 4787 : for (auto &impl_item : impl_block.get_impl_items ())
683 : : {
684 : 2467 : if (impl_item->is_marked_for_strip ())
685 : 0 : continue;
686 : :
687 : 2467 : HIR::ImplItem *lowered
688 : 2467 : = ASTLowerImplItem::translate (*impl_item, mapping.get_hirid ());
689 : 2467 : rust_assert (lowered != nullptr);
690 : 2467 : impl_items.push_back (std::unique_ptr<HIR::ImplItem> (lowered));
691 : 2467 : impl_item_ids.push_back (lowered->get_impl_mappings ().get_hirid ());
692 : : }
693 : :
694 : 2320 : BoundPolarity polarity = impl_block.is_exclam ()
695 : 2320 : ? BoundPolarity::RegularBound
696 : 2320 : : BoundPolarity::NegativeBound;
697 : 2320 : HIR::ImplBlock *hir_impl_block = new HIR::ImplBlock (
698 : : mapping, std::move (impl_items), std::move (generic_params),
699 : 6960 : std::unique_ptr<HIR::Type> (impl_type),
700 : 4640 : std::unique_ptr<HIR::TypePath> (trait_ref), where_clause, polarity, vis,
701 : 4640 : impl_block.get_inner_attrs (), impl_block.get_outer_attrs (),
702 : 4640 : impl_block.get_locus ());
703 : 2320 : translated = hir_impl_block;
704 : :
705 : 2320 : mappings->insert_hir_impl_block (hir_impl_block);
706 : 4787 : for (auto &impl_item_id : impl_item_ids)
707 : : {
708 : 2467 : mappings->insert_impl_item_mapping (impl_item_id, hir_impl_block);
709 : : }
710 : 2320 : }
711 : :
712 : : void
713 : 1016 : ASTLoweringItem::visit (AST::ExternBlock &extern_block)
714 : : {
715 : 1016 : translated = lower_extern_block (extern_block);
716 : 1016 : }
717 : :
718 : : void
719 : 596 : ASTLoweringItem::visit (AST::MacroRulesDefinition &def)
720 : : {
721 : 596 : lower_macro_definition (def);
722 : 596 : }
723 : :
724 : : HIR::SimplePath
725 : 8 : ASTLoweringSimplePath::translate (const AST::SimplePath &path)
726 : : {
727 : 8 : ASTLoweringSimplePath resolver;
728 : :
729 : 8 : return resolver.lower (path);
730 : 8 : }
731 : :
732 : : HIR::SimplePathSegment
733 : 12 : ASTLoweringSimplePath::lower (const AST::SimplePathSegment &segment)
734 : : {
735 : 12 : auto crate_num = mappings->get_current_crate ();
736 : 12 : auto node_id = segment.get_node_id ();
737 : :
738 : 12 : auto mapping = Analysis::NodeMapping (crate_num, node_id,
739 : 12 : mappings->get_next_hir_id (crate_num),
740 : 12 : UNKNOWN_LOCAL_DEFID);
741 : :
742 : 12 : auto hir_seg = HIR::SimplePathSegment (mapping);
743 : :
744 : 12 : mappings->insert_node_to_hir (node_id, mapping.get_hirid ());
745 : : // mappings->insert_simple_path_segment (crate_num, node_id, &segment);
746 : :
747 : 12 : return hir_seg;
748 : : }
749 : :
750 : : HIR::SimplePath
751 : 8 : ASTLoweringSimplePath::lower (const AST::SimplePath &path)
752 : : {
753 : 8 : auto segments = std::vector<HIR::SimplePathSegment> ();
754 : 20 : for (auto &segment : path.get_segments ())
755 : 12 : segments.emplace_back (lower (segment));
756 : :
757 : 8 : auto crate_num = mappings->get_current_crate ();
758 : 8 : auto node_id = path.get_node_id ();
759 : :
760 : 8 : auto mapping = Analysis::NodeMapping (crate_num, node_id,
761 : 8 : mappings->get_next_hir_id (crate_num),
762 : 8 : UNKNOWN_LOCAL_DEFID);
763 : :
764 : 8 : auto lowered
765 : 8 : = HIR::SimplePath (std::move (segments), mapping, path.get_locus ());
766 : :
767 : 8 : mappings->insert_node_to_hir (node_id, mapping.get_hirid ());
768 : : // mappings->insert_simple_path (crate_num, node_id, &path);
769 : :
770 : 8 : return lowered;
771 : 8 : }
772 : :
773 : : } // namespace HIR
774 : : } // namespace Rust
|
