dart2js cps: Clean up and avoid processing unreachable code.

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.
 library dart2js.ir_nodes;
 
 import 'dart:collection';
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 198 matching lines @@
 
   /// 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) {
       this.hint = hint;
     }
   }
 
+  /// True if this primitive has a value that can be used by other expressions.
+  bool get hasValue;
+
   /// True if the primitive can be removed, assuming it has no uses
   /// (this getter does not check if there are any uses).
   ///
   /// False must be returned for primitives that may throw, diverge, or have
   /// observable side-effects.
   bool get isSafeForElimination;
 
   /// True if time-of-evaluation is irrelevant for the given primitive,
   /// assuming its inputs are the same values.
   bool get isSafeForReordering;
@@ skipping 245 matching lines @@
                [this.sourceInformation])
       : arguments = _referenceList(args);
 
   InvokeStatic.byReference(this.target,
                            this.selector,
                            this.arguments,
                            [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitInvokeStatic(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 enum CallingConvention {
   /// JS receiver is the Dart receiver, there are no extra arguments.
   ///
   /// For example: `foo.bar$1(x)`
   Normal,
@@ skipping 55 matching lines @@
         this.arguments = _referenceList(arguments);
 
   InvokeMethod.byReference(this.receiver,
                            this.selector,
                            this.mask,
                            this.arguments,
                            this.sourceInformation);
 
   accept(Visitor visitor) => visitor.visitInvokeMethod(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, 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
@@ skipping 40 matching lines @@
   InvokeMethodDirectly(Primitive receiver,
                        this.target,
                        this.selector,
                        List<Primitive> arguments,
                        this.sourceInformation)
       : this.receiver = new Reference<Primitive>(receiver),
         this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, this);
   }
 }
 
 /// Non-const call to a constructor.
 ///
 /// The [target] may be a generative constructor (forwarding or normal)
 /// or a non-redirecting factory.
@@ skipping 25 matching lines @@
   InvokeConstructor(this.dartType,
                     this.target,
                     this.selector,
                     List<Primitive> args,
                     this.sourceInformation,
                     {this.allocationSiteType})
       : arguments = _referenceList(args);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 /// An alias for [value] in a context where the value is known to satisfy
 /// [type].
 ///
 /// Refinement nodes are inserted before the type propagator pass and removed
 /// afterwards, so as not to complicate passes that don't reason about types,
 /// but need to reason about value references being identical (i.e. referring
 /// to the same primitive).
 class Refinement extends Primitive {
   Reference<Primitive> value;
   final TypeMask refineType;
 
   Refinement(Primitive value, this.refineType)
     : value = new Reference<Primitive>(value);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => false;
 
   accept(Visitor visitor) => visitor.visitRefinement(this);
 
   Primitive get effectiveDefinition => value.definition.effectiveDefinition;
 
   void setParentPointers() {
     value.parent = this;
   }
@@ skipping 16 matching lines @@
   ///
   /// If [dartType] is a [TypeVariableType], this is a singleton list with the
   /// internal representation of the type held in that type variable.
   ///
   /// If [dartType] is a [FunctionType], this is a singleton list with the
   /// internal representation of that type,
   ///
   /// Otherwise the list is empty.
   final List<Reference<Primitive>> typeArguments;
 
-  /// The Interceptor for [value].  May be `null` if the test can be done
-  /// without an interceptor.  May be the same as [value] after self-interceptor
-  /// optimization.
-  // TODO(24523): Remove this field.
-  Reference<Primitive> interceptor;
-
   TypeTest(Primitive value,
            this.dartType,
            List<Primitive> typeArguments)
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeTest(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     value.parent = this;
     _setParentsOnList(typeArguments, this);
-    if (interceptor != null) interceptor.parent = this;
   }
 }
 
 /// An "is" type test for a raw type, performed by testing a flag property.
 ///
 /// Returns `true` if [interceptor] is for [dartType].
 class TypeTestViaFlag extends Primitive {
   Reference<Primitive> interceptor;
   final DartType dartType;
 
   TypeTestViaFlag(Primitive interceptor, this.dartType)
       : this.interceptor = new Reference<Primitive>(interceptor);
 
   accept(Visitor visitor) => visitor.visitTypeTestViaFlag(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     interceptor.parent = this;
   }
 }
 
 /// An "as" type cast.
 ///
@@ skipping 13 matching lines @@
   final List<Reference<Primitive>> typeArguments;
 
   TypeCast(Primitive value,
            this.dartType,
            List<Primitive> typeArguments)
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeCast(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     value.parent = this;
     _setParentsOnList(typeArguments, this);
   }
 }
 
 /// Apply a built-in operator.
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinOperator extends Primitive {
   BuiltinOperator operator;
   List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
   ApplyBuiltinOperator(this.operator,
                        List<Primitive> arguments,
                        this.sourceInformation)
       : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitApplyBuiltinOperator(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 /// Apply a built-in method.
 ///
 /// It must be known that the arguments have the proper types.
 class ApplyBuiltinMethod extends Primitive {
   BuiltinMethod method;
   Reference<Primitive> receiver;
   List<Reference<Primitive>> arguments;
   final SourceInformation sourceInformation;
 
   bool receiverIsNotNull;
 
   ApplyBuiltinMethod(this.method,
                      Primitive receiver,
                      List<Primitive> arguments,
                      this.sourceInformation,
                      {this.receiverIsNotNull: false})
       : this.receiver = new Reference<Primitive>(receiver),
         this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitApplyBuiltinMethod(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     receiver.parent = this;
     _setParentsOnList(arguments, this);
   }
 }
 
 /// Throw a value.
@@ skipping 39 matching lines @@
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutable extends Primitive {
   final Reference<MutableVariable> variable;
 
   GetMutable(MutableVariable variable)
       : this.variable = new Reference<MutableVariable>(variable);
 
   accept(Visitor visitor) => visitor.visitGetMutable(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     variable.parent = this;
   }
 }
 
 /// Assign a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  This can be seen as a dereferencing assignment:
 ///
 ///   { [variable] := [value]; [body] }
 class SetMutable extends Primitive {
   final Reference<MutableVariable> variable;
   final Reference<Primitive> value;
 
   SetMutable(MutableVariable variable, Primitive value)
       : this.variable = new Reference<MutableVariable>(variable),
         this.value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutable(this);
 
+  bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     variable.parent = this;
     value.parent = this;
   }
 }
 
 /// Invoke a continuation in tail position.
@@ skipping 84 matching lines @@
   final Reference<Primitive> object;
   FieldElement field;
   final Reference<Primitive> value;
 
   SetField(Primitive object, this.field, Primitive value)
       : this.object = new Reference<Primitive>(object),
         this.value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetField(this);
 
+  bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     object.parent = this;
     value.parent = this;
   }
 }
 
 /// Directly reads from a field on a given object.
 ///
 /// The [object] must either be `null` or an object that has [field].
 class GetField extends Primitive {
   final Reference<Primitive> object;
   FieldElement field;
 
   /// True if the object is known not to be null.
   // TODO(asgerf): This is a placeholder until we agree on how to track
   //               side effects.
   bool objectIsNotNull = false;
 
   GetField(Primitive object, this.field)
       : this.object = new Reference<Primitive>(object);
 
   accept(Visitor visitor) => visitor.visitGetField(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   toString() => 'GetField($field)';
 
   void setParentPointers() {
     object.parent = this;
   }
 }
 
 /// Get the length of a string or native list.
 class GetLength extends Primitive {
   final Reference<Primitive> object;
 
   /// True if the object is known not to be null.
   bool objectIsNotNull = false;
 
   GetLength(Primitive object) : this.object = new Reference<Primitive>(object);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitGetLength(this);
 
   void setParentPointers() {
     object.parent = this;
   }
 }
 
 /// Read an entry from a string or native list.
 ///
 /// [object] must be null or a native list or a string, and [index] must be
 /// an integer.
 class GetIndex extends Primitive {
   final Reference<Primitive> object;
   final Reference<Primitive> index;
 
   /// True if the object is known not to be null.
   bool objectIsNotNull = false;
 
   GetIndex(Primitive object, Primitive index)
       : this.object = new Reference<Primitive>(object),
         this.index = new Reference<Primitive>(index);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => objectIsNotNull;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitGetIndex(this);
 
   void setParentPointers() {
     object.parent = this;
     index.parent = this;
   }
 }
 
 /// Set an entry on a native list.
 ///
 /// [object] must be null or a native list, and [index] must be an integer.
 ///
 /// The primitive itself has no value and may not be referenced.
 class SetIndex extends Primitive {
   final Reference<Primitive> object;
   final Reference<Primitive> index;
   final Reference<Primitive> value;
 
   SetIndex(Primitive object, Primitive index, Primitive value)
       : this.object = new Reference<Primitive>(object),
         this.index = new Reference<Primitive>(index),
         this.value = new Reference<Primitive>(value);
 
+  bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   accept(Visitor v) => v.visitSetIndex(this);
 
   void setParentPointers() {
     object.parent = this;
     index.parent = this;
     value.parent = this;
   }
 }
 
 /// Reads the value of a static field or tears off a static method.
 ///
 /// Note that lazily initialized fields should be read using GetLazyStatic.
 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);
 
