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, 378 insertions, 0 deletions

diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h
new file mode 100644
index 0000000..6f21bc3
--- /dev/null
+++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h
@@ -0,0 +1,378 @@
+// 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/>.
+
+#ifndef RUST_AST_RESOLVE_STMT_H
+#define RUST_AST_RESOLVE_STMT_H
+
+#include "rust-ast-resolve-base.h"
+#include "rust-ast-full.h"
+#include "rust-ast-resolve-type.h"
+#include "rust-ast-resolve-pattern.h"
+#include "rust-ast-resolve-expr.h"
+
+namespace Rust {
+namespace Resolver {
+
+class ResolveStmt : public ResolverBase
+{
+  using Rust::Resolver::ResolverBase::visit;
+
+public:
+  static void go (AST::Stmt *stmt, const CanonicalPath &prefix,
+		  const CanonicalPath &canonical_prefix,
+		  const CanonicalPath &enum_prefix)
+  {
+    if (stmt->is_marked_for_strip ())
+      return;
+
+    ResolveStmt resolver (prefix, canonical_prefix, enum_prefix);
+    stmt->accept_vis (resolver);
+  }
+
+  void visit (AST::ExprStmtWithBlock &stmt) override
+  {
+    ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
+  }
+
+  void visit (AST::ExprStmtWithoutBlock &stmt) override
+  {
+    ResolveExpr::go (stmt.get_expr ().get (), prefix, canonical_prefix);
+  }
+
+  void visit (AST::ConstantItem &constant) override
+  {
+    auto decl = CanonicalPath::new_seg (constant.get_node_id (),
+					constant.get_identifier ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (constant.get_node_id (), cpath);
+
+    resolver->get_name_scope ().insert (
+      path, constant.get_node_id (), constant.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (constant.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    ResolveType::go (constant.get_type ().get ());
+    ResolveExpr::go (constant.get_expr ().get (), prefix, canonical_prefix);
+  }
+
+  void visit (AST::LetStmt &stmt) override
+  {
+    if (stmt.has_init_expr ())
+      {
+	ResolveExpr::go (stmt.get_init_expr ().get (), prefix,
+			 canonical_prefix);
+      }
+
+    PatternDeclaration::go (stmt.get_pattern ().get ());
+    if (stmt.has_type ())
+      ResolveType::go (stmt.get_type ().get ());
+  }
+
+  void visit (AST::TupleStruct &struct_decl) override
+  {
+    auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (),
+					struct_decl.get_identifier ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (struct_decl.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    NodeId scope_node_id = struct_decl.get_node_id ();
+    resolver->get_type_scope ().push (scope_node_id);
+
+    if (struct_decl.has_generics ())
+      {
+	for (auto &generic : struct_decl.get_generic_params ())
+	  ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+      }
+
+    for (AST::TupleField &field : struct_decl.get_fields ())
+      ResolveType::go (field.get_field_type ().get ());
+
+    resolver->get_type_scope ().pop ();
+  }
+
+  void visit (AST::Enum &enum_decl) override
+  {
+    auto decl = CanonicalPath::new_seg (enum_decl.get_node_id (),
+					enum_decl.get_identifier ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (enum_decl.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, enum_decl.get_node_id (), enum_decl.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (enum_decl.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    NodeId scope_node_id = enum_decl.get_node_id ();
+    resolver->get_type_scope ().push (scope_node_id);
+
+    if (enum_decl.has_generics ())
+      {
+	for (auto &generic : enum_decl.get_generic_params ())
+	  ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+      }
+
+    for (auto &variant : enum_decl.get_variants ())
+      ResolveStmt::go (variant.get (), path, canonical_prefix, path);
+
+    resolver->get_type_scope ().pop ();
+  }
+
+  void visit (AST::EnumItem &item) override
+  {
+    auto decl = enum_prefix.append (
+      CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (item.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, item.get_node_id (), item.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (item.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    // Done, no fields.
+  }
+
+  void visit (AST::EnumItemTuple &item) override
+  {
+    auto decl = enum_prefix.append (
+      CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (item.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, item.get_node_id (), item.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (item.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    for (auto &field : item.get_tuple_fields ())
+      {
+	if (field.get_field_type ()->is_marked_for_strip ())
+	  continue;
+
+	ResolveType::go (field.get_field_type ().get ());
+      }
+  }
+
+  void visit (AST::EnumItemStruct &item) override
+  {
+    auto decl = enum_prefix.append (
+      CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (item.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, item.get_node_id (), item.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (item.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    for (auto &field : item.get_struct_fields ())
+      {
+	if (field.get_field_type ()->is_marked_for_strip ())
+	  continue;
+
+	ResolveType::go (field.get_field_type ().get ());
+      }
+  }
+
+  void visit (AST::EnumItemDiscriminant &item) override
+  {
+    auto decl = enum_prefix.append (
+      CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()));
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (item.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, item.get_node_id (), item.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (item.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    // Done, no fields.
+  }
+
+  void visit (AST::StructStruct &struct_decl) override
+  {
+    auto decl = CanonicalPath::new_seg (struct_decl.get_node_id (),
+					struct_decl.get_identifier ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (struct_decl.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (struct_decl.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    NodeId scope_node_id = struct_decl.get_node_id ();
+    resolver->get_type_scope ().push (scope_node_id);
+
+    if (struct_decl.has_generics ())
+      {
+	for (auto &generic : struct_decl.get_generic_params ())
+	  ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+      }
+
+    for (AST::StructField &field : struct_decl.get_fields ())
+      {
+	if (field.get_field_type ()->is_marked_for_strip ())
+	  continue;
+
+	ResolveType::go (field.get_field_type ().get ());
+      }
+
+    resolver->get_type_scope ().pop ();
+  }
+
+  void visit (AST::Union &union_decl) override
+  {
+    auto decl = CanonicalPath::new_seg (union_decl.get_node_id (),
+					union_decl.get_identifier ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (union_decl.get_node_id (), cpath);
+
+    resolver->get_type_scope ().insert (
+      path, union_decl.get_node_id (), union_decl.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (union_decl.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    NodeId scope_node_id = union_decl.get_node_id ();
+    resolver->get_type_scope ().push (scope_node_id);
+
+    if (union_decl.has_generics ())
+      for (auto &generic : union_decl.get_generic_params ())
+	ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+
+    for (AST::StructField &field : union_decl.get_variants ())
+      {
+	if (field.get_field_type ()->is_marked_for_strip ())
+	  continue;
+
+	ResolveType::go (field.get_field_type ().get ());
+      }
+
+    resolver->get_type_scope ().pop ();
+  }
+
+  void visit (AST::Function &function) override
+  {
+    auto decl = CanonicalPath::new_seg (function.get_node_id (),
+					function.get_function_name ());
+    auto path = decl; // this ensures we have the correct relative resolution
+    auto cpath = canonical_prefix.append (decl);
+    mappings->insert_canonical_path (function.get_node_id (), cpath);
+
+    resolver->get_name_scope ().insert (
+      path, function.get_node_id (), function.get_locus (), false,
+      [&] (const CanonicalPath &, NodeId, Location locus) -> void {
+	RichLocation r (function.get_locus ());
+	r.add_range (locus);
+	rust_error_at (r, "redefined multiple times");
+      });
+
+    NodeId scope_node_id = function.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 ());
+
+    if (function.has_generics ())
+      for (auto &generic : function.get_generic_params ())
+	ResolveGenericParam::go (generic.get (), prefix, canonical_prefix);
+
+    if (function.has_return_type ())
+      ResolveType::go (function.get_return_type ().get ());
+
+    // we make a new scope so the names of parameters are resolved and shadowed
+    // correctly
+    for (auto &param : function.get_function_params ())
+      {
+	ResolveType::go (param.get_type ().get ());
+	PatternDeclaration::go (param.get_pattern ().get ());
+      }
+
+    // resolve the function body
+    ResolveExpr::go (function.get_definition ().get (), path, cpath);
+
+    resolver->get_name_scope ().pop ();
+    resolver->get_type_scope ().pop ();
+    resolver->get_label_scope ().pop ();
+  }
+
+  void visit (AST::ExternBlock &extern_block) override;
+
+private:
+  ResolveStmt (const CanonicalPath &prefix,
+	       const CanonicalPath &canonical_prefix,
+	       const CanonicalPath &enum_prefix)
+    : ResolverBase (), prefix (prefix), canonical_prefix (canonical_prefix),
+      enum_prefix (enum_prefix)
+  {}
+
+  const CanonicalPath &prefix;
+  const CanonicalPath &canonical_prefix;
+
+  /* item declaration statements are not given a canonical path, but enum items
+   * (variants) do inherit the enum path/identifier name.  */
+  const CanonicalPath &enum_prefix;
+};
+
+} // namespace Resolver
+} // namespace Rust
+
+#endif // RUST_AST_RESOLVE_STMT_H