nr2.0: Handle glob imports of enum variants.

gcc/rust/ChangeLog:

	* resolve/rust-early-name-resolver-2.0.cc (Early::resolve_glob_import): Adapt for enums.
	(Early::finalize_glob_import): Likewise.
	* resolve/rust-early-name-resolver-2.0.h: Likewise.
	* resolve/rust-finalize-imports-2.0.cc (GlobbingVisitor::go): Likewise.
	(GlobbingVisitor::visit_module_container): New function.
	(GlobbingVisitor::visit_enum_container): New function.
	* resolve/rust-finalize-imports-2.0.h: Declare them.
	* resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit): Insert enums as potential
	containers.

gcc/testsuite/ChangeLog:

	* rust/compile/glob_import_enum.rs: New test.

Author: CohenArthur

gcc/rust/resolve/rust-early-name-resolver-2.0.cc

@@ -17,8 +17,11 @@
 // <http://www.gnu.org/licenses/>.
 
 #include "rust-early-name-resolver-2.0.h"
+#include "optional.h"
 #include "rust-ast-full.h"
 #include "rust-diagnostics.h"
+#include "rust-hir-map.h"
+#include "rust-item.h"
 #include "rust-toplevel-name-resolver-2.0.h"
 #include "rust-attributes.h"
 #include "rust-finalize-imports-2.0.h"
@@ -75,8 +78,9 @@ Early::resolve_glob_import (NodeId use_dec_id, TopLevel::ImportKind &&glob)
   if (!resolved.has_value ())
     return false;
 
-  auto result
-    = Analysis::Mappings::get ().lookup_ast_module (resolved->get_node_id ());
+  auto result = Analysis::Mappings::get ().lookup_glob_container (
+    resolved->get_node_id ());
+
   if (!result)
     return false;
 
@@ -394,12 +398,12 @@ void
 Early::finalize_glob_import (NameResolutionContext &ctx,
 			     const Early::ImportPair &mapping)
 {
-  auto module = Analysis::Mappings::get ().lookup_ast_module (
-    mapping.data.module ().get_node_id ());
-  rust_assert (module);
+  auto container = Analysis::Mappings::get ().lookup_glob_container (
+    mapping.data.container ().get_node_id ());
+
+  rust_assert (container);
 
-  GlobbingVisitor glob_visitor (ctx);
-  glob_visitor.go (module.value ());
+  GlobbingVisitor (ctx).go (container.value ());
 }
 
 void

gcc/rust/resolve/rust-early-name-resolver-2.0.h

@@ -83,15 +83,15 @@ class Early : public DefaultResolver
       return ImportData (Kind::Rebind, std::move (definitions));
     }
 
-    static ImportData Glob (Rib::Definition module)
+    static ImportData Glob (Rib::Definition container)
     {
-      return ImportData (Kind::Glob, module);
+      return ImportData (Kind::Glob, container);
     }
 
-    Rib::Definition module () const
+    Rib::Definition container () const
     {
       rust_assert (kind == Kind::Glob);
-      return glob_module;
+      return glob_container;
     }
 
     std::vector<std::pair<Rib::Definition, Namespace>> definitions () const
@@ -107,8 +107,8 @@ class Early : public DefaultResolver
       : kind (kind), resolved_definitions (std::move (definitions))
     {}
 
-    ImportData (Kind kind, Rib::Definition module)
-      : kind (kind), glob_module (module)
+    ImportData (Kind kind, Rib::Definition container)
+      : kind (kind), glob_container (container)
     {}
 
     // TODO: Should this be a union?
@@ -117,7 +117,7 @@ class Early : public DefaultResolver
     std::vector<std::pair<Rib::Definition, Namespace>> resolved_definitions;
 
     // For Glob
-    Rib::Definition glob_module;
+    Rib::Definition glob_container;
   };
 
   struct ImportPair

gcc/rust/resolve/rust-finalize-imports-2.0.cc

@@ -21,18 +21,43 @@
 #include "rust-hir-map.h"
 #include "rust-name-resolution-context.h"
 #include "rust-rib.h"
+#include "rust-system.h"
 #include "rust-toplevel-name-resolver-2.0.h"
 
 namespace Rust {
 namespace Resolver2_0 {
 
 void
-GlobbingVisitor::go (AST::Module *module)
+GlobbingVisitor::go (AST::Item *container)
 {
-  for (auto &i : module->get_items ())
+  switch (container->get_item_kind ())
+    {
+    case AST::Item::Kind::Module:
+      visit_module_container (static_cast<AST::Module &> (*container));
+      break;
+    case AST::Item::Kind::Enum:
+      visit_enum_container (static_cast<AST::Enum &> (*container));
+      break;
+    default:
+      rust_unreachable ();
+    }
+}
+
+void
+GlobbingVisitor::visit_module_container (AST::Module &module)
+{
+  for (auto &i : module.get_items ())
     visit (i);
 }
 
+void
+GlobbingVisitor::visit_enum_container (AST::Enum &item)
+{
+  for (auto &variant : item.get_variants ())
+    ctx.insert_globbed (variant->get_identifier (), variant->get_node_id (),
+			Namespace::Types);
+}
+
 void
 GlobbingVisitor::visit (AST::Module &module)
 {

gcc/rust/resolve/rust-finalize-imports-2.0.h

@@ -18,6 +18,7 @@
 
 #include "rust-ast.h"
 #include "rust-expr.h"
+#include "rust-item.h"
 #include "rust-name-resolution-context.h"
 #include "rust-toplevel-name-resolver-2.0.h"
 #include "rust-early-name-resolver-2.0.h"
@@ -32,7 +33,11 @@ class GlobbingVisitor : public AST::DefaultASTVisitor
 public:
   GlobbingVisitor (NameResolutionContext &ctx) : ctx (ctx) {}
 
-  void go (AST::Module *module);
+  void go (AST::Item *container);
+
+  void visit_module_container (AST::Module &module);
+  void visit_enum_container (AST::Enum &item);
+
   void visit (AST::Module &module) override;
   void visit (AST::MacroRulesDefinition &macro) override;
   void visit (AST::Function &function) override;

gcc/rust/resolve/rust-toplevel-name-resolver-2.0.cc

@@ -103,9 +103,9 @@ TopLevel::visit (AST::Module &module)
 {
   DefaultResolver::visit (module);
 
-  if (Analysis::Mappings::get ().lookup_ast_module (module.get_node_id ())
+  if (Analysis::Mappings::get ().lookup_glob_container (module.get_node_id ())
       == tl::nullopt)
-    Analysis::Mappings::get ().insert_ast_module (&module);
+    Analysis::Mappings::get ().insert_glob_container (&module);
 }
 
 void
@@ -339,6 +339,13 @@ TopLevel::visit (AST::Enum &enum_item)
 		       Namespace::Types);
 
   DefaultResolver::visit (enum_item);
+
+  // Since enums can be containers for imports, we need to insert them like we
+  // do for modules
+  if (Analysis::Mappings::get ().lookup_glob_container (
+	enum_item.get_node_id ())
+      == tl::nullopt)
+    Analysis::Mappings::get ().insert_glob_container (&enum_item);
 }
 
 void

gcc/testsuite/rust/compile/glob_import_enum.rs

@@ -0,0 +1,16 @@
+use self::Ordering::*;
+use Ordering::*;
+
+enum Ordering {
+    A,
+    B,
+}
+
+fn foo(_: Ordering) {}
+
+fn main() {
+    let a = A;
+
+    foo(a);
+    foo(B);
+}