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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.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.
-
-// IrNodes are kept in a separate library to have precise control over their
-// dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
-import '../dart_types.dart' show DartType, GenericType, TypeVariableType;
-import '../dart2jslib.dart' as dart2js show
-    CURRENT_ELEMENT_SPANNABLE,
-    InternalErrorFunction,
-    invariant;
+import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart' show Selector, SelectorKind;
 
 abstract class Node {
   /// A pointer to the parent node. Is null until set by optimization passes.
   Node parent;
 
   accept(Visitor visitor);
 }
 
+/// Expressions can be evaluated, and may diverge, throw, and/or have
+/// side-effects.
+///
+/// Evaluation continues by stepping into a sub-expression, invoking a
+/// continuation, or throwing an exception.
+///
+/// Expressions do not a return value. Expressions that produce values should
+/// invoke a [Continuation] with the result as argument. Alternatively, values
+/// that can be obtained without side-effects, divergence, or throwing
+/// exceptions can be built using a [LetPrim].
 abstract class Expression extends Node {
   Expression plug(Expression expr) => throw 'impossible';
 }
 
 /// The base class of things that variables can refer to: primitives,
 /// continuations, function and continuation parameters, etc.
 abstract class Definition<T extends Definition<T>> extends Node {
   // The head of a linked-list of occurrences, in no particular order.
   Reference<T> firstRef;
 
@@ skipping 15 matching lines @@
     previous.next = firstRef;
     if (firstRef != null) firstRef.previous = previous;
     firstRef = other.firstRef;
     other.firstRef = null;
   }
 }
 
 /// An expression that cannot throw or diverge and has no side-effects.
 /// All primitives are named using the identity of the [Primitive] object.
 ///
-/// Primitives may allocate objects, this is not considered side-effect here.
+/// Primitives may allocate objects; this is not considered side-effect here.
 ///
 /// Although primitives may not mutate state, they may depend on state.
