Remove reference to compiler from libary loader, fix analyzer warning

pkg/compiler/lib/src/library_loader.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.library_loader;
 
 import 'dart:async';
 
 import 'common/names.dart' show Uris;
-import 'common/tasks.dart' show CompilerTask, GenericTask;
+import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
-import 'compiler.dart' show Compiler;
 import 'elements/elements.dart'
     show
         CompilationUnitElement,
         Element,
         ImportElement,
         ExportElement,
         LibraryElement;
 import 'elements/modelx.dart'
     show
         CompilationUnitElementX,
@@ skipping 85 matching lines @@
  * 'sdk/lib/_internal/sdk_library_metadata/lib/libraries.dart'. This is done
  * through a [ResolvedUriTranslator] provided from the compiler. The translator
  * checks whether a library by that name exists and in case of internal
  * libraries whether access is granted.
  *
  * ## Resource URI ##
  *
  * A 'resource URI' is an absolute URI with a scheme supported by the input
  * provider. For the standard implementation this means a URI with the 'file'
  * scheme. Readable URIs are converted into resource URIs as part of the
- * [Compiler.readScript] method. In the standard implementation the package URIs
- * are converted to file URIs using the package root URI provided on the
+ * [ScriptLoader.readScript] method. In the standard implementation the package
+ * URIs are converted to file URIs using the package root URI provided on the
  * command line as base. If the package root URI is
  * 'file:///current/working/dir/' then the package URI 'package:foo/bar.dart'
  * will be resolved to the resource URI
  * 'file:///current/working/dir/foo/bar.dart'.
  *
  * The distinction between readable URI and resource URI is necessary to ensure
  * that these imports
  *
  *     import 'package:foo.dart' as a;
  *     import 'packages/foo.dart' as b;
  *
  * do _not_ resolve to the same library when the package root URI happens to
  * point to the 'packages' folder.
  *
  */
 abstract class LibraryLoaderTask implements CompilerTask {
   factory LibraryLoaderTask(
-      Compiler compiler,
       ResolvedUriTranslator uriTranslator,
       ScriptLoader scriptLoader,
       ElementScanner scriptScanner,
       LibraryDeserializer deserializer,
       LibraryLoaderListener listener,
-      Environment environment) = _LibraryLoaderTask;
+      Environment environment,
+      DiagnosticReporter reporter,
+      Measurer measurer) = _LibraryLoaderTask;
 
   /// Returns all libraries that have been loaded.
   Iterable<LibraryElement> get libraries;
 
   /// Looks up the library with the [canonicalUri].
   LibraryElement lookupLibrary(Uri canonicalUri);
 
   /// Loads the library specified by the [resolvedUri] and returns its
   /// [LibraryElement].
   ///
@@ skipping 136 matching lines @@
   final LibraryDeserializer deserializer;
 
   /// Hooks to inform others about progress done by this loader.
   // TODO(sigmund): move away from this.
   final LibraryLoaderListener listener;
 
   /// Definitions provided via the `-D` command line flags. Used to resolve
   /// conditional imports.
   final Environment environment;
 
-  final Compiler compiler;
-  DiagnosticReporter get reporter => compiler.reporter;
+  final DiagnosticReporter reporter;
 
-  _LibraryLoaderTask(Compiler compiler, this.uriTranslator, this.scriptLoader,
-      this.scanner, this.deserializer, this.listener, this.environment)
-      : compiler = compiler,
-        super(compiler.measurer);
+  _LibraryLoaderTask(this.uriTranslator, this.scriptLoader,
+      this.scanner, this.deserializer, this.listener, this.environment,
+      this.reporter, Measurer measurer)
+      : super(measurer);
 
   String get name => 'LibraryLoader';
 
   final Map<Uri, LibraryElement> libraryCanonicalUriMap =
       new Map<Uri, LibraryElement>();
   final Map<Uri, LibraryElement> libraryResourceUriMap =
       new Map<Uri, LibraryElement>();
   final Map<String, LibraryElement> libraryNames =
       new Map<String, LibraryElement>();
 
@@ skipping 62 matching lines @@
 
   Future<Null> resetLibraries(
       Future<Iterable<LibraryElement>> reuseLibraries(
           Iterable<LibraryElement> libraries)) {
     assert(currentHandler == null);
     return measureSubtask(_reuseLibrarySubtaskName, () {
       return new Future<Iterable<LibraryElement>>(() {
         // Wrap in Future to shield against errors in user code.
         return reuseLibraries(libraryCanonicalUriMap.values);
       }).catchError((exception, StackTrace trace) {
-        compiler.reportCrashInUserCode(
+        reporter.onCrashInUserCode(
             'Uncaught exception in reuseLibraries', exception, trace);
         throw exception; // Async rethrow.
       }).then((Iterable<LibraryElement> reusedLibraries) {
         measure(() {
           resetImplementation(reusedLibraries);
         });
       });
     });
   }
 
@@ skipping 1104 matching lines @@
   Future onLibrariesLoaded(LoadedLibraries results);
 
   /// Called whenever a library element is created.
   void onLibraryCreated(LibraryElement library);
 
   /// Called whenever a library is scanned from a script file.
   Future onLibraryScanned(LibraryElement library, LibraryLoader loader);
 }
 
 const _reuseLibrarySubtaskName = "Reuse library";