Roll to pickup pool changes

packages/initialize/lib/src/mirror_loader.dart

 // Copyright (c) 2015, 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 initialize.mirror_loader;
 
 import 'dart:collection' show Queue;
 import 'dart:mirrors';
 import 'package:path/path.dart' as path;
 import 'package:initialize/initialize.dart';
 
-final _root = currentMirrorSystem().isolate.rootLibrary;
-final _libs = currentMirrorSystem().libraries;
+final LibraryMirror _root = currentMirrorSystem().isolate.rootLibrary;
+final Map<Uri, LibraryMirror> _libs = currentMirrorSystem().libraries;
 
 Queue<Function> loadInitializers(
     {List<Type> typeFilter, InitializerFilter customFilter, Uri from}) {
   return new InitializationCrawler(typeFilter, customFilter, from: from).run();
 }
 
 // Crawls a library and all its dependencies for `Initializer` annotations using
 // mirrors
 class InitializationCrawler {
   // Set of all visited annotations, keys are the declarations that were
   // annotated, values are the annotations that have been processed.
   static final _annotationsFound =
       new Map<DeclarationMirror, Set<InstanceMirror>>();
 
   // If non-null, then only these annotations should be processed.
   final List<Type> typeFilter;
 
   // If non-null, then only annotations which return true when passed to this
   // function will be processed.
   final InitializerFilter customFilter;
 
   /// The library to start crawling from.
   final LibraryMirror _rootLibrary;
 
   /// Note: The [from] argument is only supported in the mirror_loader.dart. It
   /// is not supported statically.
   InitializationCrawler(this.typeFilter, this.customFilter, {Uri from})
-      : _rootLibrary = from == null
-          ? _root
-          : _libs[from] {
+      : _rootLibrary = from == null ? _root : _libs[from] {
     if (_rootLibrary == null) throw 'Unable to find library at $from.';
   }
 
   // The primary function in this class, invoke it to crawl and collect all the
   // annotations into a queue of init functions.
   Queue<Function> run() {
     var librariesSeen = new Set<LibraryMirror>();
     var queue = new Queue<Function>();
 
     _readLibraryDeclarations(_rootLibrary, librariesSeen, queue);
@@ skipping 64 matching lines @@
         }
       }
     }
 
     return queue;
   }
 
   Iterable<DeclarationMirror> _sortedDeclarationsWithMetadata(
       LibraryMirror lib) {
     return new List()
-      ..addAll(_sortDeclarations(lib, lib.declarations.values
-          .where((d) => d is MethodMirror && d.metadata.isNotEmpty)))
-      ..addAll(_sortDeclarations(lib, lib.declarations.values
-          .where((d) => d is ClassMirror && d.metadata.isNotEmpty)));
+      ..addAll(_sortDeclarations(
+          lib,
+          lib.declarations.values
+              .where((d) => d is MethodMirror && d.metadata.isNotEmpty)))
+      ..addAll(_sortDeclarations(
+          lib,
+          lib.declarations.values
+              .where((d) => d is ClassMirror && d.metadata.isNotEmpty)));
   }
 
   List<DeclarationMirror> _sortDeclarations(
       LibraryMirror sourceLib, Iterable<DeclarationMirror> declarations) {
     var declarationList = declarations.toList();
     declarationList.sort((DeclarationMirror a, DeclarationMirror b) {
       // If in the same file, compare by line.
       var aSourceUri = a.location.sourceUri;
       var bSourceUri = b.location.sourceUri;
       if (aSourceUri == bSourceUri) {
@@ skipping 54 matching lines @@
 
       var annotatedValue;
       if (declaration is ClassMirror) {
         annotatedValue = declaration.reflectedType;
       } else if (declaration is MethodMirror) {
         if (declaration.owner is! LibraryMirror) {
           // TODO(jakemac): Support static class methods.
           throw _TOP_LEVEL_FUNCTIONS_ONLY;
         }
         annotatedValue = (declaration.owner as ObjectMirror)
-            .getField(declaration.simpleName).reflectee;
+            .getField(declaration.simpleName)
+            .reflectee;
       } else if (declaration is LibraryMirror) {
         var package;
         var filePath;
         Uri uri = declaration.uri;
         // Convert to a package style uri if possible.
         if (_isHttpStylePackageUrl(uri)) {
           uri = _packageUriFor(uri);
         }
         if (uri.scheme == 'file' || uri.scheme.startsWith('http')) {
           filePath = path.url.relative(uri.path,
@@ skipping 32 matching lines @@
     return true;
   }
 }
 
 final _TOP_LEVEL_FUNCTIONS_ONLY = new UnsupportedError(
     'Only top level methods are supported for initializers');
 
 final _UNSUPPORTED_DECLARATION = new UnsupportedError(
     'Initializers are only supported on libraries, classes, and top level '
     'methods');