Make test of malformed types a dynamic type error.

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 = new Set<HInstruction>();
   final Set<HInstruction> allocatedFixedLists = new Set<HInstruction>();
 }
@@ skipping 17 matching lines @@
     return new jsAst.Call(new jsAst.VariableUse(helperName), arguments);
   }
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
     // No additional arguments needed.
   }
 }
 
+class MalformedCheckedModeHelper extends CheckedModeHelper {
+  const MalformedCheckedModeHelper(String name) : super(name);
+
+  void generateAdditionalArguments(SsaCodeGenerator codegen,
+                                   HTypeConversion node,
+                                   List<jsAst.Expression> arguments) {
+    ErroneousElement element = node.typeExpression.element;
+    arguments.add(js.string(element.message));
+  }
+}
+
 class PropertyCheckedModeHelper extends CheckedModeHelper {
   const PropertyCheckedModeHelper(String name) : super(name);
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
                                    HTypeConversion node,
                                    List<jsAst.Expression> arguments) {
     DartType type = node.typeExpression;
     String additionalArgument = codegen.backend.namer.operatorIsType(type);
     arguments.add(js.string(additionalArgument));
   }
@@ skipping 283 matching lines @@
 
   /// List of elements that the backend may use.
   final Set<Element> helpersUsed = new Set<Element>();
 
 
   /// Set of typedefs that are used as type literals.
   final Set<TypedefElement> typedefTypeLiterals = new Set<TypedefElement>();
 
   /// All the checked mode helpers.
   static const checkedModeHelpers = const [
+      const MalformedCheckedModeHelper('checkMalformedType'),
       const CheckedModeHelper('voidTypeCheck'),
       const CheckedModeHelper('stringTypeCast'),
       const CheckedModeHelper('stringTypeCheck'),
       const CheckedModeHelper('doubleTypeCast'),
       const CheckedModeHelper('doubleTypeCheck'),
       const CheckedModeHelper('numTypeCast'),
       const CheckedModeHelper('numTypeCheck'),
       const CheckedModeHelper('boolTypeCast'),
       const CheckedModeHelper('boolTypeCheck'),
       const CheckedModeHelper('intTypeCast'),
@@ skipping 630 matching lines @@
           enqueue(world, helper.getElement(compiler), elements);
         }
         // We also need the native variant of the check (for DOM types).
         helper = getNativeCheckedModeHelper(type, typeCast: false);
         if (helper != null) {
           enqueue(world, helper.getElement(compiler), elements);
         }
       }
     }
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
+    if (type.kind == TypeKind.MALFORMED_TYPE) {
+      enqueueInResolution(getThrowTypeError(), elements);
+    }
     if (!type.treatAsRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), elements);
       }
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
@@ skipping 316 matching lines @@
     if (name == null) return null;
     CheckedModeHelper helper = checkedModeHelperByName[name];
     assert(helper != null);
     return helper;
   }
 
   String getCheckedModeHelperNameInternal(DartType type,
                                           {bool typeCast,
                                            bool nativeCheckOnly}) {
     assert(type.kind != TypeKind.TYPEDEF);
+    if (type.kind == TypeKind.MALFORMED_TYPE) {
+      // The same error is thrown for type test and type cast of a malformed
+      // type so we only need one check method.
+      return 'checkMalformedType';
+    }
     Element element = type.element;
     bool nativeCheck = nativeCheckOnly ||
         emitter.nativeEmitter.requiresNativeIsCheck(element);
 
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     nativeCheck = true;
 
     if (type == compiler.types.voidType) {
@@ skipping 524 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }