gcc/rust/resolve/rust-default-resolver.cc

   1 // Copyright (C) 2020-2024 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-default-resolver.h"
  20 #include "rust-ast-full.h"
  21 #include "rust-ast-visitor.h"
  22 #include "rust-item.h"
  23
  24 namespace Rust {
  25 namespace Resolver2_0 {
  26
  27 void
  28 DefaultResolver::visit (AST::BlockExpr &expr)
  29 {
  30   // extracting the lambda from the `scoped` call otherwise the code looks like
  31   // a hot turd thanks to our .clang-format
  32
  33   auto inner_fn = [this, &expr] () {
  34     for (auto &stmt : expr.get_statements ())
  35       stmt->accept_vis (*this);
  36
  37     if (expr.has_tail_expr ())
  38       expr.get_tail_expr ().accept_vis (*this);
  39   };
  40
  41   ctx.scoped (Rib::Kind::Normal, expr.get_node_id (), inner_fn);
  42 }
  43
  44 void
  45 DefaultResolver::visit (AST::Module &module)
  46 {
  47   auto item_fn = [this, &module] () {
  48     for (auto &item : module.get_items ())
  49       item->accept_vis (*this);
  50   };
  51
  52   ctx.scoped (Rib::Kind::Module, module.get_node_id (), item_fn,
  53               module.get_name ());
  54 }
  55
  56 void
  57 DefaultResolver::visit (AST::Function &function)
  58 {
  59   auto def_fn = [this, &function] () {
  60     for (auto &p : function.get_function_params ())
  61       {
  62         if (p->is_variadic ())
  63           {
  64             auto &param = static_cast<AST::VariadicParam &> (*p);
  65             if (param.has_pattern ())
  66               param.get_pattern ().accept_vis (*this);
  67           }
  68         else if (p->is_self ())
  69           {
  70             auto &param = static_cast<AST::SelfParam &> (*p);
  71             param.get_type ().accept_vis (*this);
  72             param.get_lifetime ().accept_vis (*this);
  73           }
  74         else
  75           {
  76             auto &param = static_cast<AST::FunctionParam &> (*p);
  77             param.get_pattern ().accept_vis (*this);
  78             param.get_type ().accept_vis (*this);
  79           }
  80       }
  81
  82     if (function.has_return_type ())
  83       visit (function.get_return_type ());
  84
  85     if (function.has_body ())
  86       function.get_definition ().value ()->accept_vis (*this);
  87   };
  88
  89   ctx.scoped (Rib::Kind::Function, function.get_node_id (), def_fn);
  90 }
  91
  92 void
  93 DefaultResolver::visit (AST::ForLoopExpr &expr)
  94 {
  95   ctx.scoped (Rib::Kind::Normal, expr.get_node_id (), [this, &expr] () {
  96     expr.get_pattern ().accept_vis (*this);
  97     expr.get_iterator_expr ().accept_vis (*this);
  98     expr.get_loop_block ().accept_vis (*this);
  99   });
 100 }
 101
 102 void
 103 DefaultResolver::visit (AST::Trait &trait)
 104 {
 105   auto inner_fn = [this, &trait] () {
 106     for (auto &item : trait.get_trait_items ())
 107       item->accept_vis (*this);
 108   };
 109
 110   ctx.scoped (Rib::Kind::TraitOrImpl, trait.get_node_id (), inner_fn,
 111               trait.get_identifier () /* FIXME: Is that valid?*/);
 112 }
 113
 114 void
 115 DefaultResolver::visit (AST::InherentImpl &impl)
 116 {
 117   auto inner_fn = [this, &impl] () {
 118     visit (impl.get_type ());
 119     for (auto &item : impl.get_impl_items ())
 120       item->accept_vis (*this);
 121   };
 122
 123   ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn);
 124 }
 125
 126 void
 127 DefaultResolver::visit (AST::TraitImpl &impl)
 128 {
 129   auto inner_fn = [this, &impl] () {
 130     for (auto &item : impl.get_impl_items ())
 131       item->accept_vis (*this);
 132   };
 133
 134   ctx.scoped (Rib::Kind::TraitOrImpl, impl.get_node_id (), inner_fn);
 135 }
 136
 137 void
 138 DefaultResolver::visit (AST::StructStruct &type)
 139 {
 140   // do we need to scope anything here? no, right?
 141
 142   // we also can't visit `StructField`s by default, so there's nothing to do -
 143   // correct? or should we do something like
 144
 145   AST::DefaultASTVisitor::visit (type);
 146
 147   // FIXME: ???
 148 }
 149
 150 void
 151 DefaultResolver::visit (AST::Enum &type)
 152 {
 153   // FIXME: Do we need to scope anything by default?
 154
 155   auto variant_fn = [this, &type] () {
 156     for (auto &variant : type.get_variants ())
 157       variant->accept_vis (*this);
 158   };
 159
 160   ctx.scoped (Rib::Kind::Item /* FIXME: Correct? */, type.get_node_id (),
 161               variant_fn, type.get_identifier ());
 162 }
 163
 164 void
 165 DefaultResolver::visit (AST::StructExprFieldIdentifierValue &)
 166 {}
 167
 168 void
 169 DefaultResolver::visit (AST::StructExprFieldIndexValue &)
 170 {}
 171
 172 void
 173 DefaultResolver::visit (AST::ClosureExprInner &expr)
 174 {
 175   if (expr.is_marked_for_strip ())
 176     return;
 177
 178   for (auto &param : expr.get_params ())
 179     {
 180       if (param.is_error ())
 181         continue;
 182
 183       param.get_pattern ().accept_vis (*this);
 184       if (param.has_type_given ())
 185         param.get_type ().accept_vis (*this);
 186     }
 187
 188   expr.get_definition_expr ().accept_vis (*this);
 189 }
 190
 191 void
 192 DefaultResolver::visit (AST::ClosureExprInnerTyped &expr)
 193 {
 194   if (expr.is_marked_for_strip ())
 195     return;
 196
 197   for (auto &param : expr.get_params ())
 198     {
 199       if (param.is_error ())
 200         continue;
 201
 202       param.get_pattern ().accept_vis (*this);
 203       if (param.has_type_given ())
 204         param.get_type ().accept_vis (*this);
 205     }
 206
 207   expr.get_definition_block ().accept_vis (*this);
 208   expr.get_return_type ().accept_vis (*this);
 209 }
 210
 211 void
 212 DefaultResolver::visit (AST::ContinueExpr &expr)
 213 {}
 214
 215 void
 216 DefaultResolver::visit (AST::RangeFromToExpr &expr)
 217 {}
 218
 219 void
 220 DefaultResolver::visit (AST::RangeFromExpr &expr)
 221 {}
 222
 223 void
 224 DefaultResolver::visit (AST::RangeToExpr &expr)
 225 {}
 226
 227 void
 228 DefaultResolver::visit (AST::RangeFromToInclExpr &expr)
 229 {}
 230
 231 void
 232 DefaultResolver::visit (AST::RangeToInclExpr &expr)
 233 {}
 234
 235 void
 236 DefaultResolver::visit (AST::ReturnExpr &expr)
 237 {}
 238
 239 void
 240 DefaultResolver::visit (AST::LoopExpr &expr)
 241 {}
 242
 243 void
 244 DefaultResolver::visit (AST::WhileLoopExpr &expr)
 245 {}
 246
 247 void
 248 DefaultResolver::visit (AST::WhileLetLoopExpr &expr)
 249 {}
 250
 251 void
 252 DefaultResolver::visit (AST::IfExpr &expr)
 253 {
 254   expr.get_condition_expr ().accept_vis (*this);
 255   expr.get_if_block ().accept_vis (*this);
 256 }
 257
 258 void
 259 DefaultResolver::visit (AST::IfExprConseqElse &expr)
 260 {
 261   expr.get_condition_expr ().accept_vis (*this);
 262   expr.get_if_block ().accept_vis (*this);
 263   expr.get_else_block ().accept_vis (*this);
 264 }
 265
 266 void
 267 DefaultResolver::visit (AST::IfLetExpr &expr)
 268 {}
 269
 270 void
 271 DefaultResolver::visit (AST::IfLetExprConseqElse &)
 272 {}
 273
 274 void
 275 DefaultResolver::visit (AST::MatchExpr &expr)
 276 {
 277   if (expr.is_marked_for_strip ())
 278     return;
 279
 280   expr.get_scrutinee_expr ().accept_vis (*this);
 281   for (auto &arm : expr.get_match_cases ())
 282     {
 283       arm.get_expr ().accept_vis (*this);
 284       for (auto &pat : arm.get_arm ().get_patterns ())
 285         pat->accept_vis (*this);
 286       if (arm.get_arm ().has_match_arm_guard ())
 287         arm.get_arm ().get_guard_expr ().accept_vis (*this);
 288     }
 289 }
 290
 291 void
 292 DefaultResolver::visit (AST::AwaitExpr &expr)
 293 {}
 294
 295 void
 296 DefaultResolver::visit (AST::AsyncBlockExpr &expr)
 297 {}
 298
 299 void
 300 DefaultResolver::visit (AST::DelimTokenTree &)
 301 {}
 302
 303 void
 304 DefaultResolver::visit (AST::AttrInputMetaItemContainer &)
 305 {}
 306
 307 void
 308 DefaultResolver::visit (AST::IdentifierExpr &expr)
 309 {}
 310
 311 void
 312 DefaultResolver::visit (AST::LifetimeParam &)
 313 {}
 314
 315 void
 316 DefaultResolver::visit (AST::ConstGenericParam &)
 317 {}
 318
 319 void
 320 DefaultResolver::visit (AST::PathInExpression &expr)
 321 {
 322   for (auto &seg : expr.get_segments ())
 323     if (seg.has_generic_args ())
 324       {
 325         auto &args = seg.get_generic_args ();
 326         for (auto &arg : args.get_generic_args ())
 327           arg.accept_vis (*this);
 328         for (auto &arg : args.get_binding_args ())
 329           if (!arg.is_error ())
 330             arg.get_type ().accept_vis (*this);
 331         for (auto &arg : args.get_lifetime_args ())
 332           arg.accept_vis (*this);
 333       }
 334 }
 335
 336 void
 337 DefaultResolver::visit (AST::TypePathSegmentGeneric &)
 338 {}
 339
 340 void
 341 DefaultResolver::visit (AST::TypePathSegmentFunction &)
 342 {}
 343
 344 void
 345 DefaultResolver::visit (AST::TypePath &)
 346 {}
 347
 348 void
 349 DefaultResolver::visit (AST::QualifiedPathInExpression &)
 350 {}
 351
 352 void
 353 DefaultResolver::visit (AST::QualifiedPathInType &)
 354 {}
 355
 356 void
 357 DefaultResolver::visit (AST::LiteralExpr &expr)
 358 {}
 359
 360 void
 361 DefaultResolver::visit (AST::AttrInputLiteral &)
 362 {}
 363
 364 void
 365 DefaultResolver::visit (AST::AttrInputMacro &)
 366 {}
 367
 368 void
 369 DefaultResolver::visit (AST::MetaItemLitExpr &expr)
 370 {}
 371
 372 void
 373 DefaultResolver::visit (AST::MetaItemPathLit &)
 374 {}
 375
 376 void
 377 DefaultResolver::visit (AST::StructExprStruct &)
 378 {}
 379
 380 void
 381 DefaultResolver::visit (AST::StructExprStructFields &)
 382 {}
 383
 384 void
 385 DefaultResolver::visit (AST::StructExprStructBase &)
 386 {}
 387
 388 void
 389 DefaultResolver::visit (AST::TypeParam &)
 390 {}
 391
 392 void
 393 DefaultResolver::visit (AST::LifetimeWhereClauseItem &)
 394 {}
 395
 396 void
 397 DefaultResolver::visit (AST::TypeBoundWhereClauseItem &)
 398 {}
 399
 400 void
 401 DefaultResolver::visit (AST::ExternCrate &)
 402 {}
 403
 404 void
 405 DefaultResolver::visit (AST::UseTreeGlob &)
 406 {}
 407
 408 void
 409 DefaultResolver::visit (AST::UseTreeList &)
 410 {}
 411
 412 void
 413 DefaultResolver::visit (AST::UseTreeRebind &)
 414 {}
 415
 416 void
 417 DefaultResolver::visit (AST::UseDeclaration &)
 418 {}
 419
 420 void
 421 DefaultResolver::visit (AST::TypeAlias &)
 422 {}
 423
 424 void
 425 DefaultResolver::visit (AST::EnumItem &)
 426 {}
 427
 428 void
 429 DefaultResolver::visit (AST::EnumItemTuple &item)
 430 {
 431   for (auto &field : item.get_tuple_fields ())
 432     field.get_field_type ().accept_vis (*this);
 433 }
 434
 435 void
 436 DefaultResolver::visit (AST::EnumItemStruct &item)
 437 {
 438   for (auto &field : item.get_struct_fields ())
 439     field.get_field_type ().accept_vis (*this);
 440 }
 441
 442 void
 443 DefaultResolver::visit (AST::EnumItemDiscriminant &item)
 444 {
 445   if (item.has_expr ())
 446     item.get_expr ().accept_vis (*this);
 447 }
 448
 449 void
 450 DefaultResolver::visit (AST::ConstantItem &item)
 451 {
 452   auto expr_vis = [this, &item] () {
 453     item.get_expr ().accept_vis (*this);
 454     visit (item.get_type ());
 455   };
 456
 457   // FIXME: Why do we need a Rib here?
 458   ctx.scoped (Rib::Kind::Item, item.get_node_id (), expr_vis);
 459 }
 460
 461 void
 462 DefaultResolver::visit (AST::StaticItem &item)
 463 {
 464   auto expr_vis = [this, &item] () { item.get_expr ().accept_vis (*this); };
 465
 466   // FIXME: Why do we need a Rib here?
 467   ctx.scoped (Rib::Kind::ConstantItem, item.get_node_id (), expr_vis);
 468 }
 469
 470 void
 471 DefaultResolver::visit (AST::TraitItemConst &)
 472 {}
 473
 474 void
 475 DefaultResolver::visit (AST::TraitItemType &)
 476 {}
 477
 478 void
 479 DefaultResolver::visit (AST::ExternalTypeItem &)
 480 {}
 481
 482 void
 483 DefaultResolver::visit (AST::ExternalStaticItem &)
 484 {}
 485
 486 void
 487 DefaultResolver::visit (AST::MacroMatchRepetition &)
 488 {}
 489
 490 void
 491 DefaultResolver::visit (AST::MacroMatcher &)
 492 {}
 493
 494 void
 495 DefaultResolver::visit (AST::MacroRulesDefinition &)
 496 {}
 497
 498 void
 499 DefaultResolver::visit (AST::MacroInvocation &)
 500 {}
 501
 502 void
 503 DefaultResolver::visit (AST::MetaItemPath &)
 504 {}
 505
 506 void
 507 DefaultResolver::visit (AST::MetaItemSeq &)
 508 {}
 509
 510 void
 511 DefaultResolver::visit (AST::MetaListPaths &)
 512 {}
 513
 514 void
 515 DefaultResolver::visit (AST::MetaListNameValueStr &)
 516 {}
 517
 518 void
 519 DefaultResolver::visit (AST::RangePatternBoundPath &)
 520 {}
 521
 522 void
 523 DefaultResolver::visit (AST::RangePatternBoundQualPath &)
 524 {}
 525
 526 void
 527 DefaultResolver::visit (AST::RangePattern &)
 528 {}
 529
 530 void
 531 DefaultResolver::visit (AST::ReferencePattern &)
 532 {}
 533
 534 void
 535 DefaultResolver::visit (AST::StructPatternFieldTuplePat &)
 536 {}
 537
 538 void
 539 DefaultResolver::visit (AST::StructPatternFieldIdentPat &)
 540 {}
 541
 542 void
 543 DefaultResolver::visit (AST::StructPatternFieldIdent &)
 544 {}
 545
 546 void
 547 DefaultResolver::visit (AST::StructPattern &)
 548 {}
 549
 550 void
 551 DefaultResolver::visit (AST::TupleStructItemsNoRange &)
 552 {}
 553
 554 void
 555 DefaultResolver::visit (AST::TupleStructItemsRange &)
 556 {}
 557
 558 void
 559 DefaultResolver::visit (AST::TupleStructPattern &)
 560 {}
 561
 562 void
 563 DefaultResolver::visit (AST::TuplePatternItemsMultiple &)
 564 {}
 565
 566 void
 567 DefaultResolver::visit (AST::TuplePatternItemsRanged &)
 568 {}
 569
 570 void
 571 DefaultResolver::visit (AST::TuplePattern &)
 572 {}
 573
 574 void
 575 DefaultResolver::visit (AST::GroupedPattern &)
 576 {}
 577
 578 void
 579 DefaultResolver::visit (AST::SlicePattern &)
 580 {}
 581
 582 void
 583 DefaultResolver::visit (AST::AltPattern &)
 584 {}
 585
 586 void
 587 DefaultResolver::visit (AST::EmptyStmt &)
 588 {}
 589
 590 void
 591 DefaultResolver::visit (AST::TraitBound &)
 592 {}
 593
 594 void
 595 DefaultResolver::visit (AST::ImplTraitType &)
 596 {}
 597
 598 void
 599 DefaultResolver::visit (AST::TraitObjectType &)
 600 {}
 601
 602 void
 603 DefaultResolver::visit (AST::ParenthesisedType &)
 604 {}
 605
 606 void
 607 DefaultResolver::visit (AST::ImplTraitTypeOneBound &)
 608 {}
 609
 610 void
 611 DefaultResolver::visit (AST::TraitObjectTypeOneBound &)
 612 {}
 613
 614 void
 615 DefaultResolver::visit (AST::TupleType &)
 616 {}
 617
 618 void
 619 DefaultResolver::visit (AST::ReferenceType &)
 620 {}
 621
 622 void
 623 DefaultResolver::visit (AST::ArrayType &)
 624 {}
 625
 626 void
 627 DefaultResolver::visit (AST::SliceType &)
 628 {}
 629
 630 void
 631 DefaultResolver::visit (AST::BareFunctionType &)
 632 {}
 633
 634 void
 635 DefaultResolver::visit (AST::SelfParam &)
 636 {}
 637
 638 void
 639 DefaultResolver::visit (AST::FunctionParam &)
 640 {}
 641
 642 void
 643 DefaultResolver::visit (AST::VariadicParam &)
 644 {}
 645
 646 } // namespace Resolver2_0
 647 } // namespace Rust