Implement 'as' operator.

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 1471 matching lines @@
   SubtractOperation get operation() => const SubtractOperation();
   int typeCode() => 9;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * An [HSwitch] instruction has one input for the incoming
  * value, and one input per constant that it can switch on.
  * Its block has one successor per constant, and one for the default.
- * If the switch didn't have a default case, the last successor is
- * the join block.
  */
 class HSwitch extends HControlFlow {
   HSwitch(List<HInstruction> inputs) : super(inputs);
 
   HConstant constant(int index) => inputs[index + 1];
   HInstruction get expression() => inputs[0];
 
+  /**
+   * Provides the target to jump to if none of the constants match
+   * the expression. If the switc had no default case, this is the
+   * following join-block.
+   */
   HBasicBlock get defaultTarget() => block.successors.last();
 
   accept(HVisitor visitor) => visitor.visitSwitch(this);
 
   String toString() => "HSwitch cases = $inputs";
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
@@ skipping 295 matching lines @@
   // 'Not' only works on booleans. That's what we want as input.
   HType computeDesiredTypeForInput(HInstruction input) => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => 18;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HParameterValue extends HInstruction {
-  HParameterValue(element) : super(<HInstruction>[]) {
+  HParameterValue(Element element) : super(<HInstruction>[]) {
     sourceElement = element;
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
   toString() => 'parameter ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitParameterValue(this);
   bool isCodeMotionInvariant() => true;
 }
@@ skipping 386 matching lines @@
   HInstruction get typeInfoCall() => inputs[1];
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }
 
 class HTypeConversion extends HCheck {
+  static final int UNCHECKED = 0;
+  static final int CHECKED = 1;
+  static final int CAST = 2;
+
   HType type;
-  final bool checked;
+  final int kind;
 
   HTypeConversion(HType this.type,
                   HInstruction input,
-                  [bool this.checked = false])
+                  [this.kind = UNCHECKED])
     : super(<HInstruction>[input]) {
       sourceElement = input.sourceElement;
   }
 
+  bool get checked() => kind != UNCHECKED;
+  /**
+   * Whether to use cast-semantics instead of checked-mode assignment semantics
+   * for the conversion. The difference is that a cast throws on [:null:] and
+   * throws a different exception on a failed match.
+   */
+  bool get isCast() => kind == CAST;
+
   HType get guaranteedType() => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool hasSideEffects() => checked;
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
@@ skipping 324 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }