Support local variables in dart2dart.

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.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.
 
 library dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../util/util.dart';
 import '../elements/elements.dart'
@@ skipping 199 matching lines @@
   // Uses of IR definitions are replaced with Tree variables.  This is the
   // mapping from definitions to variables.
   final Map<ir.Definition, Variable> variables = {};
 
   FunctionDefinition function;
   ir.Continuation returnContinuation;
 
   Builder(this.compiler);
 
   FunctionDefinition build(ir.FunctionDefinition node) {
-    node.accept(this);
+    visit(node);
     return function;
   }
 
   List<Expression> translateArguments(List<ir.Reference> args) {
     return new List.generate(args.length,
          (int index) => variables[args[index].definition]);
   }
 
   Expression visitFunctionDefinition(ir.FunctionDefinition node) {
     returnContinuation = node.returnContinuation;
     List<Variable> parameters = <Variable>[];
     for (ir.Parameter p in node.parameters) {
       Variable parameter = new Variable(p.element);
       parameters.add(parameter);
       variables[p] = parameter;
     }
-    function = new FunctionDefinition(parameters, node.body.accept(this));
+    function = new FunctionDefinition(parameters, visit(node.body));
     return null;
   }
 
   Expression visitLetPrim(ir.LetPrim node) {
     // LetPrim is translated to LetVal.
-    Expression definition = node.primitive.accept(this);
+    Expression definition = visit(node.primitive);
     if (node.primitive.hasAtLeastOneUse) {
       Variable variable = new Variable(null);
       variables[node.primitive] = variable;
       return new LetVal(node.primitive.hasExactlyOneUse, variable,
-          definition, node.body.accept(this));
+          definition, visit(node.body));
+    } else if (node.primitive is ir.Constant) {
+      // TODO(kmillikin): Implement more systematic treatment of pure CPS
+      // values (e.g., as part of a shrinking reductions pass).
+      return visit(node.body);
     } else {
-      return new Sequence([definition, node.body.accept(this)]);
+      return new Sequence([definition, visit(node.body)]);
     }
   }
 
   Expression visitLetCont(ir.LetCont node) {
     // TODO(kmillikin): Allow continuations to have multiple uses.  This could
     // arise due to the representation of local control flow or due to
     // optimization.
     assert(node.continuation.hasAtMostOneUse);
-    return node.body.accept(this);
+    return visit(node.body);
   }
 
   Expression visitInvokeStatic(ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       if (cont.parameter.hasAtLeastOneUse) {
         Variable variable = new Variable(null);
         variables[cont.parameter] = variable;
         return new LetVal(cont.parameter.hasExactlyOneUse, variable,
-            invoke, cont.body.accept(this));
+            invoke, visit(cont.body));
       } else {
-        return new Sequence([invoke, cont.body.accept(this)]);
+        return new Sequence([invoke, visit(cont.body)]);
       }
     }
   }
 
   Expression visitInvokeContinuation(ir.InvokeContinuation node) {
     // TODO(kmillikin): Support non-return continuations.  These could arise
     // due to local control flow or due to inlining or other optimization.
     assert(node.continuation.definition == returnContinuation);
     return new Return(variables[node.argument.definition]);
   }
