gccrs: Improve Rib::Definition shadowing

gcc/rust/ChangeLog:

	* resolve/rust-finalize-imports-2.0.cc
	(GlobbingVisitor::visit): Replace calls to insert_shadowable with
	insert_globbed.
	* resolve/rust-forever-stack.h
	(ForeverStack::insert_globbed): Add.
	* resolve/rust-forever-stack.hxx
	(ForeverStack::insert_globbed): Add.
	(ForeverStack::dfs): Handle modifications to Rib::Definition
	fields.
	* resolve/rust-late-name-resolver-2.0.cc
	(Late::visit): Make IdentifierPattern-based declarations
	shadowable.
	* resolve/rust-name-resolution-context.cc
	(NameResolutionContext::insert_globbed): Add.
	* resolve/rust-name-resolution-context.h
	(NameResolutionContext::insert_globbed): Add.
	* resolve/rust-rib.cc
	(Rib::Definition::Definition): Use Rib::Definition::Mode to
	indicate shadowing mode instead of boolean, handle modifications
	to Rib::Definition fields.
	(Rib::Definition::is_ambiguous): Handle modifications to
	Rib::Definition fields.
	(Rib::Definition::to_string): Likewise.
	(Rib::Definition::Shadowable): Handle changed constructor
	signature.
	(Rib::Definition::NonShadowable): Likewise.
	(Rib::Definition::Globbed): Add.
	(Rib::insert): Handle changes to Rib::Definition fields.
	* resolve/rust-rib.h
	(Rib::Definition::Globbed): Add.
	(Rib::Definition::ids): Remove.
	(Rib::Definition::ids_shadowable): Add.
	(Rib::Definition::ids_non_shadowable): Add.
	(Rib::Definition::ids_globbed): Add.
	(Rib::Definition::get_node_id): Handle modifications to
	Rib::Definition fields.
	(Rib::Definition::Mode): Add.
	(Rib::Definition::Definition): Use Rib::Definition::Mode to
	indicate shadowing mode instead of boolean.

gcc/testsuite/ChangeLog:

	* rust/compile/nr2/exclude: Remove shadow1.rs.

Signed-off-by: Owen Avery <powerboat9.gamer@gmail.com>

diff --git a/gcc/rust/resolve/rust-finalize-imports-2.0.cc b/gcc/rust/resolve/rust-finalize-imports-2.0.cc
index 5ce05a9c62408aa10fedcceb99a87e1b8b2dc69c..71916ae432bd0c842ea272c4cc32d6b7ff50c00e 100644 (file)
--- a/gcc/rust/resolve/rust-finalize-imports-2.0.cc
+++ b/gcc/rust/resolve/rust-finalize-imports-2.0.cc
@@ -37,32 +37,32 @@ void
 GlobbingVisitor::visit (AST::Module &module)
 {
   if (module.get_visibility ().is_public ())
-    ctx.insert_shadowable (module.get_name (), module.get_node_id (),
-                          Namespace::Types);
+    ctx.insert_globbed (module.get_name (), module.get_node_id (),
+                       Namespace::Types);
 }
 
 void
 GlobbingVisitor::visit (AST::MacroRulesDefinition &macro)
 {
   if (macro.get_visibility ().is_public ())
-    ctx.insert_shadowable (macro.get_rule_name (), macro.get_node_id (),
-                          Namespace::Macros);
+    ctx.insert_globbed (macro.get_rule_name (), macro.get_node_id (),
+                       Namespace::Macros);
 }
 
 void
 GlobbingVisitor::visit (AST::Function &function)
 {
   if (function.get_visibility ().is_public ())
-    ctx.insert_shadowable (function.get_function_name (),
-                          function.get_node_id (), Namespace::Values);
+    ctx.insert_globbed (function.get_function_name (), function.get_node_id (),
+                       Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::StaticItem &static_item)
 {
   if (static_item.get_visibility ().is_public ())
-    ctx.insert_shadowable (static_item.get_identifier (),
-                          static_item.get_node_id (), Namespace::Values);
+    ctx.insert_globbed (static_item.get_identifier (),
+                       static_item.get_node_id (), Namespace::Values);
 }
 
 void
@@ -70,11 +70,11 @@ GlobbingVisitor::visit (AST::StructStruct &struct_item)
 {
   if (struct_item.get_visibility ().is_public ())
     {
-      ctx.insert_shadowable (struct_item.get_identifier (),
-                            struct_item.get_node_id (), Namespace::Types);
+      ctx.insert_globbed (struct_item.get_identifier (),
+                         struct_item.get_node_id (), Namespace::Types);
       if (struct_item.is_unit_struct ())
-       ctx.insert_shadowable (struct_item.get_identifier (),
-                              struct_item.get_node_id (), Namespace::Values);
+       ctx.insert_globbed (struct_item.get_identifier (),
+                           struct_item.get_node_id (), Namespace::Values);
     }
 }
 
@@ -83,11 +83,11 @@ GlobbingVisitor::visit (AST::TupleStruct &tuple_struct)
 {
   if (tuple_struct.get_visibility ().is_public ())
     {
-      ctx.insert_shadowable (tuple_struct.get_identifier (),
-                            tuple_struct.get_node_id (), Namespace::Types);
+      ctx.insert_globbed (tuple_struct.get_identifier (),
+                         tuple_struct.get_node_id (), Namespace::Types);
 
-      ctx.insert_shadowable (tuple_struct.get_identifier (),
-                            tuple_struct.get_node_id (), Namespace::Values);
+      ctx.insert_globbed (tuple_struct.get_identifier (),
+                         tuple_struct.get_node_id (), Namespace::Values);
     }
 }
 
@@ -95,24 +95,24 @@ void
 GlobbingVisitor::visit (AST::Enum &enum_item)
 {
   if (enum_item.get_visibility ().is_public ())
-    ctx.insert_shadowable (enum_item.get_identifier (),
-                          enum_item.get_node_id (), Namespace::Types);
+    ctx.insert_globbed (enum_item.get_identifier (), enum_item.get_node_id (),
+                       Namespace::Types);
 }
 
 void
 GlobbingVisitor::visit (AST::Union &union_item)
 {
   if (union_item.get_visibility ().is_public ())
-    ctx.insert_shadowable (union_item.get_identifier (),
-                          union_item.get_node_id (), Namespace::Values);
+    ctx.insert_globbed (union_item.get_identifier (), union_item.get_node_id (),
+                       Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::ConstantItem &const_item)
 {
   if (const_item.get_visibility ().is_public ())
-    ctx.insert_shadowable (const_item.get_identifier (),
-                          const_item.get_node_id (), Namespace::Values);
+    ctx.insert_globbed (const_item.get_identifier (), const_item.get_node_id (),
+                       Namespace::Values);
 }
 
 void

diff --git a/gcc/rust/resolve/rust-forever-stack.h b/gcc/rust/resolve/rust-forever-stack.h
index a9aca0f1af001a8e17a62d22ec8e6ddda421e3ba..c24289d0c7e4d9962628e3e1cf967c8129685a21 100644 (file)
--- a/gcc/rust/resolve/rust-forever-stack.h
+++ b/gcc/rust/resolve/rust-forever-stack.h
@@ -452,6 +452,22 @@ public:
   tl::expected<NodeId, DuplicateNameError> insert_shadowable (Identifier name,
                                                              NodeId id);
 
+  /**
+   * Insert a new glob-originated definition in the innermost `Rib` in this
+   * stack
+   *
+   * @param name The name of the definition
+   * @param id Its NodeId
+   *
+   * @return `DuplicateNameError` if that node was already present in the Rib,
+   * the node's `NodeId` otherwise.
+   *
+   * @aborts if there are no `Rib`s inserted in the current map, this function
+   *         aborts the program.
+   */
+  tl::expected<NodeId, DuplicateNameError> insert_globbed (Identifier name,
+                                                          NodeId id);
+
   /**
    * Insert a new definition at the root of this stack
    *

diff --git a/gcc/rust/resolve/rust-forever-stack.hxx b/gcc/rust/resolve/rust-forever-stack.hxx
index a7d46ce0f4ee2af6aced17c0881c18da3366b8bc..4a8b6b59d17d4e9bba5ee1c87094a9fa6eccb31d 100644 (file)
--- a/gcc/rust/resolve/rust-forever-stack.hxx
+++ b/gcc/rust/resolve/rust-forever-stack.hxx
@@ -131,6 +131,16 @@ ForeverStack<N>::insert_shadowable (Identifier name, NodeId node)
                       Rib::Definition::Shadowable (node));
 }
 
+template <Namespace N>
+tl::expected<NodeId, DuplicateNameError>
+ForeverStack<N>::insert_globbed (Identifier name, NodeId node)
+{
+  auto &innermost_rib = peek ();
+
+  return insert_inner (innermost_rib, name.as_string (),
+                      Rib::Definition::Globbed (node));
+}
+
 template <Namespace N>
 tl::expected<NodeId, DuplicateNameError>
 ForeverStack<N>::insert_at_root (Identifier name, NodeId node)
@@ -474,9 +484,17 @@ ForeverStack<N>::dfs (ForeverStack<N>::Node &starting_point, NodeId to_find)
   auto values = starting_point.rib.get_values ();
 
   for (auto &kv : values)
-    for (auto id : kv.second.ids)
-      if (id == to_find)
-       return {{starting_point, kv.first}};
+    {
+      for (auto id : kv.second.ids_shadowable)
+       if (id == to_find)
+         return {{starting_point, kv.first}};
+      for (auto id : kv.second.ids_non_shadowable)
+       if (id == to_find)
+         return {{starting_point, kv.first}};
+      for (auto id : kv.second.ids_globbed)
+       if (id == to_find)
+         return {{starting_point, kv.first}};
+    }
 
   for (auto &child : starting_point.children)
     {

diff --git a/gcc/rust/resolve/rust-late-name-resolver-2.0.cc b/gcc/rust/resolve/rust-late-name-resolver-2.0.cc
index 287972c34cef82b4719be3bd4ad6120c544d507c..c58cd967c97bab37a744ad5b7a03bd313542ad30 100644 (file)
--- a/gcc/rust/resolve/rust-late-name-resolver-2.0.cc
+++ b/gcc/rust/resolve/rust-late-name-resolver-2.0.cc
@@ -154,8 +154,8 @@ Late::visit (AST::IdentifierPattern &identifier)
   // do we insert functions in labels as well?
 
   // We do want to ignore duplicated data because some situations rely on it.
-  std::ignore
-    = ctx.values.insert (identifier.get_ident (), identifier.get_node_id ());
+  std::ignore = ctx.values.insert_shadowable (identifier.get_ident (),
+                                             identifier.get_node_id ());
 }
 
 void

diff --git a/gcc/rust/resolve/rust-name-resolution-context.cc b/gcc/rust/resolve/rust-name-resolution-context.cc
index d964684e4c21f0782a4cc62f0f00c235331a241f..d79f7b5f222a9bf2321b7c946f004891dcabce6d 100644 (file)
--- a/gcc/rust/resolve/rust-name-resolution-context.cc
+++ b/gcc/rust/resolve/rust-name-resolution-context.cc
@@ -64,6 +64,24 @@ NameResolutionContext::insert_shadowable (Identifier name, NodeId id,
     }
 }
 
+tl::expected<NodeId, DuplicateNameError>
+NameResolutionContext::insert_globbed (Identifier name, NodeId id, Namespace ns)
+{
+  switch (ns)
+    {
+    case Namespace::Values:
+      return values.insert_globbed (name, id);
+    case Namespace::Types:
+      return types.insert_globbed (name, id);
+    case Namespace::Macros:
+      return macros.insert_globbed (name, id);
+    case Namespace::Labels:
+    default:
+      // return labels.insert (name, id);
+      rust_unreachable ();
+    }
+}
+
 void
 NameResolutionContext::map_usage (Usage usage, Definition definition)
 {

diff --git a/gcc/rust/resolve/rust-name-resolution-context.h b/gcc/rust/resolve/rust-name-resolution-context.h
index e06d9298abf9f2db00d76f44689ff155c4791b53..e2652dc3b9eb9bb01d84020c6fc8b0f7bec1cfe1 100644 (file)
--- a/gcc/rust/resolve/rust-name-resolution-context.h
+++ b/gcc/rust/resolve/rust-name-resolution-context.h
@@ -175,6 +175,9 @@ public:
   tl::expected<NodeId, DuplicateNameError>
   insert_shadowable (Identifier name, NodeId id, Namespace ns);
 
+  tl::expected<NodeId, DuplicateNameError>
+  insert_globbed (Identifier name, NodeId id, Namespace ns);
+
   /**
    * Run a lambda in a "scoped" context, meaning that a new `Rib` will be pushed
    * before executing the lambda and then popped. This is useful for all kinds

diff --git a/gcc/rust/resolve/rust-rib.cc b/gcc/rust/resolve/rust-rib.cc
index 714507219e02580df0febbfed1d0ece8055e7378..b0380bb0b78f4fdf79a5fe36b19b5a53a3b7005c 100644 (file)
--- a/gcc/rust/resolve/rust-rib.cc
+++ b/gcc/rust/resolve/rust-rib.cc
@@ -22,26 +22,51 @@
 namespace Rust {
 namespace Resolver2_0 {
 
-Rib::Definition::Definition (NodeId id, bool shadowable)
-  : ids ({id}), shadowable (shadowable)
-{}
+Rib::Definition::Definition (NodeId id, Mode mode)
+{
+  switch (mode)
+    {
+    case Mode::SHADOWABLE:
+      ids_shadowable.push_back (id);
+      return;
+    case Mode::NON_SHADOWABLE:
+      ids_non_shadowable.push_back (id);
+      return;
+    case Mode::GLOBBED:
+      ids_globbed.push_back (id);
+      return;
+    default:
+      gcc_unreachable ();
+    }
+}
 
 bool
 Rib::Definition::is_ambiguous () const
 {
-  return shadowable && ids.size () > 1;
+  if (!ids_shadowable.empty ())
+    return false;
+  else if (!ids_non_shadowable.empty ())
+    return ids_non_shadowable.size () > 1;
+  else
+    return ids_globbed.size () > 1;
 }
 
 std::string
 Rib::Definition::to_string () const
 {
   std::stringstream out;
-  out << (shadowable ? "(S)" : "(NS)") << "[";
-  std::string sep;
-  for (auto id : ids)
+  const char *headers[3] = {"(S)[", "] (NS)[", "] (G)["};
+  const std::vector<NodeId> *id_lists[3]
+    = {&ids_shadowable, &ids_non_shadowable, &ids_globbed};
+  for (int i = 0; i < 3; i++)
     {
-      out << sep << id;
-      sep = ",";
+      out << headers[i];
+      std::string sep;
+      for (auto id : *id_lists[i])
+       {
+         out << sep << id;
+         sep = ",";
+       }
     }
   out << "]";
   return out.str ();
@@ -50,13 +75,19 @@ Rib::Definition::to_string () const
 Rib::Definition
 Rib::Definition::Shadowable (NodeId id)
 {
-  return Definition (id, true);
+  return Definition (id, Mode::SHADOWABLE);
 }
 
 Rib::Definition
 Rib::Definition::NonShadowable (NodeId id)
 {
-  return Definition (id, false);
+  return Definition (id, Mode::NON_SHADOWABLE);
+}
+
+Rib::Definition
+Rib::Definition::Globbed (NodeId id)
+{
+  return Definition (id, Mode::GLOBBED);
 }
 
 DuplicateNameError::DuplicateNameError (std::string name, NodeId existing)
@@ -85,29 +116,53 @@ Rib::insert (std::string name, Definition def)
       /* No old value */
       values[name] = def;
     }
-  else if (it->second.shadowable && def.shadowable)
-    { /* Both shadowable */
+  else if (it->second.ids_non_shadowable.empty ()
+          || def.ids_non_shadowable.empty ())
+    { /* No non-shadowable conflict */
       auto &current = values[name];
-      for (auto id : def.ids)
+      for (auto id : def.ids_non_shadowable)
        {
-         if (std::find (current.ids.cbegin (), current.ids.cend (), id)
-             == current.ids.cend ())
-           current.ids.push_back (id);
+         if (std::find (current.ids_non_shadowable.cbegin (),
+                        current.ids_non_shadowable.cend (), id)
+             == current.ids_non_shadowable.cend ())
+           current.ids_non_shadowable.push_back (id);
          else
+           // TODO: should this produce an error?
+           return tl::make_unexpected (DuplicateNameError (name, id));
+       }
+      for (auto id : def.ids_shadowable)
+       {
+         if (std::find (current.ids_shadowable.cbegin (),
+                        current.ids_shadowable.cend (), id)
+             == current.ids_shadowable.cend ())
+           current.ids_shadowable.push_back (id);
+         else
+           // TODO: should this produce an error?
+           return tl::make_unexpected (DuplicateNameError (name, id));
+       }
+      for (auto id : def.ids_globbed)
+       {
+         if (std::find (current.ids_globbed.cbegin (),
+                        current.ids_globbed.cend (), id)
+             == current.ids_globbed.cend ())
+           current.ids_globbed.push_back (id);
+         else
+           // TODO: should this produce an error?
            return tl::make_unexpected (DuplicateNameError (name, id));
        }
     }
-  else if (it->second.shadowable)
-    { /* Only old shadowable : replace value */
-      values[name] = def;
-    }
-  else /* Neither are shadowable */
+  else /* Multiple non-shadowable */
     {
       return tl::make_unexpected (
-       DuplicateNameError (name, it->second.ids.back ()));
+       DuplicateNameError (name, it->second.ids_non_shadowable.back ()));
     }
 
-  return def.ids.back ();
+  if (!def.ids_shadowable.empty ())
+    return def.ids_shadowable.back ();
+  else if (!def.ids_non_shadowable.empty ())
+    return def.ids_non_shadowable.back ();
+  rust_assert (!def.ids_globbed.empty ());
+  return def.ids_globbed.back ();
 }
 
 tl::optional<Rib::Definition>

diff --git a/gcc/rust/resolve/rust-rib.h b/gcc/rust/resolve/rust-rib.h
index 11a6b56abcedf56043417174e4b4fe48512c2aa1..2eb8de8f0efd9f978256ac437d18f610559ae07c 100644 (file)
--- a/gcc/rust/resolve/rust-rib.h
+++ b/gcc/rust/resolve/rust-rib.h
@@ -113,9 +113,16 @@ public:
   public:
     static Definition NonShadowable (NodeId id);
     static Definition Shadowable (NodeId id);
+    static Definition Globbed (NodeId id);
 
-    std::vector<NodeId> ids;
-    bool shadowable;
+    // checked shadowable -> non_shadowable -> globbed
+    // we have shadowable *and* globbed in order to control
+    // resolution priority
+    // we *could* use a single vector with 2 indices here
+    // but it's probably not worth it for now
+    std::vector<NodeId> ids_shadowable;
+    std::vector<NodeId> ids_non_shadowable;
+    std::vector<NodeId> ids_globbed;
 
     Definition () = default;
 
@@ -126,14 +133,29 @@ public:
 
     NodeId get_node_id () const
     {
+      if (!ids_shadowable.empty ())
+       return ids_shadowable.back ();
+
       rust_assert (!is_ambiguous ());
-      return ids[0];
+
+      if (!ids_non_shadowable.empty ())
+       return ids_non_shadowable.back ();
+
+      rust_assert (!ids_globbed.empty ());
+      return ids_globbed.back ();
     }
 
     std::string to_string () const;
 
   private:
-    Definition (NodeId id, bool shadowable);
+    enum class Mode
+    {
+      SHADOWABLE,
+      NON_SHADOWABLE,
+      GLOBBED
+    };
+
+    Definition (NodeId id, Mode mode);
   };
 
   enum class Kind

diff --git a/gcc/testsuite/rust/compile/nr2/exclude b/gcc/testsuite/rust/compile/nr2/exclude
index dec3bdd4d18ec671c467117a0b99b931c8522866..f254c56eb526f07f9bf1f85d0988a2dde94b7ba8 100644 (file)
--- a/gcc/testsuite/rust/compile/nr2/exclude
+++ b/gcc/testsuite/rust/compile/nr2/exclude
@@ -194,7 +194,6 @@ redef_error6.rs
 rustc_attr1.rs
 self-path1.rs
 self-path2.rs
-shadow1.rs
 sizeof-stray-infer-var-bug.rs
 specify-crate-name.rs
 stmt_with_block_dot.rs