diff mbox series

[077/125] gccrs: Make globbing definition shadowable by default

Message ID 20240801145809.366388-79-arthur.cohen@embecosm.com
State Committed
Commit 16e00f3b14cf5a36624c287cfcded74a38b55212
Headers
Series [001/125] Rust: Make 'tree'-level 'MAIN_NAME_P' work |

Commit Message

Arthur Cohen Aug. 1, 2024, 2:57 p.m. UTC 
  From: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

Elements from glob use declaration shall be shadowable by default.

gcc/rust/ChangeLog:

	* resolve/rust-forever-stack.h: Add a new function prototype to insert
	a shadowable definition.
	* resolve/rust-forever-stack.hxx: Add the new insert_shadowable
	function to insert shadowable definition into the forever stack.
	* resolve/rust-name-resolution-context.cc (NameResolutionContext::insert_shadowable):
	Likewise with the name resolution context.
	* resolve/rust-name-resolution-context.h: Add name resolution context
	insert_shadowable member function prototype.
	* resolve/rust-toplevel-name-resolver-2.0.cc (GlobbingVisitor::visit):
	Insert shadowable definition into the forever stack for glob use
	declaration.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>
---
 gcc/rust/resolve/rust-forever-stack.h         | 15 ++++++++
 gcc/rust/resolve/rust-forever-stack.hxx       | 10 ++++++
 .../resolve/rust-name-resolution-context.cc   | 19 ++++++++++
 .../resolve/rust-name-resolution-context.h    |  3 ++
 .../rust-toplevel-name-resolver-2.0.cc        | 35 ++++++++++---------
 5 files changed, 65 insertions(+), 17 deletions(-)
diff mbox series

Patch

diff --git a/gcc/rust/resolve/rust-forever-stack.h b/gcc/rust/resolve/rust-forever-stack.h
index 01371fc7bcd..bba5875d435 100644
--- a/gcc/rust/resolve/rust-forever-stack.h
+++ b/gcc/rust/resolve/rust-forever-stack.h
@@ -437,6 +437,21 @@  public:
    */
   tl::expected<NodeId, DuplicateNameError> insert (Identifier name, NodeId id);
 
+  /**
+   * Insert a new shadowable 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_shadowable (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 a2fdce98362..008adff4676 100644
--- a/gcc/rust/resolve/rust-forever-stack.hxx
+++ b/gcc/rust/resolve/rust-forever-stack.hxx
@@ -119,6 +119,16 @@  ForeverStack<N>::insert (Identifier name, NodeId node)
 		       Rib::Definition::NonShadowable (node));
 }
 
+template <Namespace N>
+tl::expected<NodeId, DuplicateNameError>
+ForeverStack<N>::insert_shadowable (Identifier name, NodeId node)
+{
+  auto &innermost_rib = peek ();
+
+  return insert_inner (innermost_rib, name.as_string (),
+		       Rib::Definition::Shadowable (node));
+}
+
 template <Namespace N>
 tl::expected<NodeId, DuplicateNameError>
 ForeverStack<N>::insert_at_root (Identifier name, NodeId node)
diff --git a/gcc/rust/resolve/rust-name-resolution-context.cc b/gcc/rust/resolve/rust-name-resolution-context.cc
index 0340d28f127..e8529b70bcb 100644
--- a/gcc/rust/resolve/rust-name-resolution-context.cc
+++ b/gcc/rust/resolve/rust-name-resolution-context.cc
@@ -45,6 +45,25 @@  NameResolutionContext::insert (Identifier name, NodeId id, Namespace ns)
     }
 }
 
+tl::expected<NodeId, DuplicateNameError>
+NameResolutionContext::insert_shadowable (Identifier name, NodeId id,
+					  Namespace ns)
+{
+  switch (ns)
+    {
+    case Namespace::Values:
+      return values.insert_shadowable (name, id);
+    case Namespace::Types:
+      return types.insert_shadowable (name, id);
+    case Namespace::Macros:
+      return macros.insert_shadowable (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 8702900d0f3..74f110d54de 100644
--- a/gcc/rust/resolve/rust-name-resolution-context.h
+++ b/gcc/rust/resolve/rust-name-resolution-context.h
@@ -171,6 +171,9 @@  public:
   tl::expected<NodeId, DuplicateNameError> insert (Identifier name, NodeId id,
 						   Namespace ns);
 
+  tl::expected<NodeId, DuplicateNameError>
+  insert_shadowable (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-toplevel-name-resolver-2.0.cc b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
index 501204174f2..7f4169a4d8e 100644
--- a/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
+++ b/gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc
@@ -36,71 +36,72 @@  void
 GlobbingVisitor::visit (AST::Module &module)
 {
   if (module.get_visibility ().is_public ())
-    ctx.insert (module.get_name (), module.get_node_id (), Namespace::Types);
+    ctx.insert_shadowable (module.get_name (), module.get_node_id (),
+			   Namespace::Types);
 }
 
 void
 GlobbingVisitor::visit (AST::MacroRulesDefinition &macro)
 {
   if (macro.get_visibility ().is_public ())
-    ctx.insert (macro.get_rule_name (), macro.get_node_id (),
-		Namespace::Macros);
+    ctx.insert_shadowable (macro.get_rule_name (), macro.get_node_id (),
+			   Namespace::Macros);
 }
 
 void
 GlobbingVisitor::visit (AST::Function &function)
 {
   if (function.get_visibility ().is_public ())
-    ctx.insert (function.get_function_name (), function.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (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 (static_item.get_identifier (), static_item.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (static_item.get_identifier (),
+			   static_item.get_node_id (), Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::StructStruct &struct_item)
 {
   if (struct_item.get_visibility ().is_public ())
-    ctx.insert (struct_item.get_identifier (), struct_item.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (struct_item.get_identifier (),
+			   struct_item.get_node_id (), Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::TupleStruct &tuple_struct)
 {
   if (tuple_struct.get_visibility ().is_public ())
-    ctx.insert (tuple_struct.get_identifier (), tuple_struct.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (tuple_struct.get_identifier (),
+			   tuple_struct.get_node_id (), Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::Enum &enum_item)
 {
   if (enum_item.get_visibility ().is_public ())
-    ctx.insert (enum_item.get_identifier (), enum_item.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (enum_item.get_identifier (),
+			   enum_item.get_node_id (), Namespace::Values);
 }
 
 void
 GlobbingVisitor::visit (AST::Union &union_item)
 {
   if (union_item.get_visibility ().is_public ())
-    ctx.insert (union_item.get_identifier (), union_item.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (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 (const_item.get_identifier (), const_item.get_node_id (),
-		Namespace::Values);
+    ctx.insert_shadowable (const_item.get_identifier (),
+			   const_item.get_node_id (), Namespace::Values);
 }
 
 void