gccrs: Add name resolution pass to the Rust front-end

The name resolution is split into two phases, one toplevel pass which scans
the whole "Crate" which iterates all items and nested items in modules to
generate a context class full of CanonicalPath items. It also generates
a hierarchy of parent->child and child->parent relationships using the AST
NodeId for PathResolution in the second phase.

The second phase drills into each item like functions and creates a stack
of canonical paths for variables etc so that we can store information in
a side table of usage variable 'a' resolves to NodeId '123' which refers
to the NodeId of the "let a;" statement.

	gcc/rust/
	* resolve/rust-ast-resolve-base.cc: New.
	* resolve/rust-ast-resolve-base.h: New.
	* resolve/rust-ast-resolve-expr.cc: New.
	* resolve/rust-ast-resolve-expr.h: New.
	* resolve/rust-ast-resolve-implitem.h: New.
	* resolve/rust-ast-resolve-item.cc: New.
	* resolve/rust-ast-resolve-item.h: New.
	* resolve/rust-ast-resolve-path.cc: New.
	* resolve/rust-ast-resolve-path.h: New.
	* resolve/rust-ast-resolve-pattern.cc: New.
	* resolve/rust-ast-resolve-pattern.h: New.
	* resolve/rust-ast-resolve-stmt.cc: New.
	* resolve/rust-ast-resolve-stmt.h: New.
	* resolve/rust-ast-resolve-struct-expr-field.cc: New.
	* resolve/rust-ast-resolve-struct-expr-field.h: New.
	* resolve/rust-ast-resolve-toplevel.h: New.
	* resolve/rust-ast-resolve-type.cc: New.
	* resolve/rust-ast-resolve-type.h: New.
	* resolve/rust-ast-resolve.cc: New.
	* resolve/rust-ast-resolve.h: New.
	* resolve/rust-ast-verify-assignee.h: New.
	* resolve/rust-name-resolver.cc: New.
	* resolve/rust-name-resolver.h: New.

1 files changed, 115 insertions, 0 deletions

diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
new file mode 100644
index 0000000..93fa7c8
--- /dev/null
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -0,0 +1,115 @@
+// Copyright (C) 2020-2022 Free Software Foundation, Inc.
+
+// This file is part of GCC.
+
+// GCC is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 3, or (at your option) any later
+// version.
+
+// GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GCC; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-ast-resolve.h"
+#include "rust-ast-full.h"
+#include "rust-tyty.h"
+#include "rust-ast-resolve-toplevel.h"
+#include "rust-ast-resolve-item.h"
+#include "rust-ast-resolve-expr.h"
+#include "rust-ast-resolve-struct-expr-field.h"
+
+extern bool
+saw_errors (void);
+
+namespace Rust {
+namespace Resolver {
+
+// NameResolution
+
+NameResolution *
+NameResolution::get ()
+{
+  static NameResolution *instance;
+  if (instance == nullptr)
+    instance = new NameResolution ();
+
+  return instance;
+}
+
+NameResolution::NameResolution ()
+  : resolver (Resolver::get ()), mappings (Analysis::Mappings::get ())
+{
+  // these are global
+  resolver->get_type_scope ().push (mappings->get_next_node_id ());
+  resolver->insert_builtin_types (resolver->get_type_scope ().peek ());
+  resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+}
+
+void
+NameResolution::Resolve (AST::Crate &crate)
+{
+  auto resolver = get ();
+  resolver->go (crate);
+}
+
+void
+NameResolution::go (AST::Crate &crate)
+{
+  // lookup current crate name
+  CrateNum cnum = mappings->get_current_crate ();
+  std::string crate_name;
+  bool ok = mappings->get_crate_name (cnum, crate_name);
+  rust_assert (ok);
+
+  // setup the ribs
+  NodeId scope_node_id = crate.get_node_id ();
+  resolver->get_name_scope ().push (scope_node_id);
+  resolver->get_type_scope ().push (scope_node_id);
+  resolver->get_label_scope ().push (scope_node_id);
+  resolver->push_new_name_rib (resolver->get_name_scope ().peek ());
+  resolver->push_new_type_rib (resolver->get_type_scope ().peek ());
+  resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
+
+  // get the root segment
+  CanonicalPath crate_prefix
+    = CanonicalPath::new_seg (scope_node_id, crate_name);
+  crate_prefix.set_crate_num (cnum);
+
+  // setup a dummy crate node
+  resolver->get_name_scope ().insert (
+    CanonicalPath::new_seg (crate.get_node_id (), "__$$crate__"),
+    crate.get_node_id (), Location ());
+
+  // setup the root scope
+  resolver->push_new_module_scope (scope_node_id);
+
+  // first gather the top-level namespace names then we drill down so this
+  // allows for resolving forward declarations since an impl block might have
+  // a Self type Foo which is defined after the impl block for example.
+  for (auto it = crate.items.begin (); it != crate.items.end (); it++)
+    ResolveTopLevel::go (it->get (), CanonicalPath::create_empty (),
+			 crate_prefix);
+
+  // FIXME remove this
+  if (saw_errors ())
+    {
+      resolver->pop_module_scope ();
+      return;
+    }
+
+  // next we can drill down into the items and their scopes
+  for (auto it = crate.items.begin (); it != crate.items.end (); it++)
+    ResolveItem::go (it->get (), CanonicalPath::create_empty (), crate_prefix);
+
+  // done
+  resolver->pop_module_scope ();
+}
+
+} // namespace Resolver
+} // namespace Rust