Make scoping more prominent in the CPS IR's printed representation.

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 229 matching lines @@
         return parseSetClosureVariable();
       case TYPE_OPERATOR:
         return parseTypeOperator();
       default:
         assert(false);
     }
 
     return null;
   }
 
-  /// prim1 prim2 ... primn cont)
-  /// Note that cont is *not* included in the returned list and not consumed.
-  List<Primitive> parseArgumentList() {
-    List<Primitive> args = <Primitive>[];
-    while (tokens.next != ")") {
-      Primitive prim = name2variable[tokens.read()];
-      assert(prim != null);
-      args.add(prim);
-    }
-    return args;
-  }
-
   /// (prim1 prim2 ... primn)
   List<Primitive> parsePrimitiveList() {
     tokens.consumeStart();
     List<Primitive> prims = <Primitive>[];
     while (tokens.current != ")") {
       Primitive prim = name2variable[tokens.read()];
       assert(prim != null);
       prims.add(prim);
     }
     tokens.consumeEnd();
@@ skipping 70 matching lines @@
 
     Condition cond = parseCondition();
     Continuation trueCont = name2variable[tokens.read()];
     Continuation falseCont = name2variable[tokens.read()];
     assert(trueCont != null && falseCont != null);
 
     tokens.consumeEnd();
     return new Branch(cond, trueCont, falseCont);
   }
 
-  /// (ConcatenateStrings args cont)
+  /// (ConcatenateStrings (args) cont)
   ConcatenateStrings parseConcatenateStrings() {
     tokens.consumeStart(CONCATENATE_STRINGS);
 
-    List<Primitive> args = parseArgumentList();
+    List<Primitive> args = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     return new ConcatenateStrings(cont, args);
   }
 
   /// (DeclareFunction name = function in body)
   DeclareFunction parseDeclareFunction() {
     tokens.consumeStart(DECLARE_FUNCTION);
 
     // name =
     ClosureVariable local = name2variable[tokens.read()];
     tokens.read("=");
 
     // function in
     FunctionDefinition def = parseFunctionDefinition();
     tokens.read("in");
 
     // body
     Expression body = parseExpression();
 
     tokens.consumeEnd();
     return new DeclareFunction(local, def)..plug(body);
   }
 
-  /// (InvokeConstructor name args cont)
+  /// (InvokeConstructor name (args) cont)
   InvokeConstructor parseInvokeConstructor() {
     tokens.consumeStart(INVOKE_CONSTRUCTOR);
 
     String constructorName = tokens.read();
     List<String> split = constructorName.split(".");
     assert(split.length < 3);
 
     dart_types.DartType type = new DummyNamedType(split[0]);
     Element element = new DummyElement((split.length == 1) ? "" : split[1]);
 
-    List<Primitive> args = parseArgumentList();
+    List<Primitive> args = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     Selector selector = dummySelector(constructorName, args.length);
     return new InvokeConstructor(type, element, selector, cont, args);
   }
 
-  /// (InvokeContinuation name args)
+  /// (InvokeContinuation name (args))
   InvokeContinuation parseInvokeContinuation(bool recursive) {
     tokens.consumeStart(recursive
         ? INVOKE_CONTINUATION_RECURSIVE : INVOKE_CONTINUATION);
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
-    List<Primitive> args = <Primitive>[];
-    while (tokens.current != ")") {
-      Primitive arg = name2variable[tokens.read()];
-      assert(arg != null);
-      args.add(arg);
-    }
+    List<Primitive> args = parsePrimitiveList();
 
     tokens.consumeEnd();
     return new InvokeContinuation(cont, args, recursive: recursive);
   }
 
-  /// (InvokeMethod receiver method args cont)
+  /// (InvokeMethod receiver method (args) cont)
   InvokeMethod parseInvokeMethod() {
     tokens.consumeStart(INVOKE_METHOD);
 
     Definition receiver = name2variable[tokens.read()];
     assert(receiver != null);
 
     String methodName = tokens.read();
 
-    List<Primitive> args = parseArgumentList();
+    List<Primitive> args = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     Selector selector = dummySelector(methodName, args.length);
     return new InvokeMethod(receiver, selector, cont, args);
   }
 
-  /// (InvokeStatic method args cont)
+  /// (InvokeStatic method (args) cont)
   InvokeStatic parseInvokeStatic() {
     tokens.consumeStart(INVOKE_STATIC);
 
     String methodName = tokens.read();
 
-    List<Primitive> args = parseArgumentList();
+    List<Primitive> args = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     Entity entity = new DummyEntity(methodName);
     Selector selector = dummySelector(methodName, args.length);
 
     tokens.consumeEnd();
     return new InvokeStatic(entity, selector, cont, args);
   }
 
