gcc/rust/resolve/rust-rib.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-rib.h"
  20 #include "rust-name-resolution-context.h"
  21
  22 namespace Rust {
  23 namespace Resolver2_0 {
  24
  25 Rib::Definition::Definition (NodeId id, bool shadowable)
  26   : ids ({id}), shadowable (shadowable)
  27 {}
  28
  29 bool
  30 Rib::Definition::is_ambiguous () const
  31 {
  32   return shadowable && ids.size () > 1;
  33 }
  34
  35 std::string
  36 Rib::Definition::to_string () const
  37 {
  38   std::stringstream out;
  39   out << (shadowable ? "(S)" : "(NS)") << "[";
  40   std::string sep;
  41   for (auto id : ids)
  42     {
  43       out << sep << id;
  44       sep = ",";
  45     }
  46   out << "]";
  47   return out.str ();
  48 }
  49
  50 Rib::Definition
  51 Rib::Definition::Shadowable (NodeId id)
  52 {
  53   return Definition (id, true);
  54 }
  55
  56 Rib::Definition
  57 Rib::Definition::NonShadowable (NodeId id)
  58 {
  59   return Definition (id, false);
  60 }
  61
  62 DuplicateNameError::DuplicateNameError (std::string name, NodeId existing)
  63   : name (name), existing (existing)
  64 {}
  65
  66 Rib::Rib (Kind kind) : kind (kind) {}
  67
  68 Rib::Rib (Kind kind, std::string identifier, NodeId id)
  69   : Rib (kind, {{identifier, id}})
  70 {}
  71
  72 Rib::Rib (Kind kind, std::unordered_map<std::string, NodeId> to_insert)
  73   : kind (kind)
  74 {
  75   for (auto &value : to_insert)
  76     values.insert ({value.first, Definition::NonShadowable (value.second)});
  77 }
  78
  79 tl::expected<NodeId, DuplicateNameError>
  80 Rib::insert (std::string name, Definition def)
  81 {
  82   auto it = values.find (name);
  83   if (it == values.end ())
  84     {
  85       /* No old value */
  86       values[name] = def;
  87     }
  88   else if (it->second.shadowable && def.shadowable)
  89     { /* Both shadowable */
  90       auto &current = values[name];
  91       for (auto id : def.ids)
  92         {
  93           if (std::find (current.ids.cbegin (), current.ids.cend (), id)
  94               == current.ids.cend ())
  95             {
  96               current.ids.push_back (id);
  97             }
  98         }
  99     }
 100   else if (it->second.shadowable)
 101     { /* Only old shadowable : replace value */
 102       values[name] = def;
 103     }
 104   else /* Neither are shadowable */
 105     {
 106       return tl::make_unexpected (
 107         DuplicateNameError (name, it->second.ids.back ()));
 108     }
 109
 110   return def.ids.back ();
 111 }
 112
 113 tl::optional<Rib::Definition>
 114 Rib::get (const std::string &name)
 115 {
 116   auto it = values.find (name);
 117
 118   if (it == values.end ())
 119     return tl::nullopt;
 120
 121   return it->second;
 122 }
 123
 124 const std::unordered_map<std::string, Rib::Definition> &
 125 Rib::get_values () const
 126 {
 127   return values;
 128 }
 129
 130 } // namespace Resolver2_0
 131 } // namespace Rust