Treat ambiguous types as malformed.

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 87 matching lines @@
         codegen.use(node.context);
         arguments.add(codegen.pop());
       } else {
         codegen.use(node.context);
         arguments.add(codegen.pop());
       }
     }
   }
 }
 
-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.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:
  *   canInline(function) implies canInline(function, insideLoop:true)
  *   !canInline(function, insideLoop: true) implies !canInline(function)
  */
 class FunctionInlineCache {
   final Map<FunctionElement, bool> canBeInlined =
       new Map<FunctionElement, bool>();
 
   final Map<FunctionElement, bool> canBeInlinedInsideLoop =
@@ skipping 711 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.containsAmbiguousTypes) {
-        enqueueInResolution(getThrowMalformedSubtypeError(), elements);
-        return;
-      }
-    } 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);
       }
       enqueueInResolution(getCheckSubtype(), elements);
@@ skipping 240 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.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 AmbiguousTypeCheckedModeHelper(
-              const SourceString('malformedTypeCast'))
-          : const AmbiguousTypeCheckedModeHelper(
-              const SourceString('malformedTypeCheck'));
-    } else if (type == compiler.types.voidType) {
+    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'));
     } else if (element == jsDoubleClass || element == compiler.doubleClass) {
       if (nativeCheckOnly) return null;
@@ skipping 105 matching lines @@
   }
 
   Element getExceptionUnwrapper() {
     return compiler.findHelper(const SourceString('unwrapException'));
   }
 
   Element getThrowRuntimeError() {
     return compiler.findHelper(const SourceString('throwRuntimeError'));
   }
 
-  Element getThrowMalformedSubtypeError() {
-    return compiler.findHelper(
-        const SourceString('throwMalformedSubtypeError'));
-  }
-
   Element getThrowAbstractClassInstantiationError() {
     return compiler.findHelper(
         const SourceString('throwAbstractClassInstantiationError'));
   }
 
   Element getStringInterpolationHelper() {
     return compiler.findHelper(const SourceString('S'));
   }
 
   Element getWrapExceptionHelper() {
@@ skipping 213 matching lines @@
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }