Merge #1611

1611: Initial state capture for closures r=philberty a=philberty

This patch set adds the initial support closure captures, move semantics are not
handled here. We track what variables are being captured by a closure during
name resolution so that when a VAR_DECL is resolved, we check if we are inside
a closure context node_id which is the same id as its associated rib id. So when
we resolve a name that resides in an outermost rib we can add this to set of 
node-id's that are captured by this closure.

There is a gap here for the case where we need to check if it is inside a nested
function and that function contains closures which could wrongly capture variables
in the enclosing function. This will also be a problem for nested functions in general.

Fixes #195

Co-authored-by: Philip Herron <philip.herron@embecosm.com>

10 files changed, 312 insertions, 88 deletions

diff --git a/gcc/rust/resolve/rust-ast-resolve-expr.cc b/gcc/rust/resolve/rust-ast-resolve-expr.cc
index 60b3eba..2063dce 100644
--- a/gcc/rust/resolve/rust-ast-resolve-expr.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-expr.cc
@@ -209,7 +209,7 @@ ResolveExpr::visit (AST::IfLetExpr &expr)
 
   for (auto &pattern : expr.get_patterns ())
     {
-      PatternDeclaration::go (pattern.get ());
+      PatternDeclaration::go (pattern.get (), Rib::ItemType::Var);
     }
 
   ResolveExpr::go (expr.get_if_block ().get (), prefix, canonical_prefix);
