Support new malformed types semantics.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2199 matching lines @@
     List<js.Expression> arguments = <js.Expression>[object, record];
     FunctionElement helper =
         compiler.findHelper(const SourceString('isJsIndexable'));
     world.registerStaticUse(helper);
     String helperName = backend.namer.isolateAccess(helper);
     push(new js.Call(new js.VariableUse(helperName), arguments));
     if (negative) push(new js.Prefix('!', pop()));
   }
 
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
-    assert(invariant(input, !type.isMalformed,
-                     message: 'Attempt to check malformed type $type'));
     Element element = type.element;
     if (element == backend.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
     } else if (element == backend.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
         checkMutableArray(input);
       }
@@ skipping 110 matching lines @@
 
     if (node.isVariableCheck || node.isCompoundCheck) {
       use(node.checkCall);
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       assert(node.isRawCheck);
       LibraryElement coreLibrary = compiler.coreLibrary;
       ClassElement objectClass = compiler.objectClass;
       Element element = type.element;
 
-      if (identical(element, objectClass) ||
-          identical(element, compiler.dynamicClass)) {
+      if (identical(element, objectClass) || type.treatAsDynamic) {
         // The constant folder also does this optimization, but we make
         // it safe by assuming it may have not run.
         push(newLiteralBool(!negative), node);
       } else if (element == compiler.stringClass) {
         checkString(input, relation);
         attachLocationToLast(node);
       } else if (element == compiler.doubleClass) {
         checkDouble(input, relation);
         attachLocationToLast(node);
       } else if (element == compiler.numClass) {
@@ skipping 623 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }