Decouple WorkItem from Compiler

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 75 matching lines @@
     Compiler compiler, CompilerOptions options);
 
 abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
   WorldImpl get _world => resolverWorld.openWorld;
   Types types;
   _CompilerCoreTypes _coreTypes;
   CompilerDiagnosticReporter _reporter;
-  _CompilerResolution _resolution;
+  CompilerResolution _resolution;
   ParsingContext _parsingContext;
 
   final CacheStrategy cacheStrategy;
 
   ImpactStrategy impactStrategy = const ImpactStrategy();
 
   /**
    * Map from token to the first preceding comment token.
    */
   final TokenMap commentMap = new TokenMap();
@@ skipping 101 matching lines @@
       : this.options = options,
         this.cacheStrategy = new CacheStrategy(options.hasIncrementalSupport),
         this.userOutputProvider = outputProvider == null
             ? const NullCompilerOutput()
             : outputProvider {
     if (makeReporter != null) {
       _reporter = makeReporter(this, options);
     } else {
       _reporter = new CompilerDiagnosticReporter(this, options);
     }
-    _resolution = new _CompilerResolution(this);
+    _resolution = createResolution();
     // TODO(johnniwinther): Initialize core types in [initializeCoreClasses] and
     // make its field final.
     _coreTypes = new _CompilerCoreTypes(_resolution, reporter);
     types = new Types(_resolution);
     tracer = new Tracer(this, this.outputProvider);
 
     if (options.verbose) {
       progress = new Stopwatch()..start();
     }
 
     // TODO(johnniwinther): Separate the dependency tracking from the enqueuing
     // for global dependencies.
     globalDependencies = new GlobalDependencyRegistry();
 
     if (makeBackend != null) {
       backend = makeBackend(this);
     } else {
-      js_backend.JavaScriptBackend jsBackend = new js_backend.JavaScriptBackend(
-          this,
-          generateSourceMap: options.generateSourceMap,
-          useStartupEmitter: options.useStartupEmitter,
-          useNewSourceInfo: options.useNewSourceInfo,
-          useKernel: options.useKernel);
-      backend = jsBackend;
+      backend = createBackend();
     }
     enqueuer = backend.makeEnqueuer();
 
     if (options.dumpInfo && options.useStartupEmitter) {
       throw new ArgumentError(
           '--dump-info is not supported with the fast startup emitter');
     }
 
     tasks = [
       dietParser = new DietParserTask(idGenerator, backend, reporter, measurer),
@@ skipping 42 matching lines @@
   /// The closed world after resolution but currently refined by inference.
   ClosedWorldRefiner get inferenceWorld => _world;
 
   /// The closed world after resolution and inference.
   ClosedWorld get closedWorld {
     assert(invariant(CURRENT_ELEMENT_SPANNABLE, _world.isClosed,
         message: "Closed world not computed yet."));
     return _world;
   }
 
+  /// Creates the backend.
+  ///
+  /// Override this to mock the backend for testing.
+  Backend createBackend() {
+    return new js_backend.JavaScriptBackend(this,
+        generateSourceMap: options.generateSourceMap,
+        useStartupEmitter: options.useStartupEmitter,
+        useNewSourceInfo: options.useNewSourceInfo,
+        useKernel: options.useKernel);
+  }
+
   /// Creates the scanner task.
   ///
   /// Override this to mock the scanner for testing.
   ScannerTask createScannerTask() =>
       new ScannerTask(dietParser, reporter, measurer,
           preserveComments: options.preserveComments, commentMap: commentMap);
 
+  /// Creates the resolution object.
+  ///
+  /// Override this to mock resolution for testing.
+  Resolution createResolution() => new CompilerResolution(this);
+
   /// Creates the resolver task.
   ///
   /// Override this to mock the resolver for testing.
   ResolverTask createResolverTask() {
     return new ResolverTask(
         resolution, backend.constantCompilerTask, openWorld, measurer);
   }
 
   // TODO(johnniwinther): Rename these appropriately when unification of worlds/
   // universes is complete.
@@ skipping 296 matching lines @@
   /// when the '--analyze-main' option is used.
   Future<LibraryElement> analyzeUri(Uri libraryUri,
       {bool skipLibraryWithPartOfTag: true}) {
     assert(options.analyzeMain);
     reporter.log('Analyzing $libraryUri (${options.buildId})');
     return libraryLoader
         .loadLibrary(libraryUri, skipFileWithPartOfTag: true)
         .then((LibraryElement library) {
       if (library == null) return null;
       enqueuer.resolution.applyImpact(computeImpactForLibrary(library));
-      emptyQueue(enqueuer.resolution);
+      emptyQueue(enqueuer.resolution, onProgress: showResolutionProgress);
       enqueuer.resolution.logSummary(reporter.log);
       return library;
     });
   }
 
   /// Performs the compilation when all libraries have been loaded.
   void compileLoadedLibraries() =>
       selfTask.measureSubtask("Compiler.compileLoadedLibraries", () {
         WorldImpact mainImpact = computeMain();
 
@@ skipping 40 matching lines @@
         }
         // Elements required by enqueueHelpers are global dependencies
         // that are not pulled in by a particular element.
         enqueuer.resolution.applyImpact(backend.computeHelpersImpact());
         resolveLibraryMetadata();
         reporter.log('Resolving...');
         if (mainFunction != null && !mainFunction.isMalformed) {
           mainFunction.computeType(resolution);
         }
 
-        processQueue(enqueuer.resolution, mainFunction);
+        processQueue(enqueuer.resolution, mainFunction,
+            onProgress: showResolutionProgress);
         enqueuer.resolution.logSummary(reporter.log);
 
         _reporter.reportSuppressedMessagesSummary();
 
         if (compilationFailed) {
           if (!options.generateCodeWithCompileTimeErrors) return;
           if (!backend
               .enableCodegenWithErrorsIfSupported(NO_LOCATION_SPANNABLE)) {
             return;
           }
@@ skipping 36 matching lines @@
         backend.onCodegenStart();
         if (hasIsolateSupport) {
           enqueuer.codegen
               .applyImpact(backend.enableIsolateSupport(forResolution: false));
         }
         if (compileAll) {
           libraryLoader.libraries.forEach((LibraryElement library) {
             enqueuer.codegen.applyImpact(computeImpactForLibrary(library));
           });
         }
-        processQueue(enqueuer.codegen, mainFunction);
+        processQueue(enqueuer.codegen, mainFunction,
+            onProgress: showCodegenProgress);
         enqueuer.codegen.logSummary(reporter.log);
 
         int programSize = backend.assembleProgram();
 
         if (options.dumpInfo) {
           dumpInfoTask.reportSize(programSize);
           dumpInfoTask.dumpInfo();
         }
 
         backend.sourceInformationStrategy.onComplete();
@@ skipping 77 matching lines @@
         for (MetadataAnnotation metadata in library.metadata) {
           metadata.ensureResolved(resolution);
         }
       }
     }
   }
 
   /**
    * Empty the [enqueuer] queue.
    */
-  void emptyQueue(Enqueuer enqueuer) {
+  void emptyQueue(Enqueuer enqueuer, {void onProgress()}) {
     selfTask.measureSubtask("Compiler.emptyQueue", () {
       enqueuer.forEach((WorkItem work) {
+        if (onProgress != null) {
+          onProgress();
+        }
         reporter.withCurrentElement(
             work.element,
             () => selfTask.measureSubtask("world.applyImpact", () {
                   enqueuer.applyImpact(
-                      selfTask.measureSubtask(
-                          "work.run", () => work.run(this, enqueuer)),
+                      selfTask.measureSubtask("work.run", () => work.run()),
                       impactSource: work.element);
                 }));
       });
     });
   }
 
-  void processQueue(Enqueuer enqueuer, MethodElement mainMethod) {
+  void processQueue(Enqueuer enqueuer, MethodElement mainMethod,
+      {void onProgress()}) {
     selfTask.measureSubtask("Compiler.processQueue", () {
       enqueuer.open(impactStrategy);
       enqueuer.applyImpact(enqueuer.nativeEnqueuer
           .processNativeClasses(libraryLoader.libraries));
       if (mainMethod != null && !mainMethod.isMalformed) {
         enqueuer.applyImpact(backend.computeMainImpact(mainMethod,
             forResolution: enqueuer.isResolutionQueue));
       }
       if (options.verbose) {
         progress.reset();
       }
-      emptyQueue(enqueuer);
+      emptyQueue(enqueuer, onProgress: onProgress);
       enqueuer.queueIsClosed = true;
       enqueuer.close();
       // Notify the impact strategy impacts are no longer needed for this
       // enqueuer.
       impactStrategy.onImpactUsed(enqueuer.impactUse);
       backend.onQueueClosed();
       assert(compilationFailed ||
           enqueuer.checkNoEnqueuedInvokedInstanceMethods());
     });
   }
@@ skipping 30 matching lines @@
         resolved.remove(e);
       }
     }
     reporter.log('Excess resolution work: ${resolved.length}.');
     for (Element e in resolved) {
       reporter.reportWarningMessage(e, MessageKind.GENERIC,
           {'text': 'Warning: $e resolved but not compiled.'});
     }
   }
 
-  WorldImpact analyzeElement(Element element) =>
-      selfTask.measureSubtask("Compiler.analyzeElement", () {
-        assert(invariant(
-            element,
-            element.impliesType ||
-                element.isField ||
-                element.isFunction ||
-                element.isConstructor ||
-                element.isGetter ||
-                element.isSetter,
-            message: 'Unexpected element kind: ${element.kind}'));
-        assert(invariant(element, element is AnalyzableElement,
-            message: 'Element $element is not analyzable.'));
-        assert(invariant(element, element.isDeclaration));
+/*

[Harry Terkelsen, 2016/11/28 19:24:29]

delete commented code

[Johnni Winther, 2016/11/29 08:43:38]

Done.

+  WorldImpact analyze(ResolutionWorkItem work) =>
+      selfTask.measureSubtask("Compiler.analyze", () {
+        assert(invariant(work.element, !work.isAnalyzed,
+            message: 'Element ${work.element} has already been analyzed'));
+        AstElement element = work.element;
         return resolution.computeWorldImpact(element);
       });
-
-  WorldImpact analyze(ResolutionWorkItem work, ResolutionEnqueuer world) =>
-      selfTask.measureSubtask("Compiler.analyze", () {
-        assert(invariant(work.element, identical(world, enqueuer.resolution)));
-        assert(invariant(work.element, !work.isAnalyzed,
-            message: 'Element ${work.element} has already been analyzed'));
-        if (shouldPrintProgress) {
-          // TODO(ahe): Add structured diagnostics to the compiler API and
-          // use it to separate this from the --verbose option.
-          if (phase == PHASE_RESOLVING) {
-            reporter
-                .log('Resolved ${enqueuer.resolution.processedElements.length} '
-                    'elements.');
-            progress.reset();
-          }
-        }
-        AstElement element = work.element;
-        if (world.hasBeenProcessed(element)) {
-          return const WorldImpact();
-        }
-        WorldImpact worldImpact = analyzeElement(element);
-        world.registerProcessedElement(element);
-        return worldImpact;
-      });
-
-  WorldImpact codegen(CodegenWorkItem work, Enqueuer world) {
-    assert(invariant(work.element, identical(world, enqueuer.codegen)));
+*/
+  void showResolutionProgress() {
     if (shouldPrintProgress) {
       // TODO(ahe): Add structured diagnostics to the compiler API and
       // use it to separate this from the --verbose option.
+      assert(phase == PHASE_RESOLVING);
+      reporter.log('Resolved ${enqueuer.resolution.processedElements.length} '
+          'elements.');
+      progress.reset();
+    }
+  }
+
+  void showCodegenProgress() {
+    if (shouldPrintProgress) {
+      // TODO(ahe): Add structured diagnostics to the compiler API and
+      // use it to separate this from the --verbose option.
       reporter.log(
           'Compiled ${enqueuer.codegen.processedEntities.length} methods.');
       progress.reset();
     }
-    return backend.codegen(work);
   }
 
   void reportDiagnostic(DiagnosticMessage message,
       List<DiagnosticMessage> infos, api.Diagnostic kind);
 
   void reportCrashInUserCode(String message, exception, stackTrace) {
     reporter.onCrashInUserCode(message, exception, stackTrace);
   }
 
   /// Messages for which compile-time errors are reported but compilation
@@ skipping 955 matching lines @@
             {'warnings': info.warnings, 'hints': info.hints, 'uri': uri},
             options.terseDiagnostics);
         reportDiagnostic(new DiagnosticMessage(null, null, message),
             const <DiagnosticMessage>[], api.Diagnostic.HINT);
       });
     }
   }
 }
 
 // TODO(johnniwinther): Move [ResolverTask] here.
