anchor.diff:      }
     }
   
  -  JClosedWorld computeClosedWorld(Uri rootLibraryUri, Iterable<Uri> libraries) {
  +  JClosedWorld computeClosedWorld(
  +      ir.Component component,
  +      List<ModuleData> moduleData,
  +      Uri rootLibraryUri,
  +      Iterable<Uri> libraries) {
  +    frontendStrategy.registerLoadedLibraries(component, libraries);
  +    frontendStrategy.registerModuleData(moduleData);
       ResolutionEnqueuer resolutionEnqueuer = frontendStrategy
           .createResolutionEnqueuer(enqueueTask, this)
         ..onEmptyForTesting = onResolutionQueueEmptyForTesting;
  
positive.code:   bool get shouldStopAfterCodegen => options.writeCodegenUri != null;
  
    void runSequentialPhases() async {
      await selfTask.measureSubtask("compileFromKernel", () async {
        // Load kernel and compute closed world.
        ClosedWorldAndIndices closedWorldAndIndices = await produceClosedWorld();
        if (shouldStopAfterClosedWorld(closedWorldAndIndices)) return;
  
        // Run global analysis.
        GlobalTypeInferenceResults globalTypeInferenceResults =
            await produceGlobalTypeInferenceResults(closedWorldAndIndices);
        if (shouldStopAfterGlobalTypeInference) return;
  
        // Run codegen.
        CodegenResults codegenResults = await produceCodegenResults(
            globalTypeInferenceResults, closedWorldAndIndices.indices);
        if (shouldStopAfterCodegen) return;
  
        // Link.
        int programSize = runCodegenEnqueuer(codegenResults);
  
        // Dump Info.
        if (options.dumpInfo) {
          runDumpInfo(codegenResults, programSize);
        }
      });
    }
  
    void runDumpInfo(CodegenResults codegenResults, int programSize) {
  
negative.code:         globalTypeInferenceResultsData);
    }
  
    Future<ClosedWorldAndIndices> produceClosedWorld(
        load_kernel.Output output, List<ModuleData> moduleData) async {
      ir.Component component = output.component;
      ClosedWorldAndIndices closedWorldAndIndices;
      if (options.readClosedWorldUri == null) {
        Uri rootLibraryUri = output.rootLibraryUri;
        Iterable<Uri> libraries = output.libraries;
        _userCodeLocations.add(CodeLocation(rootLibraryUri));
        JsClosedWorld closedWorld =
            computeClosedWorld(component, moduleData, rootLibraryUri, libraries);
        closedWorldAndIndices = ClosedWorldAndIndices(closedWorld, null);
        if (options.writeClosedWorldUri != null) {
          serializationTask.serializeComponent(
              closedWorld.elementMap.programEnv.mainComponent);
          serializationTask.serializeClosedWorld(closedWorld);
        }
      } else {
        closedWorldAndIndices = await serializationTask.deserializeClosedWorld(
            environment, abstractValueStrategy, component);
      }
  