Line data Source code
1 : // Copyright (C) 2020-2026 Free Software Foundation, Inc.
2 :
3 : // This file is part of GCC.
4 :
5 : // GCC is free software; you can redistribute it and/or modify it under
6 : // the terms of the GNU General Public License as published by the Free
7 : // Software Foundation; either version 3, or (at your option) any later
8 : // version.
9 :
10 : // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
11 : // WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : // for more details.
14 :
15 : // You should have received a copy of the GNU General Public License
16 : // along with GCC; see the file COPYING3. If not see
17 : // <http://www.gnu.org/licenses/>.
18 :
19 : #include "rust-ast-lower-pattern.h"
20 : #include "rust-ast-lower-expr.h"
21 : #include "rust-system.h"
22 :
23 : namespace Rust {
24 : namespace HIR {
25 :
26 621086 : ASTLoweringPattern::ASTLoweringPattern ()
27 621086 : : translated (nullptr), is_let_top_level (false)
28 621086 : {}
29 :
30 : HIR::Pattern *
31 621086 : ASTLoweringPattern::translate (AST::Pattern &pattern, bool is_let_top_level)
32 : {
33 621086 : ASTLoweringPattern resolver;
34 621086 : resolver.is_let_top_level = is_let_top_level;
35 621086 : pattern.accept_vis (resolver);
36 :
37 621086 : rust_assert (resolver.translated != nullptr);
38 :
39 621086 : resolver.mappings.hir.patterns.insert (resolver.translated);
40 621086 : resolver.mappings.insert_location (
41 621086 : resolver.translated->get_mappings ().get_hirid (), pattern.get_locus ());
42 :
43 621086 : return resolver.translated;
44 621086 : }
45 :
46 : void
47 179149 : ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
48 : {
49 179149 : auto crate_num = mappings.crate.get_current_crate ();
50 358298 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
51 179149 : mappings.get_next_hir_id (crate_num),
52 179149 : UNKNOWN_LOCAL_DEFID);
53 :
54 179149 : std::unique_ptr<Pattern> subpattern;
55 179149 : if (pattern.has_subpattern ())
56 : {
57 119 : subpattern = std::unique_ptr<Pattern> (
58 119 : ASTLoweringPattern::translate (pattern.get_subpattern ()));
59 : }
60 179149 : translated
61 179149 : = new HIR::IdentifierPattern (mapping, pattern.get_ident (),
62 : pattern.get_locus (), pattern.get_is_ref (),
63 179149 : pattern.get_is_mut () ? Mutability::Mut
64 : : Mutability::Imm,
65 528404 : std::move (subpattern));
66 179149 : }
67 :
68 : void
69 7453 : ASTLoweringPattern::visit (AST::PathInExpression &pattern)
70 : {
71 7453 : translated = ASTLowerPathInExpression::translate (pattern);
72 7453 : }
73 :
74 : void
75 11983 : ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
76 : {
77 11983 : HIR::PathInExpression *path
78 11983 : = ASTLowerPathInExpression::translate (pattern.get_path ());
79 :
80 11983 : TupleStructItems *lowered = nullptr;
81 11983 : auto &items = pattern.get_items ();
82 11983 : switch (items.get_item_type ())
83 : {
84 184 : case AST::TupleStructItems::HAS_REST:
85 184 : {
86 184 : AST::TupleStructItemsHasRest &items_has_rest
87 : = static_cast<AST::TupleStructItemsHasRest &> (items);
88 :
89 184 : std::vector<std::unique_ptr<HIR::Pattern>> lower_patterns;
90 184 : lower_patterns.reserve (items_has_rest.get_lower_patterns ().size ());
91 244 : for (auto &pattern_member : items_has_rest.get_lower_patterns ())
92 : {
93 60 : lower_patterns.emplace_back (
94 60 : ASTLoweringPattern::translate (*pattern_member));
95 : }
96 :
97 184 : std::vector<std::unique_ptr<HIR::Pattern>> upper_patterns;
98 184 : upper_patterns.reserve (items_has_rest.get_upper_patterns ().size ());
99 230 : for (auto &pattern_member : items_has_rest.get_upper_patterns ())
100 : {
101 46 : upper_patterns.emplace_back (
102 46 : ASTLoweringPattern::translate (*pattern_member));
103 : }
104 :
105 184 : lowered = new HIR::TupleStructItemsHasRest (std::move (lower_patterns),
106 184 : std::move (upper_patterns));
107 184 : }
108 184 : break;
109 :
110 11799 : case AST::TupleStructItems::NO_REST:
111 11799 : {
112 11799 : AST::TupleStructItemsNoRest &items_no_rest
113 : = static_cast<AST::TupleStructItemsNoRest &> (items);
114 :
115 11799 : std::vector<std::unique_ptr<HIR::Pattern>> patterns;
116 11799 : patterns.reserve (items_no_rest.get_patterns ().size ());
117 :
118 23926 : for (auto &inner_pattern : items_no_rest.get_patterns ())
119 12127 : patterns.emplace_back (
120 12127 : ASTLoweringPattern::translate (*inner_pattern));
121 :
122 11799 : lowered = new HIR::TupleStructItemsNoRest (std::move (patterns));
123 11799 : }
124 11799 : break;
125 : }
126 :
127 11983 : auto crate_num = mappings.crate.get_current_crate ();
128 23966 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
129 11983 : mappings.get_next_hir_id (crate_num),
130 11983 : UNKNOWN_LOCAL_DEFID);
131 :
132 23966 : translated = new HIR::TupleStructPattern (
133 11983 : mapping, *path, std::unique_ptr<HIR::TupleStructItems> (lowered));
134 11983 : }
135 :
136 : void
137 572 : ASTLoweringPattern::visit (AST::StructPattern &pattern)
138 : {
139 572 : HIR::PathInExpression *path
140 572 : = ASTLowerPathInExpression::translate (pattern.get_path ());
141 :
142 572 : auto &raw_elems = pattern.get_struct_pattern_elems ();
143 :
144 572 : std::vector<std::unique_ptr<HIR::StructPatternField>> fields;
145 1382 : for (auto &field : raw_elems.get_struct_pattern_fields ())
146 : {
147 810 : HIR::StructPatternField *f = nullptr;
148 810 : switch (field->get_item_type ())
149 : {
150 36 : case AST::StructPatternField::ItemType::TUPLE_PAT:
151 36 : {
152 36 : auto &tuple
153 36 : = static_cast<AST::StructPatternFieldTuplePat &> (*field);
154 :
155 36 : auto crate_num = mappings.crate.get_current_crate ();
156 36 : Analysis::NodeMapping mapping (crate_num, tuple.get_node_id (),
157 36 : mappings.get_next_hir_id (crate_num),
158 36 : UNKNOWN_LOCAL_DEFID);
159 :
160 36 : std::unique_ptr<HIR::Pattern> pat (
161 36 : ASTLoweringPattern::translate (tuple.get_index_pattern ()));
162 :
163 72 : f = new HIR::StructPatternFieldTuplePat (mapping,
164 : tuple.get_index (),
165 : std::move (pat),
166 36 : tuple.get_outer_attrs (),
167 36 : tuple.get_locus ());
168 36 : }
169 36 : break;
170 :
171 515 : case AST::StructPatternField::ItemType::IDENT_PAT:
172 515 : {
173 515 : AST::StructPatternFieldIdentPat &ident
174 515 : = static_cast<AST::StructPatternFieldIdentPat &> (*field);
175 :
176 515 : auto crate_num = mappings.crate.get_current_crate ();
177 515 : Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
178 515 : mappings.get_next_hir_id (crate_num),
179 515 : UNKNOWN_LOCAL_DEFID);
180 :
181 515 : std::unique_ptr<HIR::Pattern> pat (
182 515 : ASTLoweringPattern::translate (ident.get_ident_pattern ()));
183 :
184 515 : f = new HIR::StructPatternFieldIdentPat (mapping,
185 : ident.get_identifier (),
186 : std::move (pat),
187 515 : ident.get_outer_attrs (),
188 1030 : ident.get_locus ());
189 515 : }
190 515 : break;
191 :
192 259 : case AST::StructPatternField::ItemType::IDENT:
193 259 : {
194 259 : AST::StructPatternFieldIdent &ident
195 259 : = static_cast<AST::StructPatternFieldIdent &> (*field.get ());
196 :
197 259 : auto crate_num = mappings.crate.get_current_crate ();
198 259 : Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
199 259 : mappings.get_next_hir_id (crate_num),
200 259 : UNKNOWN_LOCAL_DEFID);
201 :
202 259 : f = new HIR::StructPatternFieldIdent (
203 : mapping, ident.get_identifier (), ident.is_ref (),
204 259 : ident.is_mut () ? Mutability::Mut : Mutability::Imm,
205 775 : ident.get_outer_attrs (), ident.get_locus ());
206 : }
207 259 : break;
208 : }
209 :
210 : // insert the reverse mappings and locations
211 810 : auto field_id = f->get_mappings ().get_hirid ();
212 810 : auto field_node_id = f->get_mappings ().get_nodeid ();
213 810 : mappings.insert_location (field_id, f->get_locus ());
214 810 : mappings.insert_node_to_hir (field_node_id, field_id);
215 :
216 : // add it to the lowered fields list
217 810 : fields.emplace_back (f);
218 : }
219 :
220 572 : auto crate_num = mappings.crate.get_current_crate ();
221 1144 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
222 572 : mappings.get_next_hir_id (crate_num),
223 572 : UNKNOWN_LOCAL_DEFID);
224 :
225 572 : HIR::StructPatternElements elems (
226 572 : std::move (fields), pattern.get_struct_pattern_elems ().has_rest ());
227 572 : translated = new HIR::StructPattern (mapping, *path, std::move (elems));
228 572 : }
229 :
230 : void
231 36795 : ASTLoweringPattern::visit (AST::WildcardPattern &pattern)
232 : {
233 36795 : auto crate_num = mappings.crate.get_current_crate ();
234 73590 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
235 36795 : mappings.get_next_hir_id (crate_num),
236 36795 : UNKNOWN_LOCAL_DEFID);
237 :
238 36795 : translated = new HIR::WildcardPattern (mapping, pattern.get_locus ());
239 36795 : }
240 :
241 : void
242 20834 : ASTLoweringPattern::visit (AST::TuplePattern &pattern)
243 : {
244 20834 : std::unique_ptr<HIR::TuplePatternItems> items;
245 20834 : switch (pattern.get_items ().get_item_type ())
246 : {
247 20796 : case AST::TuplePatternItems::ItemType::NO_REST:
248 20796 : {
249 20796 : AST::TuplePatternItemsNoRest &ref
250 20796 : = static_cast<AST::TuplePatternItemsNoRest &> (pattern.get_items ());
251 20796 : items = lower_tuple_pattern_multiple (ref);
252 : }
253 20796 : break;
254 :
255 38 : case AST::TuplePatternItems::ItemType::HAS_REST:
256 38 : {
257 38 : AST::TuplePatternItemsHasRest &ref
258 38 : = static_cast<AST::TuplePatternItemsHasRest &> (pattern.get_items ());
259 38 : items = lower_tuple_pattern_ranged (ref);
260 : }
261 38 : break;
262 : }
263 :
264 20834 : auto crate_num = mappings.crate.get_current_crate ();
265 41668 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
266 20834 : mappings.get_next_hir_id (crate_num),
267 20834 : UNKNOWN_LOCAL_DEFID);
268 :
269 20834 : translated
270 20834 : = new HIR::TuplePattern (mapping, std::move (items), pattern.get_locus ());
271 20834 : }
272 :
273 : void
274 361137 : ASTLoweringPattern::visit (AST::LiteralPattern &pattern)
275 : {
276 361137 : auto crate_num = mappings.crate.get_current_crate ();
277 722274 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
278 361137 : mappings.get_next_hir_id (crate_num),
279 361137 : UNKNOWN_LOCAL_DEFID);
280 :
281 361137 : HIR::Literal l = lower_literal (pattern.get_literal ());
282 361137 : translated
283 361137 : = new HIR::LiteralPattern (mapping, std::move (l), pattern.get_locus (),
284 722274 : pattern.get_has_minus ());
285 361137 : }
286 :
287 : void
288 631 : ASTLoweringPattern::visit (AST::RangePattern &pattern)
289 : {
290 631 : auto upper_bound = lower_range_pattern_bound (pattern.get_upper_bound ());
291 631 : auto lower_bound = lower_range_pattern_bound (pattern.get_lower_bound ());
292 :
293 631 : auto crate_num = mappings.crate.get_current_crate ();
294 1262 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
295 631 : mappings.get_next_hir_id (crate_num),
296 631 : UNKNOWN_LOCAL_DEFID);
297 :
298 631 : bool is_inclusive = (pattern.get_range_kind () == AST::RangeKind::INCLUDED);
299 :
300 631 : translated = new HIR::RangePattern (mapping, std::move (lower_bound),
301 : std::move (upper_bound),
302 631 : pattern.get_locus (), is_inclusive);
303 631 : }
304 :
305 : void
306 6 : ASTLoweringPattern::visit (AST::GroupedPattern &pattern)
307 : {
308 6 : is_let_top_level = false;
309 6 : pattern.get_pattern_in_parens ().accept_vis (*this);
310 6 : }
311 :
312 : void
313 1867 : ASTLoweringPattern::visit (AST::ReferencePattern &pattern)
314 : {
315 1867 : auto crate_num = mappings.crate.get_current_crate ();
316 3734 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
317 1867 : mappings.get_next_hir_id (crate_num),
318 1867 : UNKNOWN_LOCAL_DEFID);
319 :
320 1867 : HIR::Pattern *inner
321 1867 : = ASTLoweringPattern::translate (pattern.get_referenced_pattern ());
322 :
323 1867 : translated
324 1867 : = new HIR::ReferencePattern (mapping, std::unique_ptr<HIR::Pattern> (inner),
325 1867 : pattern.get_is_mut () ? Mutability::Mut
326 : : Mutability::Imm,
327 3717 : pattern.get_locus ());
328 :
329 1867 : if (pattern.is_double_reference ())
330 : {
331 68 : Analysis::NodeMapping mapping2 (crate_num, pattern.get_node_id (),
332 34 : mappings.get_next_hir_id (crate_num),
333 34 : UNKNOWN_LOCAL_DEFID);
334 34 : translated
335 34 : = new HIR::ReferencePattern (mapping2,
336 34 : std::unique_ptr<HIR::Pattern> (translated),
337 34 : Mutability::Imm, pattern.get_locus ());
338 : }
339 1867 : }
340 :
341 : template <typename It>
342 : static std::vector<std::unique_ptr<HIR::Pattern>>
343 368 : lower_pattern_seq (It begin, It end)
344 : {
345 368 : std::vector<std::unique_ptr<HIR::Pattern>> ret;
346 368 : ret.reserve (end - begin);
347 706 : for (auto it = begin; it != end; it++)
348 338 : ret.emplace_back (ASTLoweringPattern::translate (**it));
349 368 : return ret;
350 : }
351 :
352 : void
353 221 : ASTLoweringPattern::visit (AST::SlicePattern &pattern)
354 : {
355 221 : tl::optional<size_t> rest_index;
356 221 : tl::optional<HIR::IdentifierPattern> rest_bind;
357 :
358 221 : std::vector<std::unique_ptr<AST::Pattern>> &sub_patterns
359 221 : = pattern.get_patterns ();
360 :
361 : // need this earlier than usual
362 : // since we might need to produce rest_bind
363 221 : auto crate_num = mappings.crate.get_current_crate ();
364 :
365 701 : for (size_t i = 0; i < sub_patterns.size (); i++)
366 : {
367 406 : auto &pat = sub_patterns[i];
368 :
369 : // ASTValidation verified there's only one Rest pattern
370 : // so we can break once we find the first one
371 406 : if (pat->get_pattern_kind () == AST::Pattern::Kind::Identifier)
372 : {
373 191 : auto &ident_pat = static_cast<AST::IdentifierPattern &> (*pat);
374 191 : if (ident_pat.has_subpattern ())
375 : {
376 33 : if (ident_pat.get_subpattern ().get_pattern_kind ()
377 : == AST::Pattern::Kind::Rest)
378 : {
379 33 : Analysis::NodeMapping rest_bind_mapping (
380 33 : crate_num, ident_pat.get_node_id (),
381 33 : mappings.get_next_hir_id (crate_num), UNKNOWN_LOCAL_DEFID);
382 :
383 33 : rest_bind = HIR::IdentifierPattern (
384 66 : std::move (rest_bind_mapping), ident_pat.get_ident (),
385 : ident_pat.get_locus (), ident_pat.get_is_ref (),
386 33 : ident_pat.get_is_mut () ? Mutability::Mut
387 99 : : Mutability::Imm);
388 33 : rest_index = i;
389 33 : break;
390 : }
391 : }
392 : }
393 215 : else if (pat->get_pattern_kind () == AST::Pattern::Kind::Rest)
394 : {
395 114 : rest_index = i;
396 114 : break;
397 : }
398 : }
399 :
400 221 : std::unique_ptr<HIR::SlicePatternItems> items;
401 :
402 221 : if (rest_index)
403 : {
404 147 : auto rest_it = sub_patterns.begin () + *rest_index;
405 441 : items = std::make_unique<HIR::SlicePatternItemsHasRest> (
406 294 : lower_pattern_seq (sub_patterns.begin (), rest_it),
407 294 : lower_pattern_seq (rest_it + 1, sub_patterns.end ()),
408 147 : std::move (rest_bind));
409 : }
410 : else
411 : {
412 148 : items = std::make_unique<HIR::SlicePatternItemsNoRest> (
413 222 : lower_pattern_seq (sub_patterns.begin (), sub_patterns.end ()));
414 : }
415 :
416 442 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
417 221 : mappings.get_next_hir_id (crate_num),
418 221 : UNKNOWN_LOCAL_DEFID);
419 :
420 221 : translated
421 221 : = new HIR::SlicePattern (mapping, std::move (items), pattern.get_locus ());
422 221 : }
423 :
424 : void
425 444 : ASTLoweringPattern::visit (AST::AltPattern &pattern)
426 : {
427 444 : auto crate_num = mappings.crate.get_current_crate ();
428 888 : Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
429 444 : mappings.get_next_hir_id (crate_num),
430 444 : UNKNOWN_LOCAL_DEFID);
431 :
432 444 : std::vector<std::unique_ptr<HIR::Pattern>> alts;
433 444 : alts.reserve (pattern.get_alts ().size ());
434 :
435 1517 : for (auto &alt : pattern.get_alts ())
436 1073 : alts.emplace_back (ASTLoweringPattern::translate (*alt));
437 :
438 444 : translated
439 444 : = new HIR::AltPattern (mapping, std::move (alts), pattern.get_locus ());
440 :
441 444 : if (is_let_top_level)
442 : {
443 1 : rich_location richloc (line_table, pattern.get_locus ());
444 1 : richloc.add_fixit_replace ("use an outer grouped pattern");
445 1 : rust_error_at (
446 : richloc, "top level or-patterns are not allowed for %<let%> bindings");
447 1 : }
448 444 : }
449 :
450 : } // namespace HIR
451 : } // namespace Rust
|