@@ -343,7 +343,7 @@ ResolveExpr::visit (AST::LoopExpr &expr)
       auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
       resolver->get_label_scope ().insert (
 	CanonicalPath::new_seg (expr.get_node_id (), label_name),
-	label_lifetime_node_id, label.get_locus (), false,
+	label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label,
 	[&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	  rust_error_at (label.get_locus (), "label redefined multiple times");
 	  rust_error_at (locus, "was defined here");
@@ -400,7 +400,7 @@ ResolveExpr::visit (AST::WhileLoopExpr &expr)
       auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
       resolver->get_label_scope ().insert (
 	CanonicalPath::new_seg (label.get_node_id (), label_name),
-	label_lifetime_node_id, label.get_locus (), false,
+	label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label,
 	[&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	  rust_error_at (label.get_locus (), "label redefined multiple times");
 	  rust_error_at (locus, "was defined here");
@@ -429,7 +429,7 @@ ResolveExpr::visit (AST::ForLoopExpr &expr)
       auto label_lifetime_node_id = label.get_lifetime ().get_node_id ();
       resolver->get_label_scope ().insert (
 	CanonicalPath::new_seg (label.get_node_id (), label_name),
-	label_lifetime_node_id, label.get_locus (), false,
+	label_lifetime_node_id, label.get_locus (), false, Rib::ItemType::Label,
 	[&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	  rust_error_at (label.get_locus (), "label redefined multiple times");
 	  rust_error_at (locus, "was defined here");
@@ -446,7 +446,7 @@ ResolveExpr::visit (AST::ForLoopExpr &expr)
   resolver->push_new_label_rib (resolver->get_type_scope ().peek ());
 
   // resolve the expression
-  PatternDeclaration::go (expr.get_pattern ().get ());
+  PatternDeclaration::go (expr.get_pattern ().get (), Rib::ItemType::Var);
   ResolveExpr::go (expr.get_iterator_expr ().get (), prefix, canonical_prefix);
   ResolveExpr::go (expr.get_loop_block ().get (), prefix, canonical_prefix);
 
@@ -520,7 +520,7 @@ ResolveExpr::visit (AST::MatchExpr &expr)
       // insert any possible new patterns
       for (auto &pattern : arm.get_patterns ())
 	{
-	  PatternDeclaration::go (pattern.get ());
+	  PatternDeclaration::go (pattern.get (), Rib::ItemType::Var);
 	}
 
       // resolve the body
@@ -581,9 +581,13 @@ ResolveExpr::visit (AST::ClosureExprInner &expr)
       resolve_closure_param (p);
     }
 
+  resolver->push_closure_context (expr.get_node_id ());
+
   ResolveExpr::go (expr.get_definition_expr ().get (), prefix,
 		   canonical_prefix);
 
+  resolver->pop_closure_context ();
+
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
   resolver->get_label_scope ().pop ();
@@ -606,9 +610,14 @@ ResolveExpr::visit (AST::ClosureExprInnerTyped &expr)
     }
 
   ResolveType::go (expr.get_return_type ().get ());
+
+  resolver->push_closure_context (expr.get_node_id ());
+
   ResolveExpr::go (expr.get_definition_block ().get (), prefix,
 		   canonical_prefix);
 
+  resolver->pop_closure_context ();
+
   resolver->get_name_scope ().pop ();
   resolver->get_type_scope ().pop ();
   resolver->get_label_scope ().pop ();
@@ -617,7 +626,7 @@ ResolveExpr::visit (AST::ClosureExprInnerTyped &expr)
 void
 ResolveExpr::resolve_closure_param (AST::ClosureParam &param)
 {
-  PatternDeclaration::go (param.get_pattern ().get ());
+  PatternDeclaration::go (param.get_pattern ().get (), Rib::ItemType::Param);
 
   if (param.has_type_given ())
     ResolveType::go (param.get_type ().get ());
diff --git a/gcc/rust/resolve/rust-ast-resolve-implitem.h b/gcc/rust/resolve/rust-ast-resolve-implitem.h
index 29dbe34..f334b71 100644
--- a/gcc/rust/resolve/rust-ast-resolve-implitem.h
+++ b/gcc/rust/resolve/rust-ast-resolve-implitem.h
@@ -56,7 +56,7 @@ public:
     auto path = prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, type.get_node_id (), type.get_locus (), false,
+      path, type.get_node_id (), type.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (type.get_locus ());
 	r.add_range (locus);
@@ -72,6 +72,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, constant.get_node_id (), constant.get_locus (), false,
+      Rib::ItemType::Const,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (constant.get_locus ());
 	r.add_range (locus);
@@ -87,6 +88,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, function.get_node_id (), function.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (function.get_locus ());
 	r.add_range (locus);
@@ -102,6 +104,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, method.get_node_id (), method.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (method.get_locus ());
 	r.add_range (locus);
@@ -141,6 +144,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, function.get_node_id (), function.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (function.get_locus ());
 	r.add_range (locus);
@@ -159,6 +163,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, method.get_node_id (), method.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (method.get_locus ());
 	r.add_range (locus);
@@ -177,6 +182,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, constant.get_node_id (), constant.get_locus (), false,
+      Rib::ItemType::Const,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (constant.get_locus ());
 	r.add_range (locus);
@@ -194,7 +200,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, type.get_node_id (), type.get_locus (), false,
+      path, type.get_node_id (), type.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (type.get_locus ());
 	r.add_range (locus);
@@ -233,6 +239,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, function.get_node_id (), function.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (function.get_locus ());
 	r.add_range (locus);
@@ -251,6 +258,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, item.get_node_id (), item.get_locus (), false,
+      Rib::ItemType::Static,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc
index 7f45161..8b9990f 100644
--- a/gcc/rust/resolve/rust-ast-resolve-item.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-item.cc
@@ -82,7 +82,8 @@ ResolveTraitItems::visit (AST::TraitItemFunc &func)
   for (auto &param : function.get_function_params ())
     {
       ResolveType::go (param.get_type ().get ());
-      PatternDeclaration::go (param.get_pattern ().get ());
+      PatternDeclaration::go (param.get_pattern ().get (),
+			      Rib::ItemType::Param);
     }
 
   if (function.has_where_clause ())
@@ -138,14 +139,15 @@ ResolveTraitItems::visit (AST::TraitItemMethod &func)
   AST::TypePath self_type_path (std::move (segments), self_param.get_locus ());
 
   ResolveType::go (&self_type_path);
-  PatternDeclaration::go (&self_pattern);
+  PatternDeclaration::go (&self_pattern, Rib::ItemType::Param);
 
   // 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 ());
+      PatternDeclaration::go (param.get_pattern ().get (),
+			      Rib::ItemType::Param);
     }
 
   if (function.has_where_clause ())
@@ -499,10 +501,8 @@ ResolveItem::visit (AST::Function &function)
   for (auto &param : function.get_function_params ())
     {
       ResolveType::go (param.get_type ().get ());
-      PatternDeclaration::go (param.get_pattern ().get ());
-
-      // the mutability checker needs to verify for immutable decls the number
-      // of assignments are <1. This marks an implicit assignment
+      PatternDeclaration::go (param.get_pattern ().get (),
+			      Rib::ItemType::Param);
     }
 
   // resolve the function body
@@ -631,14 +631,15 @@ ResolveItem::visit (AST::Method &method)
   AST::TypePath self_type_path (std::move (segments), self_param.get_locus ());
 
   ResolveType::go (&self_type_path);
-  PatternDeclaration::go (&self_pattern);
+  PatternDeclaration::go (&self_pattern, Rib::ItemType::Param);
 
   // we make a new scope so the names of parameters are resolved and shadowed
   // correctly
   for (auto &param : method.get_function_params ())
     {
       ResolveType::go (param.get_type ().get ());
-      PatternDeclaration::go (param.get_pattern ().get ());
+      PatternDeclaration::go (param.get_pattern ().get (),
+			      Rib::ItemType::Param);
     }
 
   // resolve any where clause items
diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.cc b/gcc/rust/resolve/rust-ast-resolve-pattern.cc
index 9386d36..05dadfd 100644
--- a/gcc/rust/resolve/rust-ast-resolve-pattern.cc
+++ b/gcc/rust/resolve/rust-ast-resolve-pattern.cc
@@ -49,7 +49,7 @@ PatternDeclaration::visit (AST::TupleStructPattern &pattern)
 
 	for (auto &inner_pattern : items_no_range.get_patterns ())
 	  {
-	    PatternDeclaration::go (inner_pattern.get ());
+	    PatternDeclaration::go (inner_pattern.get (), type);
 	  }
       }
       break;
diff --git a/gcc/rust/resolve/rust-ast-resolve-pattern.h b/gcc/rust/resolve/rust-ast-resolve-pattern.h
index fcbb23f..6e86c40 100644
--- a/gcc/rust/resolve/rust-ast-resolve-pattern.h
+++ b/gcc/rust/resolve/rust-ast-resolve-pattern.h
@@ -55,9 +55,9 @@ class PatternDeclaration : public ResolverBase
   using Rust::Resolver::ResolverBase::visit;
 
 public:
-  static void go (AST::Pattern *pattern)
+  static void go (AST::Pattern *pattern, Rib::ItemType type)
   {
-    PatternDeclaration resolver;
+    PatternDeclaration resolver (type);
     pattern->accept_vis (resolver);
   };
 
@@ -67,14 +67,14 @@ public:
     // as new refs to this decl will match back here so it is ok to overwrite
     resolver->get_name_scope ().insert (
       CanonicalPath::new_seg (pattern.get_node_id (), pattern.get_ident ()),
-      pattern.get_node_id (), pattern.get_locus ());
+      pattern.get_node_id (), pattern.get_locus (), type);
   }
 
   void visit (AST::WildcardPattern &pattern) override
   {
     resolver->get_name_scope ().insert (
       CanonicalPath::new_seg (pattern.get_node_id (), "_"),
-      pattern.get_node_id (), pattern.get_locus ());
+      pattern.get_node_id (), pattern.get_locus (), type);
   }
 
   // cases in a match expression
