Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/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.
 
 library js_backend.backend;
 
 import 'dart:async' show Future;
 
 import 'package:js_runtime/shared/embedded_names.dart' as embeddedNames;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/backend_api.dart'
     show
         Backend,
         BackendClasses,
         ImpactTransformer,
         ForeignResolver,
         NativeRegistry;
 import '../common/codegen.dart' show CodegenImpact, CodegenWorkItem;
-import '../common/names.dart' show Identifiers, Selectors, Uris;
+import '../common/names.dart' show Identifiers, Uris;
 import '../common/resolution.dart' show Frontend, Resolution, ResolutionImpact;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CoreClasses, CoreTypes;
+import '../core_types.dart' show CommonElements, CoreClasses, CoreTypes;
 import '../dart_types.dart';
 import '../deferred_load.dart' show DeferredLoadTask;
 import '../dump_info.dart' show DumpInfoTask;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../enqueue.dart'
     show Enqueuer, ResolutionEnqueuer, TreeShakingEnqueuerStrategy;
 import '../io/position_information.dart' show PositionSourceInformationStrategy;
 import '../io/source_information.dart' show SourceInformationStrategy;
 import '../io/start_end_information.dart'
@@ skipping 551 matching lines @@
     functionCompiler =
         new SsaFunctionCompiler(this, sourceInformationStrategy, useKernel);
     serialization = new JavaScriptBackendSerialization(this);
     backendClasses = new JavaScriptBackendClasses(helpers);
   }
 
   ConstantSystem get constantSystem => constants.constantSystem;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
+  CommonElements get commonElements => compiler.commonElements;
+
   CoreClasses get coreClasses => compiler.coreClasses;
 
   CoreTypes get coreTypes => compiler.coreTypes;
 
   Resolution get resolution => compiler.resolution;
 
   /// Returns constant environment for the JavaScript interpretation of the
   /// constants.
   JavaScriptConstantCompiler get constants {
     return constantCompilerTask.jsConstantCompiler;
@@ skipping 665 matching lines @@
     if (TRACE_CALLS) {
       impactTransformer.registerBackendImpact(
           impactBuilder, impacts.traceHelper);
     }
     impactTransformer.registerBackendImpact(
         impactBuilder, impacts.assertUnreachable);
     _registerCheckedModeHelpers(impactBuilder);
     return impactBuilder;
   }
 
