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 {

[karlklose, 2013/07/19 11:45:40]

This should be AmbiguousTypeCheckedModeHelper.

[Johnni Winther, 2013/07/29 09:59:48]

Done.

   const MalformedCheckedModeHelper(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('$type'));
     // TODO(johnniwinther): Handle escaping correctly.
     arguments.add(js.string(reasons));
   }
 }
 
 
 class JavaScriptBackend extends Backend {
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 671 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 SourceString('malformedTypeCast'))
           : const MalformedCheckedModeHelper(
               const SourceString('malformedTypeCheck'));
     } else if (type == compiler.types.voidType) {
       assert(!typeCast); // Cannot cast to void.
@@ skipping 354 matching lines @@
   }
 }
 
 /// Records that [type] is used by [user.element].
 class Dependency {
   final DartType type;
   final TreeElements user;
 
   const Dependency(this.type, this.user);
 }