Add CoreClasses

pkg/compiler/lib/src/resolution/resolution.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.resolution;
 
 import 'dart:collection' show Queue;
 
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers;
 import '../common/resolution.dart' show
     Parsing,
     Resolution,
     ResolutionImpact;
 import '../common/tasks.dart' show
     CompilerTask,
     DeferredAction;
 import '../compiler.dart' show
     Compiler;
 import '../compile_time_constants.dart' show
     ConstantCompiler;
 import '../constants/values.dart' show
     ConstantValue;
 import '../core_types.dart' show
+    CoreClasses,
     CoreTypes;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show
     BaseClassElementX,
     BaseFunctionElementX,
     ConstructorElementX,
     FieldElementX,
     FunctionElementX,
     GetterElementX,
@@ skipping 29 matching lines @@
   final ConstantCompiler constantCompiler;
 
   ResolverTask(Compiler compiler, this.constantCompiler) : super(compiler);
 
   String get name => 'Resolver';
 
   Resolution get resolution => compiler.resolution;
 
   Parsing get parsing => compiler.parsing;
 
+  CoreClasses get coreClasses => compiler.coreClasses;
+
   CoreTypes get coreTypes => compiler.coreTypes;
 
   ResolutionImpact resolve(Element element) {
     return measure(() {
       if (Elements.isMalformed(element)) {
         // TODO(johnniwinther): Add a predicate for this.
         assert(invariant(element, element is! ErroneousElement,
             message: "Element $element expected to have parse errors."));
         _ensureTreeElements(element);
         return const ResolutionImpact();
@@ skipping 49 matching lines @@
       seen.add(redirection);
       redirection = resolver.visitor.resolveConstructorRedirection(redirection);
     }
   }
 
   static void processAsyncMarker(Compiler compiler,
                                  BaseFunctionElementX element,
                                  ResolutionRegistry registry) {
     DiagnosticReporter reporter = compiler.reporter;
     Resolution resolution = compiler.resolution;
+    CoreClasses coreClasses = compiler.coreClasses;
     FunctionExpression functionExpression = element.node;
     AsyncModifier asyncModifier = functionExpression.asyncModifier;
     if (asyncModifier != null) {
 
       if (asyncModifier.isAsynchronous) {
         element.asyncMarker = asyncModifier.isYielding
             ? AsyncMarker.ASYNC_STAR : AsyncMarker.ASYNC;
       } else {
         element.asyncMarker = AsyncMarker.SYNC_STAR;
       }
@@ skipping 19 matching lines @@
             element.asyncMarker.isYielding) {
           reporter.reportErrorMessage(
               asyncModifier,
               MessageKind.YIELDING_MODIFIER_ON_ARROW_BODY,
               {'modifier': element.asyncMarker});
         }
       }
       registry.registerAsyncMarker(element);
       switch (element.asyncMarker) {
       case AsyncMarker.ASYNC:
-        compiler.futureClass.ensureResolved(resolution);
+        coreClasses.futureClass.ensureResolved(resolution);
         break;
       case AsyncMarker.ASYNC_STAR:
-        compiler.streamClass.ensureResolved(resolution);
+        coreClasses.streamClass.ensureResolved(resolution);
         break;
       case AsyncMarker.SYNC_STAR:
-        compiler.iterableClass.ensureResolved(resolution);
+        coreClasses.iterableClass.ensureResolved(resolution);
         break;
       }
     }
   }
 
   bool _isNativeClassOrExtendsNativeClass(ClassElement classElement) {
     assert(classElement != null);
     while (classElement != null) {
       if (compiler.backend.isNative(classElement)) return true;
       classElement = classElement.superclass;
@@ skipping 289 matching lines @@
     reporter.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         reporter.reportErrorMessage(
             from,
             MessageKind.CYCLIC_CLASS_HIERARCHY,
             {'className': cls.name});
         cls.supertypeLoadState = STATE_DONE;
         cls.hasIncompleteHierarchy = true;
         cls.allSupertypesAndSelf =
-            compiler.objectClass.allSupertypesAndSelf.extendClass(
+            coreClasses.objectClass.allSupertypesAndSelf.extendClass(
                 cls.computeType(resolution));
         cls.supertype = cls.allSupertypes.head;
         assert(invariant(from, cls.supertype != null,
             message: 'Missing supertype on cyclic class $cls.'));
         cls.interfaces = const Link<DartType>();
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       reporter.withCurrentElement(cls, () {
         // TODO(ahe): Cache the node in cls.
@@ skipping 24 matching lines @@
                           resolveTypeDeclaration()) {
     return reporter.withCurrentElement(element, () {
       return measure(() {
         TypeDeclarationElement previousResolvedTypeDeclaration =
             currentlyResolvedTypeDeclaration;
         currentlyResolvedTypeDeclaration = element;
         var result = resolveTypeDeclaration();
         if (previousResolvedTypeDeclaration == null) {
           do {
             while (!pendingClassesToBeResolved.isEmpty) {
-              pendingClassesToBeResolved.removeFirst().ensureResolved(resolution);
+              pendingClassesToBeResolved.removeFirst()
+                  .ensureResolved(resolution);
             }
             while (!pendingClassesToBePostProcessed.isEmpty) {
               _postProcessClassElement(
                   pendingClassesToBePostProcessed.removeFirst());
             }
           } while (!pendingClassesToBeResolved.isEmpty);
           assert(pendingClassesToBeResolved.isEmpty);
           assert(pendingClassesToBePostProcessed.isEmpty);
         }
         currentlyResolvedTypeDeclaration = previousResolvedTypeDeclaration;
@@ skipping 523 matching lines @@
   TreeElements get treeElements {
     assert(invariant(this, _treeElements !=null,
         message: "TreeElements have not been computed for $this."));
     return _treeElements;
   }
 
   void reuseElement() {
     _treeElements = null;
   }
 }