gcc/rust/hir/rust-ast-lower-pattern.cc

   1 // Copyright (C) 2020-2023 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
  22 namespace Rust {
  23 namespace HIR {
  24
  25 void
  26 ASTLoweringPattern::visit (AST::IdentifierPattern &pattern)
  27 {
  28   auto crate_num = mappings->get_current_crate ();
  29   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
  30                                  mappings->get_next_hir_id (crate_num),
  31                                  UNKNOWN_LOCAL_DEFID);
  32
  33   std::unique_ptr<Pattern> to_bind;
  34   translated
  35     = new HIR::IdentifierPattern (mapping, pattern.get_ident (),
  36                                   pattern.get_locus (), pattern.get_is_ref (),
  37                                   pattern.get_is_mut () ? Mutability::Mut
  38                                                         : Mutability::Imm,
  39                                   std::move (to_bind));
  40 }
  41
  42 void
  43 ASTLoweringPattern::visit (AST::PathInExpression &pattern)
  44 {
  45   translated = ASTLowerPathInExpression::translate (&pattern);
  46 }
  47
  48 void
  49 ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
  50 {
  51   HIR::PathInExpression *path
  52     = ASTLowerPathInExpression::translate (&pattern.get_path ());
  53
  54   TupleStructItems *lowered = nullptr;
  55   auto &items = pattern.get_items ();
  56   switch (items->get_item_type ())
  57     {
  58       case AST::TupleStructItems::RANGE: {
  59         // TODO
  60         gcc_unreachable ();
  61       }
  62       break;
  63
  64       case AST::TupleStructItems::NO_RANGE: {
  65         AST::TupleStructItemsNoRange &items_no_range
  66           = static_cast<AST::TupleStructItemsNoRange &> (*items.get ());
  67
  68         std::vector<std::unique_ptr<HIR::Pattern> > patterns;
  69         for (auto &inner_pattern : items_no_range.get_patterns ())
  70           {
  71             HIR::Pattern *p
  72               = ASTLoweringPattern::translate (inner_pattern.get ());
  73             patterns.push_back (std::unique_ptr<HIR::Pattern> (p));
  74           }
  75
  76         lowered = new HIR::TupleStructItemsNoRange (std::move (patterns));
  77       }
  78       break;
  79     }
  80
  81   auto crate_num = mappings->get_current_crate ();
  82   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
  83                                  mappings->get_next_hir_id (crate_num),
  84                                  UNKNOWN_LOCAL_DEFID);
  85
  86   translated = new HIR::TupleStructPattern (
  87     mapping, *path, std::unique_ptr<HIR::TupleStructItems> (lowered));
  88 }
  89
  90 void
  91 ASTLoweringPattern::visit (AST::StructPattern &pattern)
  92 {
  93   HIR::PathInExpression *path
  94     = ASTLowerPathInExpression::translate (&pattern.get_path ());
  95
  96   auto &raw_elems = pattern.get_struct_pattern_elems ();
  97   rust_assert (!raw_elems.has_etc ());
  98
  99   std::vector<std::unique_ptr<HIR::StructPatternField> > fields;
 100   for (auto &field : raw_elems.get_struct_pattern_fields ())
 101     {
 102       HIR::StructPatternField *f = nullptr;
 103       switch (field->get_item_type ())
 104         {
 105           case AST::StructPatternField::ItemType::TUPLE_PAT: {
 106             // TODO
 107             gcc_unreachable ();
 108           }
 109           break;
 110
 111           case AST::StructPatternField::ItemType::IDENT_PAT: {
 112             // TODO
 113             gcc_unreachable ();
 114           }
 115           break;
 116
 117           case AST::StructPatternField::ItemType::IDENT: {
 118             AST::StructPatternFieldIdent &ident
 119               = static_cast<AST::StructPatternFieldIdent &> (*field.get ());
 120
 121             auto crate_num = mappings->get_current_crate ();
 122             Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
 123                                            mappings->get_next_hir_id (
 124                                              crate_num),
 125                                            UNKNOWN_LOCAL_DEFID);
 126
 127             f = new HIR::StructPatternFieldIdent (
 128               mapping, ident.get_identifier (), ident.is_ref (),
 129               ident.is_mut () ? Mutability::Mut : Mutability::Imm,
 130               ident.get_outer_attrs (), ident.get_locus ());
 131           }
 132           break;
 133         }
 134
 135       // insert the reverse mappings and locations
 136       auto field_id = f->get_mappings ().get_hirid ();
 137       auto field_node_id = f->get_mappings ().get_nodeid ();
 138       mappings->insert_location (field_id, f->get_locus ());
 139       mappings->insert_node_to_hir (field_node_id, field_id);
 140
 141       // add it to the lowered fields list
 142       fields.push_back (std::unique_ptr<HIR::StructPatternField> (f));
 143     }
 144
 145   auto crate_num = mappings->get_current_crate ();
 146   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
 147                                  mappings->get_next_hir_id (crate_num),
 148                                  UNKNOWN_LOCAL_DEFID);
 149
 150   HIR::StructPatternElements elems (std::move (fields));
 151   translated = new HIR::StructPattern (mapping, *path, std::move (elems));
 152 }
 153
 154 void
 155 ASTLoweringPattern::visit (AST::WildcardPattern &pattern)
 156 {
 157   auto crate_num = mappings->get_current_crate ();
 158   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
 159                                  mappings->get_next_hir_id (crate_num),
 160                                  UNKNOWN_LOCAL_DEFID);
 161
 162   translated = new HIR::WildcardPattern (mapping, pattern.get_locus ());
 163 }
 164
 165 void
 166 ASTLoweringPattern::visit (AST::TuplePattern &pattern)
 167 {
 168   std::unique_ptr<HIR::TuplePatternItems> items;
 169   switch (pattern.get_items ()->get_pattern_type ())
 170     {
 171       case AST::TuplePatternItems::TuplePatternItemType::MULTIPLE: {
 172         AST::TuplePatternItemsMultiple &ref
 173           = *static_cast<AST::TuplePatternItemsMultiple *> (
 174             pattern.get_items ().get ());
 175         items = lower_tuple_pattern_multiple (ref);
 176       }
 177       break;
 178
 179       case AST::TuplePatternItems::TuplePatternItemType::RANGED: {
 180         AST::TuplePatternItemsRanged &ref
 181           = *static_cast<AST::TuplePatternItemsRanged *> (
 182             pattern.get_items ().get ());
 183         items = lower_tuple_pattern_ranged (ref);
 184       }
 185       break;
 186     }
 187
 188   auto crate_num = mappings->get_current_crate ();
 189   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
 190                                  mappings->get_next_hir_id (crate_num),
 191                                  UNKNOWN_LOCAL_DEFID);
 192
 193   translated
 194     = new HIR::TuplePattern (mapping, std::move (items), pattern.get_locus ());
 195 }
 196
 197 void
 198 ASTLoweringPattern::visit (AST::LiteralPattern &pattern)
 199 {
 200   auto crate_num = mappings->get_current_crate ();
 201   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
 202                                  mappings->get_next_hir_id (crate_num),
 203                                  UNKNOWN_LOCAL_DEFID);
 204
 205   HIR::Literal l = lower_literal (pattern.get_literal ());
 206   translated
 207     = new HIR::LiteralPattern (mapping, std::move (l), pattern.get_locus ());
 208 }
 209
 210 void
 211 ASTLoweringPattern::visit (AST::RangePattern &pattern)
 212 {
 213   auto upper_bound
 214     = lower_range_pattern_bound (pattern.get_upper_bound ().get ());
 215   auto lower_bound
 216     = lower_range_pattern_bound (pattern.get_lower_bound ().get ());
 217
 218   auto crate_num = mappings->get_current_crate ();
 219   Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
 220                                  mappings->get_next_hir_id (crate_num),
 221                                  UNKNOWN_LOCAL_DEFID);
 222
 223   translated
 224     = new HIR::RangePattern (mapping, std::move (lower_bound),
 225                              std::move (upper_bound), pattern.get_locus ());
 226 }
 227
 228 } // namespace HIR
 229 } // namespace Rust