Add intersection of disjoint masks to the TypeMask implementation.

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 1096 matching lines @@
     while (current != null) {
       if (current == other) return true;
       current = current.next;
     }
     return false;
   }
 
 
   HInstruction convertType(Compiler compiler, DartType type, int kind) {
     if (type == null) return this;
+
+    // TODO(kasperl): This needs cleaning up. We shouldn't be creating
+    // HType objects for malformed types.
+    if (kind == HTypeConversion.CHECKED_MODE_CHECK && type.isMalformed) {
+      kind = HTypeConversion.MALFORMED_CHECKED_MODE_CHECK;
+      return new HTypeConversion(new HType.subtype(type, compiler), this, kind);
+    }
+
     if (identical(type.element, compiler.dynamicClass)) return this;
     if (identical(type.element, compiler.objectClass)) return this;
 
     // If the original can't be null, type conversion also can't produce null.
     bool canBeNull = instructionType.canBeNull();
     HType convertedType = new HType.subtype(type, compiler);
 
     // No need to convert if we know the instruction has
     // [convertedType] as a bound.
     if (instructionType == convertedType) {
@@ skipping 1055 matching lines @@
 }
 
 class HTypeConversion extends HCheck {
   final int kind;
 
   static const int NO_CHECK = 0;
   static const int CHECKED_MODE_CHECK = 1;
   static const int ARGUMENT_TYPE_CHECK = 2;
   static const int CAST_TYPE_CHECK = 3;
   static const int BOOLEAN_CONVERSION_CHECK = 4;
+  static const int MALFORMED_CHECKED_MODE_CHECK = 5;
 
   HTypeConversion(HType type, HInstruction input, [this.kind = NO_CHECK])
       : super(<HInstruction>[input]) {
     assert(type != null);
     sourceElement = input.sourceElement;
     instructionType = type;
   }
   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, input, CAST_TYPE_CHECK);
 
-
   bool get isChecked => kind != NO_CHECK;
   bool get isCheckedModeCheck {
-    return kind == CHECKED_MODE_CHECK || kind == BOOLEAN_CONVERSION_CHECK;
+    return kind == CHECKED_MODE_CHECK
+        || kind == BOOLEAN_CONVERSION_CHECK
+        || kind == MALFORMED_CHECKED_MODE_CHECK;
   }
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
   bool get isBooleanConversionCheck => kind == BOOLEAN_CONVERSION_CHECK;
+  bool get isMalformedCheckedModeCheck => kind == MALFORMED_CHECKED_MODE_CHECK;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool isJsStatement() => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
   bool canThrow() => isChecked;
 
   int typeCode() => HInstruction.TYPE_CONVERSION_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
@@ skipping 356 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);
 }