Support new malformed types semantics.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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 js_backend;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked;
 
   JavaScriptItemCompilationContext()
@@ skipping 15 matching lines @@
     codegen.use(node.checkedInput);
     arguments.add(codegen.pop());
     generateAdditionalArguments(codegen, node, arguments);
     String helperName = codegen.backend.namer.isolateAccess(helperElement);
     return new jsAst.Call(new jsAst.VariableUse(helperName), arguments);
   }
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
-    assert(!node.typeExpression.isMalformed);
     // No additional arguments needed.
   }
 }
 
 class PropertyCheckedModeHelper extends CheckedModeHelper {
   const PropertyCheckedModeHelper(SourceString name) : super(name);
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
     DartType type = node.typeExpression;
-    assert(!type.isMalformed);
     String additionalArgument = codegen.backend.namer.operatorIsType(type);
     arguments.add(js.string(additionalArgument));
   }
 }
 
 class TypeVariableCheckedModeHelper extends CheckedModeHelper {
   const TypeVariableCheckedModeHelper(SourceString name) : super(name);
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
@@ skipping 41 matching lines @@
         codegen.use(node.context);
         arguments.add(codegen.pop());
       } else {
         codegen.use(node.context);
         arguments.add(codegen.pop());
       }
     }
   }
 }
 
-class MalformedCheckedModeHelper extends CheckedModeHelper {
-  const MalformedCheckedModeHelper(SourceString name) : super(name);
+class AmbiguousTypeCheckedModeHelper extends CheckedModeHelper {
+  const AmbiguousTypeCheckedModeHelper(SourceString name) : super(name);
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
     DartType type = node.typeExpression;
-    assert(type.isMalformed);
-    String reasons = Types.fetchReasonsFromMalformedType(type);
+    assert(type.containsAmbiguousTypes);
+    String reasons = Types.fetchReasonsFromAmbiguousType(type);
 
     arguments.add(js.string(quote('$type')));
     arguments.add(js.string(quote(reasons)));
   }
 
   String quote(String string) => string.replaceAll('"', r'\"');
 }
 
 /*
  * Invariants:
@@ skipping 719 matching lines @@
     world.registerInstantiatedClass(compiler.boolClass, elements);
     bool inCheckedMode = compiler.enableTypeAssertions;
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (inCheckedMode) {
       CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: false);
       if (helper != null) world.addToWorkList(helper.getElement(compiler));
       // We also need the native variant of the check (for DOM types).
       helper = getNativeCheckedModeHelper(type, typeCast: false);
       if (helper != null) world.addToWorkList(helper.getElement(compiler));
-      if (type.isMalformed) {
+      if (type.containsAmbiguousTypes) {
         enqueueInResolution(getThrowMalformedSubtypeError(), elements);
         return;
       }
-    } else if (type.isMalformed) {
+    } else if (type.containsAmbiguousTypes) {
       registerThrowRuntimeError(elements);
       return;
     }
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
     if (!type.isRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), elements);
@@ skipping 242 matching lines @@
    * Returns the checked mode helper for the type check/type cast for [type]. If
    * [nativeCheckOnly] is [:true:], only names for native helpers are returned.
    */
   CheckedModeHelper getCheckedModeHelperInternal(DartType type,
                                                  {bool typeCast,
                                                   bool nativeCheckOnly}) {
     assert(type.kind != TypeKind.TYPEDEF);
     Element element = type.element;
     bool nativeCheck = nativeCheckOnly ||
         emitter.nativeEmitter.requiresNativeIsCheck(element);
-    if (type.isMalformed) {
+    if (type.containsAmbiguousTypes) {
       // Check for malformed types first, because the type may be a list type
       // with a malformed argument type.
       if (nativeCheckOnly) return null;
       return typeCast
-          ? const MalformedCheckedModeHelper(
+          ? const AmbiguousTypeCheckedModeHelper(
               const SourceString('malformedTypeCast'))
-          : const MalformedCheckedModeHelper(
+          : const AmbiguousTypeCheckedModeHelper(
               const SourceString('malformedTypeCheck'));
     } else if (type == compiler.types.voidType) {
       assert(!typeCast); // Cannot cast to void.
       if (nativeCheckOnly) return null;
       return const CheckedModeHelper(const SourceString('voidTypeCheck'));
     } else if (element == jsStringClass || element == compiler.stringClass) {
       if (nativeCheckOnly) return null;
       return typeCast
           ? const CheckedModeHelper(const SourceString("stringTypeCast"))
           : const CheckedModeHelper(const SourceString('stringTypeCheck'));
@@ skipping 345 matching lines @@
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }