dart2js cps: Type casts and related changes to type propagation.

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 '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 10 matching lines @@
 /// 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 {
+  InteriorNode get parent; // Only InteriorNodes may contain expressions.
+
   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;
 
   bool get hasAtMostOneUse  => firstRef == null || firstRef.next == null;
@@ skipping 309 matching lines @@
                     this.target,
                     this.selector,
                     List<Primitive> args,
                     Continuation cont)
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
-// TODO(asgerf): Make a Primitive for "is" and an Expression for "as".
-
-/// An "as" cast or an "is" check.
-class TypeOperator extends Expression {
+/// An "is" type test.
+///
+/// Returns `true` if [value] not `null` and is an instance of [type].
+///
+/// [type] must not be the [Object], `dynamic` or [Null] types (though it might
+/// be a type variable containing one of these types). This design is chosen
+/// to simplify code generation for type tests.
+class TypeTest extends Primitive {
   Reference<Primitive> value;
   final DartType type;
 
+  /// 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;
+
+  TypeTest(Primitive value,
+           this.type,
+           List<Primitive> typeArguments)
+  : this.value = new Reference<Primitive>(value),
+    this.typeArguments = _referenceList(typeArguments);
+
+  accept(Visitor visitor) => visitor.visitTypeTest(this);
+}
+
+/// An "as" type cast.
+///
+/// If [value] is `null` or is an instance of [type], [continuation] is invoked
+/// with [value] as argument. Otherwise, a [CastError] is thrown.
+///
+/// Discussion:
+/// The parameter to [continuation] is redundant since it will always equal
+/// [value], which is typically in scope in the continuation. However, it might
+/// simplify type propagation, since a better type can be computed for the
+/// continuation parameter without needing flow-sensitive analysis.
+class TypeCast extends Expression {
+  Reference<Primitive> value;
+  final DartType type;
+
   /// 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;
-  final bool isTypeTest;
 
-  TypeOperator(Primitive value,
-               this.type,
-               List<Primitive> typeArguments,
-               Continuation cont,
-               {bool this.isTypeTest})
+  TypeCast(Primitive value,
+           this.type,
+           List<Primitive> typeArguments,
+           Continuation cont)
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments),
-        this.continuation = new Reference<Continuation>(cont) {
-    assert(isTypeTest != null);
-  }
+        this.continuation = new Reference<Continuation>(cont);
 
-  bool get isTypeCast => !isTypeTest;
-
-  accept(Visitor visitor) => visitor.visitTypeOperator(this);
+  accept(Visitor visitor) => visitor.visitTypeCast(this);
 }
 
 /// Invoke [toString] on each argument and concatenate the results.
 class ConcatenateStrings extends Expression {
   final List<Reference<Primitive>> arguments;
   final Reference<Continuation> continuation;
 
   ConcatenateStrings(List<Primitive> args, Continuation cont)
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
@@ skipping 29 matching lines @@
 /// translation, a [NonTailThrow] is used as that value.  A cleanup pass
 /// removes these and replaces them with [Throw] expressions.
 class NonTailThrow extends Primitive {
   final Reference<Primitive> value;
 
   NonTailThrow(Primitive value) : value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitNonTailThrow(this);
 }
 
+/// An expression that is known to be unreachable.
+///
+/// This can be placed as the body of a call continuation, when the caller is
+/// known never to invoke it, e.g. because the calling expression always throws.
+class Unreachable extends Expression {
+  accept(Visitor visitor) => visitor.visitUnreachable(this);
+}
+
 /// Gets the value from a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  A [LetPrim] with a [GetMutableVariable] can then be seen as:
 ///
 ///   let prim p = ![variable] in [body]
 ///
 class GetMutableVariable extends Primitive {
   final Reference<MutableVariable> variable;
 
@@ skipping 36 matching lines @@
   bool isRecursive;
 
   InvokeContinuation(Continuation cont, List<Primitive> args,
                      {this.isRecursive: false})
       : continuation = new Reference<Continuation>(cont),
         arguments = _referenceList(args) {
     assert(cont.parameters == null || cont.parameters.length == args.length);
     if (isRecursive) cont.isRecursive = true;
   }
 
+  /// Build a one-argument InvokeContinuation using existing reference objects.
+  ///
+  /// This is useful for converting call continuations to local continuations.
+  InvokeContinuation.fromCall(this.continuation,
+                              Reference<Primitive> argument)
+    : arguments = <Reference<Primitive>>[argument],
+      isRecursive = false;
+
   /// A continuation invocation whose target and arguments will be filled
   /// in later.
   ///
   /// Used as a placeholder for a jump whose target is not yet created
   /// (e.g., in the translation of break and continue).
   InvokeContinuation.uninitialized({this.isRecursive: false})
       : continuation = null,
         arguments = null;
 
   accept(Visitor visitor) => visitor.visitInvokeContinuation(this);
@@ skipping 360 matching lines @@
   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 visitTypeCast(TypeCast node);
   T visitSetMutableVariable(SetMutableVariable node);
   T visitSetStatic(SetStatic node);
   T visitGetLazyStatic(GetLazyStatic node);
   T visitSetField(SetField node);
+  T visitUnreachable(Unreachable node);
 
   // Definitions.
   T visitLiteralList(LiteralList node);
   T visitLiteralMap(LiteralMap node);
   T visitConstant(Constant 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);
   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);
+  T visitTypeTest(TypeTest 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();
 
@@ skipping 97 matching lines @@
   }
 
   processBranch(Branch node) {}
   visitBranch(Branch node) {
     processBranch(node);
     processReference(node.trueContinuation);
     processReference(node.falseContinuation);
     visit(node.condition);
   }
 
-  processTypeOperator(TypeOperator node) {}
-  visitTypeOperator(TypeOperator node) {
-    processTypeOperator(node);
+  processTypeCast(TypeCast node) {}
+  visitTypeCast(TypeCast node) {
+    processTypeCast(node);
     processReference(node.continuation);
     processReference(node.value);
     node.typeArguments.forEach(processReference);
   }
 
+  processTypeTest(TypeTest node) {}
+  visitTypeTest(TypeTest node) {
+    processTypeTest(node);
+    processReference(node.value);
+    node.typeArguments.forEach(processReference);
+  }
+
   processSetMutableVariable(SetMutableVariable node) {}
   visitSetMutableVariable(SetMutableVariable node) {
     processSetMutableVariable(node);
     processReference(node.variable);
     processReference(node.value);
     visit(node.body);
   }
 
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
@@ skipping 129 matching lines @@
   visitNonTailThrow(NonTailThrow node) {
     processNonTailThrow(node);
     processReference(node.value);
   }
 
   processCreateInvocationMirror(CreateInvocationMirror node) {}
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     processCreateInvocationMirror(node);
     node.arguments.forEach(processReference);
   }
+
+  processUnreachable(Unreachable node) {}
+  visitUnreachable(Unreachable node) {
+    processUnreachable(node);
+  }
 }
+
+/// Visit a just-deleted subterm and unlink all [Reference]s in it.
+class RemovalVisitor extends RecursiveVisitor {
+  const RemovalVisitor();
+
+  processReference(Reference reference) {
+    reference.unlink();
+  }
+
+  static void remove(Node node) {
+    (const RemovalVisitor()).visit(node);
+  }
+}