Enable full type-checks in checked mode.

sdk/lib/_internal/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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 1069 matching lines @@
   HInstruction convertType(Compiler compiler, DartType type, int kind) {
     if (type == null) return this;
     if (identical(type.element, compiler.dynamicClass)) return this;
     if (identical(type.element, compiler.objectClass)) return this;
     if (type.isMalformed || type.kind != TypeKind.INTERFACE) {
       return new HTypeConversion(type, kind, HType.UNKNOWN, this);
     } else if (kind == HTypeConversion.BOOLEAN_CONVERSION_CHECK) {
       // Boolean conversion checks work on non-nullable booleans.
       return new HTypeConversion(type, kind, HType.BOOLEAN, this);
     } else {
+      if (kind == HTypeConversion.CHECKED_MODE_CHECK && !type.isRaw) {

[ngeoffray, 2013/05/15 08:45:33]

Use:

} else if {
  throw...
} else {
  ...
}

instead?

[karlklose, 2013/05/15 12:59:16]

Done.

+        throw 'creating compound check to $type (this = ${this})';
+      }
       HType subtype = new HType.subtype(type, compiler);
       return new HTypeConversion(type, kind, subtype, this);
     }
   }
 
   /**
    * Return whether the instructions do not belong to a loop or
    * belong to the same loop.
    */
   bool hasSameLoopHeaderAs(HInstruction other) {
@@ skipping 1026 matching lines @@
     sideEffects.setChangesIndex();
   }
   String toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
   HInstruction get value => inputs[2];
 }
 
-// TODO(karlklose): use this class to represent type conversions as well.
 class HIs extends HInstruction {
   /// A check against a raw type: 'o is int', 'o is A'.
   static const int RAW_CHECK = 0;
   /// A check against a type with type arguments: 'o is List<int>', 'o is C<T>'.
   static const int COMPOUND_CHECK = 1;
   /// A check against a single type variable: 'o is T'.
   static const int VARIABLE_CHECK = 2;
 
   final DartType typeExpression;
   final bool nullOk;
@@ skipping 46 matching lines @@
 
   HTypeConversion(this.typeExpression, this.kind,
                   HType type, HInstruction input,
                   [this.receiverTypeCheckSelector])
       : super(<HInstruction>[input]) {
     assert(!isReceiverTypeCheck || receiverTypeCheckSelector != null);
     sourceElement = input.sourceElement;
     instructionType = type;
   }
 
+  HTypeConversion.withTypeRepresentation(this.typeExpression, this.kind,
+                                         HType type, HInstruction input,
+                                         HInstruction typeRepresentation)
+      : super(<HInstruction>[input, typeRepresentation]),
+        receiverTypeCheckSelector = null {
+    sourceElement = input.sourceElement;
+    instructionType = type;
+  }
+
+  bool get hasTypeRepresentation => inputs.length > 1;
+  HInstruction get typeRepresentation => inputs[1];
+
+  HInstruction convertType(Compiler compiler, DartType type, int kind) {
+    if (typeExpression == type) return this;
+    return super.convertType(compiler, type, kind);
+  }
+
   bool get isChecked => kind != NO_CHECK;
   bool get isCheckedModeCheck {
     return kind == CHECKED_MODE_CHECK
         || kind == BOOLEAN_CONVERSION_CHECK;
   }
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
   bool get isReceiverTypeCheck => kind == RECEIVER_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
   bool get isBooleanConversionCheck => kind == BOOLEAN_CONVERSION_CHECK;
 
@@ skipping 386 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);
 }