Support local variables in dart2dart.

sdk/lib/_internal/compiler/implementation/ir/ir_pickler.dart

 // Copyright (c) 2013, 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_pickler;
 
 import 'ir_nodes.dart' as ir;
 import '../dart2jslib.dart' show
     Constant, FalseConstant, TrueConstant, IntConstant, DoubleConstant,
     StringConstant, NullConstant, ListConstant, MapConstant,
@@ skipping 22 matching lines @@
  * int      ::= see [writeInt] for number encoding
  *
  * string   ::= byte(STRING_ASCII) int(length) {byte(ascii)}
  *            | byte(STRING_UTF8) int(length) {byte(utf8)}
  *
  * node      ::= byte(NODE_CONSTANT) constant node(next)
  *             | byte(NODE_LET_CONT) int(parameter count) node(next) node(body)
  *             | byte(NODE_INVOKE_STATIC) element selector
  *                   reference(continuation) {reference(argument)}
  *             | byte(NODE_INVOKE_CONTINUATION) reference(continuation)
- *                   reference(argument)
+ *                   {reference(argument)}
  *
  * reference ::= int(indexDelta)
  *
  * constant   ::= byte(CONST_BOOL) byte(0 or 1)
  *              | byte(CONST_DOUBLE) byte{8}
  *              | byte(CONST_INT) int(value)
  *              | byte(CONST_STRING_LITERAL) string
  *              | byte(CONST_STRING_RAW) string int(length)
  *              | byte(CONST_STRING_ESCAPED) string int(length)
  *              | byte(CONST_STRING_CONS) constant(left) constant(right)
  *              | byte(CONST_NULL)
  *
  * selector   ::= byte(BACKREFERENCE) reference
  *              | byte(SELECTOR_UNTYPED) int(kind) string(name) element(library)
  *                    int(argumentsCount) int(namedArgumentsCount)
  *                    {string(parameterName)}
  *
  * element    ::= int(constantPoolIndex)
  */
 class Pickles {
   static const int BACKREFERENCE = 1;
 
   static const int STRING_ASCII = BACKREFERENCE + 1;
   static const int STRING_UTF8  = STRING_ASCII + 1;
 
   static const int FIRST_NODE_TAG           = STRING_UTF8 + 1;
   static const int NODE_CONSTANT            = FIRST_NODE_TAG;
-  static const int NODE_LET_CONT            = NODE_CONSTANT + 1;
+  static const int NODE_IS_TRUE             = NODE_CONSTANT + 1;
+  static const int NODE_LET_CONT            = NODE_IS_TRUE + 1;
   static const int NODE_INVOKE_STATIC       = NODE_LET_CONT + 1;
   static const int NODE_INVOKE_CONTINUATION = NODE_INVOKE_STATIC + 1;
-  static const int LAST_NODE_TAG            = NODE_INVOKE_CONTINUATION;
+  static const int NODE_BRANCH              = NODE_INVOKE_CONTINUATION + 1;
+  static const int LAST_NODE_TAG            = NODE_BRANCH;
 
   static const int FIRST_CONST_TAG      = LAST_NODE_TAG + 1;
   static const int CONST_BOOL           = FIRST_CONST_TAG;
   static const int CONST_INT            = CONST_BOOL + 1;
   static const int CONST_DOUBLE         = CONST_INT + 1;
   static const int CONST_STRING_LITERAL = CONST_DOUBLE + 1;
   static const int CONST_STRING_RAW     = CONST_STRING_LITERAL + 1;
   static const int CONST_STRING_ESCAPED = CONST_STRING_RAW + 1;
   static const int CONST_STRING_CONS    = CONST_STRING_ESCAPED + 1;
   static const int CONST_NULL           = CONST_STRING_CONS + 1;
@@ skipping 81 matching lines @@
    * This buffer is used in [writeConstDouble] to obtain a byte representation
    * for doubles.
    */
   ByteData doubleData = new ByteData(8);
 
   List<int> pickle(ir.FunctionDefinition function) {
     data = new Uint8List(INITIAL_SIZE);
     offset = 0;
     emitted = <Object, int>{};
     index = 0;
-    function.accept(this);
+    visit(function);
 
     int sizeOffset = offset;
     writeInt(emitted.length);
     int sizeBytes = offset - sizeOffset;
 
     // The array is longer than necessary, create a copy with the actual size.
     Uint8List result = new Uint8List(offset);
     // Emit the number or entries in the beginning.
     for (int i = 0, j = sizeOffset; i < sizeBytes; i++, j++) {
       result[i] = data[j];
@@ skipping 88 matching lines @@
   void recordForBackReference(Object entry) {
     assert(emitted[entry] == null);
     emitted[entry] = index++;
   }
 
   void writeBackReference(Object entry) {
     int entryIndex = emitted[entry];
     writeInt(index - entryIndex);
   }
 
-  void writeBackReferenceList(List entries) {
-    writeInt(entries.length);
-    for (int i = 0; i < entries.length; i++) {
-      writeBackReference(entries[i]);
+  void writeBackReferenceList(int length, Iterable entries) {
+    writeInt(length);
+    for (var x in entries) {
+      writeBackReference(x);
     }
   }
 
   void writeConstBool(bool b) {
     writeByte(Pickles.CONST_BOOL);
     writeByte(b ? 1 : 0);
   }
 
   void writeConstInt(int n) {
     writeByte(Pickles.CONST_INT);
@@ skipping 58 matching lines @@
   }
 
   void visitFunctionDefinition(ir.FunctionDefinition node) {
     // The continuation parameter is bound in the body.
     recordForBackReference(node.returnContinuation);
     writeInt(node.parameters.length);
     for (var parameter in node.parameters) {
       recordForBackReference(parameter);
       writeElement(parameter.element);
     }
-    node.body.accept(this);
+    visit(node.body);
   }
 
   void visitLetPrim(ir.LetPrim node) {
-    node.primitive.accept(this);
+    visit(node.primitive);
     // The right-hand side is bound in the body.
     recordForBackReference(node.primitive);
-    node.body.accept(this);
+    visit(node.body);
   }
 
   void visitLetCont(ir.LetCont node) {
     // There are two choices of which expression tree to write first---the
     // continuation body or the LetCont body.  The unpickler will unpickle the
     // the first recursively and the second iteratively.  Since the hole in
     // LetCont contexts is in the continuation body, the continuation should be
     // written second.
     writeByte(Pickles.NODE_LET_CONT);
     writeInt(node.continuation.parameters.length);
     // The continuation is bound in the body.
     recordForBackReference(node.continuation);
-    node.body.accept(this);
+    visit(node.body);
     // The continuation parameters are bound in the continuation's body.
     node.continuation.parameters.forEach(recordForBackReference);
-    node.continuation.body.accept(this);
+    visit(node.continuation.body);
   }
 
   void visitInvokeStatic(ir.InvokeStatic node) {
     writeByte(Pickles.NODE_INVOKE_STATIC);
     writeElement(node.target);
     writeSelector(node.selector);
     // TODO(lry): compact encoding when the arity of the selector and the
     // arguments list are the same
     writeBackReference(node.continuation.definition);
-    writeBackReferenceList(node.arguments.map(
-        (a) => a.definition).toList(growable: false));
+    writeBackReferenceList(node.arguments.length,
+                           node.arguments.map((a) => a.definition));
   }
 
   void visitInvokeContinuation(ir.InvokeContinuation node) {
     writeByte(Pickles.NODE_INVOKE_CONTINUATION);
     writeBackReference(node.continuation.definition);
-    writeBackReference(node.argument.definition);
+    writeBackReferenceList(node.arguments.length,
+                           node.arguments.map((a) => a.definition));
+  }
+
+  void visitBranch(ir.Branch node) {
+    writeByte(Pickles.NODE_BRANCH);
+    visit(node.condition);
+    writeBackReference(node.trueContinuation.definition);
+    writeBackReference(node.falseContinuation.definition);
   }
 
   void visitConstant(ir.Constant node) {
     writeByte(Pickles.NODE_CONSTANT);
     node.value.accept(constantPickler);
   }
 
+  void visitIsTrue(ir.IsTrue node) {
+    writeByte(Pickles.NODE_IS_TRUE);
+    writeBackReference(node.value.definition);
+  }
+
   void visitNode(ir.Node node) {
     throw "Unexpected $node in pickler.";
   }
 }
 
 /**
  * A visitor for constants which writes the constant values to its [Pickler].
  */
 class ConstantPickler extends ConstantVisitor {
 
@@ skipping 27 matching lines @@
   void visitList(ListConstant constant) => abort(constant);
   void visitMap(MapConstant constant) => abort(constant);
   void visitInterceptor(InterceptorConstant constant) => abort(constant);
   void visitDummy(DummyConstant constant) => abort(constant);
   void visitFunction(FunctionConstant constant) => abort(constant);
   void visitType(TypeConstant constant) => abort(constant);
   void visitConstructed(ConstructedConstant constant) => abort(constant);
 
   void abort(Constant value) => throw "Can not pickle constant $value";
 }