@@ -89,7 +89,9 @@ public:
   void visit (AST::RangePattern &pattern) override;
 
 private:
-  PatternDeclaration () : ResolverBase () {}
+  PatternDeclaration (Rib::ItemType type) : ResolverBase (), type (type) {}
+
+  Rib::ItemType type;
 };
 
 } // namespace Resolver
diff --git a/gcc/rust/resolve/rust-ast-resolve-stmt.h b/gcc/rust/resolve/rust-ast-resolve-stmt.h
index 6f21bc3..cf74ea2 100644
--- a/gcc/rust/resolve/rust-ast-resolve-stmt.h
+++ b/gcc/rust/resolve/rust-ast-resolve-stmt.h
@@ -64,6 +64,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, constant.get_node_id (), constant.get_locus (), false,
+      Rib::ItemType::Const,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (constant.get_locus ());
 	r.add_range (locus);
@@ -82,7 +83,7 @@ public:
 			 canonical_prefix);
       }
 
-    PatternDeclaration::go (stmt.get_pattern ().get ());
+    PatternDeclaration::go (stmt.get_pattern ().get (), Rib::ItemType::Var);
     if (stmt.has_type ())
       ResolveType::go (stmt.get_type ().get ());
   }
@@ -97,6 +98,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (struct_decl.get_locus ());
 	r.add_range (locus);
@@ -128,6 +130,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, enum_decl.get_node_id (), enum_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (enum_decl.get_locus ());
 	r.add_range (locus);
