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

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.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_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values;
-import '../dart_types.dart' show DartType, GenericType, InterfaceType, TypeVariableType;
+import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
-import '../universe/universe.dart';
 import '../universe/universe.dart' show Selector;
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
 // unnecessary names, recognizing high-level control constructs.  Combining
 // these separate concerns is complicated and the constraints of the CPS-based
 // language do not permit a multi-stage translation.
 //
@@ skipping 258 matching lines @@
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitConstant(this, arg);
 
   values.ConstantValue get value => expression.value;
 }
 
 class This extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitThis(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitThis(this, arg);
 }
 
-class ReifyTypeVar extends Expression implements DartSpecificNode {
-  TypeVariableElement typeVariable;
-
-  ReifyTypeVar(this.typeVariable);
-
-  accept(ExpressionVisitor visitor) => visitor.visitReifyTypeVar(this);
-  accept1(ExpressionVisitor1 visitor, arg) {
-    return visitor.visitReifyTypeVar(this, arg);
-  }
-}
-
 class LiteralList extends Expression {
-  final GenericType type;
+  final InterfaceType type;
   final List<Expression> values;
 
   LiteralList(this.type, this.values);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralList(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLiteralList(this, arg);
   }
 }
 
 class LiteralMapEntry {
   Expression key;
   Expression value;
 
   LiteralMapEntry(this.key, this.value);
 }
 
 class LiteralMap extends Expression {
-  final GenericType type;
+  final InterfaceType type;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLiteralMap(this, arg);
   }
 }
 
@@ skipping 50 matching lines @@
 /// Logical negation.
 class Not extends Expression {
   Expression operand;
 
   Not(this.operand);
 
   accept(ExpressionVisitor visitor) => visitor.visitNot(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitNot(this, arg);
 }
 
-class FunctionExpression extends Expression implements DartSpecificNode {
+/// Currently unused.
+///
+/// See CreateFunction in the cps_ir_nodes.dart.
+class FunctionExpression extends Expression {
   final FunctionDefinition definition;
 
   FunctionExpression(this.definition);
 
   accept(ExpressionVisitor visitor) => visitor.visitFunctionExpression(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitFunctionExpression(this, arg);
   }
 }
 
-/// Declares a local function.
-/// Used for functions that may not occur in expression context due to
-/// being recursive or having a return type.
-/// The [variable] must not occur as the left-hand side of an [Assign] or
-/// any other [FunctionDeclaration].
-class FunctionDeclaration extends Statement implements DartSpecificNode {
-  Variable variable;
-  final FunctionDefinition definition;
-  Statement next;
-
-  FunctionDeclaration(this.variable, this.definition, this.next) {
-    ++variable.writeCount;
-  }
-
-  accept(StatementVisitor visitor) => visitor.visitFunctionDeclaration(this);
-  accept1(StatementVisitor1 visitor, arg) {
-    return visitor.visitFunctionDeclaration(this, arg);
-  }
-}
-
 /// A [LabeledStatement] or [WhileTrue] or [WhileCondition].
 abstract class JumpTarget extends Statement {
   Label get label;
   Statement get body;
 }
 
 /**
  * A labeled statement.  Breaks to the label within the labeled statement
  * target the successor statement.
  */
@@ skipping 98 matching lines @@
   void set next(Statement s) => throw 'UNREACHABLE';
 
   Continue(this.target) {
     ++target.useCount;
   }
 
   accept(StatementVisitor visitor) => visitor.visitContinue(this);
   accept1(StatementVisitor1 visitor, arg) => visitor.visitContinue(this, arg);
 }
 
-/// Declares a captured [variable] with an initial [value].
-///
-/// All uses of the variable must be inside the [next] statement.
-class VariableDeclaration extends Statement implements DartSpecificNode {
-  Variable variable;
-  Expression value;
-  Statement next;
-
-  VariableDeclaration(this.variable, this.value, this.next) {
-    assert(variable.isCaptured); // Because otherwise no declaration is needed.
-    ++variable.writeCount;
-  }
-
-  accept(StatementVisitor visitor) {
-    return visitor.visitVariableDeclaration(this);
-  }
-
-  accept1(StatementVisitor1 visitor, arg) {
-    return visitor.visitVariableDeclaration(this, arg);
-  }
-}
-
 /**
  * A return exit from the function.
  *
  * In contrast to the CPS-based IR, the return value is an arbitrary
  * expression.
  */
 class Return extends Statement {
   /// Should not be null. Use [Constant] with [NullConstantValue] for void
   /// returns.
   /// Even in constructors this holds true. Take special care when translating
@@ skipping 82 matching lines @@
       variable.writeCount++; // Being a catch parameter counts as a write.
     }
   }
 
   accept(StatementVisitor visitor) => visitor.visitTry(this);
   accept1(StatementVisitor1 visitor, arg) {
     return visitor.visitTry(this, arg);
   }
 }
 
