dart2js cps: Remove dart2dart from cps pipeline and clean up.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
@@ skipping 101 matching lines @@
   /// referred to by [reference].
   /// This increments the reference count for the given variable, so the
   /// returned expression must be used in the tree.
   Expression getVariableUse(cps_ir.Reference<cps_ir.Primitive> reference) {
     if (thisParameter != null && reference.definition == thisParameter) {
       return new This();
     }
     return new VariableUse(getVariable(reference.definition));
   }
 
-  RootNode build(cps_ir.RootNode node) {
-    // TODO(asgerf): Don't have build AND buildXXX as public API.
-    if (node is cps_ir.FieldDefinition) {
-      return buildField(node);
-    } else if (node is cps_ir.ConstructorDefinition) {
-      return buildConstructor(node);
-    } else {
-      assert(dart2js.invariant(
-          CURRENT_ELEMENT_SPANNABLE,
-          node is cps_ir.FunctionDefinition,
-          message: 'expected FunctionDefinition or FieldDefinition, '
-            ' found $node'));
-      return buildFunction(node);
-    }
-  }
-
-  FieldDefinition buildField(cps_ir.FieldDefinition node) {
-    Statement body;
-    if (!node.isEmpty) {
-      currentElement = node.element;
-      returnContinuation = node.body.returnContinuation;
-
-      phiTempVar = new Variable(node.element, null);
-
-      body = visit(node.body);
-    }
-    return new FieldDefinition(node.element, body);
-  }
-
   Variable addFunctionParameter(cps_ir.Definition variable) {
     if (variable is cps_ir.Parameter) {
       return getVariable(variable);
     } else {
       return addMutableVariable(variable as cps_ir.MutableVariable)
               ..isCaptured = true;
     }
   }
 
   FunctionDefinition buildFunction(cps_ir.FunctionDefinition node) {
     currentElement = node.element;
     if (parent != null) {
       // Local function's 'this' refers to enclosing method's 'this'
       thisParameter = parent.thisParameter;
     } else {
       thisParameter = node.thisParameter;
     }
     List<Variable> parameters =
         node.parameters.map(addFunctionParameter).toList();
-    Statement body;
-    if (!node.isEmpty) {
-      returnContinuation = node.body.returnContinuation;
-      phiTempVar = new Variable(node.element, null);
-      body = visit(node.body);
-    }
-
-    return new FunctionDefinition(node.element, parameters,
-        body, node.localConstants, node.defaultParameterValues);
-  }
-
-  ConstructorDefinition buildConstructor(cps_ir.ConstructorDefinition node) {
-    currentElement = node.element;
-    thisParameter = node.thisParameter;
-    List<Variable> parameters =
-        node.parameters.map(addFunctionParameter).toList();
-    List<Initializer> initializers;
-    Statement body;
-    if (!node.isEmpty) {
-      initializers = node.initializers.map(visit).toList();
-      returnContinuation = node.body.returnContinuation;
-
-      phiTempVar = new Variable(node.element, null);
-      body = visit(node.body);
-    }
-
-    return new ConstructorDefinition(node.element, parameters,
-        body, initializers, node.localConstants, node.defaultParameterValues);
+    returnContinuation = node.returnContinuation;
+    phiTempVar = new Variable(node.element, null);
+    Statement body = visit(node.body);
+    return new FunctionDefinition(node.element, parameters, body);
   }
 
   /// Returns a list of variables corresponding to the arguments to a method
   /// call or similar construct.
   ///
   /// The `readCount` for these variables will be incremented.
   ///
   /// The list will be typed as a list of [Expression] to allow inplace updates
   /// on the list during the rewrite phases.
   List<Expression> translateArguments(List<cps_ir.Reference> args) {
@@ skipping 119 matching lines @@
   visitInterceptor(cps_ir.Interceptor node) => unexpectedNode(node);
   visitCreateInstance(cps_ir.CreateInstance node) => unexpectedNode(node);
   visitGetField(cps_ir.GetField node) => unexpectedNode(node);
   visitCreateBox(cps_ir.CreateBox node) => unexpectedNode(node);
   visitCreateInvocationMirror(cps_ir.CreateInvocationMirror node) {
     return unexpectedNode(node);
   }
 
   // Executable definitions are not visited directly.  They have 'build'
   // functions as entry points.
-  visitFieldDefinition(cps_ir.FieldDefinition node) {
-    return unexpectedNode(node);
-  }
   visitFunctionDefinition(cps_ir.FunctionDefinition node) {
     return unexpectedNode(node);
   }
-  visitConstructorDefinition(cps_ir.ConstructorDefinition node) {
-    return unexpectedNode(node);
-  }
-
-  Initializer visitFieldInitializer(cps_ir.FieldInitializer node) {
-    returnContinuation = node.body.returnContinuation;
-    return new FieldInitializer(node.element, visit(node.body.body));
-  }
-
-  Initializer visitSuperInitializer(cps_ir.SuperInitializer node) {
-    List<Statement> arguments =
-        node.arguments.map((cps_ir.Body argument) {
-      returnContinuation = argument.returnContinuation;
-      return visit(argument.body);
-    }).toList();
-    return new SuperInitializer(node.target, node.selector, arguments);
-  }
 
   Statement visitLetPrim(cps_ir.LetPrim node) {
     Variable variable = getVariable(node.primitive);
 
     // Don't translate unused primitives.
     if (variable == null) return visit(node.body);
 
-    Node definition = visit(node.primitive);
-
-    // visitPrimitive returns a Statement without successor if it cannot occur
-    // in expression context (currently only the case for FunctionDeclarations).
-    if (definition is Statement) {
-      definition.next = visit(node.body);
-      return definition;
-    } else {
-      return Assign.makeStatement(variable, definition, visit(node.body));
-    }
-  }
-
-  Statement visitBody(cps_ir.Body node) {
-    return visit(node.body);
+    Expression value = visit(node.primitive);
+    return Assign.makeStatement(variable, value, visit(node.body));
   }
 
   Statement visitLetCont(cps_ir.LetCont node) {
     // Introduce labels for continuations that need them.
     int safeForInliningLengthOnEntry = safeForInlining.length;
     for (cps_ir.Continuation continuation in node.continuations) {
       if (continuation.hasMultipleUses) {
         labels[continuation] = new Label();
       } else {
         safeForInlining.add(continuation);
@@ skipping 88 matching lines @@
           () => visit(cont.body) : () => new Break(labels[cont]);
       return buildContinuationAssignment(cont.parameters.single, expression,
           nextBuilder);
     }
   }
 
   Statement visitLetMutable(cps_ir.LetMutable node) {
     Variable variable = addMutableVariable(node.variable);
     Expression value = getVariableUse(node.value);
     Statement body = visit(node.body);
-    // If the variable was captured by an inner function in the body, this
-    // must be declared here so we assign to a fresh copy of the variable.
-    if (variable.isCaptured) {
-      return new VariableDeclaration(variable, value, body);
-    }
     return Assign.makeStatement(variable, value, body);
   }
 
   Expression visitGetMutableVariable(cps_ir.GetMutableVariable node) {
     return getMutableVariableUse(node.variable);
   }
 
   Statement visitSetMutableVariable(cps_ir.SetMutableVariable node) {
     Variable variable = getMutableVariable(node.variable.definition);
     Expression value = getVariableUse(node.value);
     return Assign.makeStatement(variable, value, visit(node.body));
   }
 
-  Statement visitDeclareFunction(cps_ir.DeclareFunction node) {
-    Variable variable = addMutableVariable(node.variable);
-    FunctionDefinition function = makeSubFunction(node.definition);
-    return new FunctionDeclaration(variable, function, visit(node.body));
-  }
-
   Statement visitTypeOperator(cps_ir.TypeOperator node) {
     Expression value = getVariableUse(node.value);
     List<Expression> typeArgs = translateArguments(node.typeArguments);
     Expression concat =
         new TypeOperator(value, node.type, typeArgs,
                          isTypeTest: node.isTypeTest);
     return continueWithExpression(node.continuation, concat);
   }
 
   Statement visitInvokeConstructor(cps_ir.InvokeConstructor node) {
@@ skipping 59 matching lines @@
     assert(cont.parameters.isEmpty);
     elseStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
   Expression visitConstant(cps_ir.Constant node) {
     return new Constant(node.expression);
   }
 
-  Expression visitReifyTypeVar(cps_ir.ReifyTypeVar node) {
-    return new ReifyTypeVar(node.typeVariable);
-  }
-
   Expression visitLiteralList(cps_ir.LiteralList node) {
     return new LiteralList(
             node.type,
             translateArguments(node.values));
   }
 
   Expression visitLiteralMap(cps_ir.LiteralMap node) {
     return new LiteralMap(
         node.type,
         new List<LiteralMapEntry>.generate(node.entries.length, (int index) {
           return new LiteralMapEntry(
               getVariableUse(node.entries[index].key),
               getVariableUse(node.entries[index].value));
         })
     );
   }
 
   FunctionDefinition makeSubFunction(cps_ir.FunctionDefinition function) {
     return createInnerBuilder().buildFunction(function);
   }
 
-  Node visitCreateFunction(cps_ir.CreateFunction node) {
+  Expression visitCreateFunction(cps_ir.CreateFunction node) {
     FunctionDefinition def = makeSubFunction(node.definition);
     FunctionType type = node.definition.element.type;
     bool hasReturnType = !type.returnType.treatAsDynamic;
-    if (hasReturnType) {
-      // This function cannot occur in expression context.
-      // The successor will be filled in by visitLetPrim.
-      return new FunctionDeclaration(getVariable(node), def, null);
-    } else {
-      return new FunctionExpression(def);
-    }
+    return new FunctionExpression(def);
   }
 
   visitParameter(cps_ir.Parameter node) {
     // Continuation parameters are not visited (continuations themselves are
     // not visited yet).
     unexpectedNode(node);
   }
 
   visitContinuation(cps_ir.Continuation node) {
     // Until continuations with multiple uses are supported, they are not
@@ skipping 39 matching lines @@
 
   Statement visitSetStatic(cps_ir.SetStatic node) {
     SetStatic setStatic = new SetStatic(
         node.element,
         getVariableUse(node.value),
         node.sourceInformation);
     return new ExpressionStatement(setStatic, visit(node.body));
   }
 }