-  onResolutionComplete(ClosedWorldRefiner closedWorldRefiner) {
+  onResolutionComplete(
+      ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (Entity entity in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(entity, closedWorldRefiner);
     }
-    super.onResolutionComplete(closedWorldRefiner);
-    computeMembersNeededForReflection();
-    rti.computeClassesNeedingRti();
+    computeMembersNeededForReflection(closedWorld);
+    rti.computeClassesNeedingRti(
+        compiler.enqueuer.resolution.universe, closedWorld);
     _registeredMetadata.clear();
   }
 
   onTypeInferenceComplete() {
     super.onTypeInferenceComplete();
     noSuchMethodRegistry.onTypeInferenceComplete();
   }
 
   WorldImpact registerCallMethodWithFreeTypeVariables(Element callMethod,
       {bool forResolution}) {
@@ skipping 345 matching lines @@
         element == coreClasses.boolClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'boolTypeCast' : 'boolTypeCheck';
     } else if (element == helpers.jsIntClass ||
         element == coreClasses.intClass ||
         element == helpers.jsUInt32Class ||
         element == helpers.jsUInt31Class ||
         element == helpers.jsPositiveIntClass) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'intTypeCast' : 'intTypeCheck';
-    } else if (Elements.isNumberOrStringSupertype(element, compiler)) {
+    } else if (Elements.isNumberOrStringSupertype(element, commonElements)) {
       if (nativeCheck) {
         return typeCast
             ? 'numberOrStringSuperNativeTypeCast'
             : 'numberOrStringSuperNativeTypeCheck';
       } else {
         return typeCast
             ? 'numberOrStringSuperTypeCast'
             : 'numberOrStringSuperTypeCheck';
       }
-    } else if (Elements.isStringOnlySupertype(element, compiler)) {
+    } else if (Elements.isStringOnlySupertype(element, commonElements)) {
       if (nativeCheck) {
         return typeCast
             ? 'stringSuperNativeTypeCast'
             : 'stringSuperNativeTypeCheck';
       } else {
         return typeCast ? 'stringSuperTypeCast' : 'stringSuperTypeCheck';
       }
     } else if ((element == coreClasses.listClass ||
             element == helpers.jsArrayClass) &&
         type.treatAsRaw) {
       if (nativeCheckOnly) return null;
       return typeCast ? 'listTypeCast' : 'listTypeCheck';
     } else {
-      if (Elements.isListSupertype(element, compiler)) {
+      if (Elements.isListSupertype(element, commonElements)) {
         if (nativeCheck) {
           return typeCast
               ? 'listSuperNativeTypeCast'
               : 'listSuperNativeTypeCheck';
         } else {
           return typeCast ? 'listSuperTypeCast' : 'listSuperTypeCheck';
         }
       } else {
         if (type.isInterfaceType && !type.treatAsRaw) {
           return typeCast ? 'subtypeCast' : 'assertSubtype';
@@ skipping 326 matching lines @@
    * reflection.
    *
    * We have to precompute this set as we cannot easily answer the need for
    * reflection locally when looking at the member: We lack the information by
    * which classes a member is inherited. Called after resolution is complete.
    *
    * We filter out private libraries here, as their elements should not
    * be visible by reflection unless some other interfaces makes them
    * accessible.
    */
-  void computeMembersNeededForReflection() {
+  void computeMembersNeededForReflection(ClosedWorld closedWorld) {
     if (_membersNeededForReflection != null) return;
-    if (compiler.commonElements.mirrorsLibrary == null) {
+    if (closedWorld.commonElements.mirrorsLibrary == null) {
       _membersNeededForReflection = const ImmutableEmptySet<Element>();
       return;
     }
     // Compute a mapping from class to the closures it contains, so we
     // can include the correct ones when including the class.
     Map<ClassElement, List<LocalFunctionElement>> closureMap =
         new Map<ClassElement, List<LocalFunctionElement>>();
     for (LocalFunctionElement closure in compiler.resolverWorld.allClosures) {
       closureMap.putIfAbsent(closure.enclosingClass, () => []).add(closure);
     }
@@ skipping 21 matching lines @@
             memberNames.add(member.name);
             reflectableMembers.add(element);
             element.nestedClosures
                 .forEach((SynthesizedCallMethodElementX callFunction) {
               reflectableMembers.add(callFunction);
               reflectableMembers.add(callFunction.closureClass);
             });
           }
         });
         // 4) all overriding members of subclasses/subtypes (should be resolved)
-        if (compiler.closedWorld.hasAnyStrictSubtype(cls)) {
-          compiler.closedWorld.forEachStrictSubtypeOf(cls,
-              (ClassElement subcls) {
+        if (closedWorld.hasAnyStrictSubtype(cls)) {
+          closedWorld.forEachStrictSubtypeOf(cls, (ClassElement subcls) {
             subcls.forEachClassMember((Member member) {
               if (memberNames.contains(member.name)) {
                 // TODO(20993): find out why this assertion fails.
                 // assert(invariant(member.element,
                 //    resolution.hasBeenProcessed(member.element)));
                 if (resolution.hasBeenProcessed(member.element)) {
                   reflectableMembers.add(member.element);
                 }
               }
             });
@@ skipping 58 matching lines @@
     // As we do not think about closures as classes, yet, we have to make sure
     // their superclasses are available for reflection manually.
     if (foundClosure) {
       reflectableMembers.add(helpers.closureClass);
     }
     Set<Element> closurizedMembers = compiler.resolverWorld.closurizedMembers;
     if (closurizedMembers.any(reflectableMembers.contains)) {
       reflectableMembers.add(helpers.boundClosureClass);
     }
     // Add typedefs.
-    reflectableMembers.addAll(
-        compiler.closedWorld.allTypedefs.where(referencedFromMirrorSystem));
+    reflectableMembers
+        .addAll(closedWorld.allTypedefs.where(referencedFromMirrorSystem));
     // Register all symbols of reflectable elements
     for (Element element in reflectableMembers) {
       symbolsUsed.add(element.name);
     }
     _membersNeededForReflection = reflectableMembers;
   }
 
   // TODO(20791): compute closure classes after resolution and move this code to
   // [computeMembersNeededForReflection].
   void maybeMarkClosureAsNeededForReflection(
@@ skipping 16 matching lines @@
     // chance of making the dispatch record access monomorphic.
     jsAst.PropertyAccess record =
         new jsAst.PropertyAccess(use2, dispatchProperty);
 
     List<jsAst.Expression> arguments = <jsAst.Expression>[use1, record];
     FunctionElement helper = helpers.isJsIndexable;
     jsAst.Expression helperExpression = emitter.staticFunctionAccess(helper);
     return new jsAst.Call(helperExpression, arguments);
   }
 
-  bool isTypedArray(TypeMask mask) {
-    // Just checking for [:TypedData:] is not sufficient, as it is an
-    // abstract class any user-defined class can implement. So we also
-    // check for the interface [JavaScriptIndexingBehavior].
-    ClassElement typedDataClass = compiler.commonElements.typedDataClass;
-    return typedDataClass != null &&
-        compiler.closedWorld.isInstantiated(typedDataClass) &&
-        mask.satisfies(typedDataClass, compiler.closedWorld) &&
-        mask.satisfies(
-            helpers.jsIndexingBehaviorInterface, compiler.closedWorld);
-  }
-
-  bool couldBeTypedArray(TypeMask mask) {
-    bool intersects(TypeMask type1, TypeMask type2) =>
-        !type1.intersection(type2, compiler.closedWorld).isEmpty;
-    // TODO(herhut): Maybe cache the TypeMask for typedDataClass and
-    //               jsIndexingBehaviourInterface.
-    ClassElement typedDataClass = compiler.commonElements.typedDataClass;
-    return typedDataClass != null &&
-        compiler.closedWorld.isInstantiated(typedDataClass) &&
-        intersects(
-            mask, new TypeMask.subtype(typedDataClass, compiler.closedWorld)) &&
-        intersects(
-            mask,
-            new TypeMask.subtype(
-                helpers.jsIndexingBehaviorInterface, compiler.closedWorld));
-  }
-
   /// Returns all static fields that are referenced through [targetsUsed].
   /// If the target is a library or class all nested static fields are
   /// included too.
   Iterable<Element> _findStaticFieldTargets() {
     List staticFields = [];
 
     void addFieldsInContainer(ScopeContainerElement container) {
       container.forEachLocalMember((Element member) {
         if (!member.isInstanceMember && member.isField) {
           staticFields.add(member);
@@ skipping 994 matching lines @@
   ClassElement get typeImplementation => helpers.typeLiteralClass;
   ClassElement get boolImplementation => helpers.jsBoolClass;
   ClassElement get nullImplementation => helpers.jsNullClass;
   ClassElement get syncStarIterableImplementation => helpers.syncStarIterable;
   ClassElement get asyncFutureImplementation => helpers.futureImplementation;
   ClassElement get asyncStarStreamImplementation => helpers.controllerStream;
   ClassElement get functionImplementation => helpers.coreClasses.functionClass;
   ClassElement get indexableImplementation => helpers.jsIndexableClass;
   ClassElement get mutableIndexableImplementation =>
       helpers.jsMutableIndexableClass;
+  ClassElement get indexingBehaviorImplementation =>
+      helpers.jsIndexingBehaviorInterface;
 
   bool isDefaultEqualityImplementation(Element element) {
     assert(element.name == '==');
     ClassElement classElement = element.enclosingClass;
     return classElement == helpers.coreClasses.objectClass ||
         classElement == helpers.jsInterceptorClass ||
         classElement == helpers.jsNullClass;
   }
+
+  @override
+  bool isInterceptorClass(ClassElement cls) {
+    return helpers.backend.isInterceptorClass(cls);
+  }
+
+  @override
+  bool isNative(Element element) {
+    return helpers.backend.isNative(element);
+  }
 }