dart2dart: Remove the list of closureVariables from FunctionDefinitions.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes_sexpr.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dart2js.ir_nodes_sexpr;
 
 import '../constants/values.dart';
 import '../util/util.dart';
 import 'cps_ir_nodes.dart';
 
@@ skipping 17 matching lines @@
 
   String access(Reference<Definition> r) {
     return decorator(r.definition, namer.getName(r.definition));
   }
 
   String visitParameter(Parameter node) {
     return namer.nameParameter(node);
   }
 
   String visitClosureVariable(ClosureVariable node) {
-    return namer.getName(node);
+    return namer.nameClosureVariable(node);
   }
 
   /// Main entry point for creating a [String] from a [Node].  All recursive
   /// calls must go through this method.
   String visit(Node node) {
     String s = super.visit(node);
     return decorator(node, s);
   }
 
   String visitFunctionDefinition(FunctionDefinition node) {
     String name = node.element.name;
     namer.setReturnContinuation(node.body.returnContinuation);
-    String closureVariables =
-        node.closureVariables.map(namer.nameClosureVariable).join(' ');
     String parameters = node.parameters.map(visit).join(' ');
     String body = indentBlock(() => visit(node.body.body));
-    return '$indentation(FunctionDefinition $name ($parameters) return'
-        ' ($closureVariables)\n$body)';
+    return '$indentation(FunctionDefinition $name ($parameters) return\n'
+        '$body)';
   }
 
   String visitFieldDefinition(FieldDefinition node) {
     String name = node.element.name;
     if (node.hasInitializer) {
       namer.setReturnContinuation(node.body.returnContinuation);
       String body = indentBlock(() => visit(node.body.body));
       return '$indentation(FieldDefinition $name () return\n'
              '$body)';
     } else {
@@ skipping 123 matching lines @@
         indentBlock(() => indentBlock(() => visit(node.definition)));
     return '(CreateFunction\n$function)';
   }
 
   String visitContinuation(Continuation node) {
     // Continuations are visited directly in visitLetCont.
     return '(Unexpected Continuation)';
   }
 
   String visitGetClosureVariable(GetClosureVariable node) {
-    return '(GetClosureVariable ${visit(node.variable.definition)})';
+    namer.nameClosureVariableIfAbsent(node.variable.definition);
+    return '(GetClosureVariable ${access(node.variable)})';
   }
 
   String visitSetClosureVariable(SetClosureVariable node) {
+    namer.nameClosureVariableIfAbsent(node.variable.definition);
     String value = access(node.value);
     String body = indentBlock(() => visit(node.body));
-    return '$indentation(SetClosureVariable ${visit(node.variable.definition)} '
+    return '$indentation(SetClosureVariable ${access(node.variable)} '
            '$value\n$body)';
   }
 
   String visitTypeOperator(TypeOperator node) {
     String receiver = access(node.receiver);
     String cont = access(node.continuation);
     String operator = node.isTypeTest ? 'is' : 'as';
     return '$indentation(TypeOperator $operator $receiver ${node.type} $cont)';
   }
 
@@ skipping 25 matching lines @@
   String visitSetField(SetField node) {
     String object = access(node.object);
     String field = node.field.name;
     String value = access(node.value);
     String body = indentBlock(() => visit(node.body));
     return '$indentation(SetField $object $field $value)\n$body';
   }
 
   String visitGetField(GetField node) {
     String object = access(node.object);
-    String field = node.field.toString();
+    String field = node.field.name;
     return '(GetField $object $field)';
   }
 
   String visitCreateBox(CreateBox node) {
     return '(CreateBox)';
   }
 
   String visitCreateInstance(CreateInstance node) {
     String className = node.classElement.name;
     String arguments = node.arguments.map(access).join(' ');
     return '(CreateInstance $className ($arguments))';
   }
 
   String visitIdentical(Identical node) {
     String left = access(node.left);
     String right = access(node.right);
     return '(Identical $left $right)';
   }
 
   String visitInterceptor(Interceptor node) {
-    return '(Interceptor ${node.input})';
+    return '(Interceptor ${access(node.input)})';
   }
 }
 
 class ConstantStringifier extends ConstantValueVisitor<String, Null> {
   // Some of these methods are unimplemented because we haven't had a need
   // to print such constants.  When printing is implemented, the corresponding
   // parsing support should be added to SExpressionUnstringifier.parseConstant
   // in the dart2js tests (currently in the file
   // tests/compiler/dart2js/backend_dart/sexpr_unstringifier.dart).
 
@@ skipping 62 matching lines @@
   String nameParameter(Parameter parameter) {
     assert(!_names.containsKey(parameter));
     return _names[parameter] = parameter.hint.name;
   }
 
   String nameClosureVariable(ClosureVariable variable) {
     assert(!_names.containsKey(variable));
     return _names[variable] = variable.hint.name;
   }
 
+  String nameClosureVariableIfAbsent(ClosureVariable variable) {
+    if (!_names.containsKey(variable)) {
+      _names[variable] = variable.hint.name;
+    }
+  }
+
   String nameContinuation(Continuation node) {
     assert(!_names.containsKey(node));
     return _names[node] = 'k${_continuationCounter++}';
   }
 
   String nameValue(Primitive node) {
     assert(!_names.containsKey(node));
     return _names[node] = 'v${_valueCounter++}';
   }
 
   void setReturnContinuation(Continuation node) {
     assert(!_names.containsKey(node) || _names[node] == 'return');
     _names[node] = 'return';
   }
 
   String getName(Node node) {
     assert(_names.containsKey(node));
     return _names[node];
   }
 }