gcc/rust/util/rust-hir-map.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-hir-map.h"
  20 #include "rust-ast-full.h"
  21 #include "rust-diagnostics.h"
  22 #include "rust-hir-full.h"
  23 #include "rust-macro-builtins.h"
  24 #include "rust-mapping-common.h"
  25
  26 namespace Rust {
  27 namespace Analysis {
  28
  29 NodeMapping
  30 NodeMapping::get_error ()
  31 {
  32   return NodeMapping (UNKNOWN_CREATENUM, UNKNOWN_NODEID, UNKNOWN_HIRID,
  33                       UNKNOWN_LOCAL_DEFID);
  34 }
  35
  36 CrateNum
  37 NodeMapping::get_crate_num () const
  38 {
  39   return crateNum;
  40 }
  41
  42 NodeId
  43 NodeMapping::get_nodeid () const
  44 {
  45   return nodeId;
  46 }
  47
  48 HirId
  49 NodeMapping::get_hirid () const
  50 {
  51   return hirId;
  52 }
  53
  54 LocalDefId
  55 NodeMapping::get_local_defid () const
  56 {
  57   return localDefId;
  58 }
  59
  60 DefId
  61 NodeMapping::get_defid () const
  62 {
  63   return get_defid (get_crate_num (), get_local_defid ());
  64 }
  65
  66 DefId
  67 NodeMapping::get_defid (CrateNum crate_num, LocalDefId local_defid)
  68 {
  69   return DefId{crate_num, local_defid};
  70 }
  71
  72 std::string
  73 NodeMapping::as_string () const
  74 {
  75   std::ostringstream ss;
  76   ss << "["
  77      << "C: " << get_crate_num ();
  78   if (get_nodeid () != UNKNOWN_NODEID)
  79     ss << " Nid: " << get_nodeid ();
  80
  81   if (get_hirid () != UNKNOWN_HIRID)
  82     ss << " Hid: " << get_hirid ();
  83
  84   if (get_local_defid () != UNKNOWN_LOCAL_DEFID)
  85     ss << " Lid: " << get_local_defid ();
  86
  87   ss << "]";
  88   return ss.str ();
  89 }
  90
  91 // Mappings Class now
  92 static const HirId kDefaultNodeIdBegin = 1;
  93 static const HirId kDefaultHirIdBegin = 1;
  94 static const HirId kDefaultCrateNumBegin = 0;
  95
  96 Mappings::Mappings ()
  97   : crateNumItr (kDefaultCrateNumBegin), currentCrateNum (UNKNOWN_CREATENUM),
  98     hirIdIter (kDefaultHirIdBegin), nodeIdIter (kDefaultNodeIdBegin)
  99 {
 100   Analysis::NodeMapping node (0, 0, 0, 0);
 101   builtinMarker
 102     = new HIR::ImplBlock (node, {}, {}, nullptr, nullptr, HIR::WhereClause ({}),
 103                           Positive,
 104                           HIR::Visibility (HIR::Visibility::VisType::PUBLIC),
 105                           {}, {}, Location ());
 106 }
 107
 108 Mappings::~Mappings () { delete builtinMarker; }
 109
 110 Mappings *
 111 Mappings::get ()
 112 {
 113   static std::unique_ptr<Mappings> instance;
 114   if (!instance)
 115     instance = std::unique_ptr<Mappings> (new Mappings ());
 116
 117   return instance.get ();
 118 }
 119
 120 CrateNum
 121 Mappings::get_next_crate_num (const std::string &name)
 122 {
 123   auto id = crateNumItr;
 124   crateNumItr++;
 125   set_crate_name (id, name);
 126   return id;
 127 }
 128
 129 void
 130 Mappings::set_current_crate (CrateNum crateNum)
 131 {
 132   currentCrateNum = crateNum;
 133 }
 134
 135 CrateNum
 136 Mappings::get_current_crate () const
 137 {
 138   return currentCrateNum;
 139 }
 140
 141 bool
 142 Mappings::get_crate_name (CrateNum crate_num, std::string &name) const
 143 {
 144   auto it = crate_names.find (crate_num);
 145   if (it == crate_names.end ())
 146     return false;
 147
 148   name.assign (it->second);
 149   return true;
 150 }
 151
 152 void
 153 Mappings::set_crate_name (CrateNum crate_num, const std::string &name)
 154 {
 155   crate_names[crate_num] = name;
 156 }
 157
 158 std::string
 159 Mappings::get_current_crate_name () const
 160 {
 161   std::string name;
 162   bool ok = get_crate_name (get_current_crate (), name);
 163   rust_assert (ok);
 164   return name;
 165 }
 166
 167 bool
 168 Mappings::lookup_crate_name (const std::string &crate_name,
 169                              CrateNum &resolved_crate_num) const
 170 {
 171   for (const auto &it : crate_names)
 172     {
 173       if (it.second.compare (crate_name) == 0)
 174         {
 175           resolved_crate_num = it.first;
 176           return true;
 177         }
 178     }
 179   return false;
 180 }
 181
 182 bool
 183 Mappings::crate_num_to_nodeid (const CrateNum &crate_num, NodeId &node_id) const
 184 {
 185   auto it = ast_crate_mappings.find (crate_num);
 186   if (it == ast_crate_mappings.end ())
 187     return false;
 188
 189   node_id = it->second->get_node_id ();
 190   return true;
 191 }
 192
 193 bool
 194 Mappings::node_is_crate (NodeId node_id) const
 195 {
 196   for (const auto &it : ast_crate_mappings)
 197     {
 198       NodeId crate_node_id = it.second->get_node_id ();
 199       if (crate_node_id == node_id)
 200         return true;
 201     }
 202   return false;
 203 }
 204
 205 NodeId
 206 Mappings::get_next_node_id ()
 207 {
 208   auto it = nodeIdIter;
 209   nodeIdIter++;
 210   return it;
 211 }
 212
 213 HirId
 214 Mappings::get_next_hir_id (CrateNum crateNum)
 215 {
 216   auto id = hirIdIter;
 217   hirIdIter++;
 218
 219   auto it = hirNodesWithinCrate.find (crateNum);
 220   if (it == hirNodesWithinCrate.end ())
 221     {
 222       hirNodesWithinCrate.insert ({crateNum, {}});
 223     }
 224
 225   hirNodesWithinCrate[crateNum].insert (id);
 226   return id;
 227 }
 228
 229 LocalDefId
 230 Mappings::get_next_localdef_id (CrateNum crateNum)
 231 {
 232   auto it = localIdIter.find (crateNum);
 233   if (it == localIdIter.end ())
 234     {
 235       localIdIter.insert ({crateNum, 1});
 236     }
 237
 238   it = localIdIter.find (crateNum);
 239   rust_assert (it != localIdIter.end ());
 240
 241   LocalDefId id = it->second;
 242   localIdIter[crateNum] = id + 1;
 243   return id;
 244 }
 245
 246 AST::Crate &
 247 Mappings::get_ast_crate (CrateNum crateNum)
 248 {
 249   auto it = ast_crate_mappings.find (crateNum);
 250   rust_assert (it != ast_crate_mappings.end ());
 251   return *it->second;
 252 }
 253
 254 AST::Crate &
 255 Mappings::get_ast_crate_by_node_id (NodeId id)
 256 {
 257   auto i = crate_node_to_crate_num.find (id);
 258   rust_assert (i != crate_node_to_crate_num.end ());
 259
 260   CrateNum crateNum = i->second;
 261   auto it = ast_crate_mappings.find (crateNum);
 262   rust_assert (it != ast_crate_mappings.end ());
 263   return *it->second;
 264 }
 265
 266 AST::Crate &
 267 Mappings::insert_ast_crate (std::unique_ptr<AST::Crate> &&crate,
 268                             CrateNum crate_num)
 269 {
 270   auto it = ast_crate_mappings.find (crate_num);
 271   rust_assert (it == ast_crate_mappings.end ());
 272
 273   // store it
 274   ast_crate_mappings.insert ({crate_num, crate.release ()});
 275
 276   // return the reference to it
 277   it = ast_crate_mappings.find (crate_num);
 278   rust_assert (it != ast_crate_mappings.end ());
 279   return *it->second;
 280 }
 281
 282 HIR::Crate &
 283 Mappings::get_hir_crate (CrateNum crateNum)
 284 {
 285   auto it = hir_crate_mappings.find (crateNum);
 286   rust_assert (it != hir_crate_mappings.end ());
 287   return *it->second;
 288 }
 289
 290 bool
 291 Mappings::is_local_hirid_crate (HirId crateNum)
 292 {
 293   for (const auto &it : hir_crate_mappings)
 294     {
 295       const auto &crate = it.second;
 296       if (crate->get_mappings ().get_hirid () == crateNum)
 297         return true;
 298     }
 299   return false;
 300 }
 301
 302 HIR::Crate &
 303 Mappings::insert_hir_crate (std::unique_ptr<HIR::Crate> &&crate)
 304 {
 305   CrateNum crateNum = crate->get_mappings ().get_crate_num ();
 306   auto it = hir_crate_mappings.find (crateNum);
 307   rust_assert (it == hir_crate_mappings.end ());
 308
 309   insert_node_to_hir (crate->get_mappings ().get_nodeid (),
 310                       crate->get_mappings ().get_hirid ());
 311   hir_crate_mappings.insert ({crateNum, crate.release ()});
 312
 313   it = hir_crate_mappings.find (crateNum);
 314   rust_assert (it != hir_crate_mappings.end ());
 315   return *it->second;
 316 }
 317
 318 void
 319 Mappings::insert_defid_mapping (DefId id, HIR::Item *item)
 320 {
 321   CrateNum crate_num = id.crateNum;
 322   LocalDefId local_def_id = id.localDefId;
 323
 324   rust_assert (lookup_defid (id) == nullptr);
 325   rust_assert (lookup_local_defid (crate_num, local_def_id) == nullptr);
 326   rust_assert (lookup_trait_item_defid (id) == nullptr);
 327
 328   defIdMappings[id] = item;
 329   insert_local_defid_mapping (crate_num, local_def_id, item);
 330 }
 331
 332 HIR::Item *
 333 Mappings::lookup_defid (DefId id)
 334 {
 335   auto it = defIdMappings.find (id);
 336   if (it == defIdMappings.end ())
 337     return nullptr;
 338
 339   return it->second;
 340 }
 341
 342 void
 343 Mappings::insert_defid_mapping (DefId id, HIR::TraitItem *item)
 344 {
 345   CrateNum crate_num = id.crateNum;
 346   LocalDefId local_def_id = id.localDefId;
 347
 348   rust_assert (lookup_defid (id) == nullptr);
 349   rust_assert (lookup_local_defid (crate_num, local_def_id) == nullptr);
 350   rust_assert (lookup_trait_item_defid (id) == nullptr);
 351
 352   defIdTraitItemMappings[id] = item;
 353 }
 354
 355 HIR::TraitItem *
 356 Mappings::lookup_trait_item_defid (DefId id)
 357 {
 358   auto it = defIdTraitItemMappings.find (id);
 359   if (it == defIdTraitItemMappings.end ())
 360     return nullptr;
 361
 362   return it->second;
 363 }
 364
 365 void
 366 Mappings::insert_hir_item (HIR::Item *item)
 367 {
 368   auto id = item->get_mappings ().get_hirid ();
 369   rust_assert (lookup_hir_item (id) == nullptr);
 370
 371   hirItemMappings[id] = item;
 372   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 373 }
 374
 375 HIR::Item *
 376 Mappings::lookup_hir_item (HirId id)
 377 {
 378   auto it = hirItemMappings.find (id);
 379   if (it == hirItemMappings.end ())
 380     return nullptr;
 381
 382   return it->second;
 383 }
 384
 385 void
 386 Mappings::insert_hir_trait_item (HIR::TraitItem *item)
 387 {
 388   auto id = item->get_mappings ().get_hirid ();
 389   rust_assert (lookup_hir_trait_item (id) == nullptr);
 390
 391   hirTraitItemMappings[id] = item;
 392   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 393 }
 394
 395 HIR::TraitItem *
 396 Mappings::lookup_hir_trait_item (HirId id)
 397 {
 398   auto it = hirTraitItemMappings.find (id);
 399   if (it == hirTraitItemMappings.end ())
 400     return nullptr;
 401
 402   return it->second;
 403 }
 404
 405 void
 406 Mappings::insert_hir_extern_block (HIR::ExternBlock *block)
 407 {
 408   auto id = block->get_mappings ().get_hirid ();
 409   rust_assert (lookup_hir_extern_block (id) == nullptr);
 410
 411   hirExternBlockMappings[id] = block;
 412   insert_node_to_hir (block->get_mappings ().get_nodeid (), id);
 413 }
 414
 415 HIR::ExternBlock *
 416 Mappings::lookup_hir_extern_block (HirId id)
 417 {
 418   auto it = hirExternBlockMappings.find (id);
 419   if (it == hirExternBlockMappings.end ())
 420     return nullptr;
 421
 422   return it->second;
 423 }
 424
 425 void
 426 Mappings::insert_hir_extern_item (HIR::ExternalItem *item, HirId parent_block)
 427 {
 428   auto id = item->get_mappings ().get_hirid ();
 429   rust_assert (lookup_hir_extern_item (id, nullptr) == nullptr);
 430
 431   hirExternItemMappings[id] = {item, parent_block};
 432   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 433 }
 434
 435 HIR::ExternalItem *
 436 Mappings::lookup_hir_extern_item (HirId id, HirId *parent_block)
 437 {
 438   auto it = hirExternItemMappings.find (id);
 439   if (it == hirExternItemMappings.end ())
 440     return nullptr;
 441
 442   *parent_block = it->second.second;
 443
 444   return it->second.first;
 445 }
 446
 447 void
 448 Mappings::insert_hir_impl_block (HIR::ImplBlock *item)
 449 {
 450   auto id = item->get_mappings ().get_hirid ();
 451   rust_assert (lookup_hir_impl_block (id) == nullptr);
 452
 453   HirId impl_type_id = item->get_type ()->get_mappings ().get_hirid ();
 454   hirImplBlockMappings[id] = item;
 455   hirImplBlockTypeMappings[impl_type_id] = item;
 456   insert_node_to_hir (item->get_mappings ().get_nodeid (), id);
 457 }
 458
 459 HIR::ImplBlock *
 460 Mappings::lookup_hir_impl_block (HirId id)
 461 {
 462   auto it = hirImplBlockMappings.find (id);
 463   if (it == hirImplBlockMappings.end ())
 464     return nullptr;
 465
 466   return it->second;
 467 }
 468
 469 bool
 470 Mappings::lookup_impl_block_type (HirId id, HIR::ImplBlock **impl_block)
 471 {
 472   auto it = hirImplBlockTypeMappings.find (id);
 473   if (it == hirImplBlockTypeMappings.end ())
 474     return false;
 475
 476   *impl_block = it->second;
 477   return true;
 478 }
 479
 480 void
 481 Mappings::insert_module (HIR::Module *module)
 482 {
 483   auto id = module->get_mappings ().get_hirid ();
 484   rust_assert (lookup_module (id) == nullptr);
 485
 486   hirModuleMappings[id] = module;
 487   insert_node_to_hir (module->get_mappings ().get_nodeid (), id);
 488 }
 489
 490 HIR::Module *
 491 Mappings::lookup_module (HirId id)
 492 {
 493   auto it = hirModuleMappings.find (id);
 494   if (it == hirModuleMappings.end ())
 495     return nullptr;
 496
 497   return it->second;
 498 }
 499
 500 void
 501 Mappings::insert_hir_implitem (HirId parent_impl_id, HIR::ImplItem *item)
 502 {
 503   auto id = item->get_impl_mappings ().get_hirid ();
 504   rust_assert (lookup_hir_implitem (id, nullptr) == nullptr);
 505
 506   hirImplItemMappings[id]
 507     = std::pair<HirId, HIR::ImplItem *> (parent_impl_id, item);
 508   insert_node_to_hir (item->get_impl_mappings ().get_nodeid (), id);
 509 }
 510
 511 HIR::ImplItem *
 512 Mappings::lookup_hir_implitem (HirId id, HirId *parent_impl_id)
 513 {
 514   auto it = hirImplItemMappings.find (id);
 515   if (it == hirImplItemMappings.end ())
 516     return nullptr;
 517
 518   std::pair<HirId, HIR::ImplItem *> &ref = it->second;
 519   if (parent_impl_id != nullptr)
 520     *parent_impl_id = ref.first;
 521
 522   return ref.second;
 523 }
 524
 525 void
 526 Mappings::insert_hir_expr (HIR::Expr *expr)
 527 {
 528   auto id = expr->get_mappings ().get_hirid ();
 529   hirExprMappings[id] = expr;
 530
 531   insert_node_to_hir (expr->get_mappings ().get_nodeid (), id);
 532   insert_location (id, expr->get_locus ());
 533 }
 534
 535 HIR::Expr *
 536 Mappings::lookup_hir_expr (HirId id)
 537 {
 538   auto it = hirExprMappings.find (id);
 539   if (it == hirExprMappings.end ())
 540     return nullptr;
 541
 542   return it->second;
 543 }
 544
 545 void
 546 Mappings::insert_hir_path_expr_seg (HIR::PathExprSegment *expr)
 547 {
 548   auto id = expr->get_mappings ().get_hirid ();
 549   rust_assert (lookup_hir_path_expr_seg (id) == nullptr);
 550
 551   hirPathSegMappings[id] = expr;
 552   insert_node_to_hir (expr->get_mappings ().get_nodeid (), id);
 553   insert_location (id, expr->get_locus ());
 554 }
 555
 556 HIR::PathExprSegment *
 557 Mappings::lookup_hir_path_expr_seg (HirId id)
 558 {
 559   auto it = hirPathSegMappings.find (id);
 560   if (it == hirPathSegMappings.end ())
 561     return nullptr;
 562
 563   return it->second;
 564 }
 565
 566 void
 567 Mappings::insert_hir_generic_param (HIR::GenericParam *param)
 568 {
 569   auto id = param->get_mappings ().get_hirid ();
 570   rust_assert (lookup_hir_generic_param (id) == nullptr);
 571
 572   hirGenericParamMappings[id] = param;
 573   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 574   insert_location (id, param->get_locus ());
 575 }
 576
 577 HIR::GenericParam *
 578 Mappings::lookup_hir_generic_param (HirId id)
 579 {
 580   auto it = hirGenericParamMappings.find (id);
 581   if (it == hirGenericParamMappings.end ())
 582     return nullptr;
 583
 584   return it->second;
 585 }
 586
 587 void
 588 Mappings::insert_hir_type (HIR::Type *type)
 589 {
 590   auto id = type->get_mappings ().get_hirid ();
 591   rust_assert (lookup_hir_type (id) == nullptr);
 592
 593   hirTypeMappings[id] = type;
 594   insert_node_to_hir (type->get_mappings ().get_nodeid (), id);
 595 }
 596
 597 HIR::Type *
 598 Mappings::lookup_hir_type (HirId id)
 599 {
 600   auto it = hirTypeMappings.find (id);
 601   if (it == hirTypeMappings.end ())
 602     return nullptr;
 603
 604   return it->second;
 605 }
 606
 607 void
 608 Mappings::insert_hir_stmt (HIR::Stmt *stmt)
 609 {
 610   auto id = stmt->get_mappings ().get_hirid ();
 611   rust_assert (lookup_hir_stmt (id) == nullptr);
 612
 613   hirStmtMappings[id] = stmt;
 614   insert_node_to_hir (stmt->get_mappings ().get_nodeid (), id);
 615 }
 616
 617 HIR::Stmt *
 618 Mappings::lookup_hir_stmt (HirId id)
 619 {
 620   auto it = hirStmtMappings.find (id);
 621   if (it == hirStmtMappings.end ())
 622     return nullptr;
 623
 624   return it->second;
 625 }
 626
 627 void
 628 Mappings::insert_hir_param (HIR::FunctionParam *param)
 629 {
 630   auto id = param->get_mappings ().get_hirid ();
 631   rust_assert (lookup_hir_param (id) == nullptr);
 632
 633   hirParamMappings[id] = param;
 634   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 635 }
 636
 637 HIR::FunctionParam *
 638 Mappings::lookup_hir_param (HirId id)
 639 {
 640   auto it = hirParamMappings.find (id);
 641   if (it == hirParamMappings.end ())
 642     return nullptr;
 643
 644   return it->second;
 645 }
 646
 647 void
 648 Mappings::insert_hir_self_param (HIR::SelfParam *param)
 649 {
 650   auto id = param->get_mappings ().get_hirid ();
 651   rust_assert (lookup_hir_self_param (id) == nullptr);
 652
 653   hirSelfParamMappings[id] = param;
 654   insert_node_to_hir (param->get_mappings ().get_nodeid (), id);
 655 }
 656
 657 HIR::SelfParam *
 658 Mappings::lookup_hir_self_param (HirId id)
 659 {
 660   auto it = hirSelfParamMappings.find (id);
 661   if (it == hirSelfParamMappings.end ())
 662     return nullptr;
 663
 664   return it->second;
 665 }
 666
 667 void
 668 Mappings::insert_hir_struct_field (HIR::StructExprField *field)
 669 {
 670   auto id = field->get_mappings ().get_hirid ();
 671   rust_assert (lookup_hir_struct_field (id) == nullptr);
 672
 673   hirStructFieldMappings[id] = field;
 674   insert_node_to_hir (field->get_mappings ().get_nodeid (), id);
 675 }
 676
 677 HIR::StructExprField *
 678 Mappings::lookup_hir_struct_field (HirId id)
 679 {
 680   auto it = hirStructFieldMappings.find (id);
 681   if (it == hirStructFieldMappings.end ())
 682     return nullptr;
 683
 684   return it->second;
 685 }
 686
 687 void
 688 Mappings::insert_hir_pattern (HIR::Pattern *pattern)
 689 {
 690   auto id = pattern->get_pattern_mappings ().get_hirid ();
 691   rust_assert (lookup_hir_pattern (id) == nullptr);
 692
 693   hirPatternMappings[id] = pattern;
 694   insert_node_to_hir (pattern->get_pattern_mappings ().get_nodeid (), id);
 695 }
 696
 697 HIR::Pattern *
 698 Mappings::lookup_hir_pattern (HirId id)
 699 {
 700   auto it = hirPatternMappings.find (id);
 701   if (it == hirPatternMappings.end ())
 702     return nullptr;
 703
 704   return it->second;
 705 }
 706
 707 void
 708 Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
 709                                       HIR::Item *item)
 710 {
 711   rust_assert (lookup_local_defid (crateNum, id) == nullptr);
 712   localDefIdMappings[crateNum][id] = item;
 713 }
 714
 715 HIR::Item *
 716 Mappings::lookup_local_defid (CrateNum crateNum, LocalDefId id)
 717 {
 718   auto it = localDefIdMappings.find (crateNum);
 719   if (it == localDefIdMappings.end ())
 720     return nullptr;
 721
 722   auto iy = it->second.find (id);
 723   if (iy == it->second.end ())
 724     return nullptr;
 725
 726   return iy->second;
 727 }
 728
 729 void
 730 Mappings::walk_local_defids_for_crate (CrateNum crateNum,
 731                                        std::function<bool (HIR::Item *)> cb)
 732 {
 733   auto it = localDefIdMappings.find (crateNum);
 734   if (it == localDefIdMappings.end ())
 735     return;
 736
 737   for (auto iy = it->second.begin (); iy != it->second.end (); iy++)
 738     {
 739       if (!cb (iy->second))
 740         return;
 741     }
 742 }
 743
 744 void
 745 Mappings::insert_node_to_hir (NodeId id, HirId ref)
 746 {
 747   nodeIdToHirMappings[id] = ref;
 748   hirIdToNodeMappings[ref] = id;
 749 }
 750
 751 bool
 752 Mappings::lookup_node_to_hir (NodeId id, HirId *ref)
 753 {
 754   auto it = nodeIdToHirMappings.find (id);
 755   if (it == nodeIdToHirMappings.end ())
 756     return false;
 757
 758   *ref = it->second;
 759   return true;
 760 }
 761
 762 bool
 763 Mappings::lookup_hir_to_node (HirId id, NodeId *ref)
 764 {
 765   auto it = hirIdToNodeMappings.find (id);
 766   if (it == hirIdToNodeMappings.end ())
 767     return false;
 768
 769   *ref = it->second;
 770   return true;
 771 }
 772
 773 void
 774 Mappings::insert_location (HirId id, Location locus)
 775 {
 776   locations[id] = locus;
 777 }
 778
 779 Location
 780 Mappings::lookup_location (HirId id)
 781 {
 782   auto it = locations.find (id);
 783   if (it == locations.end ())
 784     return Location ();
 785
 786   return it->second;
 787 }
 788
 789 bool
 790 Mappings::resolve_nodeid_to_stmt (NodeId id, HIR::Stmt **stmt)
 791 {
 792   auto it = nodeIdToHirMappings.find (id);
 793   if (it == nodeIdToHirMappings.end ())
 794     return false;
 795
 796   HirId resolved = it->second;
 797   auto resolved_stmt = lookup_hir_stmt (resolved);
 798   *stmt = resolved_stmt;
 799   return resolved_stmt != nullptr;
 800 }
 801
 802 void
 803 Mappings::iterate_impl_items (
 804   std::function<bool (HirId, HIR::ImplItem *, HIR::ImplBlock *)> cb)
 805 {
 806   for (auto it = hirImplItemMappings.begin (); it != hirImplItemMappings.end ();
 807        it++)
 808     {
 809       auto id = it->first;
 810       auto impl_item = it->second.second;
 811       auto impl
 812         = lookup_associated_impl (impl_item->get_impl_mappings ().get_hirid ());
 813       if (!cb (id, impl_item, impl))
 814         return;
 815     }
 816 }
 817
 818 void
 819 Mappings::iterate_impl_blocks (std::function<bool (HirId, HIR::ImplBlock *)> cb)
 820 {
 821   for (auto it = hirImplBlockMappings.begin ();
 822        it != hirImplBlockMappings.end (); it++)
 823     {
 824       HirId id = it->first;
 825       HIR::ImplBlock *impl_block = it->second;
 826       if (!cb (id, impl_block))
 827         return;
 828     }
 829 }
 830
 831 void
 832 Mappings::iterate_trait_items (
 833   std::function<bool (HIR::TraitItem *, HIR::Trait *)> cb)
 834 {
 835   for (auto it = hirTraitItemMappings.begin ();
 836        it != hirTraitItemMappings.end (); it++)
 837     {
 838       HirId trait_item_id = it->first;
 839       HIR::TraitItem *trait_item = it->second;
 840       HIR::Trait *trait = lookup_trait_item_mapping (trait_item_id);
 841
 842       if (!cb (trait_item, trait))
 843         return;
 844     }
 845 }
 846
 847 void
 848 Mappings::insert_macro_def (AST::MacroRulesDefinition *macro)
 849 {
 850   static std::map<
 851     std::string, std::function<AST::Fragment (Location, AST::MacroInvocData &)>>
 852     builtin_macros = {
 853       {"assert", MacroBuiltin::assert_handler},
 854       {"file", MacroBuiltin::file_handler},
 855       {"line", MacroBuiltin::line_handler},
 856       {"column", MacroBuiltin::column_handler},
 857       {"include_bytes", MacroBuiltin::include_bytes_handler},
 858       {"include_str", MacroBuiltin::include_str_handler},
 859       {"compile_error", MacroBuiltin::compile_error_handler},
 860       {"concat", MacroBuiltin::concat_handler},
 861       {"env", MacroBuiltin::env_handler},
 862       {"cfg", MacroBuiltin::cfg_handler},
 863       {"include", MacroBuiltin::include_handler},
 864     };
 865
 866   auto outer_attrs = macro->get_outer_attrs ();
 867   bool should_be_builtin
 868     = std::any_of (outer_attrs.begin (), outer_attrs.end (),
 869                    [] (AST::Attribute attr) {
 870                      return attr.get_path () == "rustc_builtin_macro";
 871                    });
 872   if (should_be_builtin)
 873     {
 874       auto builtin = builtin_macros.find (macro->get_rule_name ());
 875       if (builtin != builtin_macros.end ())
 876         macro->set_builtin_transcriber (builtin->second);
 877       else
 878         rust_error_at (macro->get_locus (),
 879                        "cannot find a built-in macro with name %qs",
 880                        macro->get_rule_name ().c_str ());
 881     }
 882
 883   auto it = macroMappings.find (macro->get_node_id ());
 884   rust_assert (it == macroMappings.end ());
 885
 886   macroMappings[macro->get_node_id ()] = macro;
 887 }
 888
 889 bool
 890 Mappings::lookup_macro_def (NodeId id, AST::MacroRulesDefinition **def)
 891 {
 892   auto it = macroMappings.find (id);
 893   if (it == macroMappings.end ())
 894     return false;
 895
 896   *def = it->second;
 897   return true;
 898 }
 899
 900 void
 901 Mappings::insert_macro_invocation (AST::MacroInvocation &invoc,
 902                                    AST::MacroRulesDefinition *def)
 903 {
 904   auto it = macroInvocations.find (invoc.get_macro_node_id ());
 905   rust_assert (it == macroInvocations.end ());
 906
 907   macroInvocations[invoc.get_macro_node_id ()] = def;
 908 }
 909
 910 bool
 911 Mappings::lookup_macro_invocation (AST::MacroInvocation &invoc,
 912                                    AST::MacroRulesDefinition **def)
 913 {
 914   auto it = macroInvocations.find (invoc.get_macro_node_id ());
 915   if (it == macroInvocations.end ())
 916     return false;
 917
 918   *def = it->second;
 919   return true;
 920 }
 921
 922 void
 923 Mappings::insert_visibility (NodeId id, Privacy::ModuleVisibility visibility)
 924 {
 925   visibility_map.insert ({id, visibility});
 926 }
 927
 928 bool
 929 Mappings::lookup_visibility (NodeId id, Privacy::ModuleVisibility &def)
 930 {
 931   auto it = visibility_map.find (id);
 932   if (it == visibility_map.end ())
 933     return false;
 934
 935   def = it->second;
 936   return true;
 937 }
 938
 939 void
 940 Mappings::insert_module_child (NodeId module, NodeId child)
 941 {
 942   auto it = module_child_map.find (module);
 943   if (it == module_child_map.end ())
 944     module_child_map.insert ({module, {child}});
 945   else
 946     it->second.emplace_back (child);
 947 }
 948
 949 Optional<std::vector<NodeId> &>
 950 Mappings::lookup_module_children (NodeId module)
 951 {
 952   auto it = module_child_map.find (module);
 953   if (it == module_child_map.end ())
 954     return Optional<std::vector<NodeId> &>::none ();
 955
 956   return Optional<std::vector<NodeId> &>::some (it->second);
 957 }
 958
 959 void
 960 Mappings::insert_module_child_item (NodeId module,
 961                                     Resolver::CanonicalPath child)
 962 {
 963   rust_assert (!child.is_empty ());
 964   rust_assert (child.get_node_id () != UNKNOWN_NODEID);
 965
 966   auto it = module_child_items.find (module);
 967   if (it == module_child_items.end ())
 968     module_child_items.insert ({module, {child}});
 969   else
 970     it->second.emplace_back (child);
 971 }
 972
 973 Optional<std::vector<Resolver::CanonicalPath> &>
 974 Mappings::lookup_module_chidren_items (NodeId module)
 975 {
 976   auto it = module_child_items.find (module);
 977   if (it == module_child_items.end ())
 978     return Optional<std::vector<Resolver::CanonicalPath> &>::none ();
 979
 980   return Optional<std::vector<Resolver::CanonicalPath> &>::some (it->second);
 981 }
 982
 983 Optional<Resolver::CanonicalPath &>
 984 Mappings::lookup_module_child (NodeId module, const std::string &item_name)
 985 {
 986   Optional<std::vector<Resolver::CanonicalPath> &> children
 987     = lookup_module_chidren_items (module);
 988   if (children.is_none ())
 989     return Optional<Resolver::CanonicalPath &>::none ();
 990
 991   // lookup the children to match the name if we can
 992   for (auto &child : children.get ())
 993     {
 994       const std::string &raw_identifier = child.get ();
 995       bool found = raw_identifier.compare (item_name) == 0;
 996       if (found)
 997         return Optional<Resolver::CanonicalPath &>::some (child);
 998     }
 999   return Optional<Resolver::CanonicalPath &>::none ();
1000 }
1001
1002 void
1003 Mappings::insert_child_item_to_parent_module_mapping (NodeId child_item,
1004                                                       NodeId parent_module)
1005 {
1006   child_to_parent_module_map.insert ({child_item, parent_module});
1007 }
1008
1009 Optional<NodeId>
1010 Mappings::lookup_parent_module (NodeId child_item)
1011 {
1012   auto it = child_to_parent_module_map.find (child_item);
1013   if (it == child_to_parent_module_map.end ())
1014     return Optional<NodeId>::none ();
1015
1016   return Optional<NodeId>::some (it->second);
1017 }
1018
1019 bool
1020 Mappings::node_is_module (NodeId query)
1021 {
1022   return module_child_items.find (query) != module_child_items.end ();
1023 }
1024
1025 void
1026 Mappings::insert_ast_item (AST::Item *item)
1027 {
1028   auto it = ast_item_mappings.find (item->get_node_id ());
1029   rust_assert (it == ast_item_mappings.end ());
1030
1031   ast_item_mappings[item->get_node_id ()] = item;
1032 }
1033
1034 bool
1035 Mappings::lookup_ast_item (NodeId id, AST::Item **result)
1036 {
1037   auto it = ast_item_mappings.find (id);
1038   if (it == ast_item_mappings.end ())
1039     return false;
1040
1041   *result = it->second;
1042   return true;
1043 }
1044
1045 HIR::ImplBlock *
1046 Mappings::lookup_builtin_marker ()
1047 {
1048   return builtinMarker;
1049 }
1050
1051 } // namespace Analysis
1052 } // namespace Rust