Revert "Fix casts and type assertions on mixins used in native classes."

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 323 matching lines @@
   /// List of elements that the user has requested for reflection.
   final Set<Element> targetsUsed = new Set<Element>();
 
   /// List of annotations provided by user that indicate that the annotated
   /// element must be retained.
   final Set<Element> metaTargetsUsed = new Set<Element>();
 
   /// 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 CheckedModeHelper(const SourceString('voidTypeCheck')),
-      const CheckedModeHelper(const SourceString('stringTypeCast')),
-      const CheckedModeHelper(const SourceString('stringTypeCheck')),
-      const CheckedModeHelper(const SourceString('doubleTypeCast')),
-      const CheckedModeHelper(const SourceString('doubleTypeCheck')),
-      const CheckedModeHelper(const SourceString('numTypeCast')),
-      const CheckedModeHelper(const SourceString('numTypeCheck')),
-      const CheckedModeHelper(const SourceString('boolTypeCast')),
-      const CheckedModeHelper(const SourceString('boolTypeCheck')),
-      const CheckedModeHelper(const SourceString('intTypeCast')),
-      const CheckedModeHelper(const SourceString('intTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('numberOrStringSuperNativeTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('numberOrStringSuperNativeTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('numberOrStringSuperTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('numberOrStringSuperTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('stringSuperNativeTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('stringSuperNativeTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('stringSuperTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('stringSuperTypeCheck')),
-      const CheckedModeHelper(const SourceString('listTypeCast')),
-      const CheckedModeHelper(const SourceString('listTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('listSuperNativeTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('listSuperNativeTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('listSuperTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('listSuperTypeCheck')),
-      const PropertyCheckedModeHelper(
-          const SourceString('interceptedTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('interceptedTypeCheck')),
-      const SubtypeCheckedModeHelper(
-          const SourceString('subtypeCast')),
-      const SubtypeCheckedModeHelper(
-          const SourceString('assertSubtype')),
-      const TypeVariableCheckedModeHelper(
-          const SourceString('subtypeOfRuntimeTypeCast')),
-      const TypeVariableCheckedModeHelper(
-          const SourceString('assertSubtypeOfRuntimeType')),
-      const FunctionTypeCheckedModeHelper(
-          const SourceString('functionSubtypeCast')),
-      const FunctionTypeCheckedModeHelper(
-          const SourceString('assertFunctionSubtype')),
-      const PropertyCheckedModeHelper(
-          const SourceString('propertyTypeCast')),
-      const PropertyCheckedModeHelper(
-          const SourceString('propertyTypeCheck')) ];
-
-  // Checked mode helpers indexed by name.
-  Map<String, Checkedmodehelpers> checkedModeHelperByName =
-      new Map<String, CheckedModeHelper>.fromIterable(
-          checkedModeHelpers,
-          key: (helper) => helper.name.slowToString());
-
   JavaScriptBackend(Compiler compiler, bool generateSourceMap, bool disableEval)
       : namer = determineNamer(compiler),
         oneShotInterceptors = new Map<String, Selector>(),
         interceptedElements = new Map<SourceString, Set<Element>>(),
         rti = new RuntimeTypes(compiler),
         specializedGetInterceptors = new Map<String, Set<ClassElement>>(),
         super(compiler, JAVA_SCRIPT_CONSTANT_SYSTEM) {
     emitter = disableEval
         ? new CodeEmitterNoEvalTask(compiler, namer, generateSourceMap)
         : new CodeEmitterTask(compiler, namer, generateSourceMap);
@@ skipping 245 matching lines @@
       ClassElement cls, Enqueuer enqueuer) {
     if (enqueuer.isResolutionQueue) {
       cls.ensureResolved(compiler);
       cls.forEachMember((ClassElement classElement, Element member) {
         if (member.isSynthesized) return;
         // All methods on [Object] are shadowed by [Interceptor].
         if (classElement == compiler.objectClass) return;
         Set<Element> set = interceptedElements.putIfAbsent(
             member.name, () => new Set<Element>());
         set.add(member);
+        if (classElement == jsInterceptorClass) return;
+        if (classElement.isMixinApplication) {
+          MixinApplicationElement mixinApplication = classElement;
+          assert(member.getEnclosingClass() == mixinApplication.mixin);
+          classesMixedIntoNativeClasses.add(mixinApplication.mixin);
+        }
       },
       includeSuperAndInjectedMembers: true);
-
-      // Walk superclass chain to find mixins.
-      for (; cls != null; cls = cls.superclass) {
-        if (cls.isMixinApplication) {
-          MixinApplicationElement mixinApplication = cls;
-          classesMixedIntoNativeClasses.add(mixinApplication.mixin);
-        }
-      }
     }
   }
 
   void addInterceptors(ClassElement cls,
                        Enqueuer enqueuer,
                        TreeElements elements) {
     if (enqueuer.isResolutionQueue) {
       _interceptedClasses.add(jsInterceptorClass);
       _interceptedClasses.add(cls);
       cls.ensureResolved(compiler);
@@ skipping 140 matching lines @@
     addInterceptors(jsBoolClass, world, elements);
     addInterceptors(jsNullClass, world, elements);
     if (compiler.enableTypeAssertions) {
       // Unconditionally register the helper that checks if the
       // expression in an if/while/for is a boolean.
       // TODO(ngeoffray): Should we have the resolver register those instead?
       Element e =
           compiler.findHelper(const SourceString('boolConversionCheck'));
       if (e != null) enqueue(world, e, elements);
     }
-    registerCheckedModeHelpers(elements);
   }
 
   onResolutionComplete() => rti.computeClassesNeedingRti();
 
   void registerStringInterpolation(TreeElements elements) {
     enqueueInResolution(getStringInterpolationHelper(), elements);
   }
 
   void registerCatchStatement(Enqueuer enqueuer, TreeElements elements) {
     void ensure(ClassElement classElement) {
@@ skipping 82 matching lines @@
     enqueueInResolution(getCreateRuntimeType(), elements);
   }
 
   void registerIsCheck(DartType type, Enqueuer world, TreeElements elements) {
     type = type.unalias(compiler);
     enqueueClass(world, 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) {
-      if (!world.isResolutionQueue) {
-        // All helpers are added to resolution queue in enqueueHelpers. These
-        // calls to enqueueInResolution serve as assertions that the helper was
-        // in fact added.
-        // TODO(13155): Find a way to enqueue helpers lazily.
-        CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: false);
-        if (helper != null) {
-          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);
-        }
-      }
+      CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: false);
+      if (helper != null) 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.isRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       if (inCheckedMode) {
         enqueueInResolution(getAssertSubtype(), elements);
       }
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
         if (inCheckedMode) {
           enqueueInResolution(getAssertSubtypeOfRuntimeType(), elements);
         }
       }
       enqueueClass(world, compiler.listClass, elements);
     }
     if (type is FunctionType) {
       enqueueInResolution(getCheckFunctionSubtype(), elements);
     }
     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.
       enqueue(world,
               compiler.findHelper(const SourceString('defineProperty')),
               elements);
     }
-  }
+   }
 
-  void registerAsCheck(DartType type, Enqueuer world, TreeElements elements) {
+  void registerAsCheck(DartType type, TreeElements elements) {
     type = type.unalias(compiler);
-    if (!world.isResolutionQueue) {
-      // All helpers are added to resolution queue in enqueueHelpers. These
-      // calls to enqueueInResolution serve as assertions that the helper was in
-      // fact added.
-      // TODO(13155): Find a way to enqueue helpers lazily.
-      CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: true);
+    CheckedModeHelper helper = getCheckedModeHelper(type, typeCast: true);
+    enqueueInResolution(helper.getElement(compiler), elements);
+    // We also need the native variant of the check (for DOM types).
+    helper = getNativeCheckedModeHelper(type, typeCast: true);
+    if (helper != null) {
       enqueueInResolution(helper.getElement(compiler), elements);
-      // We also need the native variant of the check (for DOM types).
-      helper = getNativeCheckedModeHelper(type, typeCast: true);
-      if (helper != null) {
-        enqueueInResolution(helper.getElement(compiler), elements);
-      }
     }
   }
 
   void registerThrowNoSuchMethod(TreeElements elements) {
     enqueueInResolution(getThrowNoSuchMethod(), elements);
     // Also register the types of the arguments passed to this method.
     enqueueClass(compiler.enqueuer.resolution, compiler.listClass, elements);
     enqueueClass(compiler.enqueuer.resolution, compiler.stringClass, elements);
   }
 
@@ skipping 229 matching lines @@
         type, typeCast: typeCast, nativeCheckOnly: true);
   }
 
   /**
    * 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}) {
-    String name = getCheckedModeHelperNameInternal(type,
-        typeCast: typeCast, nativeCheckOnly: nativeCheckOnly);
-    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);
     Element element = type.element;
     bool nativeCheck = nativeCheckOnly ||
         emitter.nativeEmitter.requiresNativeIsCheck(element);
     if (type == compiler.types.voidType) {
       assert(!typeCast); // Cannot cast to void.
       if (nativeCheckOnly) return null;
-      return 'voidTypeCheck';
+      return const CheckedModeHelper(const SourceString('voidTypeCheck'));
     } else if (element == jsStringClass || element == compiler.stringClass) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'stringTypeCast'
-          : 'stringTypeCheck';
+          ? const CheckedModeHelper(const SourceString("stringTypeCast"))
+          : const CheckedModeHelper(const SourceString('stringTypeCheck'));
     } else if (element == jsDoubleClass || element == compiler.doubleClass) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'doubleTypeCast'
-          : 'doubleTypeCheck';
+          ? const CheckedModeHelper(const SourceString("doubleTypeCast"))
+          : const CheckedModeHelper(const SourceString('doubleTypeCheck'));
     } else if (element == jsNumberClass || element == compiler.numClass) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'numTypeCast'
-          : 'numTypeCheck';
+          ? const CheckedModeHelper(const SourceString("numTypeCast"))
+          : const CheckedModeHelper(const SourceString('numTypeCheck'));
     } else if (element == jsBoolClass || element == compiler.boolClass) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'boolTypeCast'
-          : 'boolTypeCheck';
+          ? const CheckedModeHelper(const SourceString("boolTypeCast"))
+          : const CheckedModeHelper(const SourceString('boolTypeCheck'));
     } else if (element == jsIntClass || element == compiler.intClass) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'intTypeCast'
-          : 'intTypeCheck';
+          ? const CheckedModeHelper(const SourceString("intTypeCast"))
+          : const CheckedModeHelper(const SourceString('intTypeCheck'));
     } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
       if (nativeCheck) {
         return typeCast
-            ? 'numberOrStringSuperNativeTypeCast'
-            : 'numberOrStringSuperNativeTypeCheck';
+            ? const PropertyCheckedModeHelper(
+                const SourceString("numberOrStringSuperNativeTypeCast"))
+            : const PropertyCheckedModeHelper(
+                const SourceString('numberOrStringSuperNativeTypeCheck'));
       } else {
         return typeCast
-          ? 'numberOrStringSuperTypeCast'
-          : 'numberOrStringSuperTypeCheck';
+          ? const PropertyCheckedModeHelper(
+              const SourceString("numberOrStringSuperTypeCast"))
+          : const PropertyCheckedModeHelper(
+              const SourceString('numberOrStringSuperTypeCheck'));
       }
     } else if (Elements.isStringOnlySupertype(element, compiler)) {
       if (nativeCheck) {
         return typeCast
-            ? 'stringSuperNativeTypeCast'
-            : 'stringSuperNativeTypeCheck';
+            ? const PropertyCheckedModeHelper(
+                const SourceString("stringSuperNativeTypeCast"))
+            : const PropertyCheckedModeHelper(
+                const SourceString('stringSuperNativeTypeCheck'));
       } else {
         return typeCast
-            ? 'stringSuperTypeCast'
-            : 'stringSuperTypeCheck';
+            ? const PropertyCheckedModeHelper(
+                const SourceString("stringSuperTypeCast"))
+            : const PropertyCheckedModeHelper(
+                const SourceString('stringSuperTypeCheck'));
       }
     } else if ((element == compiler.listClass || element == jsArrayClass) &&
                type.isRaw) {
       if (nativeCheckOnly) return null;
       return typeCast
-          ? 'listTypeCast'
-          : 'listTypeCheck';
+          ? const CheckedModeHelper(const SourceString("listTypeCast"))
+          : const CheckedModeHelper(const SourceString('listTypeCheck'));
     } else {
       if (Elements.isListSupertype(element, compiler)) {
         if (nativeCheck) {
           return typeCast
-              ? 'listSuperNativeTypeCast'
-              : 'listSuperNativeTypeCheck';
+              ? const PropertyCheckedModeHelper(
+                  const SourceString("listSuperNativeTypeCast"))
+              : const PropertyCheckedModeHelper(
+                  const SourceString('listSuperNativeTypeCheck'));
         } else {
           return typeCast
-              ? 'listSuperTypeCast'
-              : 'listSuperTypeCheck';
+              ? const PropertyCheckedModeHelper(
+                  const SourceString("listSuperTypeCast"))
+              : const PropertyCheckedModeHelper(
+                  const SourceString('listSuperTypeCheck'));
         }
       } else {
         if (nativeCheck) {
           // TODO(karlklose): can we get rid of this branch when we use
           // interceptors?
           return typeCast
-              ? 'interceptedTypeCast'
-              : 'interceptedTypeCheck';
+              ? const PropertyCheckedModeHelper(
+                  const SourceString("interceptedTypeCast"))
+              : const PropertyCheckedModeHelper(
+                  const SourceString('interceptedTypeCheck'));
         } else {
           if (type.kind == TypeKind.INTERFACE && !type.isRaw) {
             return typeCast
-                ? 'subtypeCast'
-                : 'assertSubtype';
+                ? const SubtypeCheckedModeHelper(
+                    const SourceString('subtypeCast'))
+                : const SubtypeCheckedModeHelper(
+                    const SourceString('assertSubtype'));
           } else if (type.kind == TypeKind.TYPE_VARIABLE) {
             return typeCast
-                ? 'subtypeOfRuntimeTypeCast'
-                : 'assertSubtypeOfRuntimeType';
+                ? const TypeVariableCheckedModeHelper(
+                    const SourceString('subtypeOfRuntimeTypeCast'))
+                : const TypeVariableCheckedModeHelper(
+                    const SourceString('assertSubtypeOfRuntimeType'));
           } else if (type.kind == TypeKind.FUNCTION) {
             return typeCast
-                ? 'functionSubtypeCast'
-                : 'assertFunctionSubtype';
+                ? const FunctionTypeCheckedModeHelper(
+                    const SourceString('functionSubtypeCast'))
+                : const FunctionTypeCheckedModeHelper(
+                    const SourceString('assertFunctionSubtype'));
           } else {
             return typeCast
-                ? 'propertyTypeCast'
-                : 'propertyTypeCheck';
+                ? const PropertyCheckedModeHelper(
+                    const SourceString('propertyTypeCast'))
+                : const PropertyCheckedModeHelper(
+                    const SourceString('propertyTypeCheck'));
           }
         }
       }
     }
   }
 
-  void registerCheckedModeHelpers(TreeElements elements) {
-    // We register all the helpers in the resolution queue.
-    // TODO(13155): Find a way to register fewer helpers.
-    for (CheckedModeHelper helper in checkedModeHelpers) {
-      enqueueInResolution(helper.getElement(compiler), elements);
-    }
-  }
-
   /**
    * Returns [:true:] if the checking of [type] is performed directly on the
    * object and not on an interceptor.
    */
   bool hasDirectCheckFor(DartType type) {
     Element element = type.element;
     return element == compiler.stringClass ||
         element == compiler.boolClass ||
         element == compiler.numClass ||
         element == compiler.intClass ||
@@ skipping 389 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }