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