Refactored treatment of closure variables in dart2js CPS.

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 166 matching lines @@
     return new Selector(kind, name, null, argumentCount);
   }
 
   /// Returns the tokens in s. Note that string literals are not necessarily
   /// preserved; for instance, "(literalString)" is transformed to
   /// " ( literalString ) ".
   Tokens tokenize(String s) =>
       new Tokens(
           s.replaceAll("(", " ( ")
            .replaceAll(")", " ) ")
+           .replaceAll("{", " { ")
+           .replaceAll("}", " } ")
            .replaceAll(new RegExp(r"[ \t\n]+"), " ")
            .trim()
            .split(" ")
            .map(canonicalizeOperators)
            .toList());
 
   /// Canonicalizes strings containing operator names.
   String canonicalizeOperators(String token) {
     String opname = OPERATORS.lookup(token);
     if (opname != null) {
@@ skipping 65 matching lines @@
     tokens.consumeEnd();
     return prims;
   }
 
   /// (FunctionDefinition name (args cont) body)
   FunctionDefinition parseFunctionDefinition() {
     tokens.consumeStart(FUNCTION_DEFINITION);
 
     // name
     Element element = new DummyElement("");
-    if (tokens.current != "(") {
+    if (tokens.current != '(' && tokens.current != '{') {
       // This is a named function.
       element = new DummyElement(tokens.read());
     }
 
+    // [closure-vars]
+    List<ClosureVariable> closureVariables = <ClosureVariable>[];
+    if (tokens.current == '{') {
+      tokens.read('{');
+      while (tokens.current != '}') {
+        String varName = tokens.read();
+        ClosureVariable variable =
+            new ClosureVariable(element, new DummyElement(varName));
+        closureVariables.add(variable);
+        name2variable[varName] = variable;
+      }
+      tokens.read('}');
+    }
+
     // (args cont)
-    List<Parameter> parameters = <Parameter>[];
+    List<Definition> parameters = <Definition>[];
     tokens.consumeStart();
     while (tokens.next != ")") {
       String paramName = tokens.read();
-      Parameter param = new Parameter(new DummyElement(paramName));
-      name2variable[paramName] = param;
-      parameters.add(param);
+      if (name2variable.containsKey(paramName)) {
+        parameters.add(name2variable[paramName]);
+      } else {
+        Parameter param = new Parameter(new DummyElement(paramName));
+        name2variable[paramName] = param;
+        parameters.add(param);
+      }
     }
 
     String contName = tokens.read("return");
     Continuation cont = name2variable[contName];
     assert(cont != null);
     tokens.consumeEnd();
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
-    return new FunctionDefinition(element, cont, parameters, body, null, null);
+    return new FunctionDefinition(element, cont, parameters, body, null, null,
+        closureVariables);
   }
 
   /// (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 =
-    Local local = new DummyLocal(tokens.read());
+    ClosureVariable local = name2variable[tokens.read()];
     tokens.read("=");
 
     // function in
     FunctionDefinition def = parseFunctionDefinition();
     tokens.read("in");
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
@@ skipping 120 matching lines @@
     // body
     Expression body = parseExpression();
 
     return new LetCont(cont, body);
   }
 
   /// (SetClosureVariable name value body)
   SetClosureVariable parseSetClosureVariable() {
     tokens.consumeStart(SET_CLOSURE_VARIABLE);
 
-    Local local = new DummyLocal(tokens.read());
+    ClosureVariable local = name2variable[tokens.read()];
     Primitive value = name2variable[tokens.read()];
     assert(value != null);
 
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new SetClosureVariable(local, value)
                   ..plug(body);
   }
 
@@ skipping 141 matching lines @@
     tokens.consumeStart(CREATE_FUNCTION);
     FunctionDefinition def = parseFunctionDefinition();
     tokens.consumeEnd();
     return new CreateFunction(def);
   }
 
   /// (GetClosureVariable name)
   GetClosureVariable parseGetClosureVariable() {
     tokens.consumeStart(GET_CLOSURE_VARIABLE);
 
-    Local local = new DummyLocal(tokens.read());
+    ClosureVariable local = name2variable[tokens.read()];
     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();
   }
 }