@@ skipping 36 matching lines @@
  * See [visitVariable] for the implementation of the heuristic for propagating
  * a definition.
  */
 class Unnamer extends Visitor<Expression> {
   // The binding environment.  The rightmost element of the list is the nearest
   // enclosing binding.
   List<LetVal> environment;
 
   void unname(FunctionDefinition definition) {
     environment = <LetVal>[];
-    definition.body = definition.body.accept(this);
+    definition.body = visit(definition.body);
 
     // TODO(kmillikin):  Allow definitions that are not propagated.  Here,
     // this means rebuilding the binding with a recursively unnamed definition,
     // or else introducing a variable definition and an assignment.
     assert(environment.isEmpty);
   }
 
   Expression visitVariable(Variable node) {
     // Propagate a variable's definition to its use site if:
     // 1.  It has a single use, to avoid code growth and potential duplication
     //     of side effects, AND
     // 2a. It is pure (i.e., does not have side effects that prevent it from
     //     being moved), OR
     // 2b. There are only pure expressions between the definition and use.
 
     // TODO(kmillikin): It's not always beneficial to propagate pure
     // definitions---it can prevent propagation of their inputs.  Implement
     // a heuristic to avoid this.
 
     // TODO(kmillikin): Replace linear search with something faster in
     // practice.
     bool seenImpure = false;
     for (int i = environment.length - 1; i >= 0; --i) {
       if (environment[i].variable == node) {
         if ((!seenImpure || environment[i].definition.isPure)
             && environment[i].hasExactlyOneUse) {
           // Use the definition if it is pure or if it is the first impure
           // definition (i.e., propagating past only pure expressions).
-          return environment.removeAt(i).definition.accept(this);
+          return visit(environment.removeAt(i).definition);
         }
         break;
       } else if (!environment[i].definition.isPure) {
         // Once the first impure definition is seen, impure definitions should
         // no longer be propagated.  Continue searching for a pure definition.
         seenImpure = true;
       }
     }
     // If the definition could not be propagated, leave the variable use.
     return node;
   }
 
   Expression visitSequence(Sequence node) {
     for (int i = 0; i < node.expressions.length; ++i) {
-      node.expressions[i] = node.expressions[i].accept(this);
+      node.expressions[i] = visit(node.expressions[i]);
     }
     return node;
   }
 
   Expression visitLetVal(LetVal node) {
     environment.add(node);
-    Expression body = node.body.accept(this);
+    Expression body = visit(node.body);
 
     if (!environment.isEmpty && environment.last == node) {
       // The definition could not be propagated.  Residualize the let binding.
       node.body = body;
       environment.removeLast();
-      node.definition = node.definition.accept(this);
+      node.definition = visit(node.definition);
       return node;
     }
     assert(!environment.contains(node));
     return body;
   }
 
   Expression visitInvokeStatic(InvokeStatic node) {
     // Process arguments right-to-left, the opposite of evaluation order.
     for (int i = node.arguments.length - 1; i >= 0; --i) {
-      node.arguments[i] = node.arguments[i].accept(this);
+      node.arguments[i] = visit(node.arguments[i]);
     }
     return node;
   }
 
   Expression visitReturn(Return node) {
-    node.value = node.value.accept(this);
+    node.value = visit(node.value);
     return node;
   }
 
   visitConstant(Constant node) {
     return node;
   }
 }
 
 /**
  * [Emitter] translates Tree to a Dart AST.
@@ skipping 65 matching lines @@
     // Reset the variable index.  This function is not reentrant.
     Variable.counter = 0;
     this.treeElements = treeElements;
     ast.Identifier name = makeIdentifier(element.name);
 
     TypeEmitter typeEmitter = new TypeEmitter();
     FunctionSignature signature = element.functionSignature;
     ast.TypeAnnotation returnType;
     if (!signature.type.returnType.isDynamic) {
       returnType =
-          signature.type.returnType.accept(typeEmitter, treeElements);
+          typeEmitter.visitType(signature.type.returnType, treeElements);
     }
 
     List<ast.VariableDefinitions> parameterList = <ast.VariableDefinitions>[];
     for (Variable parameter in definition.parameters) {
       ParameterElement element = parameter.element;
       parameter.assignIdentifier();
       ast.TypeAnnotation type;
       if (!element.type.isDynamic) {
-        type = element.type.accept(typeEmitter, treeElements);
+        type = typeEmitter.visitType(element.type, treeElements);
       }
       parameterList.add(new ast.VariableDefinitions(
           type,
           ast.Modifiers.EMPTY,
           new ast.NodeList.singleton(parameter.identifier)));
     }
     ast.NodeList parameters =
         new ast.NodeList(openParen,
                          new Link<ast.Node>.fromList(parameterList),
                          closeParen,
                          ',');
 
-    ast.Node body = definition.body.accept(this);
+    ast.Node body = visit(definition.body);
 
     if (!variables.isEmpty) {
       // Introduce hoisted definitions for all variables.
       ast.Identifier modifier =
           new ast.Identifier(new KeywordToken(Keyword.keywords['var'], -1));
       ast.VariableDefinitions definitions = new ast.VariableDefinitions(
           null,
           new ast.Modifiers(new ast.NodeList(
               null,
               new Link<ast.Node>.fromList([modifier]),
@@ skipping 36 matching lines @@
     }
 
     return new ast.FunctionExpression(name, parameters, body, returnType,
         ast.Modifiers.EMPTY, null, null);
   }
 
   /**
    * Translate a list of arguments to an AST NodeList.
    */
   ast.NodeList translateArguments(List<Expression> args) {
-    List<ast.Expression> arguments =
-        args.map((e) => e.accept(this)).toList(growable: false);
+    List<ast.Expression> arguments = args.map(visit).toList(growable: false);
     return makeArgumentList(arguments);
   }
 
   /**
    * Concatenate a pair of AST expressions or statements into a single Block
    * statement.
    */
   ast.Node concatenate(ast.Node first, ast.Node second) {
     // This is a convenient but very inefficient way to accumulate statements.
     // The Block and NodeList nodes are not mutable so we can't simply use a
@@ skipping 24 matching lines @@
   }
 
   ast.Node visitVariable(Variable node) {
     // The scope of variables is the body of their binding, so a name has
     // already been generated when we visit a variable.
     assert(node.identifier != null);
     return new ast.Send(null, node.identifier);
   }
 
   ast.Node visitSequence(Sequence node) {
-    return node.expressions.map((e) => e.accept(this)).reduce(concatenate);
+    return node.expressions.map(visit).reduce(concatenate);
   }
 
   ast.Node visitLetVal(LetVal node) {
     // Let bindings translate into assignments.
     ast.Identifier identifier = node.variable.assignIdentifier();
     variables.add(identifier);
 
-    ast.Expression expression = node.definition.accept(this);
+    ast.Expression expression = visit(node.definition);
     ast.Expression assignment = makeAssignment(identifier, expression);
 
-    ast.Node rest = node.body.accept(this);
+    ast.Node rest = visit(node.body);
     return concatenate(assignment, rest);
   }
 
   ast.Node visitInvokeStatic(InvokeStatic node) {
     ast.Identifier name = makeIdentifier(node.target.name);
     ast.Send send =
         new ast.Send(null, name, translateArguments(node.arguments));
     treeElements[send] = node.target;
     return send;
   }
 
   ast.Node visitReturn(Return node) {
-    ast.Expression expression = node.value.accept(this);
+    ast.Expression expression = visit(node.value);
     return new ast.Return(
         new KeywordToken(Keyword.keywords['return'], -1),
         semicolon,
         expression);
   }
 
   ast.Node visitConstant(Constant node) {
     return node.value.accept(constantEmitter);
   }
 }
 
 class TypeEmitter extends
     DartTypeVisitor<ast.TypeAnnotation, dart2js.TreeElementMapping> {
 
   // Supported types are verified at IR construction time.  The unimplemented
   // emit methods should be unreachable.
   ast.TypeAnnotation unimplemented() => throw new UnimplementedError();
 
   ast.TypeAnnotation makeSimpleAnnotation(
       DartType type,
       dart2js.TreeElementMapping treeElements) {
     ast.TypeAnnotation annotation =
         new ast.TypeAnnotation(Emitter.makeIdentifier(type.toString()), null);
     treeElements.setType(annotation, type);
     return annotation;
   }
 
   ast.TypeAnnotation visitType(DartType type,
                                dart2js.TreeElementMapping treeElements) {
-    return unimplemented();
+    return type.accept(this, treeElements);
   }
 
   ast.TypeAnnotation visitVoidType(VoidType type,
                                    dart2js.TreeElementMapping treeElements) {
     return makeSimpleAnnotation(type, treeElements);
   }
 
   ast.TypeAnnotation visitInterfaceType(
       InterfaceType type,
       dart2js.TreeElementMapping treeElements) {
@@ skipping 70 matching lines @@
   }
 
   ast.Expression visitInterceptor(dart2js.InterceptorConstant constant) {
     return unimplemented();
   }
 
   ast.Expression visitDummy(dart2js.DummyConstant constant) {
     return unimplemented();
   }
 }