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-type.h"
20 : :
21 : : namespace Rust {
22 : : namespace HIR {
23 : :
24 : : HIR::TypePath *
25 : 30239 : ASTLowerTypePath::translate (AST::TypePath &type)
26 : : {
27 : 30239 : ASTLowerTypePath resolver;
28 : 30239 : type.accept_vis (resolver);
29 : 30239 : rust_assert (resolver.translated != nullptr);
30 : 30239 : return resolver.translated;
31 : 30239 : }
32 : :
33 : : void
34 : 19 : ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment)
35 : : {
36 : 19 : auto crate_num = mappings->get_current_crate ();
37 : 19 : auto hirid = mappings->get_next_hir_id (crate_num);
38 : 19 : Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
39 : 19 : UNKNOWN_LOCAL_DEFID);
40 : :
41 : 19 : HIR::PathIdentSegment ident (segment.get_ident_segment ().as_string ());
42 : :
43 : 19 : AST::TypePathFunction &fn = segment.get_type_path_function ();
44 : 19 : std::vector<std::unique_ptr<HIR::Type>> inputs;
45 : 38 : for (auto ¶m : fn.get_params ())
46 : : {
47 : 19 : HIR::Type *hir_type = ASTLoweringType::translate (*param);
48 : 19 : inputs.push_back (std::unique_ptr<HIR::Type> (hir_type));
49 : : }
50 : :
51 : 19 : HIR::Type *result_type
52 : 19 : = fn.has_return_type () ? ASTLoweringType::translate (fn.get_return_type ())
53 : 19 : : nullptr;
54 : :
55 : 19 : HIR::TypePathFunction function_path (std::move (inputs),
56 : 38 : std::unique_ptr<HIR::Type> (
57 : 19 : result_type));
58 : :
59 : 19 : translated_segment = new HIR::TypePathSegmentFunction (
60 : 19 : mapping, std::move (ident), segment.get_separating_scope_resolution (),
61 : 57 : std::move (function_path), segment.get_locus ());
62 : 19 : }
63 : :
64 : : void
65 : 29896 : ASTLowerTypePath::visit (AST::TypePathSegment &segment)
66 : : {
67 : 29896 : auto crate_num = mappings->get_current_crate ();
68 : 29896 : auto hirid = mappings->get_next_hir_id (crate_num);
69 : 29896 : Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
70 : 29896 : UNKNOWN_LOCAL_DEFID);
71 : :
72 : 29896 : HIR::PathIdentSegment ident (segment.get_ident_segment ().as_string ());
73 : 29896 : translated_segment
74 : 29896 : = new HIR::TypePathSegment (std::move (mapping), ident,
75 : 29896 : segment.get_separating_scope_resolution (),
76 : 29896 : segment.get_locus ());
77 : 29896 : }
78 : :
79 : : void
80 : 1353 : ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment)
81 : : {
82 : 1353 : std::vector<HIR::GenericArgsBinding> binding_args; // TODO
83 : :
84 : 1353 : std::string segment_name = segment.get_ident_segment ().as_string ();
85 : 1353 : bool has_separating_scope_resolution
86 : 1353 : = segment.get_separating_scope_resolution ();
87 : :
88 : 1353 : auto generic_args = lower_generic_args (segment.get_generic_args ());
89 : :
90 : 1353 : auto crate_num = mappings->get_current_crate ();
91 : 1353 : auto hirid = mappings->get_next_hir_id (crate_num);
92 : 1353 : Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid,
93 : 1353 : UNKNOWN_LOCAL_DEFID);
94 : :
95 : 1353 : translated_segment
96 : 1353 : = new HIR::TypePathSegmentGeneric (std::move (mapping), segment_name,
97 : : has_separating_scope_resolution,
98 : 2706 : generic_args, segment.get_locus ());
99 : 1353 : }
100 : :
101 : : void
102 : 30239 : ASTLowerTypePath::visit (AST::TypePath &path)
103 : : {
104 : 30239 : std::vector<std::unique_ptr<HIR::TypePathSegment>> translated_segments;
105 : :
106 : 61348 : for (auto &seg : path.get_segments ())
107 : : {
108 : 31109 : translated_segment = nullptr;
109 : 31109 : seg->accept_vis (*this);
110 : 31109 : rust_assert (translated_segment != nullptr);
111 : :
112 : 62218 : translated_segments.push_back (
113 : 31109 : std::unique_ptr<HIR::TypePathSegment> (translated_segment));
114 : : }
115 : :
116 : 30239 : auto crate_num = mappings->get_current_crate ();
117 : 30239 : auto hirid = mappings->get_next_hir_id (crate_num);
118 : 30239 : Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
119 : 30239 : mappings->get_next_localdef_id (crate_num));
120 : :
121 : 30239 : translated
122 : 30239 : = new HIR::TypePath (std::move (mapping), std::move (translated_segments),
123 : : path.get_locus (),
124 : 30239 : path.has_opening_scope_resolution_op ());
125 : 30239 : }
126 : :
127 : : HIR::QualifiedPathInType *
128 : 159 : ASTLowerQualifiedPathInType::translate (AST::QualifiedPathInType &type)
129 : : {
130 : 159 : ASTLowerQualifiedPathInType resolver;
131 : 159 : type.accept_vis (resolver);
132 : 159 : rust_assert (resolver.translated != nullptr);
133 : 159 : return resolver.translated;
134 : 159 : }
135 : :
136 : : void
137 : 159 : ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path)
138 : : {
139 : 159 : auto crate_num = mappings->get_current_crate ();
140 : 159 : auto hirid = mappings->get_next_hir_id (crate_num);
141 : 159 : Analysis::NodeMapping qual_mappings (
142 : 159 : crate_num, path.get_qualified_path_type ().get_node_id (), hirid,
143 : 159 : UNKNOWN_LOCAL_DEFID);
144 : :
145 : 159 : HIR::Type *qual_type
146 : 159 : = ASTLoweringType::translate (path.get_qualified_path_type ().get_type ());
147 : 159 : HIR::TypePath *qual_trait = ASTLowerTypePath::translate (
148 : 159 : path.get_qualified_path_type ().get_as_type_path ());
149 : :
150 : 159 : HIR::QualifiedPathType qual_path_type (
151 : 318 : qual_mappings, std::unique_ptr<HIR::Type> (qual_type),
152 : 159 : std::unique_ptr<HIR::TypePath> (qual_trait),
153 : 159 : path.get_qualified_path_type ().get_locus ());
154 : :
155 : 159 : translated_segment = nullptr;
156 : 159 : path.get_associated_segment ()->accept_vis (*this);
157 : 159 : rust_assert (translated_segment != nullptr);
158 : :
159 : 159 : std::unique_ptr<HIR::TypePathSegment> associated_segment (translated_segment);
160 : :
161 : 159 : std::vector<std::unique_ptr<HIR::TypePathSegment>> translated_segments;
162 : 159 : for (auto &seg : path.get_segments ())
163 : : {
164 : 0 : translated_segment = nullptr;
165 : 0 : seg->accept_vis (*this);
166 : 0 : rust_assert (translated_segment != nullptr);
167 : :
168 : 0 : translated_segments.push_back (
169 : 0 : std::unique_ptr<HIR::TypePathSegment> (translated_segment));
170 : : }
171 : :
172 : 159 : Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid,
173 : 159 : mappings->get_next_localdef_id (crate_num));
174 : 159 : translated = new HIR::QualifiedPathInType (std::move (mapping),
175 : : std::move (qual_path_type),
176 : : std::move (associated_segment),
177 : : std::move (translated_segments),
178 : 318 : path.get_locus ());
179 : 159 : }
180 : :
181 : : HIR::Type *
182 : 35445 : ASTLoweringType::translate (AST::Type &type, bool default_to_static_lifetime)
183 : : {
184 : 35445 : ASTLoweringType resolver (default_to_static_lifetime);
185 : 35445 : type.accept_vis (resolver);
186 : :
187 : 35445 : rust_assert (resolver.translated != nullptr);
188 : 35445 : resolver.mappings->insert_hir_type (resolver.translated);
189 : 35445 : resolver.mappings->insert_location (
190 : 35445 : resolver.translated->get_mappings ().get_hirid (),
191 : 35445 : resolver.translated->get_locus ());
192 : :
193 : 35445 : return resolver.translated;
194 : 35445 : }
195 : :
196 : : void
197 : 37 : ASTLoweringType::visit (AST::BareFunctionType &fntype)
198 : : {
199 : 37 : bool is_variadic = false;
200 : 37 : std::vector<HIR::LifetimeParam> lifetime_params;
201 : 39 : for (auto &lifetime_param : fntype.get_for_lifetimes ())
202 : : {
203 : 2 : auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
204 : 2 : lifetime_params.push_back (
205 : : *static_cast<HIR::LifetimeParam *> (generic_param));
206 : : }
207 : :
208 : 37 : HIR::FunctionQualifiers qualifiers
209 : 37 : = lower_qualifiers (fntype.get_function_qualifiers ());
210 : :
211 : 37 : std::vector<HIR::MaybeNamedParam> named_params;
212 : 72 : for (auto ¶m : fntype.get_function_params ())
213 : : {
214 : 35 : HIR::MaybeNamedParam::ParamKind kind;
215 : 35 : switch (param.get_param_kind ())
216 : : {
217 : : case AST::MaybeNamedParam::ParamKind::UNNAMED:
218 : : kind = HIR::MaybeNamedParam::ParamKind::UNNAMED;
219 : : break;
220 : : case AST::MaybeNamedParam::ParamKind::IDENTIFIER:
221 : : kind = HIR::MaybeNamedParam::ParamKind::IDENTIFIER;
222 : : break;
223 : : case AST::MaybeNamedParam::ParamKind::WILDCARD:
224 : : kind = HIR::MaybeNamedParam::ParamKind::WILDCARD;
225 : : break;
226 : 0 : default:
227 : 0 : rust_unreachable ();
228 : : }
229 : :
230 : 35 : HIR::Type *param_type
231 : 35 : = ASTLoweringType::translate (param.get_type (),
232 : 35 : default_to_static_lifetime);
233 : :
234 : 35 : HIR::MaybeNamedParam p (param.get_name (), kind,
235 : 70 : std::unique_ptr<HIR::Type> (param_type),
236 : 105 : param.get_locus ());
237 : 35 : named_params.push_back (std::move (p));
238 : : }
239 : :
240 : 37 : HIR::Type *return_type = nullptr;
241 : 37 : if (fntype.has_return_type ())
242 : : {
243 : 33 : return_type = ASTLoweringType::translate (fntype.get_return_type (),
244 : 33 : default_to_static_lifetime);
245 : : }
246 : :
247 : 37 : auto crate_num = mappings->get_current_crate ();
248 : 37 : Analysis::NodeMapping mapping (crate_num, fntype.get_node_id (),
249 : 37 : mappings->get_next_hir_id (crate_num),
250 : 37 : mappings->get_next_localdef_id (crate_num));
251 : :
252 : 74 : translated = new HIR::BareFunctionType (
253 : : std::move (mapping), std::move (lifetime_params), std::move (qualifiers),
254 : : std::move (named_params), is_variadic,
255 : 37 : std::unique_ptr<HIR::Type> (return_type), fntype.get_locus ());
256 : 37 : }
257 : :
258 : : void
259 : 230 : ASTLoweringType::visit (AST::TupleType &tuple)
260 : : {
261 : 230 : std::vector<std::unique_ptr<HIR::Type>> elems;
262 : 580 : for (auto &e : tuple.get_elems ())
263 : : {
264 : 350 : HIR::Type *t
265 : 350 : = ASTLoweringType::translate (*e, default_to_static_lifetime);
266 : 350 : elems.push_back (std::unique_ptr<HIR::Type> (t));
267 : : }
268 : :
269 : 230 : auto crate_num = mappings->get_current_crate ();
270 : 230 : Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (),
271 : 230 : mappings->get_next_hir_id (crate_num),
272 : 230 : mappings->get_next_localdef_id (crate_num));
273 : :
274 : 230 : translated = new HIR::TupleType (std::move (mapping), std::move (elems),
275 : 230 : tuple.get_locus ());
276 : 230 : }
277 : :
278 : : void
279 : 27112 : ASTLoweringType::visit (AST::TypePath &path)
280 : : {
281 : 27112 : translated = ASTLowerTypePath::translate (path);
282 : 27112 : }
283 : :
284 : : void
285 : 159 : ASTLoweringType::visit (AST::QualifiedPathInType &path)
286 : : {
287 : 159 : translated = ASTLowerQualifiedPathInType::translate (path);
288 : 159 : }
289 : :
290 : : void
291 : 392 : ASTLoweringType::visit (AST::ArrayType &type)
292 : : {
293 : 392 : HIR::Type *translated_type
294 : 392 : = ASTLoweringType::translate (type.get_elem_type (),
295 : 392 : default_to_static_lifetime);
296 : 392 : HIR::Expr *array_size = ASTLoweringExpr::translate (type.get_size_expr ());
297 : :
298 : 392 : auto crate_num = mappings->get_current_crate ();
299 : 392 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
300 : 392 : mappings->get_next_hir_id (crate_num),
301 : 392 : mappings->get_next_localdef_id (crate_num));
302 : :
303 : 392 : translated
304 : 784 : = new HIR::ArrayType (mapping, std::unique_ptr<HIR::Type> (translated_type),
305 : 392 : std::unique_ptr<HIR::Expr> (array_size),
306 : 392 : type.get_locus ());
307 : 392 : }
308 : :
309 : : void
310 : 1816 : ASTLoweringType::visit (AST::ReferenceType &type)
311 : : {
312 : 1816 : HIR::Lifetime lifetime
313 : 1816 : = lower_lifetime (type.get_lifetime (), default_to_static_lifetime);
314 : :
315 : 1816 : HIR::Type *base_type
316 : 3632 : = ASTLoweringType::translate (type.get_base_type (),
317 : 1816 : default_to_static_lifetime);
318 : :
319 : 1816 : auto crate_num = mappings->get_current_crate ();
320 : 1816 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
321 : 1816 : mappings->get_next_hir_id (crate_num),
322 : 1816 : mappings->get_next_localdef_id (crate_num));
323 : :
324 : 3632 : translated = new HIR::ReferenceType (mapping,
325 : 1816 : type.get_has_mut () ? Mutability::Mut
326 : : : Mutability::Imm,
327 : 3632 : std::unique_ptr<HIR::Type> (base_type),
328 : 5448 : type.get_locus (), lifetime);
329 : 1816 : }
330 : :
331 : : void
332 : 4687 : ASTLoweringType::visit (AST::RawPointerType &type)
333 : : {
334 : 4687 : HIR::Type *base_type
335 : 4687 : = ASTLoweringType::translate (type.get_type_pointed_to (),
336 : 4687 : default_to_static_lifetime);
337 : :
338 : 4687 : auto crate_num = mappings->get_current_crate ();
339 : 4687 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
340 : 4687 : mappings->get_next_hir_id (crate_num),
341 : 4687 : mappings->get_next_localdef_id (crate_num));
342 : :
343 : 4687 : translated
344 : 4687 : = new HIR::RawPointerType (mapping,
345 : 4687 : type.get_pointer_type ()
346 : : == AST::RawPointerType::PointerType::MUT
347 : : ? Mutability::Mut
348 : : : Mutability::Imm,
349 : 4687 : std::unique_ptr<HIR::Type> (base_type),
350 : 9014 : type.get_locus ());
351 : 4687 : }
352 : :
353 : : void
354 : 748 : ASTLoweringType::visit (AST::SliceType &type)
355 : : {
356 : 748 : HIR::Type *base_type
357 : 748 : = ASTLoweringType::translate (type.get_elem_type (),
358 : 748 : default_to_static_lifetime);
359 : :
360 : 748 : auto crate_num = mappings->get_current_crate ();
361 : 748 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
362 : 748 : mappings->get_next_hir_id (crate_num),
363 : 748 : mappings->get_next_localdef_id (crate_num));
364 : :
365 : 748 : translated
366 : 748 : = new HIR::SliceType (mapping, std::unique_ptr<HIR::Type> (base_type),
367 : 748 : type.get_locus ());
368 : 748 : }
369 : :
370 : : void
371 : 131 : ASTLoweringType::visit (AST::InferredType &type)
372 : : {
373 : 131 : auto crate_num = mappings->get_current_crate ();
374 : 131 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
375 : 131 : mappings->get_next_hir_id (crate_num),
376 : 131 : mappings->get_next_localdef_id (crate_num));
377 : :
378 : 131 : translated = new HIR::InferredType (mapping, type.get_locus ());
379 : 131 : }
380 : :
381 : : void
382 : 23 : ASTLoweringType::visit (AST::NeverType &type)
383 : : {
384 : 23 : auto crate_num = mappings->get_current_crate ();
385 : 23 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
386 : 23 : mappings->get_next_hir_id (crate_num),
387 : 23 : mappings->get_next_localdef_id (crate_num));
388 : :
389 : 23 : translated = new HIR::NeverType (mapping, type.get_locus ());
390 : 23 : }
391 : :
392 : : void
393 : 103 : ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type)
394 : : {
395 : 103 : std::vector<std::unique_ptr<HIR::TypeParamBound>> bounds;
396 : 103 : HIR::TypeParamBound *translated_bound
397 : 103 : = ASTLoweringTypeBounds::translate (type.get_trait_bound ());
398 : 103 : bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (translated_bound));
399 : :
400 : 103 : auto crate_num = mappings->get_current_crate ();
401 : 103 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
402 : 103 : mappings->get_next_hir_id (crate_num),
403 : 103 : mappings->get_next_localdef_id (crate_num));
404 : :
405 : 103 : translated = new HIR::TraitObjectType (mapping, std::move (bounds),
406 : 103 : type.get_locus (), type.is_dyn ());
407 : 103 : }
408 : :
409 : : void
410 : 7 : ASTLoweringType::visit (AST::TraitObjectType &type)
411 : : {
412 : 7 : std::vector<std::unique_ptr<HIR::TypeParamBound>> bounds;
413 : :
414 : 21 : for (auto &bound : type.get_type_param_bounds ())
415 : : {
416 : 14 : HIR::TypeParamBound *translated_bound
417 : 14 : = ASTLoweringTypeBounds::translate (*bound);
418 : 14 : bounds.push_back (
419 : 14 : std::unique_ptr<HIR::TypeParamBound> (translated_bound));
420 : : }
421 : :
422 : 7 : auto crate_num = mappings->get_current_crate ();
423 : 7 : Analysis::NodeMapping mapping (crate_num, type.get_node_id (),
424 : 7 : mappings->get_next_hir_id (crate_num),
425 : 7 : mappings->get_next_localdef_id (crate_num));
426 : :
427 : 7 : translated = new HIR::TraitObjectType (mapping, std::move (bounds),
428 : 7 : type.get_locus (), type.is_dyn ());
429 : 7 : }
430 : :
431 : : HIR::GenericParam *
432 : 5006 : ASTLowerGenericParam::translate (AST::GenericParam ¶m)
433 : : {
434 : 5006 : ASTLowerGenericParam resolver;
435 : 5006 : param.accept_vis (resolver);
436 : :
437 : 5006 : rust_assert (resolver.translated != nullptr);
438 : 5006 : resolver.mappings->insert_location (
439 : 5006 : resolver.translated->get_mappings ().get_hirid (), param.get_locus ());
440 : 5006 : resolver.mappings->insert_hir_generic_param (resolver.translated);
441 : :
442 : 5006 : return resolver.translated;
443 : 5006 : }
444 : :
445 : : void
446 : 148 : ASTLowerGenericParam::visit (AST::LifetimeParam ¶m)
447 : : {
448 : 148 : auto crate_num = mappings->get_current_crate ();
449 : 148 : Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
450 : 148 : mappings->get_next_hir_id (crate_num),
451 : 148 : mappings->get_next_localdef_id (crate_num));
452 : :
453 : 296 : HIR::Lifetime lt (mapping, param.get_lifetime ().get_lifetime_type (),
454 : 148 : param.get_lifetime ().get_lifetime_name (),
455 : 148 : param.get_lifetime ().get_locus ());
456 : :
457 : 148 : translated = new HIR::LifetimeParam (mapping, lt, param.get_locus (),
458 : 444 : std::vector<Lifetime> ());
459 : 148 : }
460 : :
461 : : void
462 : 16 : ASTLowerGenericParam::visit (AST::ConstGenericParam ¶m)
463 : : {
464 : 16 : auto crate_num = mappings->get_current_crate ();
465 : 16 : Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
466 : 16 : mappings->get_next_hir_id (crate_num),
467 : 16 : mappings->get_next_localdef_id (crate_num));
468 : :
469 : 16 : auto type = ASTLoweringType::translate (param.get_type ());
470 : :
471 : 16 : HIR::Expr *default_expr = nullptr;
472 : 16 : if (param.has_default_value ())
473 : 12 : default_expr = ASTLoweringExpr::translate (
474 : 12 : param.get_default_value ().get_expression ());
475 : :
476 : 48 : translated = new HIR::ConstGenericParam (param.get_name ().as_string (),
477 : 48 : std::unique_ptr<Type> (type),
478 : 32 : std::unique_ptr<Expr> (default_expr),
479 : 16 : mapping, param.get_locus ());
480 : 16 : }
481 : :
482 : : void
483 : 4842 : ASTLowerGenericParam::visit (AST::TypeParam ¶m)
484 : : {
485 : 4842 : AST::Attribute outer_attr = AST::Attribute::create_empty ();
486 : 4842 : std::vector<std::unique_ptr<HIR::TypeParamBound>> type_param_bounds;
487 : 4842 : if (param.has_type_param_bounds ())
488 : : {
489 : 502 : for (auto &bound : param.get_type_param_bounds ())
490 : : {
491 : 252 : HIR::TypeParamBound *lowered_bound = lower_bound (*bound);
492 : 252 : type_param_bounds.push_back (
493 : 252 : std::unique_ptr<HIR::TypeParamBound> (lowered_bound));
494 : : }
495 : : }
496 : :
497 : 4842 : HIR::Type *type = param.has_type ()
498 : 4842 : ? ASTLoweringType::translate (param.get_type ())
499 : 4842 : : nullptr;
500 : :
501 : 4842 : auto crate_num = mappings->get_current_crate ();
502 : 4842 : Analysis::NodeMapping mapping (crate_num, param.get_node_id (),
503 : 4842 : mappings->get_next_hir_id (crate_num),
504 : 4842 : mappings->get_next_localdef_id (crate_num));
505 : :
506 : 4842 : translated
507 : 4842 : = new HIR::TypeParam (mapping, param.get_type_representation (),
508 : : param.get_locus (), std::move (type_param_bounds),
509 : 9684 : std::unique_ptr<Type> (type), std::move (outer_attr));
510 : 4842 : }
511 : :
512 : : HIR::TypeParamBound *
513 : 597 : ASTLoweringTypeBounds::translate (AST::TypeParamBound &type)
514 : : {
515 : 597 : ASTLoweringTypeBounds resolver;
516 : 597 : type.accept_vis (resolver);
517 : :
518 : 597 : rust_assert (resolver.translated != nullptr);
519 : 597 : resolver.mappings->insert_location (
520 : 597 : resolver.translated->get_mappings ().get_hirid (),
521 : 597 : resolver.translated->get_locus ());
522 : :
523 : 597 : return resolver.translated;
524 : 597 : }
525 : :
526 : : void
527 : 585 : ASTLoweringTypeBounds::visit (AST::TraitBound &bound)
528 : : {
529 : 585 : std::vector<HIR::LifetimeParam> for_lifetimes;
530 : 592 : for (auto &lifetime_param : bound.get_for_lifetimes ())
531 : : {
532 : 7 : auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
533 : 7 : for_lifetimes.push_back (
534 : : *static_cast<HIR::LifetimeParam *> (generic_param));
535 : : }
536 : :
537 : 585 : AST::TypePath &ast_trait_path = bound.get_type_path ();
538 : 585 : HIR::TypePath *trait_path = ASTLowerTypePath::translate (ast_trait_path);
539 : :
540 : 585 : auto crate_num = mappings->get_current_crate ();
541 : 585 : Analysis::NodeMapping mapping (crate_num, bound.get_node_id (),
542 : 585 : mappings->get_next_hir_id (crate_num),
543 : 585 : UNKNOWN_LOCAL_DEFID);
544 : :
545 : 585 : BoundPolarity polarity = bound.has_opening_question_mark ()
546 : 585 : ? BoundPolarity::AntiBound
547 : 585 : : BoundPolarity::RegularBound;
548 : 585 : translated
549 : 585 : = new HIR::TraitBound (mapping, *trait_path, bound.get_locus (),
550 : 1170 : bound.is_in_parens (), polarity, for_lifetimes);
551 : 585 : }
552 : :
553 : : void
554 : 12 : ASTLoweringTypeBounds::visit (AST::Lifetime &bound)
555 : : {
556 : 12 : HIR::Lifetime lifetime = lower_lifetime (bound);
557 : 12 : translated = new HIR::Lifetime (lifetime);
558 : 12 : }
559 : :
560 : : HIR::WhereClauseItem *
561 : 81 : ASTLowerWhereClauseItem::translate (AST::WhereClauseItem &item)
562 : : {
563 : 81 : ASTLowerWhereClauseItem compiler;
564 : 81 : item.accept_vis (compiler);
565 : :
566 : 81 : rust_assert (compiler.translated != nullptr);
567 : : // FIXME
568 : : // compiler.mappings->insert_location (
569 : : // compiler.translated->get_mappings ().get_hirid (),
570 : : // compiler.translated->get_locus ());
571 : :
572 : 81 : return compiler.translated;
573 : 81 : }
574 : :
575 : : void
576 : 0 : ASTLowerWhereClauseItem::visit (AST::LifetimeWhereClauseItem &item)
577 : : {
578 : 0 : HIR::Lifetime l = lower_lifetime (item.get_lifetime ());
579 : 0 : std::vector<HIR::Lifetime> lifetime_bounds;
580 : 0 : for (auto &lifetime_bound : item.get_lifetime_bounds ())
581 : : {
582 : 0 : HIR::Lifetime ll = lower_lifetime (lifetime_bound);
583 : 0 : lifetime_bounds.push_back (std::move (ll));
584 : 0 : }
585 : :
586 : 0 : auto crate_num = mappings->get_current_crate ();
587 : 0 : Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
588 : 0 : mappings->get_next_hir_id (crate_num),
589 : 0 : UNKNOWN_LOCAL_DEFID);
590 : :
591 : 0 : translated = new HIR::LifetimeWhereClauseItem (mapping, std::move (l),
592 : : std::move (lifetime_bounds),
593 : 0 : item.get_locus ());
594 : 0 : }
595 : :
596 : : void
597 : 81 : ASTLowerWhereClauseItem::visit (AST::TypeBoundWhereClauseItem &item)
598 : : {
599 : : // FIXME
600 : 81 : std::vector<HIR::LifetimeParam> for_lifetimes;
601 : :
602 : 90 : for (auto &lifetime_param : item.get_for_lifetimes ())
603 : : {
604 : 9 : auto generic_param = ASTLowerGenericParam::translate (lifetime_param);
605 : 9 : for_lifetimes.push_back (
606 : : *static_cast<HIR::LifetimeParam *> (generic_param));
607 : : }
608 : :
609 : 81 : std::unique_ptr<HIR::Type> bound_type = std::unique_ptr<HIR::Type> (
610 : 81 : ASTLoweringType::translate (item.get_type ()));
611 : :
612 : 81 : std::vector<std::unique_ptr<HIR::TypeParamBound>> type_param_bounds;
613 : 162 : for (auto &bound : item.get_type_param_bounds ())
614 : : {
615 : 81 : HIR::TypeParamBound *b = ASTLoweringTypeBounds::translate (*bound);
616 : 81 : type_param_bounds.push_back (std::unique_ptr<HIR::TypeParamBound> (b));
617 : : }
618 : :
619 : 81 : auto crate_num = mappings->get_current_crate ();
620 : 81 : Analysis::NodeMapping mapping (crate_num, item.get_node_id (),
621 : 81 : mappings->get_next_hir_id (crate_num),
622 : 81 : UNKNOWN_LOCAL_DEFID);
623 : :
624 : 81 : translated
625 : 81 : = new HIR::TypeBoundWhereClauseItem (mapping, std::move (for_lifetimes),
626 : : std::move (bound_type),
627 : : std::move (type_param_bounds),
628 : 81 : item.get_locus ());
629 : 81 : }
630 : :
631 : : } // namespace HIR
632 : : } // namespace Rust
|
