Remove Compiler.commonElements

pkg/compiler/lib/src/compiler.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 dart2js.compiler_base;
 
 import 'dart:async' show Future;
 
 import '../compiler_new.dart' as api;
 import 'backend_strategy.dart';
@@ skipping 70 matching lines @@
 typedef CompilerDiagnosticReporter MakeReporterFunction(
     Compiler compiler, CompilerOptions options);
 
 abstract class Compiler {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
   DartTypes types;
   FrontendStrategy frontendStrategy;
   BackendStrategy backendStrategy;
-  CommonElements _commonElements;
   ElementEnvironment _elementEnvironment;
   CompilerDiagnosticReporter _reporter;
   CompilerResolution _resolution;
   ParsingContext _parsingContext;
 
   ImpactStrategy impactStrategy = const ImpactStrategy();
 
   /**
    * Map from token to the first preceding comment token.
    */
@@ skipping 13 matching lines @@
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   ResolvedUriTranslator get resolvedUriTranslator;
 
   LibraryEntity mainApp;
   FunctionEntity mainFunction;
 
   DiagnosticReporter get reporter => _reporter;
   ElementEnvironment get elementEnvironment => _elementEnvironment;
-  CommonElements get commonElements => _commonElements;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
   // TODO(zarah): Remove this map and incorporate compile-time errors
   // in the model.
   /// Tracks elements with compile-time errors.
   final Map<Entity, List<DiagnosticMessage>> elementsWithCompileTimeErrors =
       new Map<Entity, List<DiagnosticMessage>>();
 
   final Environment environment;
@@ skipping 60 matching lines @@
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
     frontendStrategy = options.loadFromDill
         ? new KernelFrontEndStrategy(reporter, environment)
         : new ResolutionFrontEndStrategy(this);
     backendStrategy = options.loadFromDill
         ? new KernelBackendStrategy(this)
         : new ElementBackendStrategy(this);
     _resolution = createResolution();
     _elementEnvironment = frontendStrategy.elementEnvironment;
-    _commonElements = frontendStrategy.commonElements;
     types = new Types(_resolution);
 
     if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     backend = createBackend();
     enqueuer = backend.makeEnqueuer();
 
     tasks = [
@@ skipping 286 matching lines @@
   /// already created.
   ///
   /// During normal compilation resolution only started once, but through
   /// [analyzeUri] resolution is started repeatedly.
   ResolutionEnqueuer startResolution() {
     ResolutionEnqueuer resolutionEnqueuer;
     if (enqueuer.hasResolution) {
       resolutionEnqueuer = enqueuer.resolution;
     } else {
       resolutionEnqueuer = enqueuer.createResolutionEnqueuer();
-      backend.onResolutionStart(resolutionEnqueuer);
+      backend.onResolutionStart();
     }
     resolutionEnqueuer.addDeferredActions(libraryLoader.pullDeferredActions());
     return resolutionEnqueuer;
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries(LibraryEntity rootLibrary) =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         ResolutionEnqueuer resolutionEnqueuer = startResolution();
         WorldImpactBuilderImpl mainImpact = new WorldImpactBuilderImpl();
@@ skipping 33 matching lines @@
             resolutionEnqueuer
                 .applyImpact(computeImpactForLibrary(rootLibrary));
           }
           if (librariesToAnalyzeWhenRun != null) {
             for (Uri libraryUri in librariesToAnalyzeWhenRun) {
               resolutionEnqueuer.applyImpact(computeImpactForLibrary(
                   libraryLoader.lookupLibrary(libraryUri)));
             }
           }
         }
-        if (commonElements.mirrorsLibrary != null && !options.loadFromDill) {
+        if (frontendStrategy.commonElements.mirrorsLibrary != null &&
+            !options.loadFromDill) {
           // TODO(johnniwinther): Support mirrors from dill.
           resolveLibraryMetadata();
         }
         reporter.log('Resolving...');
 
         processQueue(resolutionEnqueuer, mainFunction, libraryLoader.libraries,
             onProgress: showResolutionProgress);
         backend.onResolutionEnd();
         resolutionEnqueuer.logSummary(reporter.log);
 
@@ skipping 131 matching lines @@
         }
       });
     }
     return impactBuilder;
   }
 
   // Resolves metadata on library elements.  This is necessary in order to
   // resolve metadata classes referenced only from metadata on library tags.
   // TODO(ahe): Figure out how to do this lazily.
   void resolveLibraryMetadata() {
-    assert(commonElements.mirrorsLibrary != null);
+    assert(frontendStrategy.commonElements.mirrorsLibrary != null);
     for (LibraryElement library in libraryLoader.libraries) {
       if (library.metadata != null) {
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
@@ skipping 561 matching lines @@
 
   CompilerResolution(this._compiler);
 
   @override
   DiagnosticReporter get reporter => _compiler.reporter;
 
   @override
   ParsingContext get parsingContext => _compiler.parsingContext;
 
   @override
-  CommonElements get commonElements => _compiler.commonElements;
+  CommonElements get commonElements =>
+      _compiler.frontendStrategy.commonElements;
 
   @override
   Types get types => _compiler.types;
 
   @override
   Target get target => _compiler.backend.target;
 
   @override
   ResolverTask get resolver => _compiler.resolver;
 
   @override
   ResolutionEnqueuer get enqueuer => _compiler.enqueuer.resolution;
 
   @override
   CompilerOptions get options => _compiler.options;
 
   @override
   IdGenerator get idGenerator => _compiler.idGenerator;
 
   @override
   ConstantEnvironment get constants => _compiler.constants;
 
   @override
   MirrorUsageAnalyzerTask get mirrorUsageAnalyzerTask =>
       _compiler.mirrorUsageAnalyzerTask;
 
-  LibraryElement get coreLibrary => _compiler._commonElements.coreLibrary;
+  LibraryElement get coreLibrary =>
+      _compiler.frontendStrategy.commonElements.coreLibrary;
 
   @override
   bool get wasProxyConstantComputedTestingOnly => _proxyConstant != null;
 
   @override
   void registerClass(ClassElement cls) {
     enqueuer.worldBuilder.registerClass(cls);
   }
 
   @override
@@ skipping 243 matching lines @@
   _ElementScanner(this.scanner);
   void scanLibrary(LibraryElement library) => scanner.scanLibrary(library);
   void scanUnit(CompilationUnitElement unit) => scanner.scan(unit);
 }
 
 class _EmptyEnvironment implements Environment {
   const _EmptyEnvironment();
 
   String valueOf(String key) => null;
 }