gcc/rust/hir/tree/rust-hir-pattern.h

   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 #ifndef RUST_HIR_PATTERN_H
  20 #define RUST_HIR_PATTERN_H
  21
  22 #include "rust-common.h"
  23 #include "rust-hir.h"
  24
  25 namespace Rust {
  26 namespace HIR {
  27
  28 // Literal pattern HIR node (comparing to a literal)
  29 class LiteralPattern : public Pattern
  30 {
  31   Literal lit;
  32   Location locus;
  33   Analysis::NodeMapping mappings;
  34
  35 public:
  36   std::string as_string () const override;
  37
  38   // Constructor for a literal pattern
  39   LiteralPattern (Analysis::NodeMapping mappings, Literal lit, Location locus)
  40     : lit (std::move (lit)), locus (locus), mappings (mappings)
  41   {}
  42
  43   LiteralPattern (Analysis::NodeMapping mappings, std::string val,
  44                   Literal::LitType type, Location locus)
  45     : lit (Literal (std::move (val), type, PrimitiveCoreType::CORETYPE_STR)),
  46       locus (locus), mappings (mappings)
  47   {}
  48
  49   Location get_locus () const override { return locus; }
  50
  51   void accept_vis (HIRFullVisitor &vis) override;
  52   void accept_vis (HIRPatternVisitor &vis) override;
  53
  54   Analysis::NodeMapping get_pattern_mappings () const override final
  55   {
  56     return mappings;
  57   }
  58
  59   PatternType get_pattern_type () const override final
  60   {
  61     return PatternType::LITERAL;
  62   }
  63
  64   Literal &get_literal () { return lit; }
  65   const Literal &get_literal () const { return lit; }
  66
  67 protected:
  68   /* Use covariance to implement clone function as returning this object rather
  69    * than base */
  70   virtual LiteralPattern *clone_pattern_impl () const override
  71   {
  72     return new LiteralPattern (*this);
  73   }
  74 };
  75
  76 // Identifier pattern HIR node (bind value matched to a variable)
  77 class IdentifierPattern : public Pattern
  78 {
  79   Identifier variable_ident;
  80   bool is_ref;
  81   Mutability mut;
  82   std::unique_ptr<Pattern> to_bind;
  83   Location locus;
  84   Analysis::NodeMapping mappings;
  85
  86 public:
  87   std::string as_string () const override;
  88
  89   // Returns whether the IdentifierPattern has a pattern to bind.
  90   bool has_pattern_to_bind () const { return to_bind != nullptr; }
  91
  92   // Constructor
  93   IdentifierPattern (Analysis::NodeMapping mappings, Identifier ident,
  94                      Location locus, bool is_ref = false,
  95                      Mutability mut = Mutability::Imm,
  96                      std::unique_ptr<Pattern> to_bind = nullptr)
  97     : variable_ident (std::move (ident)), is_ref (is_ref), mut (mut),
  98       to_bind (std::move (to_bind)), locus (locus), mappings (mappings)
  99   {}
 100
 101   // Copy constructor with clone
 102   IdentifierPattern (IdentifierPattern const &other)
 103     : variable_ident (other.variable_ident), is_ref (other.is_ref),
 104       mut (other.mut), locus (other.locus), mappings (other.mappings)
 105   {
 106     // fix to get prevent null pointer dereference
 107     if (other.to_bind != nullptr)
 108       to_bind = other.to_bind->clone_pattern ();
 109   }
 110
 111   // Overload assignment operator to use clone
 112   IdentifierPattern &operator= (IdentifierPattern const &other)
 113   {
 114     variable_ident = other.variable_ident;
 115     is_ref = other.is_ref;
 116     mut = other.mut;
 117     locus = other.locus;
 118     mappings = other.mappings;
 119
 120     // fix to get prevent null pointer dereference
 121     if (other.to_bind != nullptr)
 122       to_bind = other.to_bind->clone_pattern ();
 123
 124     return *this;
 125   }
 126
 127   // default move semantics
 128   IdentifierPattern (IdentifierPattern &&other) = default;
 129   IdentifierPattern &operator= (IdentifierPattern &&other) = default;
 130
 131   Location get_locus () const override { return locus; }
 132
 133   bool is_mut () const { return mut == Mutability::Mut; }
 134
 135   void accept_vis (HIRFullVisitor &vis) override;
 136   void accept_vis (HIRPatternVisitor &vis) override;
 137
 138   Analysis::NodeMapping get_pattern_mappings () const override final
 139   {
 140     return mappings;
 141   }
 142
 143   Identifier get_identifier () const { return variable_ident; }
 144
 145   PatternType get_pattern_type () const override final
 146   {
 147     return PatternType::IDENTIFIER;
 148   }
 149
 150 protected:
 151   /* Use covariance to implement clone function as returning this object rather
 152    * than base */
 153   IdentifierPattern *clone_pattern_impl () const override
 154   {
 155     return new IdentifierPattern (*this);
 156   }
 157 };
 158
 159 // HIR node for using the '_' wildcard "match any value" pattern
 160 class WildcardPattern : public Pattern
 161 {
 162   Location locus;
 163   Analysis::NodeMapping mappings;
 164
 165 public:
 166   std::string as_string () const override { return std::string (1, '_'); }
 167
 168   WildcardPattern (Analysis::NodeMapping mappings, Location locus)
 169     : locus (locus), mappings (mappings)
 170   {}
 171
 172   Location get_locus () const override { return locus; }
 173
 174   void accept_vis (HIRFullVisitor &vis) override;
 175   void accept_vis (HIRPatternVisitor &vis) override;
 176
 177   Analysis::NodeMapping get_pattern_mappings () const override final
 178   {
 179     return mappings;
 180   }
 181
 182   PatternType get_pattern_type () const override final
 183   {
 184     return PatternType::WILDCARD;
 185   }
 186
 187 protected:
 188   /* Use covariance to implement clone function as returning this object rather
 189    * than base */
 190   WildcardPattern *clone_pattern_impl () const override
 191   {
 192     return new WildcardPattern (*this);
 193   }
 194 };
 195
 196 // Base range pattern bound (lower or upper limit) - abstract
 197 class RangePatternBound
 198 {
 199 public:
 200   enum RangePatternBoundType
 201   {
 202     LITERAL,
 203     PATH,
 204     QUALPATH
 205   };
 206
 207   virtual ~RangePatternBound () {}
 208
 209   // Unique pointer custom clone function
 210   std::unique_ptr<RangePatternBound> clone_range_pattern_bound () const
 211   {
 212     return std::unique_ptr<RangePatternBound> (
 213       clone_range_pattern_bound_impl ());
 214   }
 215
 216   virtual std::string as_string () const = 0;
 217
 218   virtual void accept_vis (HIRFullVisitor &vis) = 0;
 219
 220   virtual RangePatternBoundType get_bound_type () const = 0;
 221
 222 protected:
 223   // pure virtual as RangePatternBound is abstract
 224   virtual RangePatternBound *clone_range_pattern_bound_impl () const = 0;
 225 };
 226
 227 // Literal-based pattern bound
 228 class RangePatternBoundLiteral : public RangePatternBound
 229 {
 230   Literal literal;
 231   /* Can only be a char, byte, int, or float literal - same impl here as
 232    * previously */
 233
 234   // Minus prefixed to literal (if integer or floating-point)
 235   bool has_minus;
 236
 237   Location locus;
 238
 239 public:
 240   // Constructor
 241   RangePatternBoundLiteral (Literal literal, Location locus,
 242                             bool has_minus = false)
 243     : literal (literal), has_minus (has_minus), locus (locus)
 244   {}
 245
 246   std::string as_string () const override;
 247
 248   Location get_locus () const { return locus; }
 249
 250   Literal get_literal () const { return literal; }
 251
 252   void accept_vis (HIRFullVisitor &vis) override;
 253
 254   RangePatternBoundType get_bound_type () const override
 255   {
 256     return RangePatternBoundType::LITERAL;
 257   }
 258
 259 protected:
 260   /* Use covariance to implement clone function as returning this object rather
 261    * than base */
 262   RangePatternBoundLiteral *clone_range_pattern_bound_impl () const override
 263   {
 264     return new RangePatternBoundLiteral (*this);
 265   }
 266 };
 267
 268 // Path-based pattern bound
 269 class RangePatternBoundPath : public RangePatternBound
 270 {
 271   PathInExpression path;
 272
 273   /* TODO: should this be refactored so that PathInExpression is a subclass of
 274    * RangePatternBound? */
 275
 276 public:
 277   RangePatternBoundPath (PathInExpression path) : path (std::move (path)) {}
 278
 279   std::string as_string () const override { return path.as_string (); }
 280
 281   Location get_locus () const { return path.get_locus (); }
 282
 283   PathInExpression &get_path () { return path; }
 284   const PathInExpression &get_path () const { return path; }
 285
 286   void accept_vis (HIRFullVisitor &vis) override;
 287
 288   RangePatternBoundType get_bound_type () const override
 289   {
 290     return RangePatternBoundType::PATH;
 291   }
 292
 293 protected:
 294   /* Use covariance to implement clone function as returning this object rather
 295    * than base */
 296   RangePatternBoundPath *clone_range_pattern_bound_impl () const override
 297   {
 298     return new RangePatternBoundPath (*this);
 299   }
 300 };
 301
 302 // Qualified path-based pattern bound
 303 class RangePatternBoundQualPath : public RangePatternBound
 304 {
 305   QualifiedPathInExpression path;
 306
 307   /* TODO: should this be refactored so that QualifiedPathInExpression is a
 308    * subclass of RangePatternBound? */
 309
 310 public:
 311   RangePatternBoundQualPath (QualifiedPathInExpression path)
 312     : path (std::move (path))
 313   {}
 314
 315   std::string as_string () const override { return path.as_string (); }
 316
 317   Location get_locus () const { return path.get_locus (); }
 318
 319   void accept_vis (HIRFullVisitor &vis) override;
 320
 321   QualifiedPathInExpression &get_qualified_path () { return path; }
 322   const QualifiedPathInExpression &get_qualified_path () const { return path; }
 323
 324   RangePatternBoundType get_bound_type () const override
 325   {
 326     return RangePatternBoundType::QUALPATH;
 327   }
 328
 329 protected:
 330   /* Use covariance to implement clone function as returning this object rather
 331    * than base */
 332   RangePatternBoundQualPath *clone_range_pattern_bound_impl () const override
 333   {
 334     return new RangePatternBoundQualPath (*this);
 335   }
 336 };
 337
 338 // HIR node for matching within a certain range (range pattern)
 339 class RangePattern : public Pattern
 340 {
 341   std::unique_ptr<RangePatternBound> lower;
 342   std::unique_ptr<RangePatternBound> upper;
 343
 344   bool has_ellipsis_syntax;
 345
 346   /* location only stored to avoid a dereference - lower pattern should give
 347    * correct location so maybe change in future */
 348   Location locus;
 349   Analysis::NodeMapping mappings;
 350
 351 public:
 352   std::string as_string () const override;
 353
 354   // Constructor
 355   RangePattern (Analysis::NodeMapping mappings,
 356                 std::unique_ptr<RangePatternBound> lower,
 357                 std::unique_ptr<RangePatternBound> upper, Location locus,
 358                 bool has_ellipsis_syntax = false)
 359     : lower (std::move (lower)), upper (std::move (upper)),
 360       has_ellipsis_syntax (has_ellipsis_syntax), locus (locus),
 361       mappings (mappings)
 362   {}
 363
 364   // Copy constructor with clone
 365   RangePattern (RangePattern const &other)
 366     : lower (other.lower->clone_range_pattern_bound ()),
 367       upper (other.upper->clone_range_pattern_bound ()),
 368       has_ellipsis_syntax (other.has_ellipsis_syntax), locus (other.locus),
 369       mappings (other.mappings)
 370   {}
 371
 372   // Overloaded assignment operator to clone
 373   RangePattern &operator= (RangePattern const &other)
 374   {
 375     lower = other.lower->clone_range_pattern_bound ();
 376     upper = other.upper->clone_range_pattern_bound ();
 377     has_ellipsis_syntax = other.has_ellipsis_syntax;
 378     locus = other.locus;
 379     mappings = other.mappings;
 380
 381     return *this;
 382   }
 383
 384   // default move semantics
 385   RangePattern (RangePattern &&other) = default;
 386   RangePattern &operator= (RangePattern &&other) = default;
 387
 388   Location get_locus () const override { return locus; }
 389
 390   void accept_vis (HIRFullVisitor &vis) override;
 391   void accept_vis (HIRPatternVisitor &vis) override;
 392
 393   Analysis::NodeMapping get_pattern_mappings () const override final
 394   {
 395     return mappings;
 396   }
 397
 398   PatternType get_pattern_type () const override final
 399   {
 400     return PatternType::RANGE;
 401   }
 402
 403   std::unique_ptr<RangePatternBound> &get_lower_bound ()
 404   {
 405     rust_assert (lower != nullptr);
 406     return lower;
 407   }
 408
 409   std::unique_ptr<RangePatternBound> &get_upper_bound ()
 410   {
 411     rust_assert (upper != nullptr);
 412     return upper;
 413   }
 414
 415 protected:
 416   /* Use covariance to implement clone function as returning this object rather
 417    * than base */
 418   RangePattern *clone_pattern_impl () const override
 419   {
 420     return new RangePattern (*this);
 421   }
 422 };
 423
 424 // HIR node for pattern based on dereferencing the pointers given
 425 class ReferencePattern : public Pattern
 426 {
 427   Mutability mut;
 428   std::unique_ptr<Pattern> pattern;
 429   Location locus;
 430   Analysis::NodeMapping mappings;
 431
 432 public:
 433   std::string as_string () const override;
 434
 435   ReferencePattern (Analysis::NodeMapping mappings,
 436                     std::unique_ptr<Pattern> pattern, Mutability reference_mut,
 437                     Location locus)
 438     : mut (reference_mut), pattern (std::move (pattern)), locus (locus),
 439       mappings (mappings)
 440   {}
 441
 442   // Copy constructor requires clone
 443   ReferencePattern (ReferencePattern const &other)
 444     : mut (other.mut), pattern (other.pattern->clone_pattern ()),
 445       locus (other.locus), mappings (other.mappings)
 446   {}
 447
 448   // Overload assignment operator to clone
 449   ReferencePattern &operator= (ReferencePattern const &other)
 450   {
 451     pattern = other.pattern->clone_pattern ();
 452     mut = other.mut;
 453     locus = other.locus;
 454     mappings = other.mappings;
 455
 456     return *this;
 457   }
 458
 459   // default move semantics
 460   ReferencePattern (ReferencePattern &&other) = default;
 461   ReferencePattern &operator= (ReferencePattern &&other) = default;
 462
 463   bool is_mut () const { return mut == Mutability::Mut; }
 464
 465   void accept_vis (HIRFullVisitor &vis) override;
 466   void accept_vis (HIRPatternVisitor &vis) override;
 467
 468   Analysis::NodeMapping get_pattern_mappings () const override final
 469   {
 470     return mappings;
 471   }
 472
 473   Location get_locus () const override final { return locus; }
 474
 475   PatternType get_pattern_type () const override final
 476   {
 477     return PatternType::REFERENCE;
 478   }
 479
 480 protected:
 481   /* Use covariance to implement clone function as returning this object rather
 482    * than base */
 483   ReferencePattern *clone_pattern_impl () const override
 484   {
 485     return new ReferencePattern (*this);
 486   }
 487 };
 488
 489 // Base class for a single field in a struct pattern - abstract
 490 class StructPatternField
 491 {
 492   AST::AttrVec outer_attrs;
 493   Location locus;
 494   Analysis::NodeMapping mappings;
 495
 496 public:
 497   enum ItemType
 498   {
 499     TUPLE_PAT,
 500     IDENT_PAT,
 501     IDENT
 502   };
 503
 504   virtual ~StructPatternField () {}
 505
 506   // Unique pointer custom clone function
 507   std::unique_ptr<StructPatternField> clone_struct_pattern_field () const
 508   {
 509     return std::unique_ptr<StructPatternField> (
 510       clone_struct_pattern_field_impl ());
 511   }
 512
 513   virtual std::string as_string () const;
 514   virtual void accept_vis (HIRFullVisitor &vis) = 0;
 515   virtual ItemType get_item_type () const = 0;
 516
 517   Location get_locus () const { return locus; }
 518   Analysis::NodeMapping get_mappings () const { return mappings; };
 519
 520 protected:
 521   StructPatternField (Analysis::NodeMapping mappings,
 522                       AST::AttrVec outer_attribs, Location locus)
 523     : outer_attrs (std::move (outer_attribs)), locus (locus),
 524       mappings (mappings)
 525   {}
 526
 527   // Clone function implementation as pure virtual method
 528   virtual StructPatternField *clone_struct_pattern_field_impl () const = 0;
 529 };
 530
 531 // Tuple pattern single field in a struct pattern
 532 class StructPatternFieldTuplePat : public StructPatternField
 533 {
 534   TupleIndex index;
 535   std::unique_ptr<Pattern> tuple_pattern;
 536
 537 public:
 538   StructPatternFieldTuplePat (Analysis::NodeMapping mappings, TupleIndex index,
 539                               std::unique_ptr<Pattern> tuple_pattern,
 540                               AST::AttrVec outer_attribs, Location locus)
 541     : StructPatternField (mappings, std::move (outer_attribs), locus),
 542       index (index), tuple_pattern (std::move (tuple_pattern))
 543   {}
 544
 545   // Copy constructor requires clone
 546   StructPatternFieldTuplePat (StructPatternFieldTuplePat const &other)
 547     : StructPatternField (other), index (other.index),
 548       tuple_pattern (other.tuple_pattern->clone_pattern ())
 549   {}
 550
 551   // Overload assignment operator to perform clone
 552   StructPatternFieldTuplePat &
 553   operator= (StructPatternFieldTuplePat const &other)
 554   {
 555     StructPatternField::operator= (other);
 556     tuple_pattern = other.tuple_pattern->clone_pattern ();
 557     index = other.index;
 558     // outer_attrs = other.outer_attrs;
 559
 560     return *this;
 561   }
 562
 563   // default move semantics
 564   StructPatternFieldTuplePat (StructPatternFieldTuplePat &&other) = default;
 565   StructPatternFieldTuplePat &operator= (StructPatternFieldTuplePat &&other)
 566     = default;
 567
 568   std::string as_string () const override;
 569
 570   void accept_vis (HIRFullVisitor &vis) override;
 571
 572   ItemType get_item_type () const override final { return ItemType::TUPLE_PAT; }
 573
 574 protected:
 575   /* Use covariance to implement clone function as returning this object rather
 576    * than base */
 577   StructPatternFieldTuplePat *clone_struct_pattern_field_impl () const override
 578   {
 579     return new StructPatternFieldTuplePat (*this);
 580   }
 581 };
 582
 583 // Identifier pattern single field in a struct pattern
 584 class StructPatternFieldIdentPat : public StructPatternField
 585 {
 586   Identifier ident;
 587   std::unique_ptr<Pattern> ident_pattern;
 588
 589 public:
 590   StructPatternFieldIdentPat (Analysis::NodeMapping mappings, Identifier ident,
 591                               std::unique_ptr<Pattern> ident_pattern,
 592                               AST::AttrVec outer_attrs, Location locus)
 593     : StructPatternField (mappings, std::move (outer_attrs), locus),
 594       ident (std::move (ident)), ident_pattern (std::move (ident_pattern))
 595   {}
 596
 597   // Copy constructor requires clone
 598   StructPatternFieldIdentPat (StructPatternFieldIdentPat const &other)
 599     : StructPatternField (other), ident (other.ident),
 600       ident_pattern (other.ident_pattern->clone_pattern ())
 601   {}
 602
 603   // Overload assignment operator to clone
 604   StructPatternFieldIdentPat &
 605   operator= (StructPatternFieldIdentPat const &other)
 606   {
 607     StructPatternField::operator= (other);
 608     ident = other.ident;
 609     ident_pattern = other.ident_pattern->clone_pattern ();
 610     // outer_attrs = other.outer_attrs;
 611
 612     return *this;
 613   }
 614
 615   // default move semantics
 616   StructPatternFieldIdentPat (StructPatternFieldIdentPat &&other) = default;
 617   StructPatternFieldIdentPat &operator= (StructPatternFieldIdentPat &&other)
 618     = default;
 619
 620   std::string as_string () const override;
 621
 622   void accept_vis (HIRFullVisitor &vis) override;
 623
 624   ItemType get_item_type () const override final { return ItemType::IDENT_PAT; }
 625
 626 protected:
 627   /* Use covariance to implement clone function as returning this object rather
 628    * than base */
 629   StructPatternFieldIdentPat *clone_struct_pattern_field_impl () const override
 630   {
 631     return new StructPatternFieldIdentPat (*this);
 632   }
 633 };
 634
 635 // Identifier only (with no pattern) single field in a struct pattern
 636 class StructPatternFieldIdent : public StructPatternField
 637 {
 638   bool has_ref;
 639   Mutability mut;
 640   Identifier ident;
 641
 642 public:
 643   StructPatternFieldIdent (Analysis::NodeMapping mappings, Identifier ident,
 644                            bool is_ref, Mutability mut,
 645                            AST::AttrVec outer_attrs, Location locus)
 646     : StructPatternField (mappings, std::move (outer_attrs), locus),
 647       has_ref (is_ref), mut (mut), ident (std::move (ident))
 648   {}
 649
 650   std::string as_string () const override;
 651
 652   bool is_mut () const { return mut == Mutability::Mut; }
 653
 654   void accept_vis (HIRFullVisitor &vis) override;
 655
 656   ItemType get_item_type () const override final { return ItemType::IDENT; }
 657
 658   Identifier get_identifier () const { return ident; };
 659
 660 protected:
 661   /* Use covariance to implement clone function as returning this object rather
 662    * than base */
 663   StructPatternFieldIdent *clone_struct_pattern_field_impl () const override
 664   {
 665     return new StructPatternFieldIdent (*this);
 666   }
 667 };
 668
 669 // Elements of a struct pattern
 670 struct StructPatternElements
 671 {
 672 private:
 673   std::vector<std::unique_ptr<StructPatternField> > fields;
 674
 675 public:
 676   // Returns whether there are any struct pattern fields
 677   bool has_struct_pattern_fields () const { return !fields.empty (); }
 678
 679   /* Returns whether the struct pattern elements is entirely empty (no fields,
 680    * no etc). */
 681   bool is_empty () const { return !has_struct_pattern_fields (); }
 682
 683   // Constructor for StructPatternElements with both (potentially)
 684   StructPatternElements (
 685     std::vector<std::unique_ptr<StructPatternField> > fields)
 686     : fields (std::move (fields))
 687   {}
 688
 689   // Copy constructor with vector clone
 690   StructPatternElements (StructPatternElements const &other)
 691   {
 692     fields.reserve (other.fields.size ());
 693     for (const auto &e : other.fields)
 694       fields.push_back (e->clone_struct_pattern_field ());
 695   }
 696
 697   // Overloaded assignment operator with vector clone
 698   StructPatternElements &operator= (StructPatternElements const &other)
 699   {
 700     fields.reserve (other.fields.size ());
 701     for (const auto &e : other.fields)
 702       fields.push_back (e->clone_struct_pattern_field ());
 703
 704     return *this;
 705   }
 706
 707   // move constructors
 708   StructPatternElements (StructPatternElements &&other) = default;
 709   StructPatternElements &operator= (StructPatternElements &&other) = default;
 710
 711   // Creates an empty StructPatternElements
 712   static StructPatternElements create_empty ()
 713   {
 714     return StructPatternElements (
 715       std::vector<std::unique_ptr<StructPatternField> > ());
 716   }
 717
 718   std::string as_string () const;
 719
 720   std::vector<std::unique_ptr<StructPatternField> > &
 721   get_struct_pattern_fields ()
 722   {
 723     return fields;
 724   }
 725 };
 726
 727 // Struct pattern HIR node representation
 728 class StructPattern : public Pattern
 729 {
 730   PathInExpression path;
 731   StructPatternElements elems;
 732   Analysis::NodeMapping mappings;
 733
 734 public:
 735   std::string as_string () const override;
 736
 737   StructPattern (Analysis::NodeMapping mappings, PathInExpression struct_path,
 738                  StructPatternElements elems)
 739     : path (std::move (struct_path)), elems (std::move (elems)),
 740       mappings (mappings)
 741   {}
 742
 743   bool has_struct_pattern_elems () const { return !elems.is_empty (); }
 744
 745   Location get_locus () const override { return path.get_locus (); }
 746
 747   void accept_vis (HIRFullVisitor &vis) override;
 748   void accept_vis (HIRPatternVisitor &vis) override;
 749
 750   PathInExpression &get_path () { return path; }
 751   StructPatternElements &get_struct_pattern_elems () { return elems; }
 752
 753   Analysis::NodeMapping get_pattern_mappings () const override final
 754   {
 755     return mappings;
 756   }
 757
 758   PatternType get_pattern_type () const override final
 759   {
 760     return PatternType::STRUCT;
 761   }
 762
 763 protected:
 764   /* Use covariance to implement clone function as returning this object rather
 765    * than base */
 766   StructPattern *clone_pattern_impl () const override
 767   {
 768     return new StructPattern (*this);
 769   }
 770 };
 771
 772 // Base abstract class for patterns used in TupleStructPattern
 773 class TupleStructItems
 774 {
 775 public:
 776   enum ItemType
 777   {
 778     RANGE,
 779     NO_RANGE
 780   };
 781
 782   virtual ~TupleStructItems () {}
 783
 784   // TODO: should this store location data?
 785
 786   // Unique pointer custom clone function
 787   std::unique_ptr<TupleStructItems> clone_tuple_struct_items () const
 788   {
 789     return std::unique_ptr<TupleStructItems> (clone_tuple_struct_items_impl ());
 790   }
 791
 792   virtual std::string as_string () const = 0;
 793
 794   virtual void accept_vis (HIRFullVisitor &vis) = 0;
 795
 796   virtual ItemType get_item_type () const = 0;
 797
 798 protected:
 799   // pure virtual clone implementation
 800   virtual TupleStructItems *clone_tuple_struct_items_impl () const = 0;
 801 };
 802
 803 // Class for non-ranged tuple struct pattern patterns
 804 class TupleStructItemsNoRange : public TupleStructItems
 805 {
 806   std::vector<std::unique_ptr<Pattern> > patterns;
 807
 808 public:
 809   TupleStructItemsNoRange (std::vector<std::unique_ptr<Pattern> > patterns)
 810     : patterns (std::move (patterns))
 811   {}
 812
 813   // Copy constructor with vector clone
 814   TupleStructItemsNoRange (TupleStructItemsNoRange const &other)
 815   {
 816     patterns.reserve (other.patterns.size ());
 817     for (const auto &e : other.patterns)
 818       patterns.push_back (e->clone_pattern ());
 819   }
 820
 821   // Overloaded assignment operator with vector clone
 822   TupleStructItemsNoRange &operator= (TupleStructItemsNoRange const &other)
 823   {
 824     patterns.reserve (other.patterns.size ());
 825     for (const auto &e : other.patterns)
 826       patterns.push_back (e->clone_pattern ());
 827
 828     return *this;
 829   }
 830
 831   // move constructors
 832   TupleStructItemsNoRange (TupleStructItemsNoRange &&other) = default;
 833   TupleStructItemsNoRange &operator= (TupleStructItemsNoRange &&other)
 834     = default;
 835
 836   std::string as_string () const override;
 837
 838   void accept_vis (HIRFullVisitor &vis) override;
 839
 840   std::vector<std::unique_ptr<Pattern> > &get_patterns () { return patterns; }
 841   const std::vector<std::unique_ptr<Pattern> > &get_patterns () const
 842   {
 843     return patterns;
 844   }
 845
 846   ItemType get_item_type () const override final { return ItemType::NO_RANGE; }
 847
 848 protected:
 849   /* Use covariance to implement clone function as returning this object rather
 850    * than base */
 851   TupleStructItemsNoRange *clone_tuple_struct_items_impl () const override
 852   {
 853     return new TupleStructItemsNoRange (*this);
 854   }
 855 };
 856
 857 // Class for ranged tuple struct pattern patterns
 858 class TupleStructItemsRange : public TupleStructItems
 859 {
 860   std::vector<std::unique_ptr<Pattern> > lower_patterns;
 861   std::vector<std::unique_ptr<Pattern> > upper_patterns;
 862
 863 public:
 864   TupleStructItemsRange (std::vector<std::unique_ptr<Pattern> > lower_patterns,
 865                          std::vector<std::unique_ptr<Pattern> > upper_patterns)
 866     : lower_patterns (std::move (lower_patterns)),
 867       upper_patterns (std::move (upper_patterns))
 868   {}
 869
 870   // Copy constructor with vector clone
 871   TupleStructItemsRange (TupleStructItemsRange const &other)
 872   {
 873     lower_patterns.reserve (other.lower_patterns.size ());
 874     for (const auto &e : other.lower_patterns)
 875       lower_patterns.push_back (e->clone_pattern ());
 876
 877     upper_patterns.reserve (other.upper_patterns.size ());
 878     for (const auto &e : other.upper_patterns)
 879       upper_patterns.push_back (e->clone_pattern ());
 880   }
 881
 882   // Overloaded assignment operator to clone
 883   TupleStructItemsRange &operator= (TupleStructItemsRange const &other)
 884   {
 885     lower_patterns.reserve (other.lower_patterns.size ());
 886     for (const auto &e : other.lower_patterns)
 887       lower_patterns.push_back (e->clone_pattern ());
 888
 889     upper_patterns.reserve (other.upper_patterns.size ());
 890     for (const auto &e : other.upper_patterns)
 891       upper_patterns.push_back (e->clone_pattern ());
 892
 893     return *this;
 894   }
 895
 896   // move constructors
 897   TupleStructItemsRange (TupleStructItemsRange &&other) = default;
 898   TupleStructItemsRange &operator= (TupleStructItemsRange &&other) = default;
 899
 900   std::string as_string () const override;
 901
 902   void accept_vis (HIRFullVisitor &vis) override;
 903
 904   std::vector<std::unique_ptr<Pattern> > &get_lower_patterns ()
 905   {
 906     return lower_patterns;
 907   }
 908   const std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () const
 909   {
 910     return lower_patterns;
 911   }
 912
 913   // TODO: seems kinda dodgy. Think of better way.
 914   std::vector<std::unique_ptr<Pattern> > &get_upper_patterns ()
 915   {
 916     return upper_patterns;
 917   }
 918   const std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () const
 919   {
 920     return upper_patterns;
 921   }
 922
 923   ItemType get_item_type () const override final { return ItemType::RANGE; }
 924
 925 protected:
 926   /* Use covariance to implement clone function as returning this object rather
 927    * than base */
 928   TupleStructItemsRange *clone_tuple_struct_items_impl () const override
 929   {
 930     return new TupleStructItemsRange (*this);
 931   }
 932 };
 933
 934 // HIR node representing a tuple struct pattern
 935 class TupleStructPattern : public Pattern
 936 {
 937   PathInExpression path;
 938   std::unique_ptr<TupleStructItems> items;
 939   Analysis::NodeMapping mappings;
 940
 941   /* TOOD: should this store location data? current accessor uses path location
 942    * data */
 943
 944 public:
 945   std::string as_string () const override;
 946
 947   TupleStructPattern (Analysis::NodeMapping mappings,
 948                       PathInExpression tuple_struct_path,
 949                       std::unique_ptr<TupleStructItems> items)
 950     : path (std::move (tuple_struct_path)), items (std::move (items)),
 951       mappings (mappings)
 952   {}
 953
 954   // Copy constructor required to clone
 955   TupleStructPattern (TupleStructPattern const &other)
 956     : path (other.path), items (other.items->clone_tuple_struct_items ()),
 957       mappings (other.mappings)
 958   {}
 959
 960   // Operator overload assignment operator to clone
 961   TupleStructPattern &operator= (TupleStructPattern const &other)
 962   {
 963     path = other.path;
 964     items = other.items->clone_tuple_struct_items ();
 965     mappings = other.mappings;
 966
 967     return *this;
 968   }
 969
 970   // move constructors
 971   TupleStructPattern (TupleStructPattern &&other) = default;
 972   TupleStructPattern &operator= (TupleStructPattern &&other) = default;
 973
 974   Location get_locus () const override { return path.get_locus (); }
 975
 976   void accept_vis (HIRFullVisitor &vis) override;
 977   void accept_vis (HIRPatternVisitor &vis) override;
 978
 979   PathInExpression &get_path () { return path; }
 980
 981   std::unique_ptr<TupleStructItems> &get_items () { return items; }
 982
 983   Analysis::NodeMapping get_pattern_mappings () const override final
 984   {
 985     return mappings;
 986   }
 987
 988   PatternType get_pattern_type () const override final
 989   {
 990     return PatternType::TUPLE_STRUCT;
 991   }
 992
 993 protected:
 994   /* Use covariance to implement clone function as returning this object rather
 995    * than base */
 996   TupleStructPattern *clone_pattern_impl () const override
 997   {
 998     return new TupleStructPattern (*this);
 999   }
1000 };
1001
1002 // Base abstract class representing TuplePattern patterns
1003 class TuplePatternItems
1004 {
1005 public:
1006   enum TuplePatternItemType
1007   {
1008     MULTIPLE,
1009     RANGED,
1010   };
1011
1012   virtual ~TuplePatternItems () {}
1013
1014   // TODO: should this store location data?
1015
1016   // Unique pointer custom clone function
1017   std::unique_ptr<TuplePatternItems> clone_tuple_pattern_items () const
1018   {
1019     return std::unique_ptr<TuplePatternItems> (
1020       clone_tuple_pattern_items_impl ());
1021   }
1022
1023   virtual std::string as_string () const = 0;
1024
1025   virtual void accept_vis (HIRFullVisitor &vis) = 0;
1026
1027   virtual TuplePatternItemType get_pattern_type () const = 0;
1028
1029 protected:
1030   // pure virtual clone implementation
1031   virtual TuplePatternItems *clone_tuple_pattern_items_impl () const = 0;
1032 };
1033
1034 // Class representing TuplePattern patterns where there are multiple patterns
1035 class TuplePatternItemsMultiple : public TuplePatternItems
1036 {
1037   std::vector<std::unique_ptr<Pattern> > patterns;
1038
1039 public:
1040   TuplePatternItemsMultiple (std::vector<std::unique_ptr<Pattern> > patterns)
1041     : patterns (std::move (patterns))
1042   {}
1043
1044   // Copy constructor with vector clone
1045   TuplePatternItemsMultiple (TuplePatternItemsMultiple const &other)
1046   {
1047     patterns.reserve (other.patterns.size ());
1048     for (const auto &e : other.patterns)
1049       patterns.push_back (e->clone_pattern ());
1050   }
1051
1052   // Overloaded assignment operator to vector clone
1053   TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple const &other)
1054   {
1055     patterns.reserve (other.patterns.size ());
1056     for (const auto &e : other.patterns)
1057       patterns.push_back (e->clone_pattern ());
1058
1059     return *this;
1060   }
1061
1062   // move constructors
1063   TuplePatternItemsMultiple (TuplePatternItemsMultiple &&other) = default;
1064   TuplePatternItemsMultiple &operator= (TuplePatternItemsMultiple &&other)
1065     = default;
1066
1067   std::string as_string () const override;
1068
1069   void accept_vis (HIRFullVisitor &vis) override;
1070
1071   TuplePatternItemType get_pattern_type () const override
1072   {
1073     return TuplePatternItemType::MULTIPLE;
1074   }
1075
1076   std::vector<std::unique_ptr<Pattern> > &get_patterns () { return patterns; }
1077   const std::vector<std::unique_ptr<Pattern> > &get_patterns () const
1078   {
1079     return patterns;
1080   }
1081
1082 protected:
1083   /* Use covariance to implement clone function as returning this object rather
1084    * than base */
1085   TuplePatternItemsMultiple *clone_tuple_pattern_items_impl () const override
1086   {
1087     return new TuplePatternItemsMultiple (*this);
1088   }
1089 };
1090
1091 // Class representing TuplePattern patterns where there are a range of patterns
1092 class TuplePatternItemsRanged : public TuplePatternItems
1093 {
1094   std::vector<std::unique_ptr<Pattern> > lower_patterns;
1095   std::vector<std::unique_ptr<Pattern> > upper_patterns;
1096
1097 public:
1098   TuplePatternItemsRanged (
1099     std::vector<std::unique_ptr<Pattern> > lower_patterns,
1100     std::vector<std::unique_ptr<Pattern> > upper_patterns)
1101     : lower_patterns (std::move (lower_patterns)),
1102       upper_patterns (std::move (upper_patterns))
1103   {}
1104
1105   // Copy constructor with vector clone
1106   TuplePatternItemsRanged (TuplePatternItemsRanged const &other)
1107   {
1108     lower_patterns.reserve (other.lower_patterns.size ());
1109     for (const auto &e : other.lower_patterns)
1110       lower_patterns.push_back (e->clone_pattern ());
1111
1112     upper_patterns.reserve (other.upper_patterns.size ());
1113     for (const auto &e : other.upper_patterns)
1114       upper_patterns.push_back (e->clone_pattern ());
1115   }
1116
1117   // Overloaded assignment operator to clone
1118   TuplePatternItemsRanged &operator= (TuplePatternItemsRanged const &other)
1119   {
1120     lower_patterns.reserve (other.lower_patterns.size ());
1121     for (const auto &e : other.lower_patterns)
1122       lower_patterns.push_back (e->clone_pattern ());
1123
1124     upper_patterns.reserve (other.upper_patterns.size ());
1125     for (const auto &e : other.upper_patterns)
1126       upper_patterns.push_back (e->clone_pattern ());
1127
1128     return *this;
1129   }
1130
1131   // move constructors
1132   TuplePatternItemsRanged (TuplePatternItemsRanged &&other) = default;
1133   TuplePatternItemsRanged &operator= (TuplePatternItemsRanged &&other)
1134     = default;
1135
1136   std::string as_string () const override;
1137
1138   void accept_vis (HIRFullVisitor &vis) override;
1139
1140   TuplePatternItemType get_pattern_type () const override
1141   {
1142     return TuplePatternItemType::RANGED;
1143   }
1144
1145   std::vector<std::unique_ptr<Pattern> > &get_lower_patterns ()
1146   {
1147     return lower_patterns;
1148   }
1149   const std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () const
1150   {
1151     return lower_patterns;
1152   }
1153
1154   std::vector<std::unique_ptr<Pattern> > &get_upper_patterns ()
1155   {
1156     return upper_patterns;
1157   }
1158   const std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () const
1159   {
1160     return upper_patterns;
1161   }
1162
1163 protected:
1164   /* Use covariance to implement clone function as returning this object rather
1165    * than base */
1166   TuplePatternItemsRanged *clone_tuple_pattern_items_impl () const override
1167   {
1168     return new TuplePatternItemsRanged (*this);
1169   }
1170 };
1171
1172 // HIR node representing a tuple pattern
1173 class TuplePattern : public Pattern
1174 {
1175   std::unique_ptr<TuplePatternItems> items;
1176   Location locus;
1177   Analysis::NodeMapping mappings;
1178
1179 public:
1180   std::string as_string () const override;
1181
1182   // Returns true if the tuple pattern has items
1183   bool has_tuple_pattern_items () const { return items != nullptr; }
1184
1185   TuplePattern (Analysis::NodeMapping mappings,
1186                 std::unique_ptr<TuplePatternItems> items, Location locus)
1187     : items (std::move (items)), locus (locus), mappings (mappings)
1188   {}
1189
1190   // Copy constructor requires clone
1191   TuplePattern (TuplePattern const &other)
1192     : items (other.items->clone_tuple_pattern_items ()), locus (other.locus),
1193       mappings (other.mappings)
1194   {}
1195
1196   // Overload assignment operator to clone
1197   TuplePattern &operator= (TuplePattern const &other)
1198   {
1199     items = other.items->clone_tuple_pattern_items ();
1200     locus = other.locus;
1201     mappings = other.mappings;
1202
1203     return *this;
1204   }
1205
1206   Location get_locus () const override { return locus; }
1207
1208   void accept_vis (HIRFullVisitor &vis) override;
1209   void accept_vis (HIRPatternVisitor &vis) override;
1210
1211   Analysis::NodeMapping get_pattern_mappings () const override final
1212   {
1213     return mappings;
1214   }
1215
1216   PatternType get_pattern_type () const override final
1217   {
1218     return PatternType::TUPLE;
1219   }
1220
1221   std::unique_ptr<TuplePatternItems> &get_items () { return items; }
1222   const std::unique_ptr<TuplePatternItems> &get_items () const { return items; }
1223
1224 protected:
1225   /* Use covariance to implement clone function as returning this object rather
1226    * than base */
1227   TuplePattern *clone_pattern_impl () const override
1228   {
1229     return new TuplePattern (*this);
1230   }
1231 };
1232
1233 // HIR node representing patterns that can match slices and arrays
1234 class SlicePattern : public Pattern
1235 {
1236   std::vector<std::unique_ptr<Pattern> > items;
1237   Location locus;
1238   Analysis::NodeMapping mappings;
1239
1240 public:
1241   std::string as_string () const override;
1242
1243   SlicePattern (Analysis::NodeMapping mappings,
1244                 std::vector<std::unique_ptr<Pattern> > items, Location locus)
1245     : items (std::move (items)), locus (locus), mappings (mappings)
1246   {}
1247
1248   // Copy constructor with vector clone
1249   SlicePattern (SlicePattern const &other)
1250     : locus (other.locus), mappings (other.mappings)
1251   {
1252     items.reserve (other.items.size ());
1253     for (const auto &e : other.items)
1254       items.push_back (e->clone_pattern ());
1255   }
1256
1257   // Overloaded assignment operator to vector clone
1258   SlicePattern &operator= (SlicePattern const &other)
1259   {
1260     locus = other.locus;
1261     mappings = other.mappings;
1262
1263     items.reserve (other.items.size ());
1264     for (const auto &e : other.items)
1265       items.push_back (e->clone_pattern ());
1266
1267     return *this;
1268   }
1269
1270   // move constructors
1271   SlicePattern (SlicePattern &&other) = default;
1272   SlicePattern &operator= (SlicePattern &&other) = default;
1273
1274   Location get_locus () const override { return locus; }
1275
1276   void accept_vis (HIRFullVisitor &vis) override;
1277   void accept_vis (HIRPatternVisitor &vis) override;
1278
1279   Analysis::NodeMapping get_pattern_mappings () const override final
1280   {
1281     return mappings;
1282   }
1283
1284   PatternType get_pattern_type () const override final
1285   {
1286     return PatternType::SLICE;
1287   }
1288
1289 protected:
1290   /* Use covariance to implement clone function as returning this object rather
1291    * than base */
1292   SlicePattern *clone_pattern_impl () const override
1293   {
1294     return new SlicePattern (*this);
1295   }
1296 };
1297
1298 // Moved definition to rust-path.h
1299 class PathPattern;
1300
1301 // Forward decls for paths (defined in rust-path.h)
1302 class PathInExpression;
1303 class QualifiedPathInExpression;
1304
1305 } // namespace HIR
1306 } // namespace Rust
1307
1308 #endif