Merge CoreTypes and CoreClasses into 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 EventSink, Future;
 
 import '../compiler_new.dart' as api;
 import 'cache_strategy.dart' show CacheStrategy;
 import 'closure.dart' as closureMapping show ClosureTask;
 import 'common/backend_api.dart' show Backend;
-import 'common/codegen.dart' show CodegenWorkItem;
 import 'common/names.dart' show Selectors;
 import 'common/names.dart' show Identifiers, Uris;
 import 'common/resolution.dart'
     show
         ParsingContext,
         Resolution,
         ResolutionWorkItem,
         ResolutionImpact,
         Target;
 import 'common/tasks.dart' show CompilerTask, GenericTask, Measurer;
 import 'common/work.dart' show WorkItem;
 import 'common.dart';
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
-import 'core_types.dart' show CoreClasses, CommonElements, CoreTypes;
+import 'core_types.dart' show CommonElements;
 import 'dart_types.dart' show DartType, DynamicType, InterfaceType, Types;
 import 'deferred_load.dart' show DeferredLoadTask;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show DiagnosticReporter;
 import 'diagnostics/invariant.dart' show REPORT_EXCESS_RESOLUTION;
 import 'diagnostics/messages.dart' show Message, MessageTemplate;
 import 'dump_info.dart' show DumpInfoTask;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show ErroneousElementX;
 import 'enqueue.dart' show Enqueuer, EnqueueTask, ResolutionEnqueuer;
@@ skipping 44 matching lines @@
 typedef Backend MakeBackendFunction(Compiler compiler);
 
 typedef CompilerDiagnosticReporter MakeReporterFunction(
     Compiler compiler, CompilerOptions options);
 
 abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
   Types types;
-  _CompilerCoreTypes _coreTypes;
+  _CompilerCommonElements _commonElements;
   CompilerDiagnosticReporter _reporter;
   CompilerResolution _resolution;
   ParsingContext _parsingContext;
 
   final CacheStrategy cacheStrategy;
 
   ImpactStrategy impactStrategy = const ImpactStrategy();
 
   /**
    * Map from token to the first preceding comment token.
@@ skipping 22 matching lines @@
   api.CompilerOutput userOutputProvider;
 
   List<Uri> librariesToAnalyzeWhenRun;
 
   ResolvedUriTranslator get resolvedUriTranslator;
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   DiagnosticReporter get reporter => _reporter;
-  CommonElements get commonElements => _coreTypes;
-  CoreClasses get coreClasses => _coreTypes;
-  CoreTypes get coreTypes => _coreTypes;
+  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<Element, List<DiagnosticMessage>> elementsWithCompileTimeErrors =
       new Map<Element, List<DiagnosticMessage>>();
 
   final Environment environment;
@@ skipping 54 matching lines @@
         this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput()
             : outputProvider {
     if (makeReporter != null) {
       _reporter = makeReporter(this, options);
     } else {
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
     _resolution = createResolution();
-    // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
-    // make its field final.
-    _coreTypes = new _CompilerCoreTypes(_resolution, reporter);
+    _commonElements = new _CompilerCommonElements(_resolution, reporter);
     types = new Types(_resolution);
 
     if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies = new GlobalDependencyRegistry();
 
@@ skipping 113 matching lines @@
         });
       });
 
   /// This method is called immediately after the [LibraryElement] [library] has
   /// been created.
   ///
   /// Use this callback method to store references to specific libraries.
   /// Note that [library] has not been scanned yet, nor has its imports/exports
   /// been resolved.
   void onLibraryCreated(LibraryElement library) {
-    _coreTypes.onLibraryCreated(library);
+    _commonElements.onLibraryCreated(library);
     backend.onLibraryCreated(library);
   }
 
   /// This method is called immediately after the [library] and its parts have
   /// been scanned.
   ///
   /// Use this callback method to store references to specific member declared
   /// in certain libraries. Note that [library] has not been patched yet, nor
   /// has its imports/exports been resolved.
   ///
@@ skipping 760 matching lines @@
     return userOutputProvider.createEventSink(name, extension);
   }
 }
 
 /// Information about suppressed warnings and hints for a given library.
 class SuppressionInfo {
   int warnings = 0;
   int hints = 0;
 }
 
-class _CompilerCoreTypes implements CoreTypes, CoreClasses, CommonElements {
+class _CompilerCommonElements implements CommonElements {
   final Resolution resolution;
   final DiagnosticReporter reporter;
 
   LibraryElement coreLibrary;
   LibraryElement asyncLibrary;
   LibraryElement mirrorsLibrary;
   LibraryElement typedDataLibrary;
 
   // TODO(sigmund): possibly move this to target-specific collection of
   // elements, or refactor the library so that the helpers we need are in a
   // target-agnostic place.  Currently we are using @patch and @Native from
   // here. We hope we can make those independent of the backend and generic
   // enough so the patching algorithm can work without being configured for a
   // specific backend.
   LibraryElement jsHelperLibrary;
 
-  _CompilerCoreTypes(this.resolution, this.reporter);
+  _CompilerCommonElements(this.resolution, this.reporter);
 
   // From dart:core
 
   ClassElement _objectClass;
   ClassElement get objectClass =>
       _objectClass ??= _findRequired(coreLibrary, 'Object');
 
   ClassElement _boolClass;
   ClassElement get boolClass =>
       _boolClass ??= _findRequired(coreLibrary, 'bool');
@@ skipping 749 matching lines @@
 
   CompilerResolution(this._compiler);
 
   @override
   DiagnosticReporter get reporter => _compiler.reporter;
 
   @override
   ParsingContext get parsingContext => _compiler.parsingContext;
 
   @override
-  CoreClasses get coreClasses => _compiler.coreClasses;
-
-  @override
-  CoreTypes get coreTypes => _compiler.coreTypes;
-
-  @override
   CommonElements get commonElements => _compiler.commonElements;
 
   @override
   Types get types => _compiler.types;
 
   @override
   Target get target => _compiler.backend;
 
   @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;
 
   @override
-  LibraryElement get coreLibrary => _compiler._coreTypes.coreLibrary;
+  LibraryElement get coreLibrary => _compiler._commonElements.coreLibrary;
 
   @override
   bool get wasProxyConstantComputedTestingOnly => _proxyConstant != null;
 
   @override
   void registerClass(ClassElement cls) {
     enqueuer.universe.registerClass(cls);
   }
 
   @override
@@ skipping 258 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;
 }