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:         globalTypeInferenceResultsData);
    }
  
    Future<load_kernel.Output> loadComponent() async {
      load_kernel.Output output = await runLoadKernel();
      if (output == null || compilationFailed) return null;
  
      ir.Component component = output.component;
      List<Uri> libraries = output.libraries;
      frontendStrategy.registerLoadedLibraries(component, libraries);
      List<ModuleData> data;
      if (options.hasModularAnalysisInputs) {
        data = await serializationTask.deserializeModuleData(component);
      }
      frontendStrategy.registerModuleData(data);
  
      // After we've deserialized modular data, we trim the component of any
      // unnecessary dependencies.
      // Note: It is critical we wait to trim the dill until after we've
      // deserialized modular data because some of this data may reference
      // 'trimmed' elements.
      dumpUnusedLibrariesAndTrimComponent(component, libraries);
      return output;
    }
  
    Future<ClosedWorldAndIndices> produceClosedWorld() async {
      ClosedWorldAndIndices closedWorldAndIndices;
      if (options.readClosedWorldUri == null) {
        load_kernel.Output loadKernelOutput = await loadComponent();
        if (loadKernelOutput != null) {
          Uri rootLibraryUri = loadKernelOutput.rootLibraryUri;
          Iterable<Uri> libraries = loadKernelOutput.libraries;
          _userCodeLocations.add(CodeLocation(rootLibraryUri));
          JsClosedWorld closedWorld =
              computeClosedWorld(rootLibraryUri, libraries);
          closedWorldAndIndices = ClosedWorldAndIndices(closedWorld, null);
          if (options.writeClosedWorldUri != null) {
            serializationTask.serializeComponent(
                closedWorld.elementMap.programEnv.mainComponent);
            serializationTask.serializeClosedWorld(closedWorld);
          }
        }
      } else {
        ir.Component component =
            await serializationTask.deserializeComponentAndUpdateOptions();
        closedWorldAndIndices = await serializationTask.deserializeClosedWorld(
            environment, abstractValueStrategy, component);
      }
  
negative.code:       programSplitConstraintsData = constraintParser.read(programSplitJson);
      }
  
      await selfTask.measureSubtask("compileFromKernel", () async {
        await runSequentialPhases();
      });
    }
  
    /// Clear the internal compiler state to prevent memory leaks when invoking
  