Remove Compiler.commonElements

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 '../common.dart';
 import '../common/backend_api.dart'
     show ForeignResolver, NativeRegistry, ImpactTransformer;
 import '../common/codegen.dart' show CodegenWorkItem;
@@ skipping 296 matching lines @@
 }
 
 class JavaScriptBackend {
   static const String JS = 'JS';
   static const String JS_BUILTIN = 'JS_BUILTIN';
   static const String JS_EMBEDDED_GLOBAL = 'JS_EMBEDDED_GLOBAL';
   static const String JS_INTERCEPTOR_CONSTANT = 'JS_INTERCEPTOR_CONSTANT';
 
   final Compiler compiler;
 
+  FrontendStrategy get frontendStrategy => compiler.frontendStrategy;
+
   /// Returns true if the backend supports reflection.
   bool get supportsReflection => emitter.supportsReflection;
 
   final OptimizerHintsForTests optimizerHints;
 
   FunctionCompiler functionCompiler;
 
   CodeEmitterTask emitter;
 
   /**
@@ skipping 117 matching lines @@
   Tracer tracer;
 
   JavaScriptBackend(this.compiler,
       {bool generateSourceMap: true,
       bool useStartupEmitter: false,
       bool useMultiSourceInfo: false,
       bool useNewSourceInfo: false,
       bool useKernel: false})
       : _rti = new RuntimeTypesImpl(
             compiler.elementEnvironment, compiler.frontendStrategy.dartTypes),
-        optimizerHints = new OptimizerHintsForTests(
-            compiler.elementEnvironment, compiler.commonElements),
+        optimizerHints = new OptimizerHintsForTests(compiler.elementEnvironment,
+            compiler.frontendStrategy.commonElements),
         this.sourceInformationStrategy =
             compiler.backendStrategy.sourceInformationStrategy,
         constantCompilerTask = new JavaScriptConstantTask(compiler),
         _nativeDataResolver = new NativeDataResolverImpl(compiler),
         _rtiNeedBuilder =
             compiler.frontendStrategy.createRuntimeTypesNeedBuilder() {
     CommonElements commonElements = compiler.frontendStrategy.commonElements;
     _target = new JavaScriptBackendTarget(this);
     impacts = new BackendImpacts(compiler.options, commonElements);
     _mirrorsData = compiler.frontendStrategy.createMirrorsDataBuilder();
@@ skipping 211 matching lines @@
         !mirrorsData.invokedReflectively(method);
   }
 
   bool operatorEqHandlesNullArgument(FunctionEntity operatorEqfunction) {
     return specialOperatorEqClasses.contains(operatorEqfunction.enclosingClass);
   }
 
   void validateInterceptorImplementsAllObjectMethods(
       ClassEntity interceptorClass) {
     if (interceptorClass == null) return;
-    ClassEntity objectClass = compiler.commonElements.objectClass;
-    compiler.elementEnvironment.forEachClassMember(objectClass,
+    ClassEntity objectClass = frontendStrategy.commonElements.objectClass;
+    frontendStrategy.elementEnvironment.forEachClassMember(objectClass,
         (_, MemberEntity member) {
       if (member.isConstructor) return;
-      MemberEntity interceptorMember = compiler.elementEnvironment
+      MemberEntity interceptorMember = frontendStrategy.elementEnvironment
           .lookupClassMember(interceptorClass, member.name);
       // Interceptors must override all Object methods due to calling convention
       // differences.
       assert(
           interceptorMember.enclosingClass == interceptorClass,
           failedAt(
               interceptorMember,
               "Member ${member.name} not overridden in ${interceptorClass}. "
               "Found $interceptorMember from "
               "${interceptorMember.enclosingClass}."));
     });
   }
 
   /// Called before processing of the resolution queue is started.
-  void onResolutionStart(ResolutionEnqueuer enqueuer) {
+  void onResolutionStart() {
     // TODO(johnniwinther): Avoid the compiler.elementEnvironment.getThisType
     // calls. Currently needed to ensure resolution of the classes for various
     // queries in native behavior computation, inference and codegen.
-    compiler.elementEnvironment
-        .getThisType(compiler.commonElements.jsArrayClass);
-    compiler.elementEnvironment
-        .getThisType(compiler.commonElements.jsExtendableArrayClass);
+    frontendStrategy.elementEnvironment
+        .getThisType(frontendStrategy.commonElements.jsArrayClass);
+    frontendStrategy.elementEnvironment
+        .getThisType(frontendStrategy.commonElements.jsExtendableArrayClass);
 
     validateInterceptorImplementsAllObjectMethods(
-        compiler.commonElements.jsInterceptorClass);
+        frontendStrategy.commonElements.jsInterceptorClass);
     // The null-interceptor must also implement *all* methods.
     validateInterceptorImplementsAllObjectMethods(
-        compiler.commonElements.jsNullClass);
+        frontendStrategy.commonElements.jsNullClass);
   }
 
   /// Called when the resolution queue has been closed.
   void onResolutionEnd() {
-    compiler.frontendStrategy.annotationProcesser
+    frontendStrategy.annotationProcesser
         .processJsInteropAnnotations(nativeBasicData, nativeDataBuilder);
   }
 
   /// Called when the closed world from resolution has been computed.
   void onResolutionClosedWorld(
       ClosedWorld closedWorld, ClosedWorldRefiner closedWorldRefiner) {
     for (MemberEntity entity
         in compiler.enqueuer.resolution.processedEntities) {
       processAnnotations(
           closedWorld.commonElements, entity, closedWorldRefiner);
@@ skipping 234 matching lines @@
         'count': mirrorCount,
         'total': totalMethodCount,
         'percentage': percentage.round()
       });
 
       List<DiagnosticMessage> infos = <DiagnosticMessage>[];
       for (LibraryElement library in compiler.libraryLoader.libraries) {
         if (library.isInternalLibrary) continue;
         for (ImportElement import in library.imports) {
           LibraryElement importedLibrary = import.importedLibrary;
-          if (importedLibrary != compiler.commonElements.mirrorsLibrary)
+          if (importedLibrary != closedWorld.commonElements.mirrorsLibrary)
             continue;
           MessageKind kind =
               compiler.mirrorUsageAnalyzerTask.hasMirrorUsage(library)
                   ? MessageKind.MIRROR_IMPORT
                   : MessageKind.MIRROR_IMPORT_NO_USAGE;
           reporter.withCurrentElement(library, () {
             infos.add(reporter.createMessage(import, kind));
           });
         }
       }
@@ skipping 395 matching lines @@
 
   bool canUseAliasedSuperMember(MemberEntity member, Selector selector) {
     return !selector.isGetter;
   }
 
   /// Returns `true` if [member] is called from a subclass via `super`.
   bool isAliasedSuperMember(MemberEntity member) {
     return _aliasedSuperMembers.contains(member);
   }
 }