gcc/rust/ast/rust-pattern.cc

   1 /* General AST-related method implementations for Rust frontend.
   2    Copyright (C) 2009-2025 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "rust-system.h"
  21 #include "rust-ast-full.h"
  22 #include "rust-diagnostics.h"
  23 #include "rust-ast-visitor.h"
  24 #include "rust-macro.h"
  25 #include "rust-session-manager.h"
  26 #include "rust-lex.h"
  27 #include "rust-parse.h"
  28 #include "rust-operators.h"
  29
  30 namespace Rust {
  31 namespace AST {
  32
  33 std::string
  34 LiteralPattern::as_string () const
  35 {
  36   return lit.as_string ();
  37 }
  38
  39 std::string
  40 IdentifierPattern::as_string () const
  41 {
  42   // TODO: maybe rewrite to work with non-linearisable patterns
  43   std::string str;
  44
  45   if (is_ref)
  46     str += "ref ";
  47
  48   if (is_mut)
  49     str += "mut ";
  50
  51   str += variable_ident.as_string ();
  52
  53   if (has_pattern_to_bind ())
  54     str += " @ " + to_bind->as_string ();
  55
  56   return str;
  57 }
  58
  59 std::string
  60 RangePatternBoundLiteral::as_string () const
  61 {
  62   std::string str;
  63
  64   if (has_minus)
  65     str += "-";
  66
  67   str += literal.as_string ();
  68
  69   return str;
  70 }
  71
  72 std::string
  73 RangePattern::as_string () const
  74 {
  75   // TODO: maybe rewrite to work with non-linearisable bounds
  76   if (has_ellipsis_syntax)
  77     return lower->as_string () + "..." + upper->as_string ();
  78   else
  79     return lower->as_string () + "..=" + upper->as_string ();
  80 }
  81
  82 std::string
  83 ReferencePattern::as_string () const
  84 {
  85   // TODO: maybe rewrite to work with non-linearisable patterns
  86   std::string str ("&");
  87
  88   if (has_two_amps)
  89     str += "&";
  90
  91   if (is_mut)
  92     str += "mut ";
  93
  94   str += pattern->as_string ();
  95
  96   return str;
  97 }
  98
  99 std::string
 100 StructPatternField::as_string () const
 101 {
 102   // outer attributes
 103   std::string str = append_attributes (outer_attrs, OUTER);
 104
 105   return str;
 106 }
 107
 108 std::string
 109 StructPatternFieldTuplePat::as_string () const
 110 {
 111   // TODO: maybe rewrite to work with non-linearisable patterns
 112   std::string str = StructPatternField::as_string ();
 113
 114   str += "\n";
 115
 116   str += std::to_string (index) + " : " + tuple_pattern->as_string ();
 117
 118   return str;
 119 }
 120
 121 std::string
 122 StructPatternFieldIdentPat::as_string () const
 123 {
 124   // TODO: maybe rewrite to work with non-linearisable patterns
 125   std::string str = StructPatternField::as_string ();
 126
 127   str += "\n";
 128
 129   str += ident.as_string () + " : " + ident_pattern->as_string ();
 130
 131   return str;
 132 }
 133
 134 std::string
 135 StructPatternFieldIdent::as_string () const
 136 {
 137   std::string str = StructPatternField::as_string ();
 138
 139   str += "\n";
 140
 141   if (has_ref)
 142     str += "ref ";
 143
 144   if (has_mut)
 145     str += "mut ";
 146
 147   str += ident.as_string ();
 148
 149   return str;
 150 }
 151
 152 std::string
 153 StructPatternElements::as_string () const
 154 {
 155   std::string str ("\n  Fields: ");
 156
 157   if (!has_struct_pattern_fields ())
 158     {
 159       str += "none";
 160     }
 161   else
 162     {
 163       for (const auto &field : fields)
 164         str += "\n   " + field->as_string ();
 165     }
 166
 167   str += "\n  Etc: ";
 168   if (has_struct_pattern_etc)
 169     str += "true";
 170   else
 171     str += "false";
 172
 173   return str;
 174 }
 175
 176 std::string
 177 StructPattern::as_string () const
 178 {
 179   std::string str ("StructPattern: \n Path: ");
 180
 181   str += path.as_string ();
 182
 183   str += "\n Struct pattern elems: ";
 184   if (!has_struct_pattern_elems ())
 185     str += "none";
 186   else
 187     str += elems.as_string ();
 188
 189   return str;
 190 }
 191
 192 std::string
 193 TupleStructItemsNoRange::as_string () const
 194 {
 195   std::string str;
 196
 197   for (const auto &pattern : patterns)
 198     str += "\n  " + pattern->as_string ();
 199
 200   return str;
 201 }
 202
 203 std::string
 204 TupleStructItemsRange::as_string () const
 205 {
 206   std::string str ("\n  Lower patterns: ");
 207
 208   if (lower_patterns.empty ())
 209     {
 210       str += "none";
 211     }
 212   else
 213     {
 214       for (const auto &lower : lower_patterns)
 215         str += "\n   " + lower->as_string ();
 216     }
 217
 218   str += "\n  Upper patterns: ";
 219   if (upper_patterns.empty ())
 220     {
 221       str += "none";
 222     }
 223   else
 224     {
 225       for (const auto &upper : upper_patterns)
 226         str += "\n   " + upper->as_string ();
 227     }
 228
 229   return str;
 230 }
 231
 232 std::string
 233 TupleStructPattern::as_string () const
 234 {
 235   std::string str ("TupleStructPattern: \n Path: ");
 236
 237   str += path.as_string ();
 238
 239   str += "\n Tuple struct items: " + items->as_string ();
 240
 241   return str;
 242 }
 243
 244 std::string
 245 TuplePatternItemsMultiple::as_string () const
 246 {
 247   std::string str;
 248
 249   for (const auto &pattern : patterns)
 250     str += "\n " + pattern->as_string ();
 251
 252   return str;
 253 }
 254
 255 std::string
 256 TuplePatternItemsRanged::as_string () const
 257 {
 258   std::string str;
 259
 260   str += "\n Lower patterns: ";
 261   if (lower_patterns.empty ())
 262     {
 263       str += "none";
 264     }
 265   else
 266     {
 267       for (const auto &lower : lower_patterns)
 268         str += "\n  " + lower->as_string ();
 269     }
 270
 271   str += "\n Upper patterns: ";
 272   if (upper_patterns.empty ())
 273     {
 274       str += "none";
 275     }
 276   else
 277     {
 278       for (const auto &upper : upper_patterns)
 279         str += "\n  " + upper->as_string ();
 280     }
 281
 282   return str;
 283 }
 284
 285 std::string
 286 TuplePattern::as_string () const
 287 {
 288   return "TuplePattern: " + items->as_string ();
 289 }
 290
 291 std::string
 292 GroupedExpr::as_string () const
 293 {
 294   std::string str ("Grouped expr:");
 295
 296   // outer attrs
 297   str += append_attributes (outer_attrs, OUTER);
 298
 299   // inner attributes
 300   str += append_attributes (inner_attrs, INNER);
 301
 302   str += "\n Expr in parens: " + expr_in_parens->as_string ();
 303
 304   return str;
 305 }
 306
 307 std::string
 308 SlicePattern::as_string () const
 309 {
 310   std::string str ("SlicePattern: ");
 311
 312   for (const auto &pattern : items)
 313     str += "\n " + pattern->as_string ();
 314
 315   return str;
 316 }
 317
 318 std::string
 319 AltPattern::as_string () const
 320 {
 321   std::string str ("AltPattern: ");
 322
 323   for (const auto &pattern : alts)
 324     str += "\n " + pattern->as_string ();
 325
 326   return str;
 327 }
 328
 329 void
 330 AltPattern::accept_vis (ASTVisitor &vis)
 331 {
 332   vis.visit (*this);
 333 }
 334
 335 void
 336 GroupedPattern::accept_vis (ASTVisitor &vis)
 337 {
 338   vis.visit (*this);
 339 }
 340
 341 void
 342 GroupedExpr::accept_vis (ASTVisitor &vis)
 343 {
 344   vis.visit (*this);
 345 }
 346
 347 void
 348 SlicePattern::accept_vis (ASTVisitor &vis)
 349 {
 350   vis.visit (*this);
 351 }
 352
 353 void
 354 TuplePatternItemsRanged::accept_vis (ASTVisitor &vis)
 355 {
 356   vis.visit (*this);
 357 }
 358
 359 void
 360 TuplePattern::accept_vis (ASTVisitor &vis)
 361 {
 362   vis.visit (*this);
 363 }
 364
 365 void
 366 TuplePatternItemsMultiple::accept_vis (ASTVisitor &vis)
 367 {
 368   vis.visit (*this);
 369 }
 370
 371 void
 372 LiteralPattern::accept_vis (ASTVisitor &vis)
 373 {
 374   vis.visit (*this);
 375 }
 376
 377 void
 378 IdentifierPattern::accept_vis (ASTVisitor &vis)
 379 {
 380   vis.visit (*this);
 381 }
 382
 383 void
 384 WildcardPattern::accept_vis (ASTVisitor &vis)
 385 {
 386   vis.visit (*this);
 387 }
 388
 389 void
 390 RestPattern::accept_vis (ASTVisitor &vis)
 391 {
 392   vis.visit (*this);
 393 }
 394
 395 void
 396 RangePatternBoundLiteral::accept_vis (ASTVisitor &vis)
 397 {
 398   vis.visit (*this);
 399 }
 400
 401 void
 402 RangePatternBoundPath::accept_vis (ASTVisitor &vis)
 403 {
 404   vis.visit (*this);
 405 }
 406
 407 void
 408 RangePatternBoundQualPath::accept_vis (ASTVisitor &vis)
 409 {
 410   vis.visit (*this);
 411 }
 412
 413 void
 414 RangePattern::accept_vis (ASTVisitor &vis)
 415 {
 416   vis.visit (*this);
 417 }
 418
 419 void
 420 ReferencePattern::accept_vis (ASTVisitor &vis)
 421 {
 422   vis.visit (*this);
 423 }
 424
 425 void
 426 StructPatternFieldTuplePat::accept_vis (ASTVisitor &vis)
 427 {
 428   vis.visit (*this);
 429 }
 430
 431 void
 432 StructPatternFieldIdentPat::accept_vis (ASTVisitor &vis)
 433 {
 434   vis.visit (*this);
 435 }
 436
 437 void
 438 StructPatternFieldIdent::accept_vis (ASTVisitor &vis)
 439 {
 440   vis.visit (*this);
 441 }
 442
 443 void
 444 StructPattern::accept_vis (ASTVisitor &vis)
 445 {
 446   vis.visit (*this);
 447 }
 448
 449 void
 450 TupleStructItemsNoRange::accept_vis (ASTVisitor &vis)
 451 {
 452   vis.visit (*this);
 453 }
 454
 455 void
 456 TupleStructItemsRange::accept_vis (ASTVisitor &vis)
 457 {
 458   vis.visit (*this);
 459 }
 460
 461 void
 462 TupleStructPattern::accept_vis (ASTVisitor &vis)
 463 {
 464   vis.visit (*this);
 465 }
 466
 467 } // namespace AST
 468 } // namespace Rust