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

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, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 60 matching lines @@
   /// counter must be decremented by hand when a [Break] becomes orphaned.
   int useCount = 0;
 
   /// The [LabeledStatement] or [WhileTrue] binding this label.
   JumpTarget binding;
 }
 
 /**
  * A local variable in the tree IR.
  *
- * All tree IR variables are mutable, and may in Dart-mode be referenced inside
- * nested functions.
+ * All tree IR variables are mutable.
  *
  * To use a variable as an expression, reference it from a [VariableUse], with
  * one [VariableUse] per expression.
  *
  * [Variable]s are reference counted. The node constructors [VariableUse],
  * [Assign], [FunctionDefinition], and [Try] automatically update the reference
  * count for their variables, but when transforming the tree, the transformer
  * is responsible for updating reference counts.
  */
 class Variable extends Node {
@@ skipping 224 matching lines @@
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.type, this.entries);
 
   accept(ExpressionVisitor visitor) => visitor.visitLiteralMap(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitLiteralMap(this, arg);
   }
 }
 
+/// Type test or type cast.
+///
+/// Note that if this is a type test, then [type] cannot be `Object`, `dynamic`,
+/// or the `Null` type. These cases are compiled to other node types.
 class TypeOperator extends Expression {
   Expression value;
   final DartType type;
   final List<Expression> typeArguments;
   final bool isTypeTest;
 
   TypeOperator(this.value, this.type, this.typeArguments,
                {bool this.isTypeTest});
 
   accept(ExpressionVisitor visitor) => visitor.visitTypeOperator(this);
@@ skipping 274 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);
   }
 }
 
+/// A statement that is known to be unreachable.
+class Unreachable extends Statement {
+  Statement get next => null;
+  void set next(Statement value) => throw 'UNREACHABLE';
+
+  accept(StatementVisitor visitor) => visitor.visitUnreachable(this);
+  accept1(StatementVisitor1 visitor, arg) {
+    return visitor.visitUnreachable(this, arg);
+  }
+}
+
 class FunctionDefinition extends Node {
   final ExecutableElement element;
   final List<Variable> parameters;
   Statement body;
 
   /// Creates a function definition and updates `writeCount` for [parameters].
   FunctionDefinition(this.element, this.parameters, this.body) {
     for (Variable param in parameters) {
       param.writeCount++; // Being a parameter counts as a write.
     }
@@ skipping 190 matching lines @@
   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 visitExpressionStatement(ExpressionStatement node);
   S visitTry(Try node);
+  S visitUnreachable(Unreachable 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 visitExpressionStatement(ExpressionStatement node, A arg);
   S visitTry(Try node, A arg);
+  S visitUnreachable(Unreachable 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) {}
 
@@ skipping 144 matching lines @@
     visitExpression(node.target);
   }
 
   visitTypeExpression(TypeExpression node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     node.arguments.forEach(visitExpression);
   }
+
+  visitUnreachable(Unreachable node) {}
 }
 
 abstract class Transformer implements ExpressionVisitor<Expression>,
                                       StatementVisitor<Statement> {
    Expression visitExpression(Expression e) => e.accept(this);
    Statement visitStatement(Statement s) => s.accept(this);
 }
 
 class RecursiveTransformer extends Transformer {
   void visitInnerFunction(FunctionDefinition node) {
@@ skipping 176 matching lines @@
 
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     _replaceExpressions(node.arguments);
     return node;
   }
+
+  visitUnreachable(Unreachable node) {
+    return node;
+  }
 }