TypeResolution pass now with a TyTy module

Resolution must implement the Gathering specified in the rust-dev guide.
We need to be able to handle cases such as:

  let mut x;
  x = 1;

or

  let mut x = vec!{}
  x.push(1)

Now the TyTy module has a combine abstract method to allow the combination
of types to condense down from their integral parts.

6 files changed, 61 insertions, 30 deletions

diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.h b/gcc/rust/resolve/rust-ast-resolve-expr.h
index 9ca763d..b9e7f6a 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.h
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.h
@@ -49,23 +49,24 @@ public:
 
   void visit (AST::ReturnExpr &expr)
   {
-    if (expr.has_return_expr ())
-      ResolveExpr::go (expr.get_expr (), expr.get_node_id ());
+    if (expr.has_returned_expr ())
+      ResolveExpr::go (expr.get_returned_expr ().get (), expr.get_node_id ());
   }
 
   void visit (AST::CallExpr &expr)
   {
-    ResolveExpr::go (expr.function.get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_function_expr ().get (), expr.get_node_id ());
     expr.iterate_params ([&] (AST::Expr *p) mutable -> bool {
       ResolveExpr::go (p, expr.get_node_id ());
       return true;
     });
+    /// resolver->insert_resolved_name(NodeId refId,NodeId defId)
   }
 
   void visit (AST::AssignmentExpr &expr)
   {
-    ResolveExpr::go (expr.get_lhs (), expr.get_node_id ());
-    ResolveExpr::go (expr.get_rhs (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_left_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_right_expr ().get (), expr.get_node_id ());
   }
 
   void visit (AST::IdentifierExpr &expr)
@@ -84,8 +85,8 @@ public:
 
   void visit (AST::ArithmeticOrLogicalExpr &expr)
   {
-    ResolveExpr::go (expr.get_lhs (), expr.get_node_id ());
-    ResolveExpr::go (expr.right_expr.get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_left_expr ().get (), expr.get_node_id ());
+    ResolveExpr::go (expr.get_right_expr ().get (), expr.get_node_id ());
   }
 
 private:
diff --git a/gcc/rust/resolve/rust-ast-resolve-item.h b/gcc/rust/resolve/rust-ast-resolve-item.h
index ea79fc0..2c21a52 100644
--- a/gcc/rust/resolve/rust-ast-resolve-item.h
+++ b/gcc/rust/resolve/rust-ast-resolve-item.h
@@ -23,6 +23,7 @@
 #include "rust-ast-full.h"
 #include "rust-ast-resolve-type.h"
 #include "rust-ast-resolve-pattern.h"
+#include "rust-ast-resolve-stmt.h"
 
 namespace Rust {
 namespace Resolver {
@@ -51,11 +52,21 @@ public:
 				param.get_node_id ());
       }
 
+    // setup parent scoping for names
+    NodeId scope_node_id = function.get_definition ()->get_node_id ();
+    resolver->get_name_scope ().push (scope_node_id);
+    resolver->get_type_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 ());
+
     function.get_definition ()->iterate_stmts (
       [&] (AST::Stmt *s) mutable -> bool {
-	// TODO
+	ResolveStmt::go (s, s->get_node_id ());
 	return true;
       });
+
+    resolver->get_name_scope ().pop ();
+    resolver->get_type_scope ().pop ();
   }
 
 private:
diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.h b/gcc/rust/resolve/rust-ast-resolve-pattern.h
index fc2da70..a393d31 100644
--- a/gcc/rust/resolve/rust-ast-resolve-pattern.h
+++ b/gcc/rust/resolve/rust-ast-resolve-pattern.h
@@ -78,6 +78,7 @@ public:
 
   void visit (AST::IdentifierPattern &pattern)
   {
+    printf ("declaration for: %s\n", pattern.as_string ().c_str ());
     // if we have a duplicate id this then allows for shadowing correctly
     // as new refs to this decl will match back here so it is ok to overwrite
     resolver->get_name_scope ().insert (pattern.get_ident (),
diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h
index 42fb097..623fbd4 100644
--- a/gcc/rust/resolve/rust-ast-resolve-stmt.h
+++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h
@@ -41,16 +41,16 @@ public:
 
   void visit (AST::LetStmt &stmt)
   {
-    PatternDeclaration::go (stmt.variables_pattern.get (), stmt.get_node_id ());
+    PatternDeclaration::go (stmt.get_pattern ().get (), stmt.get_node_id ());
     if (stmt.has_type ())
-      ResolveType::go (stmt.type.get (), stmt.get_node_id ());
+      ResolveType::go (stmt.get_type ().get (), stmt.get_node_id ());
 
     if (stmt.has_init_expr ())
-      ResolveExpr::go (stmt.init_expr.get (), stmt.get_node_id ());
+      ResolveExpr::go (stmt.get_init_expr ().get (), stmt.get_node_id ());
   }
 
 private:
-  ResolveStmt () : ResolverBase (UNKNOWN_NODEID) {}
+  ResolveStmt (NodeId parent) : ResolverBase (parent) {}
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve.cc b/gcc/rust/resolve/rust-ast-resolve.cc
index 664af12..57bd0f3 100644
--- a/gcc/rust/resolve/rust-ast-resolve.cc
+++ b/gcc/rust/resolve/rust-ast-resolve.cc
@@ -20,8 +20,9 @@
 #include "rust-ast-resolve-toplevel.h"
 #include "rust-ast-resolve-item.h"
 #include "rust-ast-full.h"
+#include "rust-tyty.h"
 
-#define MKBUILTIN_TYPE(_X, _R)                                                 \
+#define MKBUILTIN_TYPE(_X, _R, _TY)                                            \
   do                                                                           \
     {                                                                          \
       AST::PathIdentSegment seg (_X);                                          \
@@ -34,6 +35,8 @@
 	= new AST::TypePath (::std::move (segs),                               \
 			     Linemap::predeclared_location (), false);         \
       _R.push_back (builtin_type);                                             \
+      tyctx->insert_builtin (_TY->get_ref (), builtin_type->get_node_id (),    \
+			     _TY);                                             \
     }                                                                          \
   while (0)
 
@@ -43,7 +46,7 @@ namespace Resolver {
 // Resolver
 
 Resolver::Resolver ()
-  : mappings (Analysis::Mappings::get ()),
+  : mappings (Analysis::Mappings::get ()), tyctx (TypeCheckContext::get ()),
     name_scope (Scope (mappings->get_current_crate ())),
     type_scope (Scope (mappings->get_current_crate ()))
 {
@@ -116,22 +119,26 @@ Resolver::get_builtin_types ()
 void
 Resolver::generate_builtins ()
 {
-  MKBUILTIN_TYPE ("u8", builtins);
-  MKBUILTIN_TYPE ("u16", builtins);
-  MKBUILTIN_TYPE ("u32", builtins);
-  MKBUILTIN_TYPE ("u64", builtins);
-
-  MKBUILTIN_TYPE ("i8", builtins);
-  MKBUILTIN_TYPE ("i16", builtins);
-  MKBUILTIN_TYPE ("i32", builtins);
-  MKBUILTIN_TYPE ("i64", builtins);
-
-  MKBUILTIN_TYPE ("f32", builtins);
-  MKBUILTIN_TYPE ("f64", builtins);
-
-  MKBUILTIN_TYPE ("char", builtins);
-  MKBUILTIN_TYPE ("str", builtins);
-  MKBUILTIN_TYPE ("bool", builtins);
+  auto u8
+    = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U8);
+  auto u16
+    = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U16);
+  auto u32
+    = new TyTy::UintType (mappings->get_next_hir_id (), TyTy::UintType::U32);
+  auto i8 = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I8);
+  auto i16
+    = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I16);
+  auto i32
+    = new TyTy::IntType (mappings->get_next_hir_id (), TyTy::IntType::I32);
+  auto rbool = new TyTy::BoolType (mappings->get_next_hir_id ());
+
+  MKBUILTIN_TYPE ("u8", builtins, u8);
+  MKBUILTIN_TYPE ("u16", builtins, u16);
+  MKBUILTIN_TYPE ("u32", builtins, u32);
+  MKBUILTIN_TYPE ("i8", builtins, i8);
+  MKBUILTIN_TYPE ("i16", builtins, i16);
+  MKBUILTIN_TYPE ("i32", builtins, i32);
+  MKBUILTIN_TYPE ("bool", builtins, rbool);
 }
 
 void
diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h
index 4aac7d5..2aa592c 100644
--- a/gcc/rust/resolve/rust-name-resolver.h
+++ b/gcc/rust/resolve/rust-name-resolver.h
@@ -21,6 +21,7 @@
 
 #include "rust-system.h"
 #include "rust-hir-map.h"
+#include "rust-hir-type-check.h"
 
 namespace Rust {
 namespace Resolver {
@@ -55,6 +56,15 @@ public:
   CrateNum get_crate_num () const { return crate_num; }
   NodeId get_node_id () const { return node_id; }
 
+  void iterate_decls (std::function<bool (NodeId)> cb)
+  {
+    for (auto it : decls_within_rib)
+      {
+	if (!cb (it))
+	  return;
+      }
+  }
+
 private:
   CrateNum crate_num;
   NodeId node_id;
@@ -174,6 +184,7 @@ private:
   void generate_builtins ();
 
   Analysis::Mappings *mappings;
+  TypeCheckContext *tyctx;
 
   std::vector<AST::TypePath *> builtins;