Even less reliance on Compiler.closedWorld

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 467 matching lines @@
               .join(MessageTemplate.IMPORT_EXPERIMENTAL_MIRRORS_PADDING)
         });
       }
     }).then((_) => backend.onLibrariesLoaded(loadedLibraries));
   }
 
   // TODO(johnniwinther): Move this to [PatchParser] when it is moved to the
   // [JavaScriptBackend]. Currently needed for testing.
   String get patchVersion => backend.patchVersion;
 
-  Element _unnamedListConstructor;
-  Element get unnamedListConstructor {
-    if (_unnamedListConstructor != null) return _unnamedListConstructor;
-    return _unnamedListConstructor =
-        coreClasses.listClass.lookupDefaultConstructor();
-  }
-
-  Element _filledListConstructor;
-  Element get filledListConstructor {
-    if (_filledListConstructor != null) return _filledListConstructor;
-    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 runInternal(Uri uri) {
     // TODO(ahe): This prevents memory leaks when invoking the compiler
     // multiple times. Implement a better mechanism where we can store
     // such caches in the compiler and get access to them through a
@@ skipping 229 matching lines @@
           });
         }
         processQueue(enqueuer.codegen, mainFunction,
             onProgress: showCodegenProgress);
         enqueuer.codegen.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram();
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
-          dumpInfoTask.dumpInfo();
+          dumpInfoTask.dumpInfo(closedWorld);
         }
 
         backend.sourceInformationStrategy.onComplete();
 
         checkQueues();
       });
 
   /// Perform the steps needed to fully end the resolution phase.
   ClosedWorldRefiner closeResolution() {
     phase = PHASE_DONE_RESOLVING;
 
     WorldImpl world = resolverWorld.openWorld.closeWorld(reporter);
     // Compute whole-program-knowledge that the backend needs. (This might
     // require the information computed in [world.closeWorld].)
-    backend.onResolutionComplete(world);
+    backend.onResolutionComplete(world, world);
 
     deferredLoadTask.onResolutionComplete(mainFunction);
 
     // TODO(johnniwinther): Move this after rti computation but before
     // reflection members computation, and (re-)close the world afterwards.
     closureToClassMapper.createClosureClasses(world);
     return world;
   }
 
   /// Compute the [WorldImpact] for accessing all elements in [library].
@@ skipping 707 matching lines @@
 
     var element = library.find(name);
     if (element == null) {
       reporter.internalError(
           library,
           "The library '${library.canonicalUri}' does not contain required "
           "element: '$name'.");
     }
     return element;
   }
+
+  ConstructorElement _unnamedListConstructor;
+  ConstructorElement get unnamedListConstructor =>
+      _unnamedListConstructor ??= listClass.lookupDefaultConstructor();
+
+  ConstructorElement _filledListConstructor;
+  ConstructorElement get filledListConstructor =>
+      _filledListConstructor ??= listClass.lookupConstructor("filled");
 }
 
 class CompilerDiagnosticReporter extends DiagnosticReporter {
   final Compiler compiler;
   final DiagnosticOptions options;
 
   Element _currentElement;
   bool hasCrashed = false;
 
   /// `true` if the last diagnostic was filtered, in which case the
@@ skipping 731 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;
 }