@@ -158,7 +161,7 @@ public:
     mappings->insert_canonical_path (item.get_node_id (), cpath);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -177,7 +180,7 @@ public:
     mappings->insert_canonical_path (item.get_node_id (), cpath);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -202,7 +205,7 @@ public:
     mappings->insert_canonical_path (item.get_node_id (), cpath);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -227,7 +230,7 @@ public:
     mappings->insert_canonical_path (item.get_node_id (), cpath);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -247,6 +250,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (struct_decl.get_locus ());
 	r.add_range (locus);
@@ -283,6 +287,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, union_decl.get_node_id (), union_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (union_decl.get_locus ());
 	r.add_range (locus);
@@ -317,6 +322,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, function.get_node_id (), function.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (function.get_locus ());
 	r.add_range (locus);
@@ -343,7 +349,8 @@ public:
     for (auto &param : function.get_function_params ())
       {
 	ResolveType::go (param.get_type ().get ());
-	PatternDeclaration::go (param.get_pattern ().get ());
+	PatternDeclaration::go (param.get_pattern ().get (),
+				Rib::ItemType::Param);
       }
 
     // resolve the function body
diff --git a/gcc/rust/resolve/rust-ast-resolve-toplevel.h b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
index 43ae8e4..c071520 100644
--- a/gcc/rust/resolve/rust-ast-resolve-toplevel.h
+++ b/gcc/rust/resolve/rust-ast-resolve-toplevel.h
@@ -57,6 +57,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, module.get_node_id (), module.get_locus (), false,
+      Rib::ItemType::Module,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (module.get_locus ());
 	r.add_range (locus);
@@ -85,6 +86,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, alias.get_node_id (), alias.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (alias.get_locus ());
 	r.add_range (locus);
@@ -105,6 +107,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (struct_decl.get_locus ());
 	r.add_range (locus);
@@ -125,6 +128,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, enum_decl.get_node_id (), enum_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (enum_decl.get_locus ());
 	r.add_range (locus);
@@ -147,7 +151,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -165,7 +169,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -183,7 +187,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -201,7 +205,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_type_scope ().insert (
-      path, item.get_node_id (), item.get_locus (), false,
+      path, item.get_node_id (), item.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (item.get_locus ());
 	r.add_range (locus);
@@ -220,6 +224,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, struct_decl.get_node_id (), struct_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (struct_decl.get_locus ());
 	r.add_range (locus);
@@ -240,6 +245,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, union_decl.get_node_id (), union_decl.get_locus (), false,
+      Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (union_decl.get_locus ());
 	r.add_range (locus);
@@ -259,7 +265,7 @@ public:
     auto cpath = canonical_prefix.append (decl);
 
     resolver->get_name_scope ().insert (
-      path, var.get_node_id (), var.get_locus (), false,
+      path, var.get_node_id (), var.get_locus (), false, Rib::ItemType::Static,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (var.get_locus ());
 	r.add_range (locus);
@@ -280,6 +286,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, constant.get_node_id (), constant.get_locus (), false,
+      Rib::ItemType::Const,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (constant.get_locus ());
 	r.add_range (locus);
@@ -300,6 +307,7 @@ public:
 
     resolver->get_name_scope ().insert (
       path, function.get_node_id (), function.get_locus (), false,
+      Rib::ItemType::Function,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (function.get_locus ());
 	r.add_range (locus);
@@ -343,6 +351,7 @@ public:
 
     resolver->get_name_scope ().insert (
       impl_prefix, impl_block.get_node_id (), impl_block.get_locus (), false,
+      Rib::ItemType::TraitImpl,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (impl_block.get_locus ());
 	r.add_range (locus);
@@ -362,6 +371,7 @@ public:
 
     resolver->get_type_scope ().insert (
       path, trait.get_node_id (), trait.get_locus (), false,
+      Rib::ItemType::Trait,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (trait.get_locus ());
 	r.add_range (locus);
@@ -437,6 +447,7 @@ public:
 
     resolver->get_type_scope ().insert (
       decl, resolved_crate, extern_crate.get_locus (), false,
+      Rib::ItemType::ExternCrate,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	RichLocation r (extern_crate.get_locus ());
 	r.add_range (locus);
diff --git a/gcc/rust/resolve/rust-ast-resolve-type.h b/gcc/rust/resolve/rust-ast-resolve-type.h
index 5a71268..8e1dbc6 100644
--- a/gcc/rust/resolve/rust-ast-resolve-type.h
+++ b/gcc/rust/resolve/rust-ast-resolve-type.h
@@ -177,7 +177,7 @@ public:
     auto seg = CanonicalPath::new_seg (param.get_node_id (),
 				       param.get_type_representation ());
     resolver->get_type_scope ().insert (
-      seg, param.get_node_id (), param.get_locus (), false,
+      seg, param.get_node_id (), param.get_locus (), false, Rib::ItemType::Type,
       [&] (const CanonicalPath &, NodeId, Location locus) -> void {
 	rust_error_at (param.get_locus (),
 		       "generic param redefined multiple times");
diff --git a/gcc/rust/resolve/rust-name-resolver.cc b/gcc/rust/resolve/rust-name-resolver.cc
index ba8c1a8..59aed21 100644
--- a/gcc/rust/resolve/rust-name-resolver.cc
+++ b/gcc/rust/resolve/rust-name-resolver.cc
@@ -19,40 +19,17 @@
 #include "rust-name-resolver.h"
 #include "rust-ast-full.h"
 
-#define MKBUILTIN_TYPE(_X, _R, _TY)                                            \
-  do                                                                           \
-    {                                                                          \
-      AST::PathIdentSegment seg (_X, Linemap::predeclared_location ());        \
-      auto typePath = ::std::unique_ptr<AST::TypePathSegment> (                \
-	new AST::TypePathSegment (::std::move (seg), false,                    \
-				  Linemap::predeclared_location ()));          \
-      ::std::vector< ::std::unique_ptr<AST::TypePathSegment> > segs;           \
-      segs.push_back (::std::move (typePath));                                 \
-      auto builtin_type                                                        \
-	= 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);                                             \
-      mappings->insert_node_to_hir (builtin_type->get_node_id (),              \
-				    _TY->get_ref ());                          \
-      mappings->insert_canonical_path (                                        \
-	builtin_type->get_node_id (),                                          \
-	CanonicalPath::new_seg (builtin_type->get_node_id (), _X));            \
-    }                                                                          \
-  while (0)
-
 namespace Rust {
 namespace Resolver {
 
 Rib::Rib (CrateNum crateNum, NodeId node_id)
-  : crate_num (crateNum), node_id (node_id),
-    mappings (Analysis::Mappings::get ())
+  : crate_num (crateNum), node_id (node_id)
 {}
 
 void
 Rib::insert_name (
   const CanonicalPath &path, NodeId id, Location locus, bool shadow,
+  ItemType type,
   std::function<void (const CanonicalPath &, NodeId, Location)> dup_cb)
 {
   auto it = path_mappings.find (path);
@@ -69,9 +46,10 @@ Rib::insert_name (
     }
 
   path_mappings[path] = id;
-  reverse_path_mappings.insert (std::pair<NodeId, CanonicalPath> (id, path));
-  decls_within_rib.insert (std::pair<NodeId, Location> (id, locus));
+  reverse_path_mappings.insert ({id, path});
+  decls_within_rib.insert ({id, locus});
   references[id] = {};
+  decl_type_mappings.insert ({id, type});
 }
 
 bool
@@ -128,6 +106,17 @@ Rib::decl_was_declared_here (NodeId def) const
   return false;
 }
 
+bool
+Rib::lookup_decl_type (NodeId def, ItemType *type) const
+{
+  auto it = decl_type_mappings.find (def);
+  if (it == decl_type_mappings.end ())
+    return false;
+
+  *type = it->second;
+  return true;
+}
+
 void
 Rib::debug () const
 {
@@ -151,15 +140,17 @@ Scope::Scope (CrateNum crate_num) : crate_num (crate_num) {}
 void
 Scope::insert (
   const CanonicalPath &ident, NodeId id, Location locus, bool shadow,
+  Rib::ItemType type,
   std::function<void (const CanonicalPath &, NodeId, Location)> dup_cb)
 {
-  peek ()->insert_name (ident, id, locus, shadow, dup_cb);
+  peek ()->insert_name (ident, id, locus, shadow, type, dup_cb);
 }
 
 void
-Scope::insert (const CanonicalPath &ident, NodeId id, Location locus)
+Scope::insert (const CanonicalPath &ident, NodeId id, Location locus,
+	       Rib::ItemType type)
 {
-  peek ()->insert_name (ident, id, locus, true,
+  peek ()->insert_name (ident, id, locus, true, type,
 			[] (const CanonicalPath &, NodeId, Location) -> void {
 			});
 }
@@ -178,6 +169,39 @@ Scope::lookup (const CanonicalPath &ident, NodeId *id)
   return lookup != UNKNOWN_NODEID;
 }
 
+bool
+Scope::lookup_decl_type (NodeId id, Rib::ItemType *type)
+{
+  bool found = false;
+  iterate ([&] (const Rib *r) -> bool {
+    if (r->decl_was_declared_here (id))
+      {
+	bool ok = r->lookup_decl_type (id, type);
+	rust_assert (ok);
+	found = true;
+	return false;
+      }
+    return true;
+  });
+  return found;
+}
+
+bool
+Scope::lookup_rib_for_decl (NodeId id, const Rib **rib)
+{
+  bool found = false;
+  iterate ([&] (const Rib *r) -> bool {
+    if (r->decl_was_declared_here (id))
+      {
+	*rib = r;
+	found = true;
+	return false;
+      }
+    return true;
+  });
+  return found;
+}
+
 void
 Scope::iterate (std::function<bool (Rib *)> cb)
 {
@@ -344,6 +368,7 @@ Resolver::insert_builtin_types (Rib *r)
 				  builtin->as_string ());
       r->insert_name (builtin_path, builtin->get_node_id (),
 		      Linemap::predeclared_location (), false,
+		      Rib::ItemType::Type,
 		      [] (const CanonicalPath &, NodeId, Location) -> void {});
     }
 }
@@ -387,24 +412,24 @@ Resolver::generate_builtins ()
   auto str = new TyTy::StrType (mappings->get_next_hir_id ());
   auto never = new TyTy::NeverType (mappings->get_next_hir_id ());
 
-  MKBUILTIN_TYPE ("u8", builtins, u8);
-  MKBUILTIN_TYPE ("u16", builtins, u16);
-  MKBUILTIN_TYPE ("u32", builtins, u32);
-  MKBUILTIN_TYPE ("u64", builtins, u64);
-  MKBUILTIN_TYPE ("u128", builtins, u128);
-  MKBUILTIN_TYPE ("i8", builtins, i8);
-  MKBUILTIN_TYPE ("i16", builtins, i16);
-  MKBUILTIN_TYPE ("i32", builtins, i32);
-  MKBUILTIN_TYPE ("i64", builtins, i64);
-  MKBUILTIN_TYPE ("i128", builtins, i128);
-  MKBUILTIN_TYPE ("bool", builtins, rbool);
-  MKBUILTIN_TYPE ("f32", builtins, f32);
-  MKBUILTIN_TYPE ("f64", builtins, f64);
-  MKBUILTIN_TYPE ("usize", builtins, usize);
-  MKBUILTIN_TYPE ("isize", builtins, isize);
-  MKBUILTIN_TYPE ("char", builtins, char_tyty);
-  MKBUILTIN_TYPE ("str", builtins, str);
-  MKBUILTIN_TYPE ("!", builtins, never);
+  setup_builtin ("u8", u8);
+  setup_builtin ("u16", u16);
+  setup_builtin ("u32", u32);
+  setup_builtin ("u64", u64);
+  setup_builtin ("u128", u128);
+  setup_builtin ("i8", i8);
+  setup_builtin ("i16", i16);
+  setup_builtin ("i32", i32);
+  setup_builtin ("i64", i64);
+  setup_builtin ("i128", i128);
+  setup_builtin ("bool", rbool);
+  setup_builtin ("f32", f32);
+  setup_builtin ("f64", f64);
+  setup_builtin ("usize", usize);
+  setup_builtin ("isize", isize);
+  setup_builtin ("char", char_tyty);
+  setup_builtin ("str", str);
+  setup_builtin ("!", never);
 
   // unit type ()
   TyTy::TupleType *unit_tyty
@@ -419,10 +444,31 @@ Resolver::generate_builtins ()
 }
 
 void
+Resolver::setup_builtin (const std::string &name, TyTy::BaseType *tyty)
+{
+  AST::PathIdentSegment seg (name, Linemap::predeclared_location ());
+  auto typePath = ::std::unique_ptr<AST::TypePathSegment> (
+    new AST::TypePathSegment (::std::move (seg), false,
+			      Linemap::predeclared_location ()));
+  ::std::vector< ::std::unique_ptr<AST::TypePathSegment> > segs;
+  segs.push_back (::std::move (typePath));
+  auto builtin_type
+    = new AST::TypePath (::std::move (segs), Linemap::predeclared_location (),
+			 false);
+  builtins.push_back (builtin_type);
+  tyctx->insert_builtin (tyty->get_ref (), builtin_type->get_node_id (), tyty);
+  mappings->insert_node_to_hir (builtin_type->get_node_id (), tyty->get_ref ());
+  mappings->insert_canonical_path (
+    builtin_type->get_node_id (),
+    CanonicalPath::new_seg (builtin_type->get_node_id (), name));
+}
+
+void
 Resolver::insert_resolved_name (NodeId refId, NodeId defId)
 {
   resolved_names[refId] = defId;
   get_name_scope ().append_reference_for_def (refId, defId);
+  insert_captured_item (defId);
 }
 
 bool
@@ -519,5 +565,104 @@ Resolver::lookup_resolved_misc (NodeId refId, NodeId *defId)
   return true;
 }
 
+void
+Resolver::push_closure_context (NodeId closure_expr_id)
+{
+  auto it = closures_capture_mappings.find (closure_expr_id);
+  rust_assert (it == closures_capture_mappings.end ());
+
+  closures_capture_mappings.insert ({closure_expr_id, {}});
+  closure_context.push_back (closure_expr_id);
+}
+
+void
+Resolver::pop_closure_context ()
+{
+  rust_assert (!closure_context.empty ());
+  closure_context.pop_back ();
+}
+
+void
+Resolver::insert_captured_item (NodeId id)
+{
+  // nothing to do unless we are in a closure context
+  if (closure_context.empty ())
+    return;
+
+  // check that this is a VAR_DECL?
+  Scope &name_scope = get_name_scope ();
+  Rib::ItemType type = Rib::ItemType::Unknown;
+  bool found = name_scope.lookup_decl_type (id, &type);
+  if (!found)
+    return;
+
+  // RIB Function { let a, let b } id = 1;
+  //   RIB Closure { let c } id = 2;
+  //     RIB IfStmt { <bind a>} id = 3;
+  //   RIB ... { ... } id = 4
+  //
+  // if we have a resolved_node_id of 'a' and the current rib is '3' we know
+  // this is binding exists in a rib with id < the closure rib id, other wise
+  // its just a normal binding and we don't care
+  //
+  // Problem the node id's dont work like this because the inner most items are
+  // created first so this means the root will have a larger id and a simple
+  // less than or greater than check wont work for more complex scoping cases
+  // but we can use our current rib context to figure this out by checking if
+  // the rib id the decl we care about exists prior to the rib for the closure
+  // id
+
+  const Rib *r = nullptr;
+  bool ok = name_scope.lookup_rib_for_decl (id, &r);
+  rust_assert (ok);
+  NodeId decl_rib_node_id = r->get_node_id ();
+
+  // iterate the closure context and add in the mapping for all to handle the
+  // case of nested closures
+  for (auto &closure_expr_id : closure_context)
+    {
+      if (!decl_needs_capture (decl_rib_node_id, closure_expr_id, name_scope))
+	continue;
+
+      // is this a valid binding to take
+      bool is_var_decl_p = type == Rib::ItemType::Var;
+      if (!is_var_decl_p)
+	{
+	  // FIXME is this an error case?
+	  return;
+	}
+
+      // append it to the context info
+      auto it = closures_capture_mappings.find (closure_expr_id);
+      rust_assert (it != closures_capture_mappings.end ());
+
+      it->second.insert (id);
+    }
+}
+
+bool
+Resolver::decl_needs_capture (NodeId decl_rib_node_id,
+			      NodeId closure_rib_node_id, const Scope &scope)
+{
+  for (const auto &rib : scope.get_context ())
+    {
+      bool rib_is_closure = rib->get_node_id () == closure_rib_node_id;
+      bool rib_is_decl = rib->get_node_id () == decl_rib_node_id;
+      if (rib_is_closure)
+	return false;
+      else if (rib_is_decl)
+	return true;
+    }
+  return false;
+}
+
+const std::set<NodeId> &
+Resolver::get_captures (NodeId id) const
+{
+  auto it = closures_capture_mappings.find (id);
+  rust_assert (it != closures_capture_mappings.end ());
+  return it->second;
+}
+
 } // namespace Resolver
 } // namespace Rust
diff --git a/gcc/rust/resolve/rust-name-resolver.h b/gcc/rust/resolve/rust-name-resolver.h
index 3716bb0..5bfdeb7 100644
--- a/gcc/rust/resolve/rust-name-resolver.h
+++ b/gcc/rust/resolve/rust-name-resolver.h
@@ -30,13 +30,33 @@ namespace Resolver {
 class Rib
 {
 public:
-  // Rust uses local_def_ids assigned by def_collector on the AST
-  // lets use NodeId instead
+  enum ItemType
+  {
+    Var,
+    Param,
+    Function,
+    Type,
+    Module,
+    Static,
+    Const,
+    Trait,
+    Impl,
+    TraitImpl,
+    ExternCrate,
+    MacroDecl,
+    Label,
+    Unknown
+  };
+
+  // FIXME
+  // Rust uses local_def_ids assigned by def_collector on the AST. Consider
+  // moving to a local-def-id
   Rib (CrateNum crateNum, NodeId node_id);
 
   // this takes the relative paths of items within a compilation unit for lookup
   void insert_name (
     const CanonicalPath &path, NodeId id, Location locus, bool shadow,
+    ItemType type,
     std::function<void (const CanonicalPath &, NodeId, Location)> dup_cb);
 
   bool lookup_canonical_path (const NodeId &id, CanonicalPath *ident);
@@ -45,6 +65,7 @@ public:
   void append_reference_for_def (NodeId def, NodeId ref);
   bool have_references_for_node (NodeId def) const;
   bool decl_was_declared_here (NodeId def) const;
+  bool lookup_decl_type (NodeId def, ItemType *type) const;
   void debug () const;
   std::string debug_str () const;
 
@@ -59,7 +80,7 @@ private:
   std::map<NodeId, CanonicalPath> reverse_path_mappings;
   std::map<NodeId, Location> decls_within_rib;
   std::map<NodeId, std::set<NodeId>> references;
-  Analysis::Mappings *mappings;
+  std::map<NodeId, ItemType> decl_type_mappings;
 };
 
 class Scope
@@ -69,10 +90,14 @@ public:
 
   void
   insert (const CanonicalPath &ident, NodeId id, Location locus, bool shadow,
+	  Rib::ItemType type,
 	  std::function<void (const CanonicalPath &, NodeId, Location)> dup_cb);
 
-  void insert (const CanonicalPath &ident, NodeId id, Location locus);
+  void insert (const CanonicalPath &ident, NodeId id, Location locus,
+	       Rib::ItemType type = Rib::ItemType::Unknown);
   bool lookup (const CanonicalPath &ident, NodeId *id);
+  bool lookup_decl_type (NodeId id, Rib::ItemType *type);
+  bool lookup_rib_for_decl (NodeId id, const Rib **rib);
 
   void iterate (std::function<bool (Rib *)> cb);
   void iterate (std::function<bool (const Rib *)> cb) const;
@@ -86,6 +111,8 @@ public:
 
   CrateNum get_crate_num () const { return crate_num; }
 
+  const std::vector<Rib *> &get_context () const { return stack; };
+
 private:
   CrateNum crate_num;
   std::vector<Rib *> stack;
@@ -168,10 +195,20 @@ public:
     return current_module_stack.at (current_module_stack.size () - 2);
   }
 
+  void push_closure_context (NodeId closure_expr_id);
+  void pop_closure_context ();
+  void insert_captured_item (NodeId id);
+  const std::set<NodeId> &get_captures (NodeId id) const;
+
+protected:
+  bool decl_needs_capture (NodeId decl_rib_node_id, NodeId closure_rib_node_id,
+			   const Scope &scope);
+
 private:
   Resolver ();
 
   void generate_builtins ();
+  void setup_builtin (const std::string &name, TyTy::BaseType *tyty);
 
   Analysis::Mappings *mappings;
   TypeCheckContext *tyctx;
@@ -210,6 +247,10 @@ private:
 
   // keep track of the current module scope ids
   std::vector<NodeId> current_module_stack;
+
+  // captured variables mappings
+  std::vector<NodeId> closure_context;
+  std::map<NodeId, std::set<NodeId>> closures_capture_mappings;
 };
 
 } // namespace Resolver