-  /// (InvokeSuperMethod method args cont)
+  /// (InvokeSuperMethod method (args) cont)
   InvokeSuperMethod parseInvokeSuperMethod() {
     tokens.consumeStart(INVOKE_SUPER_METHOD);
 
     String methodName = tokens.read();
 
-    List<Primitive> args = parseArgumentList();
+    List<Primitive> args = parsePrimitiveList();
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     Selector selector = dummySelector(methodName, args.length);
     return new InvokeSuperMethod(selector, cont, args);
   }
 
-  /// (LetCont (cont args) (cont_body)) body
+  /// (LetCont (name (args) cont_body) body)
   LetCont parseLetCont(bool recursive) {
     tokens.consumeStart(recursive ? LET_CONT_RECURSIVE : LET_CONT);
 
-    // (name args) (cont_body))
+    // (name
     tokens.consumeStart();
     String name = tokens.read();
 
+    // (args)
+    tokens.consumeStart();
     List<Parameter> params = <Parameter>[];
     while (tokens.current != ")") {
       String paramName = tokens.read();
       Parameter param = new Parameter(new DummyElement(paramName));
       name2variable[paramName] = param;
       params.add(param);
     }
     tokens.consumeEnd();
 
     Continuation cont = new Continuation(params);
     name2variable[name] = cont;
 
     cont.isRecursive = recursive;
+    // cont_body
     cont.body = parseExpression();
     tokens.consumeEnd();
 
-    // body
+    // body)
     Expression body = parseExpression();
+    tokens.consumeEnd();
 
     return new LetCont(cont, body);
   }
 
   /// (SetClosureVariable name value body)
   SetClosureVariable parseSetClosureVariable() {
     tokens.consumeStart(SET_CLOSURE_VARIABLE);
 
     ClosureVariable local = name2variable[tokens.read()];
     Primitive value = name2variable[tokens.read()];
@@ skipping 17 matching lines @@
 
     dart_types.DartType type = new DummyNamedType(tokens.read());
 
     Continuation cont = name2variable[tokens.read()];
     assert(cont != null);
 
     tokens.consumeEnd();
     return new TypeOperator(recv, type, cont, isTypeTest: operator == 'is');
   }
 
-  /// (LetPrim name (primitive)) body
+  /// (LetPrim (name primitive) body)
   LetPrim parseLetPrim() {
     tokens.consumeStart(LET_PRIM);
 
-    // name
+    // (name
+    tokens.consumeStart();
     String name = tokens.read();
 
-    // (primitive)
+    // primitive)
     Primitive primitive = parsePrimitive();
     name2variable[name] = primitive;
     tokens.consumeEnd();
 
-    // body
+    // body)
     Expression body = parseExpression();
+    tokens.consumeEnd();
 
     return new LetPrim(primitive)..plug(body);
   }
 
   Primitive parsePrimitive() {
     assert(tokens.current == "(");
 
     switch (tokens.next) {
       case CONSTANT:
         return parseConstant();
@@ skipping 87 matching lines @@
   /// (GetClosureVariable name)
   GetClosureVariable parseGetClosureVariable() {
     tokens.consumeStart(GET_CLOSURE_VARIABLE);
 
     ClosureVariable local = name2variable[tokens.read()];
     tokens.consumeEnd();
 
     return new GetClosureVariable(local);
   }
 
-  /// (LiteralList values)
+  /// (LiteralList (values))
   LiteralList parseLiteralList() {
     tokens.consumeStart(LITERAL_LIST);
     List<Primitive> values = parsePrimitiveList();
     tokens.consumeEnd();
     return new LiteralList(null, values);
   }
 
-  /// (LiteralMap keys values)
+  /// (LiteralMap (keys) (values))
   LiteralMap parseLiteralMap() {
     tokens.consumeStart(LITERAL_MAP);
 
     List<Primitive> keys   = parsePrimitiveList();
     List<Primitive> values = parsePrimitiveList();
 
     List<LiteralMapEntry> entries = <LiteralMapEntry>[];
     for (int i = 0; i < keys.length; i++) {
       entries.add(new LiteralMapEntry(keys[i], values[i]));
     }
@@ skipping 12 matching lines @@
     return new ReifyTypeVar(type);
   }
 
   /// (This)
   This parseThis() {
     tokens.consumeStart(THIS);
     tokens.consumeEnd();
     return new This();
   }
 }