MalformedType used for all invalid type annotations.

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 1594 matching lines @@
     // TODO(ngeoffray): Type intercepted calls.
     if (node.isInterceptorCall) return defaultSelector;
     // If [JSInvocationMirror.invokeOn] has been called, we must not create a
     // typed selector based on the receiver type.
     if (node.element == null && // Invocation is not exact.
         backend.compiler.enabledInvokeOn) {
       return defaultSelector;
     }
     HType receiverHType = types[node.inputs[0]];
     DartType receiverType = receiverHType.computeType(compiler);
-    if (receiverType != null) {
+    if (receiverType != null &&
+        !identical(receiverType.kind, TypeKind.MALFORMED_TYPE)) {

[ngeoffray, 2012/12/05 15:43:46]

Is that important? If it's malformed, it will say yes to any subtype check,
right? So having a TypedSelector should be fine.

[Johnni Winther, 2012/12/05 18:33:51]

It is to make a distinction between List<SomeMalformedType> and
SomeMalformedType. In the first case we actually know as much as if the type was
List<dynamic> and we should use that, whereas in the latter case we know
nothing.

[ngeoffray, 2012/12/05 18:37:38]

What I'm trying to understand is whether that will lead to bad JS code being
generated (because of tree shaking on typed selectors), or it will lead to code
being better optimized. If it's the latter, then I would remove the check, since
a malformed program is not something we care about optimizing.

[Johnni Winther, 2012/12/05 19:11:20]

It's the latter.

       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     Selector setter = node.selector;
     String name = backend.namer.setterName(setter.library, setter.name);
@@ skipping 103 matching lines @@
         || node.element == backend.jsStringLength) {
       // We're accessing a native JavaScript property called 'length'
       // on a JS String or a JS array. Therefore, the name of that
       // property should not be mangled.
       push(new js.PropertyAccess.field(pop(), 'length'), node);
     } else {
       String name = _fieldPropertyName(node.element);
       push(new js.PropertyAccess.field(pop(), name), node);
       HType receiverHType = types[node.receiver];
       DartType type = receiverHType.computeType(compiler);
-      if (type != null) {
+      if (type != null && !identical(type.kind, TypeKind.MALFORMED_TYPE)) {

[ngeoffray, 2012/12/05 15:43:46]

ditto

         world.registerFieldGetter(
             node.element.name, node.element.getLibrary(), type);
       }
     }
   }
 
   visitFieldSet(HFieldSet node) {
     String name = _fieldPropertyName(node.element);
     DartType type = types[node.receiver].computeType(compiler);
-    if (type != null) {
+    if (type != null && !identical(type.kind, TypeKind.MALFORMED_TYPE)) {

[ngeoffray, 2012/12/05 15:43:46]

ditto

       // Field setters in the generative constructor body are handled in a
       // step "SsaConstructionFieldTypes" in the ssa optimizer.
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(
             node.element.name, node.element.getLibrary(), type);
         backend.registerFieldSetter(
             work.element, node.element, types[node.value]);
       }
     }
     use(node.receiver);
@@ skipping 313 matching lines @@
         backend.registerNonCallStaticUse(node);
         if (node.element.isFunction()) {
           world.registerInstantiatedClass(compiler.functionClass);
         }
       } else if (instr.target != node) {
         backend.registerNonCallStaticUse(node);
       }
     });
     Element element = node.element;
     world.registerStaticUse(element);
-    ClassElement cls = element.getEnclosingClass();    
+    ClassElement cls = element.getEnclosingClass();
     if (element.isGenerativeConstructor()
         || (element.isFactoryConstructor() && cls == compiler.listClass)) {
       world.registerInstantiatedClass(cls);
     }
     push(new js.VariableUse(backend.namer.isolateAccess(node.element)));
   }
 
   void visitLazyStatic(HLazyStatic node) {
     Element element = node.element;
     world.registerStaticUse(element);
@@ skipping 173 matching lines @@
     js.Expression functionTest = pop();
     checkObject(input, '===');
     js.Expression objectTest = pop();
     checkType(input, type);
     push(new js.Binary('||',
                        functionTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
+    assert(invariant(input, !type.isMalformed,
+                     message: 'Attempt to check malformed type $type'));
     world.registerIsCheck(type);
     Element element = type.element;
     use(input);
     js.PropertyAccess field =
         new js.PropertyAccess.field(pop(), backend.namer.operatorIs(element));
     if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
@@ skipping 133 matching lines @@
         arguments = arguments.tail;
       }
       push(result, node);
     }
     if (node.nullOk) {
       checkNull(input);
       push(new js.Binary('||', pop(), pop()), node);
     }
   }
 
+  // TODO(johnniwinther): Refactor this method.
   void visitTypeConversion(HTypeConversion node) {
     Map<String, SourceString> castNames = const <String, SourceString> {
       "stringTypeCheck":
           const SourceString("stringTypeCast"),
       "doubleTypeCheck":
           const SourceString("doubleTypeCast"),
       "numTypeCheck":
           const SourceString("numTypeCast"),
       "boolTypeCheck":
           const SourceString("boolTypeCast"),
@@ skipping 11 matching lines @@
           const SourceString("stringSuperTypeCast"),
       "listTypeCheck":
           const SourceString("listTypeCast"),
       "listSuperNativeTypeCheck":
           const SourceString("listSuperNativeTypeCast"),
       "listSuperTypeCheck":
           const SourceString("listSuperTypeCast"),
       "callTypeCheck":
           const SourceString("callTypeCast"),
       "propertyTypeCheck":
-          const SourceString("propertyTypeCast")
+          const SourceString("propertyTypeCast"),
+      // TODO(johnniwinther): Add a malformedTypeCast which produces a TypeError
+      // with another message.
+      "malformedTypeCheck":
+          const SourceString("malformedTypeCheck")
     };
 
     if (node.isChecked) {
       DartType type = node.type.computeType(compiler);
       Element element = type.element;
       world.registerIsCheck(type);
 
       if (node.isArgumentTypeCheck) {
         if (element == compiler.intClass) {
           checkInt(node.checkedInput, '!==');
@@ skipping 20 matching lines @@
         helper = backend.getCheckedModeHelper(type);
         if (node.isCastTypeCheck) {
           helper = castNames[helper.stringValue];
         }
       }
       FunctionElement helperElement = compiler.findHelper(helper);
       world.registerStaticUse(helperElement);
       List<js.Expression> arguments = <js.Expression>[];
       use(node.checkedInput);
       arguments.add(pop());
-      if (helperElement.computeSignature(compiler).parameterCount != 1) {
+      int parameterCount =
+          helperElement.computeSignature(compiler).parameterCount;
+      if (parameterCount == 2) {
+        // 2 arguments implies that the method is either [propertyTypeCheck]
+        // or [propertyTypeCast].
+        assert(!type.isMalformed);
         String additionalArgument = backend.namer.operatorIs(element);
         arguments.add(new js.LiteralString("'$additionalArgument'"));
+      } else if (parameterCount == 3) {
+        // 3 arguments implies that the method is [malformedTypeCheck].
+        assert(type.isMalformed);
+        String reasons = fetchReasonsFromMalformedType(type);
+        arguments.add(new js.LiteralString("'$type'"));
+        // TODO(johnniwinther): Handle escaping correctly.
+        arguments.add(new js.LiteralString("'$reasons'"));
+      } else {
+        assert(!type.isMalformed);
       }
       String helperName = backend.namer.isolateAccess(helperElement);
       push(new js.Call(new js.VariableUse(helperName), arguments));
     } else {
       use(node.checkedInput);
     }
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
@@ skipping 519 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }