LCOV - code coverage report
Current view: top level - gcc/rust/hir - rust-ast-lower-pattern.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 100.0 % 270 270
Test Date: 2026-11-14 16:39:50 Functions: 100.0 % 15 15
Legend: Lines:     hit not hit

            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
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.