Implement 'as' operator.

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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 1472 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

[floitsch, 2012/06/25 18:21:09]

switch

[Lasse Reichstein Nielsen, 2012/06/26 08:26:03]

Fixed.

+   * 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 313 matching lines @@
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
   * An [HLocalValue] represents a local. Unlike [HParameterValue]s its
   * first use must be in an HLocalSet. That is, [HParameterValue]s have a
   * value from the start, whereas [HLocalValue]s need to be initialized first.
   */
 class HLocalValue extends HInstruction {
-  HLocalValue(element) : super(<HInstruction>[]) {
+  HLocalValue(Element element) : super(<HInstruction>[]) {
     sourceElement = element;
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
   toString() => 'local ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitLocalValue(this);
   bool isCodeMotionInvariant() => true;
 }
 
 class HParameterValue extends HLocalValue {
-  HParameterValue(element) : super(element);
+  HParameterValue(Element element) : super(element);
 
   toString() => 'parameter ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitParameterValue(this);
 }
 
 class HThis extends HParameterValue {
   HThis([HType type = HType.UNKNOWN]) : super(null) {
     guaranteedType = type;
   }
   toString() => 'this';
@@ skipping 388 matching lines @@
   toString() => "$expression is $typeExpression";
 }
 
 class HTypeConversion extends HCheck {
   HType type;
   final int kind;
 
   static final int NO_CHECK = 0;
   static final int CHECKED_MODE_CHECK = 1;
   static final int ARGUMENT_TYPE_CHECK = 2;
+  static final int CAST_TYPE_CHECK = 3;
 
-  HTypeConversion(HType type, HInstruction input)
-      : this.internal(type, input, NO_CHECK);
-  HTypeConversion.checkedModeCheck(HType type, HInstruction input)
-      : this.internal(type, input, CHECKED_MODE_CHECK);
-  HTypeConversion.argumentTypeCheck(HType type, HInstruction input)
-      : this.internal(type, input, ARGUMENT_TYPE_CHECK);
-
-  HTypeConversion.internal(this.type, HInstruction input, this.kind)
+  HTypeConversion(this.type, HInstruction input, [this.kind = NO_CHECK])
       : super(<HInstruction>[input]) {
     sourceElement = input.sourceElement;
   }
+  HTypeConversion.checkedModeCheck(HType type, HInstruction input)
+      : this(type, input, CHECKED_MODE_CHECK);
+  HTypeConversion.argumentTypeCheck(HType type, HInstruction input)
+      : this(type, input, ARGUMENT_TYPE_CHECK);
+  HTypeConversion.castCheck(HType type, HInstruction input)
+      : this(type, intpu, CAST_TYPE_CHECK);
 
-  bool isChecked() => kind != NO_CHECK;
-  bool isCheckedModeCheck() => kind == CHECKED_MODE_CHECK;
-  bool isArgumentTypeCheck() => kind == ARGUMENT_TYPE_CHECK;
+
+  bool get isChecked() => kind != NO_CHECK;
+  bool get isCheckedModeCheck() => kind == CHECKED_MODE_CHECK;
+  bool get isArgumentTypeCheck() => kind == ARGUMENT_TYPE_CHECK;
+  bool get isCastTypeCheck() => kind == CAST_TYPE_CHECK;
 
   HType get guaranteedType() => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool isStatement() => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
   int typeCode() => 28;
-  bool typeEquals(HInstruction other) => other is HTypeConversion;
+  bool typeEquals(HInstruction other)
+      => other is HTypeConversion

[floitsch, 2012/06/25 18:21:09]

use { } instead of "=>".

+         && ((other.kind == CAST_TYPE_CHECK) == (kind == CAST_TYPE_CHECK));

[floitsch, 2012/06/25 18:21:09]

Explain why only CAST_TYPE_CHECKs are the same.

[Lasse Reichstein Nielsen, 2012/06/26 08:26:03]

Non-casts would also be the same. I don't think I need this anyway, so I'll just
revert this change.

   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
       : super(<HInstruction>[left, right]);
   HType get guaranteedType() => HType.STRING;
@@ skipping 326 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);
 }