Add CoreClasses

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;
 
@@ skipping 19 matching lines @@
     ResolutionWorkItem,
     ResolutionImpact;
 import 'common/tasks.dart' show
     CompilerTask,
     GenericTask;
 import 'common/work.dart' show
     WorkItem;
 import 'compile_time_constants.dart';
 import 'constants/values.dart';
 import 'core_types.dart' show
+    CoreClasses,
     CoreTypes;
 import 'dart_backend/dart_backend.dart' as dart_backend;
 import 'dart_types.dart' show
     DartType,
     DynamicType,
     InterfaceType,
     Types;
 import 'deferred_load.dart' show DeferredLoadTask, OutputUnit;
 import 'diagnostics/code_location.dart';
 import 'diagnostics/diagnostic_listener.dart' show
@@ skipping 223 matching lines @@
 
   LibraryElement mainApp;
   FunctionElement mainFunction;
 
   /// Initialized when dart:mirrors is loaded.
   LibraryElement mirrorsLibrary;
 
   /// Initialized when dart:typed_data is loaded.
   LibraryElement typedDataLibrary;
 
-  ClassElement get objectClass => _coreTypes.objectClass;
-  ClassElement get boolClass => _coreTypes.boolClass;
-  ClassElement get numClass => _coreTypes.numClass;
-  ClassElement get intClass => _coreTypes.intClass;
-  ClassElement get doubleClass => _coreTypes.doubleClass;
-  ClassElement get resourceClass => _coreTypes.resourceClass;
-  ClassElement get stringClass => _coreTypes.stringClass;
-  ClassElement get functionClass => _coreTypes.functionClass;
-  ClassElement get nullClass => _coreTypes.nullClass;
-  ClassElement get listClass => _coreTypes.listClass;
-  ClassElement get typeClass => _coreTypes.typeClass;
-  ClassElement get mapClass => _coreTypes.mapClass;
-  ClassElement get symbolClass => _coreTypes.symbolClass;
-  ClassElement get stackTraceClass => _coreTypes.stackTraceClass;
-  ClassElement get futureClass => _coreTypes.futureClass;
-  ClassElement get iterableClass => _coreTypes.iterableClass;
-  ClassElement get streamClass => _coreTypes.streamClass;
-
   DiagnosticReporter get reporter => _reporter;
+  CoreClasses get coreClasses => _coreTypes;
   CoreTypes get coreTypes => _coreTypes;
   Resolution get resolution => _resolution;
   Parsing get parsing => _parsing;
 
   ClassElement typedDataClass;
 
   /// The constant for the [proxy] variable defined in dart:core.
   ConstantValue proxyConstant;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
@@ skipping 412 matching lines @@
       } else if (importsMirrorsLibrary && !enableExperimentalMirrors) {
         Set<String> importChains =
             computeImportChainsFor(loadedLibraries, Uris.dart_mirrors);
         reporter.reportWarningMessage(
             NO_LOCATION_SPANNABLE,
             MessageKind.IMPORT_EXPERIMENTAL_MIRRORS,
             {'importChain': importChains.join(
                  MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)});
       }
 
-      functionClass.ensureResolved(resolution);
-      functionApplyMethod = functionClass.lookupLocalMember('apply');
+      coreClasses.functionClass.ensureResolved(resolution);
+      functionApplyMethod =
+          coreClasses.functionClass.lookupLocalMember('apply');
 
       if (preserveComments) {
         return libraryLoader.loadLibrary(Uris.dart_mirrors)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
@@ skipping 18 matching lines @@
     }
     return element;
   }
 
   // TODO(johnniwinther): Move this to [PatchParser] when it is moved to the
   // [JavaScriptBackend]. Currently needed for testing.
   String get patchVersion => backend.patchVersion;
 
   void onClassResolved(ClassElement cls) {
     if (mirrorSystemClass == cls) {
-      mirrorSystemGetNameFunction =
-        cls.lookupLocalMember('getName');
-    } else if (symbolClass == cls) {
+      mirrorSystemGetNameFunction = cls.lookupLocalMember('getName');
+    } else if (coreClasses.symbolClass == cls) {
       symbolConstructor = cls.constructors.head;
     } else if (symbolImplementationClass == cls) {
-      symbolValidatedConstructor = symbolImplementationClass.lookupConstructor(
+      symbolValidatedConstructor = cls.lookupConstructor(
           symbolValidatedConstructorSelector.name);
     } else if (mirrorsUsedClass == cls) {
       mirrorsUsedConstructor = cls.constructors.head;
-    } else if (intClass == cls) {
-      intEnvironment = intClass.lookupConstructor(Identifiers.fromEnvironment);
-    } else if (stringClass == cls) {
-      stringEnvironment =
-          stringClass.lookupConstructor(Identifiers.fromEnvironment);
-    } else if (boolClass == cls) {
-      boolEnvironment =
-          boolClass.lookupConstructor(Identifiers.fromEnvironment);
+    } else if (coreClasses.intClass == cls) {
+      intEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
+    } else if (coreClasses.stringClass == cls) {
+      stringEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
+    } else if (coreClasses.boolClass == cls) {
+      boolEnvironment = cls.lookupConstructor(Identifiers.fromEnvironment);
     }
   }
 
   void initializeCoreClasses() {
     final List missingCoreClasses = [];
     ClassElement lookupCoreClass(String name) {
       ClassElement result = coreLibrary.find(name);
       if (result == null) {
         missingCoreClasses.add(name);
       }
@@ skipping 18 matching lines @@
       reporter.internalError(
           coreLibrary,
           'dart:core library does not contain required classes: '
           '$missingCoreClasses');
     }
   }
 
   Element _unnamedListConstructor;
   Element get unnamedListConstructor {
     if (_unnamedListConstructor != null) return _unnamedListConstructor;
-    return _unnamedListConstructor = listClass.lookupDefaultConstructor();
+    return _unnamedListConstructor =
+        coreClasses.listClass.lookupDefaultConstructor();
   }
 
   Element _filledListConstructor;
   Element get filledListConstructor {
     if (_filledListConstructor != null) return _filledListConstructor;
-    return _filledListConstructor = listClass.lookupConstructor("filled");
+    return _filledListConstructor =
+        coreClasses.listClass.lookupConstructor("filled");
   }
 
   /**
    * Get an [Uri] pointing to a patch for the dart: library with
    * the given path. Returns null if there is no patch.
    */
   Uri resolvePatchUri(String dartLibraryPath);
 
   Future runCompiler(Uri uri) {
     // TODO(ahe): This prevents memory leaks when invoking the compiler
@@ skipping 587 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 {
+class _CompilerCoreTypes implements CoreTypes, CoreClasses {
   final Resolution resolution;
 
   ClassElement objectClass;
   ClassElement boolClass;
   ClassElement numClass;
   ClassElement intClass;
   ClassElement doubleClass;
   ClassElement stringClass;
   ClassElement functionClass;
   ClassElement nullClass;
@@ skipping 601 matching lines @@
     if (_otherDependencies == null) {
       _otherDependencies = new Setlet<Element>();
     }
     _otherDependencies.add(element.implementation);
   }
 
   Iterable<Element> get otherDependencies {
     return _otherDependencies != null ? _otherDependencies : const <Element>[];
   }
 }