remove dependency on compiler from resolution

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;
@@ skipping 148 matching lines @@
   LibraryElement typedDataLibrary;
 
   DiagnosticReporter get reporter => _reporter;
   CoreClasses get coreClasses => _coreTypes;
   CoreTypes get coreTypes => _coreTypes;
   Resolution get resolution => _resolution;
   ParsingContext get parsingContext => _parsingContext;
 
   ClassElement typedDataClass;
 
-  /// The constant for the [proxy] variable defined in dart:core.
-  ConstantValue proxyConstant;
-
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   /// The class for patch annotation defined in dart:_js_helper.
   ClassElement patchAnnotationClass;
 
   // TODO(johnniwinther): Move this to the JavaScriptBackend.
   ClassElement nativeAnnotationClass;
 
   ConstructorElement _symbolConstructor;
   ConstructorElement get symbolConstructor {
     if (_symbolConstructor == null) {
@@ skipping 184 matching lines @@
   ///
   /// Override this to mock the scanner for testing.
   ScannerTask createScannerTask() =>
       new ScannerTask(dietParser, reporter, measurer,
           preserveComments: options.preserveComments, commentMap: commentMap);
 
   /// Creates the resolver task.
   ///
   /// Override this to mock the resolver for testing.
   ResolverTask createResolverTask() {
-    return new ResolverTask(this, backend.constantCompilerTask);
+    return new ResolverTask(
+        resolution, backend.constantCompilerTask, world, measurer);
   }
 
   Universe get resolverWorld => enqueuer.resolution.universe;
   Universe get codegenWorld => enqueuer.codegen.universe;
 
   bool get analyzeAll => options.analyzeAll || compileAll;
 
   bool get compileAll => false;
 
   bool get disableTypeInference =>
       options.disableTypeInference || compilationFailed;
 
+  // TODO(het): remove this from here. Either inline at all use sites or add it
+  // to Reporter.
   void unimplemented(Spannable spannable, String methodName) {
     reporter.internalError(spannable, "$methodName not implemented.");
   }
 
   // Compiles the dart script at [uri].
   //
   // The resulting future will complete with true if the compilation
   // succeeded.
   Future<bool> run(Uri uri) => selfTask.measureSubtask("Compiler.run", () {
         measurer.startWallClock();
@@ skipping 175 matching lines @@
       if (options.preserveComments) {
         return libraryLoader
             .loadLibrary(Uris.dart_mirrors)
             .then((LibraryElement libraryElement) {
           documentClass = libraryElement.find('Comment');
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
-  bool isProxyConstant(ConstantValue value) {
-    FieldElement field = coreLibrary.find('proxy');
-    if (field == null) return false;
-    if (!resolution.hasBeenResolved(field)) return false;
-    if (proxyConstant == null) {
-      proxyConstant = constants
-          .getConstantValue(resolver.constantCompiler.compileConstant(field));
-    }
-    return proxyConstant == value;
-  }
-
   Element findRequiredElement(LibraryElement library, String name) {
     var element = library.find(name);
     if (element == null) {
       reporter.internalError(
           library,
           "The library '${library.canonicalUri}' does not contain required "
           "element: '$name'.");
     }
     return element;
   }
@@ skipping 517 matching lines @@
       return true;
     }
     return !BENIGN_ERRORS.contains(message.message.kind);
   }
 
   void fatalDiagnosticReported(DiagnosticMessage message,
       List<DiagnosticMessage> infos, api.Diagnostic kind) {
     if (markCompilationAsFailed(message, kind)) {
       compilationFailed = true;
     }
-    registerCompiletimeError(currentElement, message);
+    registerCompileTimeError(currentElement, message);
   }
 
   /**
    * Reads the script specified by the [readableUri].
    *
    * See [LibraryLoader] for terminology on URIs.
    */
   Future<Script> readScript(Uri readableUri, [Spannable node]) {
     unimplemented(node, 'Compiler.readScript');
     return null;
@@ skipping 122 matching lines @@
     }
     backend.forgetElement(element);
   }
 
   /// Returns [true] if a compile-time error has been reported for element.
   bool elementHasCompileTimeError(Element element) {
     return elementsWithCompileTimeErrors.containsKey(element);
   }
 
   /// Associate [element] with a compile-time error [message].
-  void registerCompiletimeError(Element element, DiagnosticMessage message) {
+  void registerCompileTimeError(Element element, DiagnosticMessage message) {
     // The information is only needed if [generateCodeWithCompileTimeErrors].
     if (options.generateCodeWithCompileTimeErrors) {
       if (element == null) {
         // Record as global error.
         // TODO(zarah): Extend element model to represent compile-time
         // errors instead of using a map.
         element = mainFunction;
       }
       elementsWithCompileTimeErrors
           .putIfAbsent(element, () => <DiagnosticMessage>[])
@@ skipping 260 matching lines @@
     compiler.reportDiagnostic(message, infos, kind);
     if (kind == api.Diagnostic.ERROR ||
         kind == api.Diagnostic.CRASH ||
         (options.fatalWarnings && kind == api.Diagnostic.WARNING)) {
       Element errorElement;
       if (message.spannable is Element) {
         errorElement = message.spannable;
       } else {
         errorElement = currentElement;
       }
-      compiler.registerCompiletimeError(errorElement, message);
+      compiler.registerCompileTimeError(errorElement, message);
       compiler.fatalDiagnosticReported(message, infos, kind);
     }
   }
 
   @override
   bool get hasReportedError => compiler.compilationFailed;
 
   /**
    * Perform an operation, [f], returning the return value from [f].  If an
    * error occurs then report it as having occurred during compilation of
@@ skipping 332 matching lines @@
   @override
   CoreTypes get coreTypes => compiler.coreTypes;
 
   @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.coreLibrary;
+
+  @override
+  FunctionElement get identicalFunction => compiler.identicalFunction;
+
+  @override
+  ClassElement get mirrorSystemClass => compiler.mirrorSystemClass;
+
+  @override
+  FunctionElement get mirrorSystemGetNameFunction =>
+      compiler.mirrorSystemGetNameFunction;
+
+  @override
+  ConstructorElement get mirrorsUsedConstructor =>
+      compiler.mirrorsUsedConstructor;
+
+  @override
+  ConstructorElement get symbolConstructor => compiler.symbolConstructor;
+
+  @override
+  ConstantValue proxyConstant;
+
+  @override
   void registerClass(ClassElement cls) {
     compiler.world.registerClass(cls);
   }
 
   @override
   void resolveClass(ClassElement cls) {
     compiler.resolver.resolveClass(cls);
   }
 
   @override
@@ skipping 18 matching lines @@
 
   @override
   void ensureResolved(Element element) {
     if (compiler.serialization.isDeserialized(element)) {
       return;
     }
     computeWorldImpact(element);
   }
 
   @override
+  void onClassResolved(ClassElement element) =>
+      compiler.onClassResolved(element);
+
+  @override
+  void registerCompileTimeError(Element element, DiagnosticMessage message) =>
+      compiler.registerCompileTimeError(element, message);
+
+  @override
   bool hasResolvedAst(ExecutableElement element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (compiler.serialization.isDeserialized(element)) {
       return compiler.serialization.hasResolvedAst(element);
     }
     return hasBeenResolved(element.memberContext.declaration) &&
         element.hasResolvedAst;
   }
 
@@ skipping 120 matching lines @@
     } else {
       return new ResolutionWorkItem(element, compilationContext);
     }
   }
 
   @override
   void forgetElement(Element element) {
     _worldImpactCache.remove(element);
     _resolutionImpactCache.remove(element);
   }
+
+  @override
+  bool isProxyConstant(ConstantValue value) {
+    FieldElement field = coreLibrary.find('proxy');
+    if (field == null) return false;
+    if (!hasBeenResolved(field)) return false;
+    if (proxyConstant == null) {
+      proxyConstant = constants
+          .getConstantValue(resolver.constantCompiler.compileConstant(field));
+    }
+    return proxyConstant == value;
+  }
 }
 
 class GlobalDependencyRegistry extends EagerRegistry {
   final Compiler compiler;
   Setlet<Element> _otherDependencies;
 
   GlobalDependencyRegistry(this.compiler) : super('GlobalDependencies', null);
 
   // TODO(johnniwinther): Rename world/universe/enqueuer through out the
   // compiler.
@@ skipping 26 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;
 }