-class _CompilerResolution implements Resolution {
-  final Compiler compiler;
+class CompilerResolution implements Resolution {
+  final Compiler _compiler;
   final Map<Element, ResolutionImpact> _resolutionImpactCache =
       <Element, ResolutionImpact>{};
   final Map<Element, WorldImpact> _worldImpactCache = <Element, WorldImpact>{};
   bool retainCachesForTesting = false;
 
-  _CompilerResolution(this.compiler);
+  CompilerResolution(this._compiler);
 
   @override
-  DiagnosticReporter get reporter => compiler.reporter;
+  DiagnosticReporter get reporter => _compiler.reporter;
 
   @override
-  ParsingContext get parsingContext => compiler.parsingContext;
+  ParsingContext get parsingContext => _compiler.parsingContext;
 
   @override
-  CoreClasses get coreClasses => compiler.coreClasses;
+  CoreClasses get coreClasses => _compiler.coreClasses;
 
   @override
-  CoreTypes get coreTypes => compiler.coreTypes;
+  CoreTypes get coreTypes => _compiler.coreTypes;
 
   @override
-  CommonElements get commonElements => compiler.commonElements;
+  CommonElements get commonElements => _compiler.commonElements;
 
   @override
-  Types get types => compiler.types;
+  Types get types => _compiler.types;
 
   @override
-  Target get target => compiler.backend;
+  Target get target => _compiler.backend;
 
   @override
-  ResolverTask get resolver => compiler.resolver;
+  ResolverTask get resolver => _compiler.resolver;
 
   @override
-  ResolutionEnqueuer get enqueuer => compiler.enqueuer.resolution;
+  ResolutionEnqueuer get enqueuer => _compiler.enqueuer.resolution;
 
   @override
-  CompilerOptions get options => compiler.options;
+  CompilerOptions get options => _compiler.options;
 
   @override
-  IdGenerator get idGenerator => compiler.idGenerator;
+  IdGenerator get idGenerator => _compiler.idGenerator;
 
   @override
-  ConstantEnvironment get constants => compiler.constants;
+  ConstantEnvironment get constants => _compiler.constants;
 
   @override
   MirrorUsageAnalyzerTask get mirrorUsageAnalyzerTask =>
-      compiler.mirrorUsageAnalyzerTask;
+      _compiler.mirrorUsageAnalyzerTask;
 
   @override
-  LibraryElement get coreLibrary => compiler._coreTypes.coreLibrary;
+  LibraryElement get coreLibrary => _compiler._coreTypes.coreLibrary;
 
   @override
   bool get wasProxyConstantComputedTestingOnly => _proxyConstant != null;
 
   @override
   void registerClass(ClassElement cls) {
-    compiler.openWorld.registerClass(cls);
+    _compiler.openWorld.registerClass(cls);
   }
 
   @override
   void resolveClass(ClassElement cls) {
-    compiler.resolver.resolveClass(cls);
+    _compiler.resolver.resolveClass(cls);
   }
 
   @override
   void resolveTypedef(TypedefElement typdef) {
-    compiler.resolver.resolve(typdef);
+    _compiler.resolver.resolve(typdef);
   }
 
   @override
   void resolveMetadataAnnotation(MetadataAnnotation metadataAnnotation) {
-    compiler.resolver.resolveMetadataAnnotation(metadataAnnotation);
+    _compiler.resolver.resolveMetadataAnnotation(metadataAnnotation);
   }
 
   @override
   FunctionSignature resolveSignature(FunctionElement function) {
-    return compiler.resolver.resolveSignature(function);
+    return _compiler.resolver.resolveSignature(function);
   }
 
   @override
   DartType resolveTypeAnnotation(Element element, TypeAnnotation node) {
-    return compiler.resolver.resolveTypeAnnotation(element, node);
+    return _compiler.resolver.resolveTypeAnnotation(element, node);
   }
 
   @override
   void ensureResolved(Element element) {
-    if (compiler.serialization.isDeserialized(element)) {
+    if (_compiler.serialization.isDeserialized(element)) {
       return;
     }
     computeWorldImpact(element);
   }
 
   @override
   void ensureClassMembers(ClassElement element) {
-    if (!compiler.serialization.isDeserialized(element)) {
-      compiler.resolver.checkClass(element);
+    if (!_compiler.serialization.isDeserialized(element)) {
+      _compiler.resolver.checkClass(element);
     }
   }
 
   @override
   void registerCompileTimeError(Element element, DiagnosticMessage message) =>
-      compiler.registerCompileTimeError(element, 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);
+    if (_compiler.serialization.isDeserialized(element)) {
+      return _compiler.serialization.hasResolvedAst(element);
     }
     return hasBeenResolved(element.memberContext.declaration) &&
         element.hasResolvedAst;
   }
 
   @override
   ResolvedAst getResolvedAst(ExecutableElement element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     assert(invariant(element, hasResolvedAst(element),
         message: "ResolvedAst not available for $element."));
-    if (compiler.serialization.isDeserialized(element)) {
-      return compiler.serialization.getResolvedAst(element);
+    if (_compiler.serialization.isDeserialized(element)) {
+      return _compiler.serialization.getResolvedAst(element);
     }
     return element.resolvedAst;
   }
 
   @override
   ResolvedAst computeResolvedAst(Element element) {
     ensureResolved(element);
     return getResolvedAst(element);
   }
 
   @override
   bool hasResolutionImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
-    if (compiler.serialization.isDeserialized(element)) {
-      return compiler.serialization.hasResolutionImpact(element);
+    if (_compiler.serialization.isDeserialized(element)) {
+      return _compiler.serialization.hasResolutionImpact(element);
     }
     return _resolutionImpactCache.containsKey(element);
   }
 
   @override
   ResolutionImpact getResolutionImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     ResolutionImpact resolutionImpact;
-    if (compiler.serialization.isDeserialized(element)) {
-      resolutionImpact = compiler.serialization.getResolutionImpact(element);
+    if (_compiler.serialization.isDeserialized(element)) {
+      resolutionImpact = _compiler.serialization.getResolutionImpact(element);
     } else {
       resolutionImpact = _resolutionImpactCache[element];
     }
     assert(invariant(element, resolutionImpact != null,
         message: "ResolutionImpact not available for $element."));
     return resolutionImpact;
   }
 
   @override
   WorldImpact getWorldImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     WorldImpact worldImpact = _worldImpactCache[element];
     assert(invariant(element, worldImpact != null,
         message: "WorldImpact not computed for $element."));
     return worldImpact;
   }
 
   @override
   WorldImpact computeWorldImpact(Element element) {
-    assert(invariant(element, element.isDeclaration,
-        message: "Element $element must be the declaration."));
-    return _worldImpactCache.putIfAbsent(element, () {
-      assert(compiler.parser != null);
-      Node tree = compiler.parser.parse(element);
-      assert(invariant(element, !element.isSynthesized || tree == null));
-      ResolutionImpact resolutionImpact = compiler.resolver.resolve(element);
+    return _compiler.selfTask.measureSubtask("Resolution.computeWorldImpact",
+        () {
+      assert(invariant(
+          element,
+          element.impliesType ||
+              element.isField ||
+              element.isFunction ||
+              element.isConstructor ||
+              element.isGetter ||
+              element.isSetter,
+          message: 'Unexpected element kind: ${element.kind}'));
+      assert(invariant(element, element is AnalyzableElement,
+          message: 'Element $element is not analyzable.'));
+      assert(invariant(element, element.isDeclaration));

[Harry Terkelsen, 2016/11/28 19:24:29]

you have the same invariant twice

[Johnni Winther, 2016/11/29 08:43:38]

One removed!

+      assert(invariant(element, element.isDeclaration,
+          message: "Element $element must be the declaration."));
+      return _worldImpactCache.putIfAbsent(element, () {
+        assert(_compiler.parser != null);
+        Node tree = _compiler.parser.parse(element);
+        assert(invariant(element, !element.isSynthesized || tree == null));
+        ResolutionImpact resolutionImpact = _compiler.resolver.resolve(element);
 
-      if (compiler.serialization.supportSerialization ||
-          retainCachesForTesting) {
-        // [ResolutionImpact] is currently only used by serialization. The
-        // enqueuer uses the [WorldImpact] which is always cached.
-        // TODO(johnniwinther): Align these use cases better; maybe only
-        // cache [ResolutionImpact] and let the enqueuer transform it into
-        // a [WorldImpact].
-        _resolutionImpactCache[element] = resolutionImpact;
-      }
-      if (tree != null && !compiler.options.analyzeSignaturesOnly) {
-        // TODO(het): don't do this if suppressWarnings is on, currently we have
-        // to do it because the typechecker also sets types
-        // Only analyze nodes with a corresponding [TreeElements].
-        compiler.checker.check(element);
-      }
-      return transformResolutionImpact(element, resolutionImpact);
+        if (_compiler.serialization.supportSerialization ||
+            retainCachesForTesting) {
+          // [ResolutionImpact] is currently only used by serialization. The
+          // enqueuer uses the [WorldImpact] which is always cached.
+          // TODO(johnniwinther): Align these use cases better; maybe only
+          // cache [ResolutionImpact] and let the enqueuer transform it into
+          // a [WorldImpact].
+          _resolutionImpactCache[element] = resolutionImpact;
+        }
+        if (tree != null && !_compiler.options.analyzeSignaturesOnly) {
+          // TODO(het): don't do this if suppressWarnings is on, currently we
+          // have to do it because the typechecker also sets types
+          // Only analyze nodes with a corresponding [TreeElements].
+          _compiler.checker.check(element);
+        }
+        return transformResolutionImpact(element, resolutionImpact);
+      });
     });
   }
 
   @override
   WorldImpact transformResolutionImpact(
       Element element, ResolutionImpact resolutionImpact) {
-    WorldImpact worldImpact = compiler.backend.impactTransformer
+    WorldImpact worldImpact = _compiler.backend.impactTransformer
         .transformResolutionImpact(
-            compiler.enqueuer.resolution, resolutionImpact);
+            _compiler.enqueuer.resolution, resolutionImpact);
     _worldImpactCache[element] = worldImpact;
     return worldImpact;
   }
 
   @override
   void uncacheWorldImpact(Element element) {
     assert(invariant(element, element.isDeclaration,
         message: "Element $element must be the declaration."));
     if (retainCachesForTesting) return;
-    if (compiler.serialization.isDeserialized(element)) return;
+    if (_compiler.serialization.isDeserialized(element)) return;
     assert(invariant(element, _worldImpactCache[element] != null,
         message: "WorldImpact not computed for $element."));
     _worldImpactCache[element] = const WorldImpact();
     _resolutionImpactCache.remove(element);
   }
 
   @override
   void emptyCache() {
     if (retainCachesForTesting) return;
     for (Element element in _worldImpactCache.keys) {
       _worldImpactCache[element] = const WorldImpact();
     }
     _resolutionImpactCache.clear();
   }
 
   @override
   bool hasBeenResolved(Element element) {
     return _worldImpactCache.containsKey(element);
   }
 
   @override
   ResolutionWorkItem createWorkItem(Element element) {
-    if (compiler.serialization.isDeserialized(element)) {
-      return compiler.serialization.createResolutionWorkItem(element);
+    if (_compiler.serialization.isDeserialized(element)) {
+      return _compiler.serialization.createResolutionWorkItem(element);
     } else {
-      return new ResolutionWorkItem(element);
+      return new ResolutionWorkItem(this, element);
     }
   }
 
   @override
   void forgetElement(Element element) {
     _worldImpactCache.remove(element);
     _resolutionImpactCache.remove(element);
   }
 
   ConstantValue _proxyConstant;
@@ skipping 56 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;
 }