Rename ClosureVariable, use separate IR forms for declaration and assignment.

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 106 matching lines @@
   static const String BRANCH = "Branch";
   static const String CONCATENATE_STRINGS = "ConcatenateStrings";
   static const String DECLARE_FUNCTION = "DeclareFunction";
   static const String INVOKE_CONSTRUCTOR = "InvokeConstructor";
   static const String INVOKE_CONTINUATION = "InvokeContinuation";
   static const String INVOKE_STATIC = "InvokeStatic";
   static const String INVOKE_METHOD_DIRECTLY = "InvokeMethodDirectly";
   static const String INVOKE_METHOD = "InvokeMethod";
   static const String LET_PRIM = "LetPrim";
   static const String LET_CONT = "LetCont";
-  static const String SET_CLOSURE_VARIABLE = "SetClosureVariable";
+  static const String LET_MUTABLE = "LetMutable";
+  static const String SET_MUTABLE_VARIABLE = "SetMutableVariable";
   static const String TYPE_OPERATOR = "TypeOperator";
 
   // Primitives
   static const String CONSTANT = "Constant";
   static const String CREATE_FUNCTION = "CreateFunction";
-  static const String GET_CLOSURE_VARIABLE = "GetClosureVariable";
+  static const String GET_MUTABLE_VARIABLE = "GetMutableVariable";
   static const String LITERAL_LIST = "LiteralList";
   static const String LITERAL_MAP = "LiteralMap";
   static const String REIFY_TYPE_VAR = "ReifyTypeVar";
   static const String THIS = "This";
 
   // Other
   static const String FUNCTION_DEFINITION = "FunctionDefinition";
   static const String IS_TRUE = "IsTrue";
 
   // Constants
@@ skipping 79 matching lines @@
       case INVOKE_METHOD:
         return parseInvokeMethod();
       case INVOKE_STATIC:
         return parseInvokeStatic();
       case INVOKE_METHOD_DIRECTLY:
         return parseInvokeMethodDirectly();
       case LET_PRIM:
         return parseLetPrim();
       case LET_CONT:
         return parseLetCont();
-      case SET_CLOSURE_VARIABLE:
-        return parseSetClosureVariable();
+      case LET_MUTABLE:
+        return parseLetMutable();
+      case SET_MUTABLE_VARIABLE:
+        return parseSetMutableVariable();
       case TYPE_OPERATOR:
         return parseTypeOperator();
       default:
         assert(false);
     }
 
     return null;
   }
 
   /// (prim1 prim2 ... primn)
@@ skipping 84 matching lines @@
 
     tokens.consumeEnd();
     return new ConcatenateStrings(cont, args);
   }
 
   /// (DeclareFunction name = function in body)
   DeclareFunction parseDeclareFunction() {
     tokens.consumeStart(DECLARE_FUNCTION);
 
     // name =
-    ClosureVariable local = getClosureVariable(tokens.read());
+    MutableVariable local = addMutableVariable(tokens.read());
     tokens.read("=");
 
     // function in
     FunctionDefinition def = parseFunctionDefinition();
     tokens.read("in");
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
@@ skipping 133 matching lines @@
     }
     tokens.consumeEnd();
 
     // body)
     Expression body = parseExpression();
     tokens.consumeEnd();
 
     return new LetCont.many(continuations, body);
   }
 
-  /// (SetClosureVariable name value body)
-  SetClosureVariable parseSetClosureVariable() {
-    tokens.consumeStart(SET_CLOSURE_VARIABLE);
+  /// (LetMutable (name value) body)
+  LetMutable parseLetMutable() {
+    tokens.consumeStart(LET_MUTABLE);
 
+    tokens.consumeStart();
     String name = tokens.read();
-    ClosureVariable local = getClosureVariable(name);
+    MutableVariable local = addMutableVariable(name);
+    Primitive value = name2variable[tokens.read()];
+    tokens.consumeEnd();
+
+    Expression body = parseExpression();
+    tokens.consumeEnd();
+    return new LetMutable(local, value)..plug(body);
+  }
+
+  /// (SetMutableVariable name value body)
+  SetMutableVariable parseSetMutableVariable() {
+    tokens.consumeStart(SET_MUTABLE_VARIABLE);
+
+    MutableVariable local = name2variable[tokens.read()];
     Primitive value = name2variable[tokens.read()];
     assert(value != null);
 
     Expression body = parseExpression();
 
     tokens.consumeEnd();
-    return new SetClosureVariable(local, value)
+    return new SetMutableVariable(local, value)
                   ..plug(body);
   }
 
   /// (TypeOperator operator recv type cont)
   TypeOperator parseTypeOperator() {
     tokens.consumeStart(TYPE_OPERATOR);
 
     String operator = tokens.read();
 
     Primitive recv = name2variable[tokens.read()];
@@ skipping 29 matching lines @@
   }
 
   Primitive parsePrimitive() {
     assert(tokens.current == "(");
 
     switch (tokens.next) {
       case CONSTANT:
         return parseConstant();
       case CREATE_FUNCTION:
         return parseCreateFunction();
-      case GET_CLOSURE_VARIABLE:
-        return parseGetClosureVariable();
+      case GET_MUTABLE_VARIABLE:
+        return parseGetMutableVariable();
       case LITERAL_LIST:
         return parseLiteralList();
       case LITERAL_MAP:
         return parseLiteralMap();
       case REIFY_TYPE_VAR:
         return parseReifyTypeVar();
       case THIS:
         return parseThis();
       default:
         assert(false);
@@ skipping 63 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];
+  MutableVariable addMutableVariable(String name) {
+    assert(!name2variable.containsKey(name));
+    MutableVariable variable =
+        new MutableVariable(new DummyElement(""), new DummyElement(name));
+    name2variable[name] = variable;
+    return variable;
   }
 
-  /// (GetClosureVariable name)
-  GetClosureVariable parseGetClosureVariable() {
-    tokens.consumeStart(GET_CLOSURE_VARIABLE);
-
-    String name = tokens.read();
-    ClosureVariable local = getClosureVariable(name);
+  /// (GetMutableVariable name)
+  GetMutableVariable parseGetMutableVariable() {
+    tokens.consumeStart(GET_MUTABLE_VARIABLE);
+    MutableVariable local = name2variable[tokens.read()];
     tokens.consumeEnd();
 
-    return new GetClosureVariable(local);
+    return new GetMutableVariable(local);
   }
 
   /// (LiteralList (values))
   LiteralList parseLiteralList() {
     tokens.consumeStart(LITERAL_LIST);
     List<Primitive> values = parsePrimitiveList();
     tokens.consumeEnd();
     return new LiteralList(null, values);
   }
 
@@ skipping 23 matching lines @@
     return new ReifyTypeVar(type);
   }
 
   /// (This)
   This parseThis() {
     tokens.consumeStart(THIS);
     tokens.consumeEnd();
     return new This();
   }
 }