nr: Add modules to types NS

gcc/rust/ChangeLog:

	* util/rust-hir-map.cc (Mappings::insert_module_id): New function.
	(Mappings::is_module): Likewise.
	* util/rust-hir-map.h: Store a set of AST modules, declare functions for adding and
	retrieving them.
	* resolve/rust-toplevel-name-resolver-2.0.cc (TopLevel::visit): Insert modules in the type
	namespace and store them in mappings.
	* resolve/rust-late-name-resolver-2.0.cc (resolve_type_path_like): Error out when an
	expected type resolves to a module.
	* resolve/rust-name-resolution-context.cc (NameResolutionContext::map_usage): Allow reinsertions.
	* resolve/rust-name-resolution-context.h: Add empty Definition constructor.
	* resolve/rust-resolve-builtins.cc (find_builtin_node_id): New function.
	* resolve/rust-resolve-builtins.h: Declare it.

gcc/testsuite/ChangeLog:

	* rust/compile/mod_in_types_ns.rs: New test.
	* rust/compile/mod_in_types_ns2.rs: New test.

Author: CohenArthur

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

@@ -517,6 +517,33 @@ resolve_type_path_like (NameResolutionContext &ctx, bool block_big_self,
 		     "declared identifiers");
     }
 
+  if (Analysis::Mappings::get ().is_module (resolved->get_node_id ()))
+    {
+      if (type.get_segments ().size () == 1)
+	{
+	  if (auto resolved
+	      = Builtins::find_builtin_node_id (type.as_string ()))
+	    {
+	      ctx.map_usage (Usage (type.get_node_id ()),
+			     Definition (*resolved));
+
+	      // In that specific case, we also override the segment resolution
+	      // as it causes issues later down the line during typechecking
+	      ctx.map_usage (Usage (unwrap_segment_node_id (
+			       type.get_segments ().front ())),
+			     Definition (*resolved));
+	    }
+	  else
+	    {
+	      rust_error_at (type.get_locus (), ErrorCode::E0573,
+			     "expected type, found module %qs",
+			     unwrap_segment_error_string (type).c_str ());
+	    }
+	}
+
+      return;
+    }
+
   ctx.map_usage (Usage (type.get_node_id ()),
 		 Definition (resolved->get_node_id ()));
 }

gcc/rust/resolve/rust-name-resolution-context.cc

@@ -252,10 +252,10 @@ NameResolutionContext::insert_globbed (Identifier name, NodeId id, Namespace ns)
 void
 NameResolutionContext::map_usage (Usage usage, Definition definition)
 {
-  auto inserted = resolved_nodes.emplace (usage, definition).second;
+  resolved_nodes[usage] = definition;
 
-  // is that valid?
-  rust_assert (inserted);
+  // TODO: Are reinsertions okay?
+  // rust_assert (inserted);
 }
 
 tl::optional<NodeId>

gcc/rust/resolve/rust-name-resolution-context.h

@@ -153,6 +153,7 @@ class Usage
 class Definition
 {
 public:
+  explicit Definition () : id (UNKNOWN_NODEID) {}
   explicit Definition (NodeId id) : id (id) {}
 
   NodeId id;

gcc/rust/resolve/rust-resolve-builtins.cc

@@ -120,6 +120,16 @@ setup_type_ctx ()
 			 unit_type);
 }
 
+tl::optional<NodeId>
+find_builtin_node_id (const std::string &name)
+{
+  for (size_t i = 0; i < builtin_count; i++)
+    if (strcmp (name.c_str (), builtin_names[i]) == 0)
+      return builtin_node_ids[i];
+
+  return tl::nullopt;
+}
+
 } // namespace Builtins
 } // namespace Resolver2_0
 } // namespace Rust

gcc/rust/resolve/rust-resolve-builtins.h

@@ -19,6 +19,9 @@
 #ifndef RUST_RESOLVE_BUILTINS_H
 #define RUST_RESOLVE_BUILTINS_H
 
+#include "optional.h"
+#include "rust-ast.h"
+
 namespace Rust {
 namespace Resolver2_0 {
 
@@ -30,6 +33,9 @@ namespace Builtins {
 void setup_lang_prelude (NameResolutionContext &ctx);
 void setup_type_ctx ();
 
+// Return the NodeId associated with a builtin type name if it exists
+tl::optional<NodeId> find_builtin_node_id (const std::string &name);
+
 } // namespace Builtins
 } // namespace Resolver2_0
 } // namespace Rust

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

@@ -106,12 +106,16 @@ TopLevel::go (AST::Crate &crate)
 void
 TopLevel::visit (AST::Module &module)
 {
-  DefaultResolver::visit (module);
-
   if (Analysis::Mappings::get ().lookup_glob_container (module.get_node_id ())
       == tl::nullopt)
     Analysis::Mappings::get ().insert_glob_container (module.get_node_id (),
 						      &module);
+
+  insert_or_error_out (module.get_name (), module, Namespace::Types);
+
+  Analysis::Mappings::get ().insert_module_id (module.get_node_id ());
+
+  DefaultResolver::visit (module);
 }
 
 void

gcc/rust/util/rust-hir-map.cc

@@ -1168,6 +1168,18 @@ Mappings::insert_glob_container (NodeId id, AST::GlobContainer *container)
     glob_containers[id] = container;
 }
 
+void
+Mappings::insert_module_id (NodeId id)
+{
+  module_ids.insert (id);
+}
+
+bool
+Mappings::is_module (NodeId id)
+{
+  return module_ids.find (id) != module_ids.end ();
+}
+
 tl::optional<AST::GlobContainer *>
 Mappings::lookup_glob_container (NodeId id)
 {

gcc/rust/util/rust-hir-map.h

@@ -323,6 +323,10 @@ class Mappings
 
   void insert_glob_container (NodeId, AST::GlobContainer *);
   tl::optional<AST::GlobContainer *> lookup_glob_container (NodeId id);
+
+  void insert_module_id (NodeId);
+  bool is_module (NodeId id);
+
   void insert_module_child (NodeId module, NodeId child);
   tl::optional<std::vector<NodeId> &> lookup_module_children (NodeId module);
 
@@ -438,10 +442,13 @@ class Mappings
   // Module tree maps
 
   // Maps each module's node id to a list of its children
+  // TODO: I think these are only used by the old resolved and can be removed
   std::map<NodeId, std::vector<NodeId>> module_child_map;
   std::map<NodeId, std::vector<Resolver::CanonicalPath>> module_child_items;
   std::map<NodeId, NodeId> child_to_parent_module_map;
+
   std::map<NodeId, AST::GlobContainer *> glob_containers;
+  std::set<NodeId> module_ids;
 
   // AST mappings
   std::map<NodeId, AST::Item *> ast_item_mappings;

gcc/testsuite/rust/compile/mod_in_types_ns.rs

@@ -0,0 +1,8 @@
+#![feature(no_core)]
+#![no_core]
+
+mod foo {
+    mod bar {}
+
+    struct bar; // { dg-error "defined multiple times" }
+}

gcc/testsuite/rust/compile/mod_in_types_ns2.rs

@@ -0,0 +1,8 @@
+#![feature(no_core)]
+#![no_core]
+
+mod foo {
+    mod bar {}
+
+    fn baz() -> bar {} // { dg-error "expected type, found module" }
+}