Enable full type-checks in checked mode.

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;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 1204 matching lines @@
 
   void registerTypeVariableExpression(TreeElements elements) {
     registerRuntimeType(elements);
     enqueueInResolution(getRuntimeTypeToString(), elements);
     enqueueInResolution(getCreateRuntimeType(), elements);
   }
 
   void registerIsCheck(DartType type, Enqueuer world, TreeElements elements) {
     world.registerInstantiatedClass(compiler.boolClass, elements);
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
+    bool isCheckedMode = compiler.enableTypeAssertions;

[ngeoffray, 2013/05/13 09:10:59]

isCheckedMode -> inCheckedMode ?

[karlklose, 2013/05/14 13:49:41]

Done.

     if (!type.isRaw || isTypeVariable) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
+      if (isCheckedMode) {
+        enqueueInResolution(getAssertSubtype(), elements);
+      }
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
-        enqueueInResolution(getGetObjectIsSubtype(), elements);
+        enqueueInResolution(getObjectIsSubtype(), elements);
+        if (isCheckedMode) {
+          enqueueInResolution(getAssertObjectIsSubtype(), elements);
+        }
       }
       world.registerInstantiatedClass(compiler.listClass, elements);
     }
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
-    if (compiler.enableTypeAssertions) {
+    if (isCheckedMode) {
       Element e = getCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
       // We also need the native variant of the check (for DOM types).
       e = getNativeCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
     }
     if (type.element.isNative()) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
@@ skipping 65 matching lines @@
       });
     }
     // TODO(ngeoffray): Also handle T a (in checked mode).
   }
 
   void registerClassUsingVariableExpression(ClassElement cls) {
     rti.classesUsingTypeVariableExpression.add(cls);
   }
 
   bool needsRti(ClassElement cls) {
-    return rti.classesNeedingRti.contains(cls.declaration)
-        || compiler.enabledRuntimeType;
+    return rti.classesNeedingRti.contains(cls.declaration) ||
+        compiler.enabledRuntimeType ||
+        (compiler.enableTypeAssertions && !cls.typeVariables.isEmpty);

[ngeoffray, 2013/05/13 09:10:59]

Why would a class with type variable need rti? What if the type variable is
never used?

Also, maybe make the code a bit simpler to comment on, like:

// A class that has type variables always needs RTI.
if (compiler.enableTypeAssertions && !cls.typesVariables.isEmpty) return true;
...

[karlklose, 2013/05/14 13:49:41]

Removed, it was not necessary.

   }
 
   bool isDefaultNoSuchMethodImplementation(Element element) {
     assert(element.name == Compiler.NO_SUCH_METHOD);
     ClassElement classElement = element.getEnclosingClass();
     return classElement == compiler.objectClass
         || classElement == jsInterceptorClass;
   }
 
   bool isDefaultEqualityImplementation(Element element) {
@@ skipping 244 matching lines @@
     }
   }
 
   /**
    * Returns the checked mode helper that will be needed to do a type check/type
    * cast on [type] at runtime. Note that this method is being called both by
    * the resolver with interface types (int, String, ...), and by the SSA
    * backend with implementation types (JSInt, JSString, ...).
    */
   Element getCheckedModeHelper(DartType type, {bool typeCast}) {
-    return compiler.findHelper(getCheckedModeHelperName(
-        type, typeCast: typeCast, nativeCheckOnly: false));
+    SourceString name = getCheckedModeHelperName(
+        type, typeCast: typeCast, nativeCheckOnly: false);
+    return compiler.findHelper(name);
   }
 
   /**
    * Returns the native checked mode helper that will be needed to do a type
    * check/type cast on [type] at runtime. If no native helper exists for
    * [type], [:null:] is returned.
    */
   Element getNativeCheckedModeHelper(DartType type, {bool typeCast}) {
     SourceString sourceName = getCheckedModeHelperName(
         type, typeCast: typeCast, nativeCheckOnly: true);
@@ skipping 84 matching lines @@
           return typeCast
               ? const SourceString("listSuperNativeTypeCast")
               : const SourceString('listSuperNativeTypeCheck');
         } else {
           return typeCast
               ? const SourceString("listSuperTypeCast")
               : const SourceString('listSuperTypeCheck');
         }
       } else {
         if (nativeCheck) {
+          // TODO(karlklose): can we get rid of this branch when we use
+          // interceptors?
           return typeCast
               ? const SourceString("interceptedTypeCast")
               : const SourceString('interceptedTypeCheck');
         } else {
-          return typeCast
-              ? const SourceString("propertyTypeCast")
-              : const SourceString('propertyTypeCheck');
+          if (typeCast) {
+            return const SourceString("propertyTypeCast");
+          }
+          if (type.kind == TypeKind.INTERFACE && !type.isRaw) {
+            return const SourceString('assertSubtype');
+          } else if (type.kind == TypeKind.TYPE_VARIABLE) {
+            return const SourceString('assertObjectIsSubtype');

[ngeoffray, 2013/05/13 09:10:59]

Why is that called assertObjectIsSubtype? For me it's a confusing name,
shouldn't it be called assertIsSubtypeOfTypeVariable?

[karlklose, 2013/05/14 13:49:41]

I renamed the functions.

+          } else {
+            return const SourceString('propertyTypeCheck');
+          }
         }
       }
     }
   }
 
   void dumpInferredTypes() {
     print("Inferred argument types:");
     print("------------------------");
     argumentTypes.dump();
     print("");
@@ skipping 62 matching lines @@
   }
 
   Element getRuntimeTypeToString() {
     return compiler.findHelper(const SourceString('runtimeTypeToString'));
   }
 
   Element getCheckSubtype() {
     return compiler.findHelper(const SourceString('checkSubtype'));
   }
 
-  Element getGetObjectIsSubtype() {
+  Element getAssertSubtype() {
+    return compiler.findHelper(const SourceString('assertSubtype'));
+  }
+
+  Element getObjectIsSubtype() {
     return compiler.findHelper(const SourceString('objectIsSubtype'));
   }
 
+  Element getAssertObjectIsSubtype() {
+    return compiler.findHelper(const SourceString('assertObjectIsSubtype'));
+  }
+
   Element getThrowNoSuchMethod() {
     return compiler.findHelper(const SourceString('throwNoSuchMethod'));
   }
 
   Element getCreateRuntimeType() {
     return compiler.findHelper(const SourceString('createRuntimeType'));
   }
 
   Element getFallThroughError() {
     return compiler.findHelper(const SourceString("getFallThroughError"));
@@ skipping 32 matching lines @@
   ClassElement get constListImplementation => jsArrayClass;
   ClassElement get fixedListImplementation => jsFixedArrayClass;
   ClassElement get growableListImplementation => jsExtendableArrayClass;
   ClassElement get mapImplementation => mapLiteralClass;
   ClassElement get constMapImplementation => constMapLiteralClass;
   ClassElement get functionImplementation => jsFunctionClass;
   ClassElement get typeImplementation => typeLiteralClass;
   ClassElement get boolImplementation => jsBoolClass;
   ClassElement get nullImplementation => jsNullClass;
 }