-  bool get isSafeForElimination {
-    return true;
-  }
+  bool get hasValue => true;
+  bool get isSafeForElimination => true;
   bool get isSafeForReordering {
     return element is FunctionElement || element.isFinal;
   }
 
   void setParentPointers() {}
 }
 
 /// Sets the value of a static field.
 class SetStatic extends Primitive {
   final FieldElement element;
   final Reference<Primitive> value;
   final SourceInformation sourceInformation;
 
   SetStatic(this.element, Primitive value, [this.sourceInformation])
       : this.value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetStatic(this);
 
+  bool get hasValue => false;
   bool get isSafeForElimination => false;
   bool get isSafeForReordering => false;
 
   void setParentPointers() {
     value.parent = 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.
 class GetLazyStatic extends UnsafePrimitive {
   final FieldElement element;
   final SourceInformation sourceInformation;
 
   GetLazyStatic(this.element, [this.sourceInformation]);
 
   accept(Visitor visitor) => visitor.visitGetLazyStatic(this);
 
-  void setParentPointers() {
-  }
+  bool get hasValue => true;
+
+  void setParentPointers() {}
 }
 
 /// Creates an object for holding boxed variables captured by a closure.
 class CreateBox extends Primitive {
   accept(Visitor visitor) => visitor.visitCreateBox(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 /// Creates an instance of a class and initializes its fields and runtime type
 /// information.
 class CreateInstance extends Primitive {
   final ClassElement classElement;
@@ skipping 12 matching lines @@
   final SourceInformation sourceInformation;
 
   CreateInstance(this.classElement, List<Primitive> arguments,
       List<Primitive> typeInformation,
       this.sourceInformation)
       : this.arguments = _referenceList(arguments),
         this.typeInformation = _referenceList(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   toString() => 'CreateInstance($classElement)';
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
     if (typeInformation != null) _setParentsOnList(typeInformation, this);
   }
 }
@@ skipping 76 matching lines @@
   /// [interceptedClasses].
   bool get isInterceptedClassAlwaysExact {
     return flags & (INTERCEPT & ~INTERCEPT_EXACT) == 0;
   }
 
   Interceptor(Primitive input, this.sourceInformation)
       : this.input = new Reference<Primitive>(input);
 
   accept(Visitor visitor) => visitor.visitInterceptor(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     input.parent = this;
   }
 }
 
 /// Create an instance of [Invocation] for use in a call to `noSuchMethod`.
 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);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 class ForeignCode extends UnsafePrimitive {
   final js.Template codeTemplate;
   final TypeMask type;
   final List<Reference<Primitive>> arguments;
   final native.NativeBehavior nativeBehavior;
   final FunctionElement dependency;
 
   ForeignCode(this.codeTemplate, this.type, List<Primitive> arguments,
       this.nativeBehavior, {this.dependency})
       : this.arguments = _referenceList(arguments);
 
   accept(Visitor visitor) => visitor.visitForeignCode(this);
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 class Constant extends Primitive {
   final values.ConstantValue value;
   final SourceInformation sourceInformation;
 
   Constant(this.value, {this.sourceInformation}) {
     assert(value != null);
   }
 
   accept(Visitor visitor) => visitor.visitConstant(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
   final InterfaceType dartType;
   final List<Reference<Primitive>> values;
 
   /// If non-null, this is an allocation site-specific type for the list
   /// created here.
   TypeMask allocationSiteType;
 
   LiteralList(this.dartType, List<Primitive> values, {this.allocationSiteType})
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(values, 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 InterfaceType dartType;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.dartType, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     for (LiteralMapEntry entry in entries) {
       entry.key.parent = this;
       entry.value.parent = this;
     }
   }
 }
 
-/// 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);
-
-  bool get isSafeForElimination => true;
-  bool get isSafeForReordering => true;
-
-  void setParentPointers() {}
-}
-
 class Parameter extends Primitive {
   Parameter(Entity hint) {
     super.hint = hint;
   }
 
   accept(Visitor visitor) => visitor.visitParameter(this);
 
   String toString() => 'Parameter(${hint == null ? null : hint.name})';
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 /// 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'.
 class Continuation extends Definition<Continuation> implements InteriorNode {
@@ skipping 73 matching lines @@
   final Reference<Primitive> value;
 
   final SourceInformation sourceInformation;
 
   ReifyRuntimeType(Primitive value, this.sourceInformation)
     : this.value = new Reference<Primitive>(value);
 
   @override
   accept(Visitor visitor) => visitor.visitReifyRuntimeType(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     value.parent = 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 {
   final TypeVariableType variable;
   final Reference<Primitive> target;
   final SourceInformation sourceInformation;
 
   ReadTypeVariable(this.variable, Primitive target, this.sourceInformation)
       : this.target = new Reference<Primitive>(target);
 
   @override
   accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     target.parent = 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 {
   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);
   }
 
+  bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
   }
 }
 
 class Await extends UnsafePrimitive {
   final Reference<Primitive> input;
 
   Await(Primitive input)
     : this.input = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitAwait(this);
   }
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     input.parent = this;
   }
 }
 
 class Yield extends UnsafePrimitive {
   final Reference<Primitive> input;
   final bool hasStar;
 
   Yield(Primitive input, this.hasStar)
     : this.input = new Reference<Primitive>(input);
 
   @override
   accept(Visitor visitor) {
     return visitor.visitYield(this);
   }
 
+  bool get hasValue => true;
+
   void setParentPointers() {
     input.parent = this;
   }
 }
 
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
 
 void _setParentsOnNodes(List<Node> nodes, Node parent) {
@@ skipping 35 matching lines @@
   T visitGetLazyStatic(GetLazyStatic node);
   T visitSetField(SetField node);
   T visitUnreachable(Unreachable node);
   T visitAwait(Await node);
   T visitYield(Yield node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant node);
-  T visitCreateFunction(CreateFunction node);
   T visitGetMutable(GetMutable node);
   T visitParameter(Parameter node);
   T visitContinuation(Continuation node);
   T visitMutableVariable(MutableVariable node);
   T visitGetStatic(GetStatic node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   T visitCreateBox(CreateBox node);
   T visitReifyRuntimeType(ReifyRuntimeType node);
@@ skipping 134 matching lines @@
   visitTypeCast(TypeCast node) {
     processTypeCast(node);
     processReference(node.value);
     node.typeArguments.forEach(processReference);
   }
 
   processTypeTest(TypeTest node) {}
   visitTypeTest(TypeTest node) {
     processTypeTest(node);
     processReference(node.value);
-    if (node.interceptor != null) processReference(node.interceptor);
     node.typeArguments.forEach(processReference);
   }
 
   processTypeTestViaFlag(TypeTestViaFlag node) {}
   visitTypeTestViaFlag(TypeTestViaFlag node) {
     processTypeTestViaFlag(node);
     processReference(node.interceptor);
   }
 
   processSetMutable(SetMutable node) {}
@@ skipping 21 matching lines @@
       processReference(entry.key);
       processReference(entry.value);
     }
   }
 
   processConstant(Constant node) {}
   visitConstant(Constant node)  {
     processConstant(node);
   }
 
-  processCreateFunction(CreateFunction node) {}
-  visitCreateFunction(CreateFunction node) {
-    processCreateFunction(node);
-    visit(node.definition);
-  }
-
   processMutableVariable(node) {}
   visitMutableVariable(MutableVariable node) {
     processMutableVariable(node);
   }
 
   processGetMutable(GetMutable node) {}
   visitGetMutable(GetMutable node) {
     processGetMutable(node);
     processReference(node.variable);
   }
@@ skipping 257 matching lines @@
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends TrampolineRecursiveVisitor {
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (new RemovalVisitor()).visit(node);
   }
 }