+///
+/// All primitives except [Parameter] must be bound by a [LetPrim].
 abstract class Primitive extends Definition<Primitive> {
   /// The [VariableElement] or [ParameterElement] from which the primitive
   /// binding originated.
   Entity hint;
 
   /// Use the given element as a hint for naming this primitive.
   ///
   /// Has no effect if this primitive already has a non-null [element].
   void useElementAsHint(Entity hint) {
     if (this.hint == null) {
@@ skipping 23 matching lines @@
     if (previous == null) {
       assert(definition.firstRef == this);
       definition.firstRef = next;
     } else {
       previous.next = next;
     }
     if (next != null) next.previous = previous;
   }
 }
 
-/// Binding a value (primitive or constant): 'let val x = V in E'.  The bound
-/// value is in scope in the body.
-/// During one-pass construction a LetVal with an empty body is used to
-/// represent the one-hole context 'let val x = V in []'.
+/// Evaluates a primitive and binds it to variable: `let val x = V in E`.
+///
+/// The bound value is in scope in the body.
+///
+/// During one-pass construction a LetPrim with an empty body is used to
+/// represent the one-hole context `let val x = V in []`.
 class LetPrim extends Expression implements InteriorNode {
   final Primitive primitive;
   Expression body;
 
   LetPrim(this.primitive, [this.body = null]);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitLetPrim(this);
 }
 
 
 /// Binding continuations.
 ///
 /// let cont k0(v0 ...) = E0
 ///          k1(v1 ...) = E1
 ///          ...
 ///   in E
 ///
 /// The bound continuations are in scope in the body and the continuation
 /// parameters are in scope in the respective continuation bodies.
+///
 /// During one-pass construction a LetCont whose first continuation has an empty
 /// body is used to represent the one-hole context
-/// 'let cont ... k(v) = [] ... in E'.
+/// `let cont ... k(v) = [] ... in E`.
 class LetCont extends Expression implements InteriorNode {
   List<Continuation> continuations;
   Expression body;
 
   LetCont(Continuation continuation, this.body)
       : continuations = <Continuation>[continuation];
 
   LetCont.many(this.continuations, this.body);
 
   Expression plug(Expression expr) {
@@ skipping 59 matching lines @@
 ///     Node child          = node.body;
 ///     InteriorNode parent = node.parent;
 ///
 ///     child.parent = parent;
 ///     parent.body  = child;
 abstract class InteriorNode extends Node {
   Expression get body;
   void set body(Expression body);
 }
 
-/// Invoke a static function or static getter/setter.
+/// Invoke a static function.
+///
+/// All optional arguments declared by [target] are passed in explicitly, and
+/// occur at the end of [arguments] list, in normalized order.
+///
+/// Discussion:
+/// All information in the [selector] is technically redundant; it will likely
+/// be removed.
 class InvokeStatic extends Expression implements Invoke {
-  /// [FunctionElement] or [FieldElement].
-  final Entity target;
-
-  /**
-   * The selector encodes how the function is invoked: number of positional
-   * arguments, names used in named arguments. This information is required
-   * to build the [StaticCallSiteTypeInformation] for the inference graph.
-   */
+  final FunctionElement target;
   final Selector selector;
-
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
   InvokeStatic(this.target,
                this.selector,
                List<Primitive> args,
                Continuation cont,
                this.sourceInformation)
       : arguments = _referenceList(args),
-        continuation = new Reference<Continuation>(cont) {
-    assert(target is ErroneousElement || selector.name == target.name);
-  }
+        continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 }
 
-/// A [CallingConvention] codifies how arguments are matched to parameters when
-/// emitting code for a function call.
-class CallingConvention {
-  final String name;
-  const CallingConvention(this.name);
-  /// The normal way of calling a Dart function: Positional arguments are
-  /// matched with (mandatory and optional) positionals parameters from left to
-  /// right and named arguments are matched by name.
-  static const CallingConvention DART = const CallingConvention("Dart call");
-  /// Intercepted calls have an additional first argument that is the actual
-  /// receiver of the call.  See the documentation of [Interceptor] for more
-  /// information.
-  static const CallingConvention JS_INTERCEPTED =
-      const CallingConvention("intercepted JavaScript call");
-}
-
-/// Invoke a method, operator, getter, setter, or index getter/setter.
-/// Converting a method to a function object is treated as a getter invocation.
+/// Invoke a method on an object.
+///
+/// This includes getters, setters, operators, and index getter/setters.
+///
+/// Tearing off a method is treated like a getter invocation (getters and
+/// tear-offs cannot be distinguished at compile-time).
+///
+/// The [selector] records the names of named arguments. The value of named
+/// arguments occur at the end of the [arguments] list, in normalized order.
+///
+/// Discussion:
+/// If the [selector] is a [TypedSelector], the type information contained
+/// there is used by optimization passes. This is likely to change.
 class InvokeMethod extends Expression implements Invoke {
   Reference<Primitive> receiver;
   Selector selector;
-  CallingConvention callingConvention;
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
   InvokeMethod(Primitive receiver,
-               Selector selector,
+               this.selector,
                List<Primitive> arguments,
                Continuation continuation,
-               {SourceInformation sourceInformation})
-      : this.internal(new Reference<Primitive>(receiver),
-                      selector,
-                      _referenceList(arguments),
-                      new Reference<Continuation>(continuation),
-                      sourceInformation);
-
-  InvokeMethod.internal(this.receiver,
-                        this.selector,
-                        this.arguments,
-                        this.continuation,
-                        this.sourceInformation,
-                        [this.callingConvention = CallingConvention.DART]) {
-    assert(isValid);
-  }
-
-  /// Returns whether the arguments match the selector under the given calling
-  /// convention.
-  ///
-  /// This check is designed to be used in an assert, as it also checks that the
-  /// selector, arguments, and calling convention have meaningful values.
-  bool get isValid {
-    if (selector == null || callingConvention == null) return false;
-    if (callingConvention != CallingConvention.DART &&
-        callingConvention != CallingConvention.JS_INTERCEPTED) {
-      return false;
-    }
-    int numberOfArguments =
-        callingConvention == CallingConvention.JS_INTERCEPTED
-            ? arguments.length - 1
-            : arguments.length;
-    return selector.kind == SelectorKind.CALL ||
-           selector.kind == SelectorKind.OPERATOR ||
-           (selector.kind == SelectorKind.GETTER && numberOfArguments == 0) ||
-           (selector.kind == SelectorKind.SETTER && numberOfArguments == 1) ||
-           (selector.kind == SelectorKind.INDEX && numberOfArguments == 1) ||
-           (selector.kind == SelectorKind.INDEX && numberOfArguments == 2);
-  }
+               {this.sourceInformation})
+      : this.receiver = new Reference<Primitive>(receiver),
+        this.arguments = _referenceList(arguments),
+        this.continuation = new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 }
 
 /// Invoke [target] on [receiver], bypassing dispatch and override semantics.
 ///
 /// That is, if [receiver] is an instance of a class that overrides [target]
 /// with a different implementation, the overriding implementation is bypassed
 /// and [target]'s implementation is invoked.
 ///
 /// As with [InvokeMethod], this can be used to invoke a method, operator,
 /// getter, setter, or index getter/setter.
 ///
 /// If it is known that [target] does not use its receiver argument, then
 /// [receiver] may refer to a null constant primitive. This happens for direct
 /// invocations to intercepted methods, where the effective receiver is instead
 /// passed as a formal parameter.
 ///
 /// TODO(sra): Review. A direct call to a method that is mixed into a native
 /// class will still require an explicit argument.
 ///
-/// When targeting Dart, this instruction is used to represent super calls.
-/// Here, [receiver] must always be a reference to `this`, and [target] must be
-/// a method that is available in the super class.
+/// All optional arguments declared by [target] are passed in explicitly, and
+/// occur at the end of [arguments] list, in normalized order.
 class InvokeMethodDirectly extends Expression implements Invoke {
   Reference<Primitive> receiver;
-  final Element target;
+  final FunctionElement target;
   final Selector selector;
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
 
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
-                       List<Primitive> args,
-                       Continuation cont)
+                       List<Primitive> arguments,
+                       Continuation continuation)
       : this.receiver = new Reference<Primitive>(receiver),
-          arguments = _referenceList(args),
-          continuation = new Reference<Continuation>(cont) {
-    assert(selector != null);
-    assert(selector.kind == SelectorKind.CALL ||
-           selector.kind == SelectorKind.OPERATOR ||
-           (selector.kind == SelectorKind.GETTER && arguments.isEmpty) ||
-           (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
-           (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
-           (selector.kind == SelectorKind.INDEX && arguments.length == 2));
-  }
+        this.arguments = _referenceList(arguments),
+        this.continuation = new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 }
 
-/// Non-const call to a constructor. The [target] may be a generative
-/// constructor, factory, or redirecting factory.
+/// Non-const call to a constructor.
+///
+/// The [target] may be a generative constructor (forwarding or normal)
+/// or a non-redirecting factory.
+///
+/// All optional arguments declared by [target] are passed in explicitly, and
+/// occur in the [arguments] list, in normalized order.
+///
+/// Last in the [arguments] list, after the mandatory and optional arguments,
+/// the internal representation of each type argument occurs, unless it could
+/// be determined at build-time that the constructed class has no need for its
+/// runtime type information.
+///
+/// Note that [InvokeConstructor] does it itself allocate an object.
+/// The invoked constructor will do that using [CreateInstance].
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
-  final FunctionElement target;
+  final ConstructorElement target;
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
   final Selector selector;
 
-  /// The class being instantiated. This is the same as `target.enclosingClass`
-  /// and `type.element`.
-  ClassElement get targetClass => target.enclosingElement;
-
-  /// True if this is an invocation of a factory constructor.
-  bool get isFactory => target.isFactoryConstructor;
-
   InvokeConstructor(this.type,
                     this.target,
                     this.selector,
                     List<Primitive> args,
                     Continuation cont)
       : arguments = _referenceList(args),
-        continuation = new Reference<Continuation>(cont) {
-    assert(dart2js.invariant(target,
-        target.isErroneous ||
-        type.isDynamic ||
-        type.element == target.enclosingClass.declaration,
-        message: "Constructor invocation target is not a constructor: "
-                 "$target."));
-  }
+        continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
-/// "as" casts and "is" checks.
-// We might want to turn "is"-checks into a [Primitive] as it can never diverge.
-// But then we need to special-case for is-checks with an erroneous .type as
-// these will throw.
+// TODO(asgerf): Make a Primitive for "is" and an Expression for "as".
+
+/// An "as" cast or an "is" check.
 class TypeOperator extends Expression {
   Reference<Primitive> value;
   final DartType type;
 
-  /// If [type] is a [GenericType], this holds the internal representation of
+  /// If [type] is an [InterfaceType], this holds the internal representation of
   /// the type arguments to [type]. Since these may reference type variables
   /// from the enclosing class, they are not constant.
   ///
   /// If [type] is a [TypeVariableType], this is a singleton list with
   /// the internal representation of the type held in that type variable.
   ///
   /// Otherwise the list is empty.
   final List<Reference<Primitive>> typeArguments;
   final Reference<Continuation> continuation;
-  // TODO(johnniwinther): Use `Operator` class to encapsule the operator type.
   final bool isTypeTest;
 
   TypeOperator(Primitive value,
                this.type,
                List<Primitive> typeArguments,
                Continuation cont,
                {bool this.isTypeTest})
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments),
         this.continuation = new Reference<Continuation>(cont) {
@@ skipping 84 matching lines @@
         this.value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutableVariable(this);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 }
 
-/// Create a potentially recursive function and store it in a [MutableVariable].
-/// The function can access itself using [GetMutableVariable] on [variable].
-/// There must not exist a [SetMutableVariable] to [variable].
-///
-/// This can be seen as a let rec binding:
-///
-///   let rec [variable] = [definition] in [body]
-///
-class DeclareFunction extends Expression
-                      implements InteriorNode, DartSpecificNode {
-  final MutableVariable variable;
-  final FunctionDefinition definition;
-  Expression body;
-
-  DeclareFunction(this.variable, this.definition);
-
-  Expression plug(Expression expr) {
-    assert(body == null);
-    return body = expr;
-  }
-
-  accept(Visitor visitor) => visitor.visitDeclareFunction(this);
-}
-
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends Expression {
   Reference<Continuation> continuation;
   List<Reference<Primitive>> arguments;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
   bool isRecursive;
 
   InvokeContinuation(Continuation cont, List<Primitive> args,
@@ skipping 22 matching lines @@
 
 class IsTrue extends Condition {
   final Reference<Primitive> value;
 
   IsTrue(Primitive val) : value = new Reference<Primitive>(val);
 
   accept(Visitor visitor) => visitor.visitIsTrue(this);
 }
 
 /// Choose between a pair of continuations based on a condition value.
+///
+/// The two continuations must not declare any parameters.
 class Branch extends Expression {
   final Condition condition;
   final Reference<Continuation> trueContinuation;
   final Reference<Continuation> falseContinuation;
 
   Branch(this.condition, Continuation trueCont, Continuation falseCont)
       : trueContinuation = new Reference<Continuation>(trueCont),
         falseContinuation = new Reference<Continuation>(falseCont);
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
-/// Marker interface for nodes that are only handled in the JavaScript backend.
-///
-/// These nodes are generated by the unsugar step or the [JsIrBuilder] and need
-/// special translation to the Tree IR, which is implemented in JsTreeBuilder.
-abstract class JsSpecificNode implements Node {}
-
-/// Marker interface for nodes that are only handled inthe Dart backend.
-abstract class DartSpecificNode implements Node {}
-
 /// Directly assigns to a field on a given object.
-class SetField extends Expression implements InteriorNode, JsSpecificNode {
+class SetField extends Expression implements InteriorNode {
   final Reference<Primitive> object;
-  Element field;
+  FieldElement field;
   final Reference<Primitive> value;
   Expression body;
 
   SetField(Primitive object, this.field, Primitive value)
       : this.object = new Reference<Primitive>(object),
         this.value = new Reference<Primitive>(value);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitSetField(this);
 }
 
 /// Directly reads from a field on a given object.
-class GetField extends Primitive implements JsSpecificNode {
+class GetField extends Primitive {
   final Reference<Primitive> object;
-  Element field;
+  FieldElement field;
 
   GetField(Primitive object, this.field)
       : this.object = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 }
 
 /// Reads the value of a static field or tears off a static method.
 class GetStatic extends Primitive {
+  /// Can be [FieldElement] or [FunctionElement].
   final Element element;
   final SourceInformation sourceInformation;
 
   GetStatic(this.element, this.sourceInformation);
 
   accept(Visitor visitor) => visitor.visitGetStatic(this);
 }
 
 /// Sets the value of a static field.
 class SetStatic extends Expression implements InteriorNode {
-  final Element element;
+  final FieldElement element;
   final Reference<Primitive> value;
   Expression body;
   final SourceInformation sourceInformation;
 
   SetStatic(this.element, Primitive value, this.sourceInformation)
       : this.value = new Reference<Primitive>(value);
 
   Expression plug(Expression expr) {
     assert(body == null);
     return body = expr;
   }
 
   accept(Visitor visitor) => visitor.visitSetStatic(this);
 }
 
 /// Reads the value of a lazily initialized static field.
 ///
 /// If the field has not yet been initialized, its initializer is evaluated
 /// and assigned to the field.
 ///
 /// [continuation] is then invoked with the value of the field as argument.
 class GetLazyStatic extends Expression {
   final FieldElement element;
   final Reference<Continuation> continuation;
   final SourceInformation sourceInformation;
 
   GetLazyStatic(this.element,
-                Continuation cont,
+                Continuation continuation,
                 this.sourceInformation)
-      : continuation = new Reference<Continuation>(cont);
+      : continuation = new Reference<Continuation>(continuation);
 
   accept(Visitor visitor) => visitor.visitGetLazyStatic(this);
 }
 
 /// Creates an object for holding boxed variables captured by a closure.
-class CreateBox extends Primitive implements JsSpecificNode {
+class CreateBox extends Primitive {
   accept(Visitor visitor) => visitor.visitCreateBox(this);
 }
 
 /// Creates an instance of a class and initializes its fields and runtime type
 /// information.
-class CreateInstance extends Primitive implements JsSpecificNode {
+class CreateInstance extends Primitive {
   final ClassElement classElement;
 
   /// Initial values for the fields on the class.
   /// The order corresponds to the order of fields on the class.
   final List<Reference<Primitive>> arguments;
 
   /// The runtime type information structure which contains the type arguments.
   ///
   /// May be `null` to indicate that no type information is needed because the
   /// compiler determined that the type information for instances of this class
   /// is not needed at runtime.
   final List<Reference<Primitive>> typeInformation;
 
   CreateInstance(this.classElement, List<Primitive> arguments,
       List<Primitive> typeInformation)
       : this.arguments = _referenceList(arguments),
         this.typeInformation = _referenceList(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
 }
 
-class Identical extends Primitive implements JsSpecificNode {
+/// Compare objects for identity.
+///
+/// It is an error pass in a value that does not correspond to a Dart value,
+/// such as an interceptor or a box.
+class Identical extends Primitive {
   final Reference<Primitive> left;
   final Reference<Primitive> right;
   Identical(Primitive left, Primitive right)
       : left = new Reference<Primitive>(left),
         right = new Reference<Primitive>(right);
   accept(Visitor visitor) => visitor.visitIdentical(this);
 }
 
-class Interceptor extends Primitive implements JsSpecificNode {
+class Interceptor extends Primitive {
   final Reference<Primitive> input;
   final Set<ClassElement> interceptedClasses;
   Interceptor(Primitive input, this.interceptedClasses)
       : this.input = new Reference<Primitive>(input);
   accept(Visitor visitor) => visitor.visitInterceptor(this);
 }
 
 /// Create an instance of [Invocation] for use in a call to `noSuchMethod`.
-class CreateInvocationMirror extends Primitive implements JsSpecificNode {
+class CreateInvocationMirror extends Primitive {
   final Selector selector;
   final List<Reference<Primitive>> arguments;
 
   CreateInvocationMirror(this.selector, List<Primitive> arguments)
       : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitCreateInvocationMirror(this);
 }
 
 class Constant extends Primitive {
   final ConstantExpression expression;
 
   Constant(this.expression);
 
   values.ConstantValue get value => expression.value;
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
-/// Reify the given type variable as a [Type].
-/// This depends on the current binding of 'this'.
-class ReifyTypeVar extends Primitive implements DartSpecificNode {
-  final TypeVariableElement typeVariable;
-
-  ReifyTypeVar(this.typeVariable);
-
-  values.ConstantValue get constant => null;
-
-  accept(Visitor visitor) => visitor.visitReifyTypeVar(this);
-}
-
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
-  final GenericType type;
+  final InterfaceType type;
   final List<Reference<Primitive>> values;
 
   LiteralList(this.type, List<Primitive> values)
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMapEntry {
   final Reference<Primitive> key;
   final Reference<Primitive> value;
 
   LiteralMapEntry(Primitive key, Primitive value)
       : this.key = new Reference<Primitive>(key),
         this.value = new Reference<Primitive>(value);
 }
 
 class LiteralMap extends Primitive {
-  final GenericType type;
+  final InterfaceType type;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 }
 
-/// Create a non-recursive function.
-class CreateFunction extends Primitive implements DartSpecificNode {
+/// Currently unused.
+///
+/// Nested functions (from Dart code) are translated to classes by closure
+/// conversion, hence they are instantiated with [CreateInstance].
+///
+/// We keep this around for now because it might come in handy when we
+/// handle async/await in the CPS IR.
+///
+/// Instantiates a nested function. [MutableVariable]s are in scope in the
+/// inner function, but primitives are not shared across function boundaries.
+class CreateFunction extends Primitive {
   final FunctionDefinition definition;
 
   CreateFunction(this.definition);
 
   accept(Visitor visitor) => visitor.visitCreateFunction(this);
 }
 
 class Parameter extends Primitive {
   Parameter(Entity hint) {
     super.hint = hint;
   }
 
   // In addition to a parent pointer to the containing Continuation or
   // FunctionDefinition, parameters have an index into the list of parameters
   // bound by the parent.  This gives constant-time access to the continuation
   // from the parent.
   int parentIndex;
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 
   String toString() => 'Parameter(${hint == null ? null : hint.name})';
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with one
 /// parameter and no body is used to represent a function's return continuation.
-/// The return continuation is bound by the Function, not by 'let cont'.
+/// The return continuation is bound by the function, not by 'let cont'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
   final List<Parameter> parameters;
   Expression body = null;
 
   // In addition to a parent pointer to the containing LetCont, continuations
   // have an index into the list of continuations bound by the LetCont.  This
   // gives constant-time access to the continuation from the parent.
   int parent_index;
 
   // A continuation is recursive if it has any recursive invocations.
   bool isRecursive;
 
   bool get isReturnContinuation => body == null;
 
   Continuation(this.parameters, {this.isRecursive: false});
 
   Continuation.retrn() : parameters = <Parameter>[new Parameter(null)];
 
   accept(Visitor visitor) => visitor.visitContinuation(this);
 }
 
-abstract class RootNode extends Node {
-  Element get element;
-
-  /// 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;
-
-  /// List of parameters, or an empty list if this is a field.
-  /// For fields, this list is immutable.
-  List<Definition> get parameters;
-}
-
-// This is basically a function definition with an empty parameter list and a
-// field element instead of a function element and no const declarations, and
-// never a getter or setter, though that's less important.
-class FieldDefinition extends RootNode implements DartSpecificNode {
-  final FieldElement element;
-  List<Definition> get parameters => const <Definition>[];
-  final Body body;
-
-  FieldDefinition(this.element, this.body);
-
-  FieldDefinition.withoutInitializer(this.element)
-      : this.body = null;
-
-  accept(Visitor visitor) => visitor.visitFieldDefinition(this);
-
-  bool get isEmpty => body == null;
-}
-
 /// Identifies a mutable variable.
 class MutableVariable extends Definition {
   Entity hint;
 
   MutableVariable(this.hint);
 
   accept(Visitor v) => v.visitMutableVariable(this);
 }
 
-class Body extends InteriorNode {
-  Expression body;
-  final Continuation returnContinuation;
-  Body(this.body, this.returnContinuation);
-  accept(Visitor visitor) => visitor.visitBody(this);
-}
-
-/// A function definition, consisting of parameters and a body.  The parameters
-/// include a distinguished continuation parameter (held by the body).
-class FunctionDefinition extends RootNode {
+/// A function definition, consisting of parameters and a body.
+///
+/// There is an explicit parameter for the `this` argument, and a return
+/// continuation to invoke when returning from the function.
+class FunctionDefinition extends InteriorNode {
   final ExecutableElement element;
   final Parameter thisParameter;
-  /// Mixed list of [Parameter]s and [MutableVariable]s.
-  final List<Definition> parameters;
-  final Body body;
-  final List<ConstDeclaration> localConstants;
-
-  /// Values for optional parameters.
-  final List<ConstantExpression> defaultParameterValues;
+  final List<Parameter> parameters;
+  final Continuation returnContinuation;
+  Expression body;
 
   FunctionDefinition(this.element,
       this.thisParameter,
       this.parameters,
-      this.body,
-      this.localConstants,
-      this.defaultParameterValues);
-
-  FunctionDefinition.abstract(this.element,
-                              this.parameters,
-                              this.defaultParameterValues)
-      : body = null,
-        thisParameter = null,
-        localConstants = const <ConstDeclaration>[];
+      this.returnContinuation,
+      this.body);
 
   accept(Visitor visitor) => visitor.visitFunctionDefinition(this);
-
-  bool get isEmpty => body == null;
-}
-
-abstract class Initializer extends Node implements DartSpecificNode {}
-
-class FieldInitializer extends Initializer {
-  final FieldElement element;
-  final Body body;
-
-  FieldInitializer(this.element, this.body);
-  accept(Visitor visitor) => visitor.visitFieldInitializer(this);
-}
-
-class SuperInitializer extends Initializer {
-  final ConstructorElement target;
-  final List<Body> arguments;
-  final Selector selector;
-  SuperInitializer(this.target, this.arguments, this.selector);
-  accept(Visitor visitor) => visitor.visitSuperInitializer(this);
-}
-
-class ConstructorDefinition extends RootNode implements DartSpecificNode {
-  final ConstructorElement element;
-  final Parameter thisParameter;
-  /// Mixed list of [Parameter]s and [MutableVariable]s.
-  final List<Definition> parameters;
-  final Body body;
-  final List<ConstDeclaration> localConstants;
-  final List<Initializer> initializers;
-
-  /// Values for optional parameters.
-  final List<ConstantExpression> defaultParameterValues;
-
-  ConstructorDefinition(this.element,
-                        this.thisParameter,
-                        this.parameters,
-                        this.body,
-                        this.initializers,
-                        this.localConstants,
-                        this.defaultParameterValues);
-
-  // 'Abstract' here means "has no body" and is used to represent external
-  // constructors.
-  ConstructorDefinition.abstract(
-      this.element,
-      this.parameters,
-      this.defaultParameterValues)
-      : body = null,
-        initializers = null,
-        thisParameter = null,
-        localConstants = const <ConstDeclaration>[];
-
-  accept(Visitor visitor) => visitor.visitConstructorDefinition(this);
-
-  bool get isEmpty => body == null;
 }
 
 /// Converts the internal representation of a type to a Dart object of type
 /// [Type].
-class ReifyRuntimeType extends Primitive implements JsSpecificNode {
+class ReifyRuntimeType extends Primitive {
   /// Reference to the internal representation of a type (as produced, for
   /// example, by [ReadTypeVariable]).
   final Reference<Primitive> value;
   ReifyRuntimeType(Primitive value)
     : this.value = new Reference<Primitive>(value);
 
   @override
   accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
 }
 
 /// Read the value the type variable [variable] from the target object.
 ///
 /// The resulting value is an internal representation (and not neccessarily a
 /// Dart object), and must be reified by [ReifyRuntimeType], if it should be
 /// used as a Dart value.
-class ReadTypeVariable extends Primitive implements JsSpecificNode {
+class ReadTypeVariable extends Primitive {
   final TypeVariableType variable;
   final Reference<Primitive> target;
 
   ReadTypeVariable(this.variable, Primitive target)
       : this.target = new Reference<Primitive>(target);
 
   @override
   accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
 }
 
 /// Representation of a closed type (that is, a type without type variables).
 ///
 /// The resulting value is constructed from [dartType] by replacing the type
 /// variables with consecutive values from [arguments], in the order generated
 /// by [DartType.forEachTypeVariable].  The type variables in [dartType] are
 /// treated as 'holes' in the term, which means that it must be ensured at
 /// construction, that duplicate occurences of a type variable in [dartType]
 /// are assigned the same value.
-class TypeExpression extends Primitive implements JsSpecificNode {
+class TypeExpression extends Primitive {
   final DartType dartType;
   final List<Reference<Primitive>> arguments;
 
   TypeExpression(this.dartType,
                  [List<Primitive> arguments = const <Primitive>[]])
       : this.arguments = _referenceList(arguments);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitTypeExpression(this);
   }
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node);
 
   // Concrete classes.
-  T visitFieldDefinition(FieldDefinition node);
   T visitFunctionDefinition(FunctionDefinition node);
-  T visitConstructorDefinition(ConstructorDefinition node);
-  T visitBody(Body node);
-
-  // Initializers
-  T visitFieldInitializer(FieldInitializer node);
-  T visitSuperInitializer(SuperInitializer node);
 
   // Expressions.
   T visitLetPrim(LetPrim node);
   T visitLetCont(LetCont node);
   T visitLetHandler(LetHandler node);
   T visitLetMutable(LetMutable node);
   T visitInvokeContinuation(InvokeContinuation node);
   T visitInvokeStatic(InvokeStatic node);
   T visitInvokeMethod(InvokeMethod node);
   T visitInvokeMethodDirectly(InvokeMethodDirectly node);
   T visitInvokeConstructor(InvokeConstructor node);
   T visitConcatenateStrings(ConcatenateStrings node);
   T visitThrow(Throw node);
   T visitRethrow(Rethrow node);
   T visitBranch(Branch node);
   T visitTypeOperator(TypeOperator node);
   T visitSetMutableVariable(SetMutableVariable node);
-  T visitDeclareFunction(DeclareFunction node);
   T visitSetStatic(SetStatic node);
   T visitGetLazyStatic(GetLazyStatic node);
+  T visitSetField(SetField node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
-  T visitReifyTypeVar(ReifyTypeVar node);
   T visitCreateFunction(CreateFunction node);
   T visitGetMutableVariable(GetMutableVariable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
   T visitNonTailThrow(NonTailThrow node);
   T visitGetStatic(GetStatic node);
-
-  // JavaScript specific nodes.
-
-  // Conditions.
-  T visitIsTrue(IsTrue node);
-
-  // Expressions.
-  T visitSetField(SetField node);
-
-  // Definitions.
   T visitIdentical(Identical node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   T visitCreateBox(CreateBox node);
   T visitReifyRuntimeType(ReifyRuntimeType node);
   T visitReadTypeVariable(ReadTypeVariable node);
   T visitTypeExpression(TypeExpression node);
   T visitCreateInvocationMirror(CreateInvocationMirror node);
+
+  // Conditions.
+  T visitIsTrue(IsTrue node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 class RecursiveVisitor implements Visitor {
   const RecursiveVisitor();
 
   visit(Node node) => node.accept(this);
 
   processReference(Reference ref) {}
 
-  processBody(Body node) {}
-  visitBody(Body node) {
-    processBody(node);
-    visit(node.returnContinuation);
-    visit(node.body);
-  }
-
-  processFieldDefinition(FieldDefinition node) {}
-  visitFieldDefinition(FieldDefinition node) {
-    processFieldDefinition(node);
-    if (node.body != null) {
-      visit(node.body);
-    }
-  }
-
   processFunctionDefinition(FunctionDefinition node) {}
   visitFunctionDefinition(FunctionDefinition node) {
     processFunctionDefinition(node);
     if (node.thisParameter != null) visit(node.thisParameter);
     node.parameters.forEach(visit);
-    if (node.body != null) {
-      visit(node.body);
-    }
-  }
-
-  processConstructorDefinition(ConstructorDefinition node) {}
-  visitConstructorDefinition(ConstructorDefinition node) {
-    processConstructorDefinition(node);
-    if (node.thisParameter != null) visit(node.thisParameter);
-    node.parameters.forEach(visit);
-    if (node.initializers != null) {
-      node.initializers.forEach(visit);
-    }
-    if (node.body != null) {
-      visit(node.body);
-    }
-  }
-
-  processFieldInitializer(FieldInitializer node) {}
-  visitFieldInitializer(FieldInitializer node) {
-    processFieldInitializer(node);
+    visit(node.returnContinuation);
     visit(node.body);
   }
 
-  processSuperInitializer(SuperInitializer node) {}
-  visitSuperInitializer(SuperInitializer node) {
-    processSuperInitializer(node);
-    node.arguments.forEach(visit);
-  }
-
   // Expressions.
 
   processLetPrim(LetPrim node) {}
   visitLetPrim(LetPrim node) {
     processLetPrim(node);
     visit(node.primitive);
     visit(node.body);
   }
 
   processLetCont(LetCont node) {}
@@ skipping 90 matching lines @@
   }
 
   processSetMutableVariable(SetMutableVariable node) {}
   visitSetMutableVariable(SetMutableVariable node) {
     processSetMutableVariable(node);
     processReference(node.variable);
     processReference(node.value);
     visit(node.body);
   }
 
-  processDeclareFunction(DeclareFunction node) {}
-  visitDeclareFunction(DeclareFunction node) {
-    processDeclareFunction(node);
-    visit(node.variable);
-    visit(node.definition);
-    visit(node.body);
-  }
-
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
     processGetLazyStatic(node);
     processReference(node.continuation);
   }
 
-  // Definitions.
-
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
     processLiteralList(node);
     node.values.forEach(processReference);
   }
 
   processLiteralMap(LiteralMap node) {}
   visitLiteralMap(LiteralMap node) {
     processLiteralMap(node);
     for (LiteralMapEntry entry in node.entries) {
       processReference(entry.key);
       processReference(entry.value);
     }
   }
 
   processConstant(Constant node) {}
   visitConstant(Constant node)  {
     processConstant(node);
   }
 
-  processReifyTypeVar(ReifyTypeVar node) {}
-  visitReifyTypeVar(ReifyTypeVar node) {
-    processReifyTypeVar(node);
-  }
-
   processCreateFunction(CreateFunction node) {}
   visitCreateFunction(CreateFunction node) {
     processCreateFunction(node);
     visit(node.definition);
   }
 
   processMutableVariable(node) {}
   visitMutableVariable(MutableVariable node) {
     processMutableVariable(node);
   }
 
   processGetMutableVariable(GetMutableVariable node) {}
   visitGetMutableVariable(GetMutableVariable node) {
     processGetMutableVariable(node);
     processReference(node.variable);
   }
 
   processParameter(Parameter node) {}
   visitParameter(Parameter node) {
     processParameter(node);
   }
 
   processContinuation(Continuation node) {}
   visitContinuation(Continuation node) {
     processContinuation(node);
     node.parameters.forEach(visitParameter);
     if (node.body != null) visit(node.body);
   }
 
-  // Conditions.
-
   processIsTrue(IsTrue node) {}
   visitIsTrue(IsTrue node) {
     processIsTrue(node);
     processReference(node.value);
   }
 
-  // JavaScript specific nodes.
   processIdentical(Identical node) {}
   visitIdentical(Identical node) {
     processIdentical(node);
     processReference(node.left);
     processReference(node.right);
   }
 
   processInterceptor(Interceptor node) {}
   visitInterceptor(Interceptor node) {
     processInterceptor(node);
@@ skipping 61 matching lines @@
     processNonTailThrow(node);
     processReference(node.value);
   }
 
   processCreateInvocationMirror(CreateInvocationMirror node) {}
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     processCreateInvocationMirror(node);
     node.arguments.forEach(processReference);
   }
 }