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:     return closedWorld;
    }
  
    Future<load_kernel.Output> runLoadKernel() async {
      final input = load_kernel.Input(options, provider, reporter,
          initializedCompilerState, forceSerializationForTesting);
      load_kernel.Output output =
          await loadKernelTask.measure(() async => load_kernel.run(input));
      if (output == null || compilationFailed) return null;
      reporter.log("Kernel load complete");
      if (retainDataForTesting) {
        componentForTesting = output.component;
      }
      if (options.features.newDumpInfo.isEnabled && options.dumpInfo) {
        untrimmedComponentForDumpInfo = output.component;
      }
  
      if (options.cfeOnly) {
        ir.Component component = output.component;
        dumpUnusedLibrariesAndTrimComponent(component, output.libraries);
        await serializationTask.serializeComponent(component);
      }
      return output;
    }
  
    void dumpUnusedLibrariesAndTrimComponent(
        ir.Component component, List<Uri> libraries) {
      if (options.fromDill) {
        if (options.dumpUnusedLibraries) {
          dumpUnusedLibraries(component, libraries);
        }
        if (options.entryUri != null) {
          component = trimComponent(component, libraries);
        }
      }
    }
  
    void runModularAnalysis() async {
      load_kernel.Output output = await runLoadKernel();
      if (output == null || compilationFailed) return;
  
      ir.Component component = output.component;
      List<Uri> libraries = output.libraries;
      Set<Uri> moduleLibraries = output.moduleLibraries.toSet();
      _userCodeLocations
          .addAll(moduleLibraries.map((module) => CodeLocation(module)));
      final input = modular_analysis.Input(
          options, reporter, environment, component, libraries, moduleLibraries);
      ModuleData moduleData = await selfTask.measureSubtask(
          'runModularAnalysis', () async => modular_analysis.run(input));
      if (compilationFailed) return;
      serializationTask.testModuleSerialization(moduleData, component);
      serializationTask.serializeModuleData(
          moduleData, component, moduleLibraries);
    }
  
    GlobalTypeInferenceResults performGlobalTypeInference(
        JClosedWorld closedWorld) {
  
negative.code:       programSplitConstraintsData = constraintParser.read(programSplitJson);
      }
  
      await selfTask.measureSubtask("compileFromKernel", () async {
        await runSequentialPhases();
      });
    }
  
    /// Clear the internal compiler state to prevent memory leaks when invoking
  