dart2dart: Remove the list of closureVariables from FunctionDefinitions.

tests/compiler/dart2js/backend_dart/sexpr_unstringifier.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.
 
 // SExpressionUnstringifier implements the inverse operation to
 // [SExpressionStringifier].
 
 library sexpr_unstringifier;
 
 import 'package:compiler/src/constants/expressions.dart'
@@ skipping 236 matching lines @@
     List<Primitive> prims = <Primitive>[];
     while (tokens.current != ")") {
       Primitive prim = name2variable[tokens.read()];
       assert(prim != null);
       prims.add(prim);
     }
     tokens.consumeEnd();
     return prims;
   }
 
-  /// (FunctionDefinition name (args cont) body)
+  /// (FunctionDefinition name (parameters) continuation body)
   FunctionDefinition parseFunctionDefinition() {
     tokens.consumeStart(FUNCTION_DEFINITION);
 
     // name
     Element element = new DummyElement("");
     if (tokens.current != '(') {
       // This is a named function.
       element = new DummyElement(tokens.read());
     }
 
@@ skipping 10 matching lines @@
         parameters.add(param);
       }
     }
     tokens.consumeEnd();
 
     // continuation
     String contName = tokens.read("return");
     Continuation cont = name2variable[contName];
     assert(cont != null);
 
-    // [closure-variables]
-    List<ClosureVariable> closureVariables = <ClosureVariable>[];
-    tokens.consumeStart();
-    while (tokens.current != ')') {
-      String varName = tokens.read();
-      ClosureVariable variable =
-          new ClosureVariable(element, new DummyElement(varName));
-      closureVariables.add(variable);
-      name2variable[varName] = variable;
-    }
-    tokens.consumeEnd();
-
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new FunctionDefinition(element, parameters,
-        new RunnableBody(body, cont), null, null,
-        closureVariables);
+        new RunnableBody(body, cont), null, null);
   }
 
   /// (IsTrue arg)
   Condition parseCondition() {
     // Handles IsTrue only for now.
     tokens.consumeStart(IS_TRUE);
 
     Definition value = name2variable[tokens.read()];
     assert(value != null);
 
@@ skipping 25 matching lines @@
 
     tokens.consumeEnd();
     return new ConcatenateStrings(cont, args);
   }
 
   /// (DeclareFunction name = function in body)
   DeclareFunction parseDeclareFunction() {
     tokens.consumeStart(DECLARE_FUNCTION);
 
     // name =
-    ClosureVariable local = name2variable[tokens.read()];
+    ClosureVariable local = getClosureVariable(tokens.read());
     tokens.read("=");
 
     // function in
     FunctionDefinition def = parseFunctionDefinition();
     tokens.read("in");
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
@@ skipping 20 matching lines @@
     Selector selector = dummySelector(constructorName, args.length);
     return new InvokeConstructor(type, element, selector, cont, args);
   }
 
   /// (InvokeContinuation rec? name (args))
   InvokeContinuation parseInvokeContinuation() {
     tokens.consumeStart(INVOKE_CONTINUATION);
     String name = tokens.read();
     bool isRecursive = name == "rec";
     if (isRecursive) name = tokens.read();
-    
+
     Continuation cont = name2variable[name];
     assert(cont != null);
 
     List<Primitive> args = parsePrimitiveList();
 
     tokens.consumeEnd();
     return new InvokeContinuation(cont, args, recursive: isRecursive);
   }
 
   /// (InvokeMethod receiver method (args) cont)
@@ skipping 96 matching lines @@
     Expression body = parseExpression();
     tokens.consumeEnd();
 
     return new LetCont.many(continuations, body);
   }
 
   /// (SetClosureVariable name value body)
   SetClosureVariable parseSetClosureVariable() {
     tokens.consumeStart(SET_CLOSURE_VARIABLE);
 
-    ClosureVariable local = name2variable[tokens.read()];
+    String name = tokens.read();
+    ClosureVariable local = getClosureVariable(name);
     Primitive value = name2variable[tokens.read()];
     assert(value != null);
 
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new SetClosureVariable(local, value)
                   ..plug(body);
   }
 
@@ skipping 121 matching lines @@
   }
 
   /// (CreateFunction (definition))
   CreateFunction parseCreateFunction() {
     tokens.consumeStart(CREATE_FUNCTION);
     FunctionDefinition def = parseFunctionDefinition();
     tokens.consumeEnd();
     return new CreateFunction(def);
   }
 
+  ClosureVariable getClosureVariable(String name) {
+    if (!name2variable.containsKey(name)) {
+      ClosureVariable variable =
+          new ClosureVariable(new DummyElement(""), new DummyElement(name));
+      name2variable[name] = variable;
+    }
+    return name2variable[name];
+  }
+
   /// (GetClosureVariable name)
   GetClosureVariable parseGetClosureVariable() {
     tokens.consumeStart(GET_CLOSURE_VARIABLE);
 
-    ClosureVariable local = name2variable[tokens.read()];
+    String name = tokens.read();
+    ClosureVariable local = getClosureVariable(name);
     tokens.consumeEnd();
 
     return new GetClosureVariable(local);
   }
 
   /// (LiteralList (values))
   LiteralList parseLiteralList() {
     tokens.consumeStart(LITERAL_LIST);
     List<Primitive> values = parsePrimitiveList();
     tokens.consumeEnd();
@@ skipping 26 matching lines @@
     return new ReifyTypeVar(type);
   }
 
   /// (This)
   This parseThis() {
     tokens.consumeStart(THIS);
     tokens.consumeEnd();
     return new This();
   }
 }