-abstract class RootNode extends Node {
-  ExecutableElement get element;
-  List<Variable> get parameters;
-
-  /// True if there is no body for this root node.
-  ///
-  /// In some parts of the compiler, empty root nodes are used as placeholders
-  /// for abstract methods, external constructors, fields without initializers,
-  /// etc.
-  bool get isEmpty;
-
-  void forEachBody(void action(Statement node));
-  void replaceEachBody(Statement transform(Statement node));
-
-  accept(RootVisitor v);
-  accept1(RootVisitor1 v, arg);
-}
-
-class FieldDefinition extends RootNode implements DartSpecificNode {
-  final FieldElement element;
-  // The `body` of a field is its initializer.
-  Statement body;
-  List<Variable> get parameters => const <Variable>[];
-
-  FieldDefinition(this.element, this.body);
-
-  bool get isEmpty => body == null;
-
-  accept(RootVisitor v) => v.visitFieldDefinition(this);
-  accept1(RootVisitor1 v, arg) => v.visitFieldDefinition(this, arg);
-
-  void forEachBody(void action(Statement node)) {
-    if (isEmpty) return;
-    action(body);
-  }
-
-  void replaceEachBody(Statement transform(Statement node)) {
-    if (isEmpty) return;
-    body = transform(body);
-  }
-}
-
-class FunctionDefinition extends RootNode {
+class FunctionDefinition extends Node {
   final ExecutableElement element;
   final List<Variable> parameters;
   Statement body;
-  final List<ConstDeclaration> localConstants;
-  final List<ConstantExpression> defaultParameterValues;
 
   /// Creates a function definition and updates `writeCount` for [parameters].
-  FunctionDefinition(this.element, this.parameters, this.body,
-      this.localConstants, this.defaultParameterValues) {
+  FunctionDefinition(this.element, this.parameters, this.body) {
     for (Variable param in parameters) {
       param.writeCount++; // Being a parameter counts as a write.
     }
   }
-
-  bool get isEmpty => body == null;
-
-  accept(RootVisitor v) => v.visitFunctionDefinition(this);
-  accept1(RootVisitor1 v, arg) => v.visitFunctionDefinition(this, arg);
-
-  void forEachBody(void action(Statement node)) {
-    if (isEmpty) return;
-    action(body);
-  }
-
-  void replaceEachBody(Statement transform(Statement node)) {
-    if (isEmpty) return;
-    body = transform(body);
-  }
 }
 
-abstract class Initializer implements DartSpecificNode {
-  accept(InitializerVisitor v);
-  accept1(InitializerVisitor1 v, arg);
-
-  void forEachBody(void action(Statement node));
-  void replaceEachBody(Statement transform(Statement node));
-}
-
-class FieldInitializer extends Initializer {
-  final FieldElement element;
-  Statement body;
-  bool processed = false;
-
-  FieldInitializer(this.element, this.body);
-
-  accept(InitializerVisitor visitor) => visitor.visitFieldInitializer(this);
-  accept1(InitializerVisitor1 visitor, arg) {
-    return visitor.visitFieldInitializer(this, arg);
-  }
-
-  void forEachBody(void action(Statement node)) {
-    action(body);
-  }
-
-  void replaceEachBody(Statement transform(Statement node)) {
-    body = transform(body);
-  }
-}
-
-class SuperInitializer extends Initializer {
-  final ConstructorElement target;
-  final Selector selector;
-  final List<Statement> arguments;
-  bool processed = false;
-
-  SuperInitializer(this.target, this.selector, this.arguments);
-  accept(InitializerVisitor visitor) => visitor.visitSuperInitializer(this);
-  accept1(InitializerVisitor1 visitor, arg) {
-    return visitor.visitSuperInitializer(this, arg);
-  }
-
-  void forEachBody(void action(Statement node)) {
-    arguments.forEach(action);
-  }
-
-  void replaceEachBody(Statement transform(Statement node)) {
-    for (int i = 0; i < arguments.length; i++) {
-      arguments[i] = transform(arguments[i]);
-    }
-  }
-}
-
-class ConstructorDefinition extends RootNode
-                            implements DartSpecificNode {
-  final ConstructorElement element;
-  final List<Variable> parameters;
-  Statement body;
-  final List<ConstDeclaration> localConstants;
-  final List<ConstantExpression> defaultParameterValues;
-  final List<Initializer> initializers;
-
-  ConstructorDefinition(this.element,
-                        this.parameters,
-                        this.body,
-                        this.initializers,
-                        this.localConstants,
-                        this.defaultParameterValues) {
-    for (Variable param in parameters) {
-      param.writeCount++; // Being a parameter counts as a write.
-    }
-  }
-
-  bool get isEmpty => body == null;
-
-  accept(RootVisitor v) => v.visitConstructorDefinition(this);
-  accept1(RootVisitor1 v, arg) => v.visitConstructorDefinition(this, arg);
-
-  void forEachBody(void action(Statement node)) {
-    if (isEmpty) return;
-    for (Initializer init in initializers) {
-      init.forEachBody(action);
-    }
-    action(body);
-  }
-
-  void replaceEachBody(Statement transform(Statement node)) {
-    if (isEmpty) return;
-    for (Initializer init in initializers) {
-      init.replaceEachBody(transform);
-    }
-    body = transform(body);
-  }
-}
-
-abstract class JsSpecificNode implements Node {}
-
-abstract class DartSpecificNode implements Node {}
-
-class CreateBox extends Expression implements JsSpecificNode {
+class CreateBox extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
 }
 
-class CreateInstance extends Expression implements JsSpecificNode {
+class CreateInstance extends Expression {
   ClassElement classElement;
   List<Expression> arguments;
   List<Expression> typeInformation;
 
   CreateInstance(this.classElement, this.arguments, this.typeInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitCreateInstance(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitCreateInstance(this, arg);
   }
 }
 
-class GetField extends Expression implements JsSpecificNode {
+class GetField extends Expression {
   Expression object;
   Element field;
 
   GetField(this.object, this.field);
 
   accept(ExpressionVisitor visitor) => visitor.visitGetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetField(this, arg);
 }
 
-class SetField extends Expression implements JsSpecificNode {
+class SetField extends Expression {
   Expression object;
   Element field;
   Expression value;
 
   SetField(this.object, this.field, this.value);
 
   accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
@@ skipping 13 matching lines @@
   Element element;
   Expression value;
   SourceInformation sourceInformation;
 
   SetStatic(this.element, this.value, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitSetStatic(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetStatic(this, arg);
 }
 
-class ReifyRuntimeType extends Expression implements JsSpecificNode {
+class ReifyRuntimeType extends Expression {
   Expression value;
 
   ReifyRuntimeType(this.value);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReifyRuntimeType(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitReifyRuntimeType(this, arg);
   }
 }
 
-class ReadTypeVariable extends Expression implements JsSpecificNode {
+class ReadTypeVariable extends Expression {
   final TypeVariableType variable;
   Expression target;
 
   ReadTypeVariable(this.variable, this.target);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReadTypeVariable(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitReadTypeVariable(this, arg);
   }
 }
 
-class CreateInvocationMirror extends Expression implements JsSpecificNode {
+class CreateInvocationMirror extends Expression {
   final Selector selector;
   final List<Expression> arguments;
 
   CreateInvocationMirror(this.selector, this.arguments);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitCreateInvocationMirror(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
@@ skipping 23 matching lines @@
   E visitExpression(Expression node) => node.accept(this);
   E visitVariableUse(VariableUse node);
   E visitAssign(Assign node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
-  E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitGetField(GetField node);
   E visitSetField(SetField node);
   E visitGetStatic(GetStatic node);
@@ skipping 10 matching lines @@
   E visitExpression(Expression node, A arg) => node.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
   E visitAssign(Assign node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
-  E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
   E visitGetField(GetField node, A arg);
   E visitSetField(SetField node, A arg);
   E visitGetStatic(GetStatic node, A arg);
@@ skipping 10 matching lines @@
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitReturn(Return node);
   S visitThrow(Throw node);
   S visitRethrow(Rethrow node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
   S visitWhileTrue(WhileTrue node);
   S visitWhileCondition(WhileCondition node);
-  S visitFunctionDeclaration(FunctionDeclaration node);
-  S visitVariableDeclaration(VariableDeclaration node);
   S visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
 }
 
 abstract class StatementVisitor1<S, A> {
   S visitStatement(Statement node, A arg) => node.accept1(this, arg);
   S visitLabeledStatement(LabeledStatement node, A arg);
   S visitReturn(Return node, A arg);
   S visitThrow(Throw node, A arg);
   S visitRethrow(Rethrow node, A arg);
   S visitBreak(Break node, A arg);
   S visitContinue(Continue node, A arg);
   S visitIf(If node, A arg);
   S visitWhileTrue(WhileTrue node, A arg);
   S visitWhileCondition(WhileCondition node, A arg);
-  S visitFunctionDeclaration(FunctionDeclaration node, A arg);
-  S visitVariableDeclaration(VariableDeclaration node, A arg);
   S visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
 }
 
-abstract class RootVisitor<T> {
-  T visitRootNode(RootNode node) => node.accept(this);
-  T visitFunctionDefinition(FunctionDefinition node);
-  T visitConstructorDefinition(ConstructorDefinition node);
-  T visitFieldDefinition(FieldDefinition node);
-}
-
-abstract class RootVisitor1<T, A> {
-  T visitRootNode(RootNode node, A arg) => node.accept1(this, arg);
-  T visitFunctionDefinition(FunctionDefinition node, A arg);
-  T visitConstructorDefinition(ConstructorDefinition node, A arg);
-  T visitFieldDefinition(FieldDefinition node, A arg);
-}
-
-abstract class InitializerVisitor<T> {
-  T visitInitializer(Initializer node) => node.accept(this);
-  T visitFieldInitializer(FieldInitializer node);
-  T visitSuperInitializer(SuperInitializer node);
-}
-
-
-abstract class InitializerVisitor1<T, A> {
-  T visitInitializer(Initializer node, A arg) => node.accept1(this, arg);
-  T visitFieldInitializer(FieldInitializer node, A arg);
-  T visitSuperInitializer(SuperInitializer node, A arg);
-}
-
 abstract class RecursiveVisitor implements StatementVisitor, ExpressionVisitor {
   visitExpression(Expression e) => e.accept(this);
   visitStatement(Statement s) => s.accept(this);
 
   visitInnerFunction(FunctionDefinition node);
 
   visitVariable(Variable variable) {}
 
   visitVariableUse(VariableUse node) {
     visitVariable(node.variable);
   }
 
-  visitVariableDeclaration(VariableDeclaration node) {
-    visitVariable(node.variable);
-    visitStatement(node.next);
-  }
-
   visitAssign(Assign node) {
     visitVariable(node.variable);
     visitExpression(node.value);
   }
 
   visitInvokeStatic(InvokeStatic node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitInvokeMethod(InvokeMethod node) {
@@ skipping 11 matching lines @@
   }
 
   visitConcatenateStrings(ConcatenateStrings node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitConstant(Constant node) {}
 
   visitThis(This node) {}
 
-  visitReifyTypeVar(ReifyTypeVar node) {}
-
   visitConditional(Conditional node) {
     visitExpression(node.condition);
     visitExpression(node.thenExpression);
     visitExpression(node.elseExpression);
   }
 
   visitLogicalOperator(LogicalOperator node) {
     visitExpression(node.left);
     visitExpression(node.right);
   }
@@ skipping 50 matching lines @@
   visitWhileTrue(WhileTrue node) {
     visitStatement(node.body);
   }
 
   visitWhileCondition(WhileCondition node) {
     visitExpression(node.condition);
     visitStatement(node.body);
     visitStatement(node.next);
   }
 
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    visitInnerFunction(node.definition);
-    visitStatement(node.next);
-  }
-
   visitExpressionStatement(ExpressionStatement node) {
     visitExpression(node.expression);
     visitStatement(node.next);
   }
 
   visitTry(Try node) {
     visitStatement(node.tryBody);
     visitStatement(node.catchBody);
   }
 
@@ skipping 50 matching lines @@
   }
 
   void _replaceExpressions(List<Expression> list) {
     for (int i = 0; i < list.length; i++) {
       list[i] = visitExpression(list[i]);
     }
   }
 
   visitVariableUse(VariableUse node) => node;
 
-  visitVariableDeclaration(VariableDeclaration node) {
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
   visitAssign(Assign node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   visitInvokeStatic(InvokeStatic node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
@@ skipping 16 matching lines @@
 
   visitConcatenateStrings(ConcatenateStrings node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitConstant(Constant node) => node;
 
   visitThis(This node) => node;
 
-  visitReifyTypeVar(ReifyTypeVar node) => node;
-
   visitConditional(Conditional node) {
     node.condition = visitExpression(node.condition);
     node.thenExpression = visitExpression(node.thenExpression);
     node.elseExpression = visitExpression(node.elseExpression);
     return node;
   }
 
   visitLogicalOperator(LogicalOperator node) {
     node.left = visitExpression(node.left);
     node.right = visitExpression(node.right);
@@ skipping 63 matching lines @@
     return node;
   }
 
   visitWhileCondition(WhileCondition node) {
     node.condition = visitExpression(node.condition);
     node.body = visitStatement(node.body);
     node.next = visitStatement(node.next);
     return node;
   }
 
-  visitFunctionDeclaration(FunctionDeclaration node) {
-    visitInnerFunction(node.definition);
-    node.next = visitStatement(node.next);
-    return node;
-  }
-
   visitExpressionStatement(ExpressionStatement node) {
     node.expression = visitExpression(node.expression);
     node.next = visitStatement(node.next);
     return node;
   }
 
   visitTry(Try node) {
     node.tryBody = visitStatement(node.tryBody);
     node.catchBody = visitStatement(node.catchBody);
     return node;
@@ skipping 37 matching lines @@
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }