Go patch committed: Do not mark unused variables as used in closures

[Ian Lance Taylor]

This patch from Chris Manghane fixes the Go frontend to not always
mark variables in closures as used.  This is
http://golang.org/issue/6415.  Bootstrapped and ran Go testsuite on
x86_64-unknown-linux-gnu.  Committed to mainline.

Ian

diff -r cbdec4465fa8 go/parse.cc
--- a/go/parse.cc       Tue Jan 20 08:11:07 2015 -0800
+++ b/go/parse.cc       Tue Jan 20 13:24:35 2015 -0800
@@ -2450,7 +2450,7 @@
            && (named_object->is_variable()
                || named_object->is_result_variable()))
          return this->enclosing_var_reference(in_function, named_object,
-                                              location);
+                                              may_be_sink, location);
 
        switch (named_object->classification())
          {
@@ -2591,11 +2591,14 @@
 
 Expression*
 Parse::enclosing_var_reference(Named_object* in_function, Named_object* var,
-                              Location location)
+                              bool may_be_sink, Location location)
 {
   go_assert(var->is_variable() || var->is_result_variable());
 
-  this->mark_var_used(var);
+  // Any left-hand-side can be a sink, so if this can not be
+  // a sink, then it must be a use of the variable.
+  if (!may_be_sink)
+    this->mark_var_used(var);
 
   Named_object* this_function = this->gogo_->current_function();
   Named_object* closure = this_function->func_value()->closure_var();
@@ -2912,7 +2915,7 @@
        ref = Expression::make_var_reference(var, location);
       else
        ref = this->enclosing_var_reference(ev[i].in_function(), var,
-                                           location);
+                                           true, location);
       Expression* refaddr = Expression::make_unary(OPERATOR_AND, ref,
                                                   location);
       initializer->push_back(refaddr);
@@ -3215,7 +3218,7 @@
   if (in_function != NULL
       && in_function != this->gogo_->current_function()
       && (named_object->is_variable() || named_object->is_result_variable()))
-    return this->enclosing_var_reference(in_function, named_object,
+    return this->enclosing_var_reference(in_function, named_object, is_lhs,
                                         location);
 
   switch (named_object->classification())
@@ -5722,6 +5725,20 @@
   Var_expression* ve = expr->var_expression();
   if (ve != NULL)
     this->mark_var_used(ve->named_object());
+  else if (expr->deref()->field_reference_expression() != NULL
+          && this->gogo_->current_function() != NULL)
+    {
+      // We could be looking at a variable referenced from a closure.
+      // If so, we need to get the enclosed variable and mark it as used.
+      Function* this_function = this->gogo_->current_function()->func_value();
+      Named_object* closure = this_function->closure_var();
+      if (closure != NULL)
+       {
+         unsigned int var_index =
+           expr->deref()->field_reference_expression()->field_index();
+         this->mark_var_used(this_function->enclosing_var(var_index - 1));
+       }
+    }
 
   return expr;
 }
diff -r cbdec4465fa8 go/parse.h
--- a/go/parse.h        Tue Jan 20 08:11:07 2015 -0800
+++ b/go/parse.h        Tue Jan 20 13:24:35 2015 -0800
@@ -218,7 +218,7 @@
   Typed_identifier* receiver();
   Expression* operand(bool may_be_sink, bool *is_parenthesized);
   Expression* enclosing_var_reference(Named_object*, Named_object*,
-                                     Location);
+                                     bool may_be_sink, Location);
   Expression* composite_lit(Type*, int depth, Location);
   Expression* function_lit();
   Expression* create_closure(Named_object* function, Enclosing_vars*,