diff --git a/pkg/dev_compiler/lib/src/kernel/command.dart b/pkg/dev_compiler/lib/src/kernel/command.dart
index d8435ca..eccfa92 100644
--- a/pkg/dev_compiler/lib/src/kernel/command.dart
+++ b/pkg/dev_compiler/lib/src/kernel/command.dart
@@ -338,10 +338,13 @@
     result = await fe.compile(compilerState, inputs, diagnosticMessageHandler);
   } else {
     compilerState.options.onDiagnostic = diagnosticMessageHandler;
-    var incrementalComponent = await incrementalCompiler.computeDelta(
+    var incrementalCompilerResult = await incrementalCompiler.computeDelta(
         entryPoints: inputs, fullComponent: true);
-    result = fe.DdcResult(incrementalComponent, cachedSdkInput.component,
-        doneAdditionalDills, incrementalCompiler.userCode.loader.hierarchy);
+    result = fe.DdcResult(
+        incrementalCompilerResult.component,
+        cachedSdkInput.component,
+        doneAdditionalDills,
+        incrementalCompiler.userCode.loader.hierarchy);
   }
   compilerState.options.onDiagnostic = null; // See http://dartbug.com/36983.
 
diff --git a/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart b/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
index 1068a8a..864b911 100644
--- a/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
+++ b/pkg/dev_compiler/lib/src/kernel/expression_compiler_worker.dart
@@ -357,8 +357,9 @@
     var incrementalCompiler = IncrementalCompiler.forExpressionCompilationOnly(
         CompilerContext(_processedOptions), component, /*resetTicker*/ false);
 
-    var finalComponent = await incrementalCompiler
+    var incrementalCompilerResult = await incrementalCompiler
         .computeDelta(entryPoints: [libraryUri], fullComponent: true);
+    var finalComponent = incrementalCompilerResult.component;
     assert(!duplicateLibrariesReachable(finalComponent.libraries));
     assert(_canSerialize(finalComponent));
 
diff --git a/pkg/dev_compiler/test/expression_compiler/expression_compiler_e2e_suite.dart b/pkg/dev_compiler/test/expression_compiler/expression_compiler_e2e_suite.dart
index 7c5152d..46bc90a 100644
--- a/pkg/dev_compiler/test/expression_compiler/expression_compiler_e2e_suite.dart
+++ b/pkg/dev_compiler/test/expression_compiler/expression_compiler_e2e_suite.dart
@@ -117,7 +117,8 @@
     // compilers/components/names per module.
     setup.options.packagesFileUri = packages;
     var compiler = DevelopmentIncrementalCompiler(setup.options, input);
-    var component = await compiler.computeDelta();
+    var compilerResult = await compiler.computeDelta();
+    var component = compilerResult.component;
     component.computeCanonicalNames();
     // Initialize DDC.
     var moduleName = p.basenameWithoutExtension(output.toFilePath());
diff --git a/pkg/dev_compiler/test/expression_compiler/expression_compiler_test.dart b/pkg/dev_compiler/test/expression_compiler/expression_compiler_test.dart
index 66db5dd..5f96bcb 100644
--- a/pkg/dev_compiler/test/expression_compiler/expression_compiler_test.dart
+++ b/pkg/dev_compiler/test/expression_compiler/expression_compiler_test.dart
@@ -76,7 +76,8 @@
     // initialize incremental compiler and create component
     setup.options.packagesFileUri = packages;
     var compiler = DevelopmentIncrementalCompiler(setup.options, input);
-    var component = await compiler.computeDelta();
+    var compilerResult = await compiler.computeDelta();
+    var component = compilerResult.component;
     component.computeCanonicalNames();
 
     // initialize ddc
diff --git a/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart b/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart
index 4fb6eb6..a989d55 100644
--- a/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart
+++ b/pkg/dev_compiler/test/module_symbols/module_symbols_test_shared.dart
@@ -21,7 +21,8 @@
     // Initialize incremental compiler and create component.
     setup.options.packagesFileUri = packages;
     var compiler = DevelopmentIncrementalCompiler(setup.options, input);
-    var component = await compiler.computeDelta();
+    var compilerResult = await compiler.computeDelta();
+    var component = compilerResult.component;
     component.computeCanonicalNames();
     var errors = setup.errors.where((e) => e.contains('Error'));
     if (errors.isNotEmpty) {
diff --git a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
index d28d71c..dfd05f4 100644
--- a/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
+++ b/pkg/front_end/lib/src/api_prototype/incremental_kernel_generator.dart
@@ -70,9 +70,11 @@
         component);
   }
 
-  /// Returns a component whose libraries are the recompiled libraries,
-  /// or - in the case of [fullComponent] - a full Component.
-  Future<Component> computeDelta({List<Uri>? entryPoints, bool fullComponent});
+  /// Returns an [IncrementalCompilerResult] with the component whose libraries
+  /// are the recompiled libraries, or - in the case of [fullComponent] - a full
+  /// Component.
+  Future<IncrementalCompilerResult> computeDelta(
+      {List<Uri>? entryPoints, bool fullComponent});
 
   /// Returns [CoreTypes] used during compilation.
   /// Valid after [computeDelta] is called.
@@ -149,3 +151,9 @@
 bool isLegalIdentifier(String identifier) {
   return StringScanner.isLegalIdentifier(identifier);
 }
+
+class IncrementalCompilerResult {
+  final Component component;
+
+  IncrementalCompilerResult(this.component);
+}
diff --git a/pkg/front_end/lib/src/api_unstable/vm.dart b/pkg/front_end/lib/src/api_unstable/vm.dart
index 141014c..b9b4ca7 100644
--- a/pkg/front_end/lib/src/api_unstable/vm.dart
+++ b/pkg/front_end/lib/src/api_unstable/vm.dart
@@ -24,7 +24,11 @@
 export '../api_prototype/front_end.dart' show CompilerResult;
 
 export '../api_prototype/incremental_kernel_generator.dart'
-    show IncrementalKernelGenerator, IncrementalSerializer, isLegalIdentifier;
+    show
+        IncrementalCompilerResult,
+        IncrementalKernelGenerator,
+        IncrementalSerializer,
+        isLegalIdentifier;
 
 export '../api_prototype/kernel_generator.dart'
     show kernelForModule, kernelForProgram;
diff --git a/pkg/front_end/lib/src/fasta/incremental_compiler.dart b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
index 23f2625..747a3af 100644
--- a/pkg/front_end/lib/src/fasta/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/fasta/incremental_compiler.dart
@@ -62,7 +62,10 @@
 import '../api_prototype/file_system.dart' show FileSystem, FileSystemEntity;
 
 import '../api_prototype/incremental_kernel_generator.dart'
-    show IncrementalKernelGenerator, isLegalIdentifier;
+    show
+        IncrementalCompilerResult,
+        IncrementalKernelGenerator,
+        isLegalIdentifier;
 
 import '../api_prototype/lowering_predicates.dart' show isExtensionThisName;
 
@@ -143,78 +146,94 @@
 class IncrementalCompiler implements IncrementalKernelGenerator {
   final CompilerContext context;
 
-  final Ticker ticker;
-  final bool resetTicker;
+  final Ticker _ticker;
+  final bool _resetTicker;
   final bool outlineOnly;
   bool trackNeededDillLibraries = false;
-  Set<Library>? neededDillLibraries;
+  Set<Library>? _neededDillLibraries;
 
-  Set<Uri?> invalidatedUris = new Set<Uri?>();
+  Set<Uri?> _invalidatedUris = new Set<Uri?>();
 
-  DillTarget? dillLoadedData;
-  List<LibraryBuilder>? platformBuilders;
-  Map<Uri, LibraryBuilder>? userBuilders;
-  final Uri? initializeFromDillUri;
-  Component? componentToInitializeFrom;
-  bool initializedFromDill = false;
-  bool initializedIncrementalSerializer = false;
-  Uri? previousPackagesUri;
-  Map<String, Package>? previousPackagesMap;
-  Map<String, Package>? currentPackagesMap;
-  bool hasToCheckPackageUris = false;
-  final bool initializedForExpressionCompilationOnly;
-  bool computeDeltaRunOnce = false;
-  Map<Uri, List<DiagnosticMessageFromJson>> remainingComponentProblems =
+  DillTarget? _dillLoadedData;
+  List<LibraryBuilder>? _platformBuilders;
+  Map<Uri, LibraryBuilder>? _userBuilders;
+  final Uri? _initializeFromDillUri;
+  Component? _componentToInitializeFrom;
+  bool _initializedFromDill = false;
+  bool _initializedIncrementalSerializer = false;
+  Uri? _previousPackagesUri;
+  Map<String, Package>? _previousPackagesMap;
+  Map<String, Package>? _currentPackagesMap;
+  bool _hasToCheckPackageUris = false;
+  final bool _initializedForExpressionCompilationOnly;
+  bool _computeDeltaRunOnce = false;
+  Map<Uri, List<DiagnosticMessageFromJson>> _remainingComponentProblems =
       new Map<Uri, List<DiagnosticMessageFromJson>>();
-  List<Component>? modulesToLoad;
-  IncrementalSerializer? incrementalSerializer;
+  List<Component>? _modulesToLoad;
+  IncrementalSerializer? _incrementalSerializer;
 
   static final Uri debugExprUri =
       new Uri(scheme: "org-dartlang-debug", path: "synthetic_debug_expression");
 
-  IncrementalKernelTarget? userCode;
-  Set<Library>? previousSourceBuilders;
+  IncrementalKernelTarget? _userCode;
+  Set<Library>? _previousSourceBuilders;
 
   /// Guard against multiple computeDelta calls at the same time (possibly
   /// caused by lacking awaits etc).
-  Completer<dynamic>? currentlyCompiling;
+  Completer<dynamic>? _currentlyCompiling;
 
   IncrementalCompiler.fromComponent(
-      this.context, this.componentToInitializeFrom,
-      [bool? outlineOnly, this.incrementalSerializer])
-      : ticker = context.options.ticker,
-        resetTicker = true,
-        initializeFromDillUri = null,
+      this.context, this._componentToInitializeFrom,
+      [bool? outlineOnly, this._incrementalSerializer])
+      : _ticker = context.options.ticker,
+        _resetTicker = true,
+        _initializeFromDillUri = null,
         this.outlineOnly = outlineOnly ?? false,
-        this.initializedForExpressionCompilationOnly = false {
-    enableExperimentsBasedOnEnvironment();
+        this._initializedForExpressionCompilationOnly = false {
+    _enableExperimentsBasedOnEnvironment();
   }
 
   IncrementalCompiler(this.context,
-      [this.initializeFromDillUri,
+      [this._initializeFromDillUri,
       bool? outlineOnly,
-      this.incrementalSerializer])
-      : ticker = context.options.ticker,
-        resetTicker = true,
-        componentToInitializeFrom = null,
+      this._incrementalSerializer])
+      : _ticker = context.options.ticker,
+        _resetTicker = true,
+        _componentToInitializeFrom = null,
         this.outlineOnly = outlineOnly ?? false,
-        this.initializedForExpressionCompilationOnly = false {
-    enableExperimentsBasedOnEnvironment();
+        this._initializedForExpressionCompilationOnly = false {
+    _enableExperimentsBasedOnEnvironment();
   }
 
   IncrementalCompiler.forExpressionCompilationOnly(
-      this.context, this.componentToInitializeFrom,
+      this.context, this._componentToInitializeFrom,
       [bool? resetTicker])
-      : ticker = context.options.ticker,
-        this.resetTicker = resetTicker ?? true,
-        initializeFromDillUri = null,
+      : _ticker = context.options.ticker,
+        this._resetTicker = resetTicker ?? true,
+        _initializeFromDillUri = null,
         this.outlineOnly = false,
-        this.incrementalSerializer = null,
-        this.initializedForExpressionCompilationOnly = true {
-    enableExperimentsBasedOnEnvironment();
+        this._incrementalSerializer = null,
+        this._initializedForExpressionCompilationOnly = true {
+    _enableExperimentsBasedOnEnvironment();
   }
 
-  void enableExperimentsBasedOnEnvironment({Set<String>? enabledExperiments}) {
+  bool get initializedFromDill => _initializedFromDill;
+
+  bool get initializedIncrementalSerializer =>
+      _initializedIncrementalSerializer;
+
+  Set<Library>? get neededDillLibraries => _neededDillLibraries;
+
+  DillTarget? get dillLoadedData => _dillLoadedData;
+
+  IncrementalKernelTarget? get userCode => _userCode;
+
+  /// Returns the [Package] used for the package [packageName] in the most
+  /// recent compilation.
+  Package? getPackageForPackageName(String packageName) =>
+      _currentPackagesMap?[packageName];
+
+  void _enableExperimentsBasedOnEnvironment({Set<String>? enabledExperiments}) {
     // Note that these are all experimental. Use at your own risk.
     enabledExperiments ??= getExperimentEnvironment();
     // Currently there's no live experiments.
@@ -222,36 +241,37 @@
 
   @override
   void setExperimentalFeaturesForTesting(Set<String> features) {
-    enableExperimentsBasedOnEnvironment(enabledExperiments: features);
+    _enableExperimentsBasedOnEnvironment(enabledExperiments: features);
   }
 
   @override
-  Future<Component> computeDelta(
+  Future<IncrementalCompilerResult> computeDelta(
       {List<Uri>? entryPoints, bool fullComponent: false}) async {
-    while (currentlyCompiling != null) {
-      await currentlyCompiling!.future;
+    while (_currentlyCompiling != null) {
+      await _currentlyCompiling!.future;
     }
-    currentlyCompiling = new Completer();
-    if (resetTicker) {
-      ticker.reset();
+    _currentlyCompiling = new Completer();
+    if (_resetTicker) {
+      _ticker.reset();
     }
     entryPoints ??= context.options.inputs;
-    return context.runInContext<Component>((CompilerContext c) async {
-      if (computeDeltaRunOnce && initializedForExpressionCompilationOnly) {
+    return context
+        .runInContext<IncrementalCompilerResult>((CompilerContext c) async {
+      if (_computeDeltaRunOnce && _initializedForExpressionCompilationOnly) {
         throw new StateError("Initialized for expression compilation: "
             "cannot do another general compile.");
       }
-      computeDeltaRunOnce = true;
+      _computeDeltaRunOnce = true;
       // Initial setup: Load platform, initialize from dill or component etc.
-      UriTranslator uriTranslator = await setupPackagesAndUriTranslator(c);
+      UriTranslator uriTranslator = await _setupPackagesAndUriTranslator(c);
       IncrementalCompilerData data =
-          await ensurePlatformAndInitialize(uriTranslator, c);
+          await _ensurePlatformAndInitialize(uriTranslator, c);
 
       // Figure out what to keep and what to throw away.
-      Set<Uri?> invalidatedUris = this.invalidatedUris.toSet();
-      invalidateNotKeptUserBuilders(invalidatedUris);
+      Set<Uri?> invalidatedUris = this._invalidatedUris.toSet();
+      _invalidateNotKeptUserBuilders(invalidatedUris);
       ReusageResult? reusedResult =
-          computeReusedLibraries(invalidatedUris, uriTranslator, entryPoints!);
+          _computeReusedLibraries(invalidatedUris, uriTranslator, entryPoints!);
 
       // Use the reused libraries to re-write entry-points.
       if (reusedResult.arePartsUsedAsEntryPoints()) {
@@ -267,43 +287,43 @@
 
       // Experimental invalidation initialization (e.g. figure out if we can).
       ExperimentalInvalidation? experimentalInvalidation =
-          await initializeExperimentalInvalidation(reusedResult, c);
+          await _initializeExperimentalInvalidation(reusedResult, c);
       recordRebuildBodiesCountForTesting(
           experimentalInvalidation?.missingSources.length ?? 0);
 
       // Cleanup: After (potentially) removing builders we have stuff to cleanup
       // to not leak, and we might need to re-create the dill target.
-      cleanupRemovedBuilders(reusedResult, uriTranslator);
-      recreateDillTargetIfPackageWasUpdated(uriTranslator, c);
-      ClassHierarchy? hierarchy = userCode?.loader.hierarchy;
-      cleanupHierarchy(hierarchy, experimentalInvalidation, reusedResult);
+      _cleanupRemovedBuilders(reusedResult, uriTranslator);
+      _recreateDillTargetIfPackageWasUpdated(uriTranslator, c);
+      ClassHierarchy? hierarchy = _userCode?.loader.hierarchy;
+      _cleanupHierarchy(hierarchy, experimentalInvalidation, reusedResult);
       List<LibraryBuilder> reusedLibraries = reusedResult.reusedLibraries;
       reusedResult = null;
 
       // TODO(jensj): Given the code below, [userCode] is assumed always to be
       // non-null.
-      if (userCode != null) {
-        ticker.logMs("Decided to reuse ${reusedLibraries.length}"
-            " of ${userCode!.loader.libraryBuilders.length} libraries");
+      if (_userCode != null) {
+        _ticker.logMs("Decided to reuse ${reusedLibraries.length}"
+            " of ${_userCode!.loader.libraryBuilders.length} libraries");
       }
 
       // For modular compilation we can be asked to load components and track
       // which libraries we actually use for the compilation. Set that up now.
-      loadEnsureLoadedComponents(reusedLibraries);
-      resetTrackingOfUsedLibraries(hierarchy);
+      _loadEnsureLoadedComponents(reusedLibraries);
+      _resetTrackingOfUsedLibraries(hierarchy);
 
       // For each computeDelta call we create a new userCode object which needs
       // to be setup, and in the case of experimental invalidation some of the
       // builders needs to be patched up.
-      IncrementalKernelTarget? userCodeOld = userCode;
-      setupNewUserCode(c, uriTranslator, hierarchy, reusedLibraries,
+      IncrementalKernelTarget? userCodeOld = _userCode;
+      _setupNewUserCode(c, uriTranslator, hierarchy, reusedLibraries,
           experimentalInvalidation, entryPoints!.first);
       Map<LibraryBuilder, List<LibraryBuilder>>? rebuildBodiesMap =
-          experimentalInvalidationCreateRebuildBodiesBuilders(
+          _experimentalInvalidationCreateRebuildBodiesBuilders(
               experimentalInvalidation, uriTranslator);
-      entryPoints = userCode!.setEntryPoints(entryPoints!);
-      await userCode!.loader.buildOutlines();
-      experimentalInvalidationPatchUpScopes(
+      entryPoints = _userCode!.setEntryPoints(entryPoints!);
+      await _userCode!.loader.buildOutlines();
+      _experimentalInvalidationPatchUpScopes(
           experimentalInvalidation, rebuildBodiesMap);
       rebuildBodiesMap = null;
 
@@ -313,35 +333,35 @@
       // libraries loaded from .dill files or directly from components.
       // Technically, it's the combination of userCode.loader.libraries and
       // dillLoadedData.loader.libraries.
-      Component? componentWithDill = await userCode!.buildOutlines();
+      Component? componentWithDill = await _userCode!.buildOutlines();
 
       if (!outlineOnly) {
         // Checkpoint: Build the actual bodies.
         componentWithDill =
-            await userCode!.buildComponent(verify: c.options.verify);
+            await _userCode!.buildComponent(verify: c.options.verify);
       }
-      hierarchy ??= userCode!.loader.hierarchy;
+      hierarchy ??= _userCode!.loader.hierarchy;
       // ignore: unnecessary_null_comparison
       if (hierarchy != null) {
-        if (userCode!.classHierarchyChanges != null) {
-          hierarchy.applyTreeChanges([], [], userCode!.classHierarchyChanges!);
+        if (_userCode!.classHierarchyChanges != null) {
+          hierarchy.applyTreeChanges([], [], _userCode!.classHierarchyChanges!);
         }
-        if (userCode!.classMemberChanges != null) {
-          hierarchy.applyMemberChanges(userCode!.classMemberChanges!,
+        if (_userCode!.classMemberChanges != null) {
+          hierarchy.applyMemberChanges(_userCode!.classMemberChanges!,
               findDescendants: true);
         }
       }
       recordNonFullComponentForTesting(componentWithDill!);
 
       // Perform actual dill usage tracking.
-      performDillUsageTracking(hierarchy);
+      _performDillUsageTracking(hierarchy);
 
       // If we actually got a result we can throw away the old userCode and the
       // list of invalidated uris.
       // ignore: unnecessary_null_comparison
       if (componentWithDill != null) {
-        this.invalidatedUris.clear();
-        hasToCheckPackageUris = false;
+        this._invalidatedUris.clear();
+        _hasToCheckPackageUris = false;
         userCodeOld?.loader.releaseAncillaryResources();
         userCodeOld = null;
       }
@@ -349,12 +369,12 @@
       // Compute which libraries to output and which (previous) errors/warnings
       // we have to reissue. In the process do some cleanup too.
       List<Library> compiledLibraries =
-          new List<Library>.from(userCode!.loader.libraries);
+          new List<Library>.from(_userCode!.loader.libraries);
       Map<Uri, Source> uriToSource = componentWithDill.uriToSource;
-      experimentalCompilationPostCompilePatchup(
+      _experimentalCompilationPostCompilePatchup(
           experimentalInvalidation, compiledLibraries, uriToSource);
       List<Library> outputLibraries =
-          calculateOutputLibrariesAndIssueLibraryProblems(
+          _calculateOutputLibrariesAndIssueLibraryProblems(
               data.component != null || fullComponent,
               compiledLibraries,
               entryPoints!,
@@ -363,18 +383,19 @@
               uriTranslator,
               uriToSource,
               c);
-      List<String> problemsAsJson = reissueComponentProblems(componentWithDill);
+      List<String> problemsAsJson =
+          _reissueComponentProblems(componentWithDill);
 
       // If we didn't get a result, go back to the previous one so expression
       // calculation has the potential to work.
       // ignore: unnecessary_null_comparison
       if (componentWithDill == null) {
-        userCode!.loader.clearLibraryBuilders();
-        userCode = userCodeOld;
-        dillLoadedData!.loader.currentSourceLoader = userCode!.loader;
+        _userCode!.loader.clearLibraryBuilders();
+        _userCode = userCodeOld;
+        _dillLoadedData!.loader.currentSourceLoader = _userCode!.loader;
       } else {
-        previousSourceBuilders =
-            convertSourceLibraryBuildersToDill(experimentalInvalidation);
+        _previousSourceBuilders =
+            _convertSourceLibraryBuildersToDill(experimentalInvalidation);
       }
 
       experimentalInvalidation = null;
@@ -394,11 +415,11 @@
         ..problemsAsJson = problemsAsJson;
 
       // We're now done. Allow any waiting compile to start.
-      Completer<dynamic> currentlyCompilingLocal = currentlyCompiling!;
-      currentlyCompiling = null;
+      Completer<dynamic> currentlyCompilingLocal = _currentlyCompiling!;
+      _currentlyCompiling = null;
       currentlyCompilingLocal.complete();
 
-      return result;
+      return new IncrementalCompilerResult(result);
     });
   }
 
@@ -410,25 +431,25 @@
   /// source builders and they will thus be patched up here too.
   ///
   /// Returns the set of Libraries that now has new (dill) builders.
-  Set<Library> convertSourceLibraryBuildersToDill(
+  Set<Library> _convertSourceLibraryBuildersToDill(
       ExperimentalInvalidation? experimentalInvalidation) {
     bool changed = false;
     Set<Library> newDillLibraryBuilders = new Set<Library>();
-    userBuilders ??= <Uri, LibraryBuilder>{};
+    _userBuilders ??= <Uri, LibraryBuilder>{};
     Map<LibraryBuilder, List<LibraryBuilder>>? convertedLibraries;
-    for (LibraryBuilder builder in userCode!.loader.libraryBuilders) {
+    for (LibraryBuilder builder in _userCode!.loader.libraryBuilders) {
       if (builder is SourceLibraryBuilder) {
         DillLibraryBuilder dillBuilder =
-            dillLoadedData!.loader.appendLibrary(builder.library);
-        userCode!.loader.registerLibraryBuilder(
+            _dillLoadedData!.loader.appendLibrary(builder.library);
+        _userCode!.loader.registerLibraryBuilder(
             // TODO(johnniwinther): Why do we need to create
             //  [DillLibraryBuilder]s for the patch library file uris?
             dillBuilder,
             builder.isPatch ? builder.fileUri : null);
-        userBuilders![builder.importUri] = dillBuilder;
+        _userBuilders![builder.importUri] = dillBuilder;
         newDillLibraryBuilders.add(builder.library);
-        if (userCode!.loader.first == builder) {
-          userCode!.loader.first = dillBuilder;
+        if (_userCode!.loader.first == builder) {
+          _userCode!.loader.first = dillBuilder;
         }
         changed = true;
         if (experimentalInvalidation != null) {
@@ -441,8 +462,9 @@
     if (changed) {
       // We suppress finalization errors because they have already been
       // reported.
-      dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
-      assert(_checkEquivalentScopes(userCode!.loader, dillLoadedData!.loader));
+      _dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
+      assert(
+          _checkEquivalentScopes(_userCode!.loader, _dillLoadedData!.loader));
 
       if (experimentalInvalidation != null) {
         /// If doing experimental invalidation that means that some of the old
@@ -455,7 +477,7 @@
         // Maps from old library builder to map of new content.
         Map<LibraryBuilder, Map<String, Builder>>? replacementSettersMap = {};
 
-        experimentalInvalidationFillReplacementMaps(
+        _experimentalInvalidationFillReplacementMaps(
             convertedLibraries!, replacementMap, replacementSettersMap);
 
         for (LibraryBuilder builder
@@ -478,12 +500,12 @@
         replacementSettersMap = null;
       }
     }
-    userCode!.loader.buildersCreatedWithReferences.clear();
-    userCode!.loader.builderHierarchy.clear();
-    userCode!.loader.referenceFromIndex = null;
+    _userCode!.loader.buildersCreatedWithReferences.clear();
+    _userCode!.loader.builderHierarchy.clear();
+    _userCode!.loader.referenceFromIndex = null;
     convertedLibraries = null;
     experimentalInvalidation = null;
-    if (userBuilders!.isEmpty) userBuilders = null;
+    if (_userBuilders!.isEmpty) _userBuilders = null;
     return newDillLibraryBuilders;
   }
 
@@ -565,7 +587,7 @@
 
   /// Compute which libraries to output and which (previous) errors/warnings we
   /// have to reissue. In the process do some cleanup too.
-  List<Library> calculateOutputLibrariesAndIssueLibraryProblems(
+  List<Library> _calculateOutputLibrariesAndIssueLibraryProblems(
       bool fullComponent,
       List<Library> compiledLibraries,
       List<Uri> entryPoints,
@@ -577,18 +599,18 @@
     List<Library> outputLibraries;
     Set<Library> allLibraries;
     if (fullComponent) {
-      outputLibraries = computeTransitiveClosure(compiledLibraries, entryPoints,
-          reusedLibraries, hierarchy, uriTranslator, uriToSource);
+      outputLibraries = _computeTransitiveClosure(compiledLibraries,
+          entryPoints, reusedLibraries, hierarchy, uriTranslator, uriToSource);
       allLibraries = outputLibraries.toSet();
       if (!c.options.omitPlatform) {
-        for (int i = 0; i < platformBuilders!.length; i++) {
-          Library lib = platformBuilders![i].library;
+        for (int i = 0; i < _platformBuilders!.length; i++) {
+          Library lib = _platformBuilders![i].library;
           outputLibraries.add(lib);
         }
       }
     } else {
       outputLibraries = <Library>[];
-      allLibraries = computeTransitiveClosure(
+      allLibraries = _computeTransitiveClosure(
               compiledLibraries,
               entryPoints,
               reusedLibraries,
@@ -599,7 +621,7 @@
           .toSet();
     }
 
-    reissueLibraryProblems(allLibraries, compiledLibraries);
+    _reissueLibraryProblems(allLibraries, compiledLibraries);
     return outputLibraries;
   }
 
@@ -610,7 +632,7 @@
   /// contain all the libraries that would normally have been recompiled.
   /// This might be a temporary thing, but we need to figure out if the VM
   /// can (always) work with only getting the actually rebuild stuff.
-  void experimentalCompilationPostCompilePatchup(
+  void _experimentalCompilationPostCompilePatchup(
       ExperimentalInvalidation? experimentalInvalidation,
       List<Library> compiledLibraries,
       Map<Uri, Source> uriToSource) {
@@ -628,32 +650,32 @@
   /// Perform dill usage tracking if asked. Use the marking on dill builders as
   /// well as the class hierarchy to figure out which dill libraries was
   /// actually used by the compilation.
-  void performDillUsageTracking(ClassHierarchy hierarchy) {
+  void _performDillUsageTracking(ClassHierarchy hierarchy) {
     if (trackNeededDillLibraries) {
       // Which dill builders were built?
-      neededDillLibraries = new Set<Library>();
+      Set<Library> neededDillLibraries = _neededDillLibraries = {};
 
       // Propagate data from constant evaluator: Libraries used in the constant
       // evaluator - that comes from dill - are marked.
-      Set<Library> librariesUsedByConstantEvaluator = userCode!.librariesUsed;
+      Set<Library> librariesUsedByConstantEvaluator = _userCode!.librariesUsed;
 
-      for (LibraryBuilder builder in dillLoadedData!.loader.libraryBuilders) {
+      for (LibraryBuilder builder in _dillLoadedData!.loader.libraryBuilders) {
         if (builder is DillLibraryBuilder) {
           if (builder.isBuiltAndMarked ||
               librariesUsedByConstantEvaluator.contains(builder.library)) {
-            neededDillLibraries!.add(builder.library);
+            neededDillLibraries.add(builder.library);
           }
         }
       }
 
       updateNeededDillLibrariesWithHierarchy(
-          hierarchy, userCode!.loader.builderHierarchy);
+          hierarchy, _userCode!.loader.builderHierarchy);
     }
   }
 
   /// Fill in the replacement maps that describe the replacements that need to
   /// happen because of experimental invalidation.
-  void experimentalInvalidationFillReplacementMaps(
+  void _experimentalInvalidationFillReplacementMaps(
       Map<LibraryBuilder, List<LibraryBuilder>> rebuildBodiesMap,
       Map<LibraryBuilder, Map<String, Builder>> replacementMap,
       Map<LibraryBuilder, Map<String, Builder>> replacementSettersMap) {
@@ -690,7 +712,7 @@
   /// be rebuild special, namely they have to be [userCode.loader.read] with
   /// references from the original [Library] for things to work.
   Map<LibraryBuilder, List<LibraryBuilder>>
-      experimentalInvalidationCreateRebuildBodiesBuilders(
+      _experimentalInvalidationCreateRebuildBodiesBuilders(
           ExperimentalInvalidation? experimentalInvalidation,
           UriTranslator uriTranslator) {
     // Any builder(s) in [rebuildBodies] should be semi-reused: Create source
@@ -700,8 +722,9 @@
         new Map<LibraryBuilder, List<LibraryBuilder>>.identity();
     if (experimentalInvalidation != null) {
       for (LibraryBuilder library in experimentalInvalidation.rebuildBodies) {
-        LibraryBuilder newBuilder = userCode!.loader.read(library.importUri, -1,
-            accessor: userCode!.loader.first,
+        LibraryBuilder newBuilder = _userCode!.loader.read(
+            library.importUri, -1,
+            accessor: _userCode!.loader.first,
             fileUri: library.fileUri,
             referencesFrom: library.library);
         List<LibraryBuilder> builders = [newBuilder];
@@ -713,8 +736,8 @@
           // libraries.
           Uri partUri = getPartUri(library.importUri, part);
           Uri? fileUri =
-              getPartFileUri(library.library.fileUri, part, uriTranslator);
-          LibraryBuilder newPartBuilder = userCode!.loader.read(partUri, -1,
+              _getPartFileUri(library.library.fileUri, part, uriTranslator);
+          LibraryBuilder newPartBuilder = _userCode!.loader.read(partUri, -1,
               accessor: library,
               fileUri: fileUri,
               referencesFrom: library.library,
@@ -729,7 +752,7 @@
   /// When doing experimental invalidation we have to patch up the scopes of the
   /// the libraries we're not recompiling but should have recompiled if we
   /// didn't do anything special.
-  void experimentalInvalidationPatchUpScopes(
+  void _experimentalInvalidationPatchUpScopes(
       ExperimentalInvalidation? experimentalInvalidation,
       Map<LibraryBuilder, List<LibraryBuilder>> rebuildBodiesMap) {
     if (experimentalInvalidation != null) {
@@ -739,7 +762,7 @@
       // Maps from old library builder to map of new content.
       Map<LibraryBuilder, Map<String, Builder>> replacementSettersMap = {};
 
-      experimentalInvalidationFillReplacementMaps(
+      _experimentalInvalidationFillReplacementMaps(
           rebuildBodiesMap, replacementMap, replacementSettersMap);
 
       for (LibraryBuilder builder
@@ -777,20 +800,20 @@
             Builder childBuilder = iterator.current;
             if (childBuilder is SourceClassBuilder) {
               TypeBuilder? typeBuilder = childBuilder.supertypeBuilder;
-              replaceTypeBuilder(
+              _replaceTypeBuilder(
                   replacementMap, replacementSettersMap, typeBuilder);
               typeBuilder = childBuilder.mixedInTypeBuilder;
-              replaceTypeBuilder(
+              _replaceTypeBuilder(
                   replacementMap, replacementSettersMap, typeBuilder);
               if (childBuilder.onTypes != null) {
                 for (typeBuilder in childBuilder.onTypes!) {
-                  replaceTypeBuilder(
+                  _replaceTypeBuilder(
                       replacementMap, replacementSettersMap, typeBuilder);
                 }
               }
               if (childBuilder.interfaceBuilders != null) {
                 for (typeBuilder in childBuilder.interfaceBuilders!) {
-                  replaceTypeBuilder(
+                  _replaceTypeBuilder(
                       replacementMap, replacementSettersMap, typeBuilder);
                 }
               }
@@ -820,30 +843,30 @@
         fileSystem, includeComments, dillTarget, uriTranslator);
   }
 
-  /// Create a new [userCode] object, and add the reused builders to it.
-  void setupNewUserCode(
+  /// Create a new [_userCode] object, and add the reused builders to it.
+  void _setupNewUserCode(
       CompilerContext c,
       UriTranslator uriTranslator,
       ClassHierarchy? hierarchy,
       List<LibraryBuilder> reusedLibraries,
       ExperimentalInvalidation? experimentalInvalidation,
       Uri firstEntryPoint) {
-    userCode = createIncrementalKernelTarget(
+    _userCode = createIncrementalKernelTarget(
         new HybridFileSystem(
             new MemoryFileSystem(
                 new Uri(scheme: "org-dartlang-debug", path: "/")),
             c.fileSystem),
         false,
-        dillLoadedData!,
+        _dillLoadedData!,
         uriTranslator);
-    userCode!.loader.hierarchy = hierarchy;
-    dillLoadedData!.loader.currentSourceLoader = userCode!.loader;
+    _userCode!.loader.hierarchy = hierarchy;
+    _dillLoadedData!.loader.currentSourceLoader = _userCode!.loader;
 
     // Re-use the libraries we've deemed re-usable.
     List<bool> seenModes = [false, false, false, false];
     for (LibraryBuilder library in reusedLibraries) {
       seenModes[library.library.nonNullableByDefaultCompiledMode.index] = true;
-      userCode!.loader.registerLibraryBuilder(library);
+      _userCode!.loader.registerLibraryBuilder(library);
     }
     // Check compilation mode up against what we've seen here and set
     // `hasInvalidNnbdModeLibrary` accordingly.
@@ -853,14 +876,14 @@
           // Don't expect strong or invalid.
           if (seenModes[NonNullableByDefaultCompiledMode.Strong.index] ||
               seenModes[NonNullableByDefaultCompiledMode.Invalid.index]) {
-            userCode!.loader.hasInvalidNnbdModeLibrary = true;
+            _userCode!.loader.hasInvalidNnbdModeLibrary = true;
           }
           break;
         case NnbdMode.Strong:
           // Don't expect weak or invalid.
           if (seenModes[NonNullableByDefaultCompiledMode.Weak.index] ||
               seenModes[NonNullableByDefaultCompiledMode.Invalid.index]) {
-            userCode!.loader.hasInvalidNnbdModeLibrary = true;
+            _userCode!.loader.hasInvalidNnbdModeLibrary = true;
           }
           break;
         case NnbdMode.Agnostic:
@@ -868,7 +891,7 @@
           if (seenModes[NonNullableByDefaultCompiledMode.Strong.index] ||
               seenModes[NonNullableByDefaultCompiledMode.Weak.index] ||
               seenModes[NonNullableByDefaultCompiledMode.Invalid.index]) {
-            userCode!.loader.hasInvalidNnbdModeLibrary = true;
+            _userCode!.loader.hasInvalidNnbdModeLibrary = true;
           }
           break;
       }
@@ -876,7 +899,7 @@
       // Don't expect strong or invalid.
       if (seenModes[NonNullableByDefaultCompiledMode.Strong.index] ||
           seenModes[NonNullableByDefaultCompiledMode.Invalid.index]) {
-        userCode!.loader.hasInvalidNnbdModeLibrary = true;
+        _userCode!.loader.hasInvalidNnbdModeLibrary = true;
       }
     }
 
@@ -884,13 +907,13 @@
     // correctly. If the first one is in the rebuildBodies, we have to add it
     // from there first.
     Uri firstEntryPointImportUri =
-        userCode!.getEntryPointUri(firstEntryPoint, issueProblem: false);
+        _userCode!.getEntryPointUri(firstEntryPoint, issueProblem: false);
     bool wasFirstSet = false;
     if (experimentalInvalidation != null) {
       for (LibraryBuilder library in experimentalInvalidation.rebuildBodies) {
         if (library.importUri == firstEntryPointImportUri) {
-          userCode!.loader.read(library.importUri, -1,
-              accessor: userCode!.loader.first,
+          _userCode!.loader.read(library.importUri, -1,
+              accessor: _userCode!.loader.first,
               fileUri: library.fileUri,
               referencesFrom: library.library);
           wasFirstSet = true;
@@ -899,17 +922,17 @@
       }
     }
     if (!wasFirstSet) {
-      userCode!.loader.read(firstEntryPointImportUri, -1,
-          accessor: userCode!.loader.first,
+      _userCode!.loader.read(firstEntryPointImportUri, -1,
+          accessor: _userCode!.loader.first,
           fileUri: firstEntryPointImportUri != firstEntryPoint
               ? firstEntryPoint
               : null);
     }
-    if (userCode!.loader.first == null) {
+    if (_userCode!.loader.first == null) {
       LibraryBuilder? libraryBuilder =
-          userCode!.loader.lookupLibraryBuilder(firstEntryPointImportUri);
+          _userCode!.loader.lookupLibraryBuilder(firstEntryPointImportUri);
       if (libraryBuilder != null) {
-        userCode!.loader.first = libraryBuilder;
+        _userCode!.loader.first = libraryBuilder;
       }
     }
   }
@@ -917,10 +940,10 @@
   /// When tracking used libraries we mark them when we use them. To track
   /// correctly we have to unmark before the next iteration to not have too much
   /// marked and therefore incorrectly marked something as used when it is not.
-  void resetTrackingOfUsedLibraries(ClassHierarchy? hierarchy) {
+  void _resetTrackingOfUsedLibraries(ClassHierarchy? hierarchy) {
     if (trackNeededDillLibraries) {
       // Reset dill loaders and kernel class hierarchy.
-      for (LibraryBuilder builder in dillLoadedData!.loader.libraryBuilders) {
+      for (LibraryBuilder builder in _dillLoadedData!.loader.libraryBuilders) {
         if (builder is DillLibraryBuilder) {
           if (builder.isBuiltAndMarked) {
             // Clear cached calculations in classes which upon calculation can
@@ -944,7 +967,7 @@
   /// Cleanup the hierarchy to no longer reference libraries that we are
   /// invalidating (or would normally have invalidated if we hadn't done any
   /// experimental invalidation).
-  void cleanupHierarchy(
+  void _cleanupHierarchy(
       ClassHierarchy? hierarchy,
       ExperimentalInvalidation? experimentalInvalidation,
       ReusageResult reusedResult) {
@@ -970,19 +993,20 @@
   /// If the package uris needs to be re-checked the uri translator has changed,
   /// and the [DillTarget] needs to get the new uri translator. We do that
   /// by creating a new one.
-  void recreateDillTargetIfPackageWasUpdated(
+  void _recreateDillTargetIfPackageWasUpdated(
       UriTranslator uriTranslator, CompilerContext c) {
-    if (hasToCheckPackageUris) {
+    if (_hasToCheckPackageUris) {
       // The package file was changed.
       // Make sure the dill loader is on the same page.
-      DillTarget oldDillLoadedData = dillLoadedData!;
-      dillLoadedData = new DillTarget(ticker, uriTranslator, c.options.target);
+      DillTarget oldDillLoadedData = _dillLoadedData!;
+      DillTarget newDillLoadedData = _dillLoadedData =
+          new DillTarget(_ticker, uriTranslator, c.options.target);
       for (DillLibraryBuilder library
           in oldDillLoadedData.loader.libraryBuilders) {
-        dillLoadedData!.loader.registerLibraryBuilder(library);
+        newDillLoadedData.loader.registerLibraryBuilder(library);
       }
-      dillLoadedData!.loader.first = oldDillLoadedData.loader.first;
-      dillLoadedData!.loader.libraries
+      newDillLoadedData.loader.first = oldDillLoadedData.loader.first;
+      newDillLoadedData.loader.libraries
           .addAll(oldDillLoadedData.loader.libraries);
     }
   }
@@ -994,37 +1018,37 @@
   /// We also have to remove any component problems beloning to any such
   /// no-longer-used library (to avoid re-issuing errors about no longer
   /// relevant stuff).
-  void cleanupRemovedBuilders(
+  void _cleanupRemovedBuilders(
       ReusageResult reusedResult, UriTranslator uriTranslator) {
     bool removedDillBuilders = false;
     for (LibraryBuilder builder in reusedResult.notReusedLibraries) {
-      cleanupSourcesForBuilder(reusedResult, builder, uriTranslator,
+      _cleanupSourcesForBuilder(reusedResult, builder, uriTranslator,
           CompilerContext.current.uriToSource);
-      incrementalSerializer?.invalidate(builder.fileUri);
+      _incrementalSerializer?.invalidate(builder.fileUri);
 
       LibraryBuilder? dillBuilder =
           dillLoadedData!.loader.deregisterLibraryBuilder(builder.importUri);
       if (dillBuilder != null) {
         removedDillBuilders = true;
-        userBuilders?.remove(builder.importUri);
+        _userBuilders?.remove(builder.importUri);
       }
 
       // Remove component problems for libraries we don't reuse.
-      if (remainingComponentProblems.isNotEmpty) {
+      if (_remainingComponentProblems.isNotEmpty) {
         Library lib = builder.library;
-        removeLibraryFromRemainingComponentProblems(lib, uriTranslator);
+        _removeLibraryFromRemainingComponentProblems(lib, uriTranslator);
       }
     }
 
     if (removedDillBuilders) {
-      makeDillLoaderLibrariesUpToDateWithBuildersMap();
+      _makeDillLoaderLibrariesUpToDateWithBuildersMap();
     }
   }
 
   bool _importsFfi() {
-    if (userBuilders == null) return false;
+    if (_userBuilders == null) return false;
     final Uri dartFfiUri = Uri.parse("dart:ffi");
-    for (LibraryBuilder builder in userBuilders!.values) {
+    for (LibraryBuilder builder in _userBuilders!.values) {
       Library lib = builder.library;
       for (LibraryDependency dependency in lib.dependencies) {
         if (dependency.targetLibrary.importUri == dartFfiUri) {
@@ -1038,7 +1062,7 @@
   /// Figure out if we can (and was asked to) do experimental invalidation.
   /// Note that this returns (future or) [null] if we're not doing experimental
   /// invalidation.
-  Future<ExperimentalInvalidation?> initializeExperimentalInvalidation(
+  Future<ExperimentalInvalidation?> _initializeExperimentalInvalidation(
       ReusageResult reusedResult, CompilerContext c) async {
     Set<LibraryBuilder>? rebuildBodies;
     Set<LibraryBuilder> originalNotReusedLibraries;
@@ -1046,7 +1070,7 @@
 
     if (!context.options.isExperimentEnabledGlobally(
         ExperimentalFlag.alternativeInvalidationStrategy)) return null;
-    if (modulesToLoad != null) return null;
+    if (_modulesToLoad != null) return null;
     if (reusedResult.directlyInvalidated.isEmpty) return null;
     if (reusedResult.invalidatedBecauseOfPackageUpdate) return null;
 
@@ -1185,29 +1209,30 @@
 
   /// Get UriTranslator, and figure out if the packages file was (potentially)
   /// changed.
-  Future<UriTranslator> setupPackagesAndUriTranslator(CompilerContext c) async {
+  Future<UriTranslator> _setupPackagesAndUriTranslator(
+      CompilerContext c) async {
     bool bypassCache = false;
-    if (!identical(previousPackagesUri, c.options.packagesUriRaw)) {
-      previousPackagesUri = c.options.packagesUriRaw;
+    if (!identical(_previousPackagesUri, c.options.packagesUriRaw)) {
+      _previousPackagesUri = c.options.packagesUriRaw;
       bypassCache = true;
-    } else if (this.invalidatedUris.contains(c.options.packagesUri)) {
+    } else if (this._invalidatedUris.contains(c.options.packagesUri)) {
       bypassCache = true;
     }
     UriTranslator uriTranslator =
         await c.options.getUriTranslator(bypassCache: bypassCache);
-    previousPackagesMap = currentPackagesMap;
-    currentPackagesMap = createPackagesMap(uriTranslator.packages);
+    _previousPackagesMap = _currentPackagesMap;
+    _currentPackagesMap = _createPackagesMap(uriTranslator.packages);
     // TODO(jensj): We can probably (from the maps above) figure out if anything
     // changed and only set this to true if it did.
-    hasToCheckPackageUris = hasToCheckPackageUris || bypassCache;
-    ticker.logMs("Read packages file");
-    if (initializedForExpressionCompilationOnly) {
-      hasToCheckPackageUris = false;
+    _hasToCheckPackageUris = _hasToCheckPackageUris || bypassCache;
+    _ticker.logMs("Read packages file");
+    if (_initializedForExpressionCompilationOnly) {
+      _hasToCheckPackageUris = false;
     }
     return uriTranslator;
   }
 
-  Map<String, Package> createPackagesMap(PackageConfig packages) {
+  Map<String, Package> _createPackagesMap(PackageConfig packages) {
     Map<String, Package> result = new Map<String, Package>();
     for (Package package in packages.packages) {
       result[package.name] = package;
@@ -1217,26 +1242,28 @@
 
   /// Load platform and (potentially) initialize from dill,
   /// or initialize from component.
-  Future<IncrementalCompilerData> ensurePlatformAndInitialize(
+  Future<IncrementalCompilerData> _ensurePlatformAndInitialize(
       UriTranslator uriTranslator, CompilerContext c) async {
     IncrementalCompilerData data = new IncrementalCompilerData();
-    if (dillLoadedData == null) {
+    if (_dillLoadedData == null) {
       int bytesLength = 0;
-      if (componentToInitializeFrom != null) {
+      if (_componentToInitializeFrom != null) {
         // If initializing from a component it has to include the sdk,
         // so we explicitly don't load it here.
-        initializeFromComponent(uriTranslator, c, data);
-        componentToInitializeFrom = null;
+        _initializeFromComponent(uriTranslator, c, data);
+        assert(_dillLoadedData != null);
+        _componentToInitializeFrom = null;
       } else {
         List<int>? summaryBytes = await c.options.loadSdkSummaryBytes();
-        bytesLength = prepareSummary(summaryBytes, uriTranslator, c, data);
-        if (initializeFromDillUri != null) {
+        bytesLength = _prepareSummary(summaryBytes, uriTranslator, c, data);
+        assert(_dillLoadedData != null);
+        if (_initializeFromDillUri != null) {
           try {
-            bytesLength += await initializeFromDill(uriTranslator, c, data);
+            bytesLength += await _initializeFromDill(uriTranslator, c, data);
           } catch (e, st) {
             // We might have loaded x out of y libraries into the component.
             // To avoid any unforeseen problems start over.
-            bytesLength = prepareSummary(summaryBytes, uriTranslator, c, data);
+            bytesLength = _prepareSummary(summaryBytes, uriTranslator, c, data);
 
             if (e is InvalidKernelVersionError ||
                 e is InvalidKernelSdkVersionError ||
@@ -1254,51 +1281,51 @@
               if (e is CanonicalNameError) {
                 Message message = gzInitializedFrom != null
                     ? templateInitializeFromDillNotSelfContained.withArguments(
-                        initializeFromDillUri.toString(), gzInitializedFrom)
+                        _initializeFromDillUri.toString(), gzInitializedFrom)
                     : templateInitializeFromDillNotSelfContainedNoDump
-                        .withArguments(initializeFromDillUri.toString());
-                dillLoadedData!.loader
+                        .withArguments(_initializeFromDillUri.toString());
+                _dillLoadedData!.loader
                     .addProblem(message, TreeNode.noOffset, 1, null);
               } else {
                 // Unknown error: Report problem as such.
                 Message message = gzInitializedFrom != null
                     ? templateInitializeFromDillUnknownProblem.withArguments(
-                        initializeFromDillUri.toString(),
+                        _initializeFromDillUri.toString(),
                         "$e",
                         "$st",
                         gzInitializedFrom)
                     : templateInitializeFromDillUnknownProblemNoDump
                         .withArguments(
-                            initializeFromDillUri.toString(), "$e", "$st");
-                dillLoadedData!.loader
+                            _initializeFromDillUri.toString(), "$e", "$st");
+                _dillLoadedData!.loader
                     .addProblem(message, TreeNode.noOffset, 1, null);
               }
             }
           }
         }
       }
-      appendLibraries(data, bytesLength);
+      _appendLibraries(data, bytesLength);
 
       // We suppress finalization errors because they will reported via
       // problemsAsJson fields (with better precision).
-      dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
-      userBuilders = <Uri, LibraryBuilder>{};
-      platformBuilders = <LibraryBuilder>[];
+      _dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
+      _userBuilders = <Uri, LibraryBuilder>{};
+      _platformBuilders = <LibraryBuilder>[];
       for (DillLibraryBuilder builder
-          in dillLoadedData!.loader.libraryBuilders) {
+          in _dillLoadedData!.loader.libraryBuilders) {
         if (builder.importUri.scheme == "dart") {
-          platformBuilders!.add(builder);
+          _platformBuilders!.add(builder);
         } else {
-          userBuilders![builder.importUri] = builder;
+          _userBuilders![builder.importUri] = builder;
         }
       }
-      if (userBuilders!.isEmpty) userBuilders = null;
+      if (_userBuilders!.isEmpty) _userBuilders = null;
     }
     data.initializationBytes = null;
     return data;
   }
 
-  void replaceTypeBuilder(
+  void _replaceTypeBuilder(
       Map<LibraryBuilder, Map<String, Builder>> replacementMap,
       Map<LibraryBuilder, Map<String, Builder>> replacementSettersMap,
       TypeBuilder? typeBuilder) {
@@ -1320,10 +1347,10 @@
   }
 
   @override
-  CoreTypes? getCoreTypes() => userCode?.loader.coreTypes;
+  CoreTypes? getCoreTypes() => _userCode?.loader.coreTypes;
 
   @override
-  ClassHierarchy? getClassHierarchy() => userCode?.loader.hierarchy;
+  ClassHierarchy? getClassHierarchy() => _userCode?.loader.hierarchy;
 
   /// Allows for updating the list of needed libraries.
   ///
@@ -1339,7 +1366,7 @@
   void updateNeededDillLibrariesWithHierarchy(
       ClassHierarchy hierarchy, ClassHierarchyBuilder? builderHierarchy) {
     if (hierarchy is ClosedWorldClassHierarchy && !hierarchy.allBetsOff) {
-      neededDillLibraries ??= new Set<Library>();
+      Set<Library> neededDillLibraries = _neededDillLibraries ??= {};
       Set<Class> classes = new Set<Class>();
       List<Class> worklist = <Class>[];
       // Get all classes touched by kernel class hierarchy.
@@ -1380,35 +1407,35 @@
         Library library = c.enclosingLibrary;
         // Only add if loaded from a dill file (and wasn't a 'dill' that was
         // converted from source builders to dill builders).
-        if (dillLoadedData!.loader.containsLibraryBuilder(library.importUri) &&
-            (previousSourceBuilders == null ||
-                !previousSourceBuilders!.contains(library))) {
-          neededDillLibraries!.add(library);
+        if (_dillLoadedData!.loader.containsLibraryBuilder(library.importUri) &&
+            (_previousSourceBuilders == null ||
+                !_previousSourceBuilders!.contains(library))) {
+          neededDillLibraries.add(library);
         }
       }
     } else {
       // Cannot track in other kernel class hierarchies or
       // if all bets are off: Add everything (except for the libraries we just
       // converted from source builders to dill builders).
-      neededDillLibraries = new Set<Library>();
+      Set<Library> neededDillLibraries = _neededDillLibraries = {};
       for (DillLibraryBuilder builder
-          in dillLoadedData!.loader.libraryBuilders) {
-        if (previousSourceBuilders == null ||
-            !previousSourceBuilders!.contains(builder.library)) {
-          neededDillLibraries!.add(builder.library);
+          in _dillLoadedData!.loader.libraryBuilders) {
+        if (_previousSourceBuilders == null ||
+            !_previousSourceBuilders!.contains(builder.library)) {
+          neededDillLibraries.add(builder.library);
         }
       }
     }
   }
 
   /// Internal method.
-  void invalidateNotKeptUserBuilders(Set<Uri?> invalidatedUris) {
-    if (modulesToLoad != null && userBuilders != null) {
+  void _invalidateNotKeptUserBuilders(Set<Uri?> invalidatedUris) {
+    if (_modulesToLoad != null && _userBuilders != null) {
       Set<Library> loadedNotKept = new Set<Library>();
-      for (LibraryBuilder builder in userBuilders!.values) {
+      for (LibraryBuilder builder in _userBuilders!.values) {
         loadedNotKept.add(builder.library);
       }
-      for (Component module in modulesToLoad!) {
+      for (Component module in _modulesToLoad!) {
         loadedNotKept.removeAll(module.libraries);
       }
       for (Library lib in loadedNotKept) {
@@ -1418,43 +1445,44 @@
   }
 
   /// Internal method.
-  void loadEnsureLoadedComponents(List<LibraryBuilder> reusedLibraries) {
-    if (modulesToLoad != null) {
+  void _loadEnsureLoadedComponents(List<LibraryBuilder> reusedLibraries) {
+    if (_modulesToLoad != null) {
       bool loadedAnything = false;
-      for (Component module in modulesToLoad!) {
+      for (Component module in _modulesToLoad!) {
         bool usedComponent = false;
         for (Library lib in module.libraries) {
-          if (!dillLoadedData!.loader.containsLibraryBuilder(lib.importUri)) {
-            dillLoadedData!.loader.libraries.add(lib);
-            dillLoadedData!.loader.registerKnownLibrary(lib);
-            reusedLibraries.add(dillLoadedData!.loader.read(lib.importUri, -1));
+          if (!_dillLoadedData!.loader.containsLibraryBuilder(lib.importUri)) {
+            _dillLoadedData!.loader.libraries.add(lib);
+            _dillLoadedData!.loader.registerKnownLibrary(lib);
+            reusedLibraries
+                .add(_dillLoadedData!.loader.read(lib.importUri, -1));
             usedComponent = true;
           }
         }
         if (usedComponent) {
-          dillLoadedData!.uriToSource.addAll(module.uriToSource);
+          _dillLoadedData!.uriToSource.addAll(module.uriToSource);
           loadedAnything = true;
         }
       }
       if (loadedAnything) {
         // We suppress finalization errors because they will reported via
         // problemsAsJson fields (with better precision).
-        dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
-        userBuilders = <Uri, LibraryBuilder>{};
-        platformBuilders = <LibraryBuilder>[];
+        _dillLoadedData!.buildOutlines(suppressFinalizationErrors: true);
+        _userBuilders = <Uri, LibraryBuilder>{};
+        _platformBuilders = <LibraryBuilder>[];
         for (DillLibraryBuilder builder
-            in dillLoadedData!.loader.libraryBuilders) {
+            in _dillLoadedData!.loader.libraryBuilders) {
           if (builder.importUri.scheme == "dart") {
-            platformBuilders!.add(builder);
+            _platformBuilders!.add(builder);
           } else {
-            userBuilders![builder.importUri] = builder;
+            _userBuilders![builder.importUri] = builder;
           }
         }
-        if (userBuilders!.isEmpty) {
-          userBuilders = null;
+        if (_userBuilders!.isEmpty) {
+          _userBuilders = null;
         }
       }
-      modulesToLoad = null;
+      _modulesToLoad = null;
     }
   }
 
@@ -1463,7 +1491,7 @@
   }
 
   /// Internal method.
-  void reissueLibraryProblems(
+  void _reissueLibraryProblems(
       Set<Library> allLibraries, List<Library> compiledLibraries) {
     // The newly-compiled libraries have issued problems already. Re-issue
     // problems for the libraries that weren't re-compiled (ignore compile
@@ -1485,7 +1513,7 @@
 
   /// Internal method.
   /// Re-issue problems on the component and return the filtered list.
-  List<String> reissueComponentProblems(Component componentWithDill) {
+  List<String> _reissueComponentProblems(Component componentWithDill) {
     // These problems have already been reported.
     Set<String> issuedProblems = new Set<String>();
     if (componentWithDill.problemsAsJson != null) {
@@ -1495,7 +1523,7 @@
     // Report old problems that wasn't reported again.
     Set<Uri>? strongModeNNBDPackageOptOutUris;
     for (MapEntry<Uri, List<DiagnosticMessageFromJson>> entry
-        in remainingComponentProblems.entries) {
+        in _remainingComponentProblems.entries) {
       List<DiagnosticMessageFromJson> messages = entry.value;
       for (int i = 0; i < messages.length; i++) {
         DiagnosticMessageFromJson message = messages[i];
@@ -1516,7 +1544,7 @@
       // `SourceLoader.giveCombinedErrorForNonStrongLibraries` on them to issue
       // a new error.
       Set<LibraryBuilder> builders = {};
-      SourceLoader loader = userCode!.loader;
+      SourceLoader loader = _userCode!.loader;
       for (LibraryBuilder builder in loader.libraryBuilders) {
         if (strongModeNNBDPackageOptOutUris.contains(builder.fileUri)) {
           builders.add(builder);
@@ -1535,7 +1563,7 @@
   }
 
   /// Internal method.
-  Uri? getPartFileUri(
+  Uri? _getPartFileUri(
       Uri parentFileUri, LibraryPart part, UriTranslator uriTranslator) {
     Uri? fileUri = getPartUri(parentFileUri, part);
     if (fileUri.scheme == "package") {
@@ -1552,7 +1580,7 @@
   ///
   /// As a side-effect, this also cleans-up now-unreferenced builders as well as
   /// any saved component problems for such builders.
-  List<Library> computeTransitiveClosure(
+  List<Library> _computeTransitiveClosure(
       List<Library> inputLibraries,
       List<Uri> entryPoints,
       List<LibraryBuilder> reusedLibraries,
@@ -1622,7 +1650,7 @@
           }
           for (LibraryPart part in library.parts) {
             Uri? partFileUri =
-                getPartFileUri(library.fileUri, part, uriTranslator);
+                _getPartFileUri(library.fileUri, part, uriTranslator);
             partsUsed.add(partFileUri);
           }
         }
@@ -1633,26 +1661,26 @@
     bool removedDillBuilders = false;
     for (Uri uri in potentiallyReferencedLibraries.keys) {
       if (uri.scheme == "package") continue;
-      LibraryBuilder? builder = userCode!.loader.deregisterLibraryBuilder(uri);
+      LibraryBuilder? builder = _userCode!.loader.deregisterLibraryBuilder(uri);
       if (builder != null) {
         Library lib = builder.library;
         removedLibraries.add(lib);
         if (dillLoadedData!.loader.deregisterLibraryBuilder(uri) != null) {
           removedDillBuilders = true;
         }
-        cleanupSourcesForBuilder(null, builder, uriTranslator,
+        _cleanupSourcesForBuilder(null, builder, uriTranslator,
             CompilerContext.current.uriToSource, uriToSource, partsUsed);
-        userBuilders?.remove(uri);
-        removeLibraryFromRemainingComponentProblems(
+        _userBuilders?.remove(uri);
+        _removeLibraryFromRemainingComponentProblems(
             lib, uriTranslator, partsUsed);
 
         // Technically this isn't necessary as the uri is not a package-uri.
-        incrementalSerializer?.invalidate(builder.fileUri);
+        _incrementalSerializer?.invalidate(builder.fileUri);
       }
     }
     hierarchy.applyTreeChanges(removedLibraries, const [], const []);
     if (removedDillBuilders) {
-      makeDillLoaderLibrariesUpToDateWithBuildersMap();
+      _makeDillLoaderLibrariesUpToDateWithBuildersMap();
     }
 
     return result;
@@ -1663,10 +1691,10 @@
   /// will still hang around and be linked into the Component created internally
   /// in the compilation process.
   /// This method syncs the [libraries] list with the data in [builders].
-  void makeDillLoaderLibrariesUpToDateWithBuildersMap() {
-    dillLoadedData!.loader.libraries.clear();
-    for (LibraryBuilder builder in dillLoadedData!.loader.libraryBuilders) {
-      dillLoadedData!.loader.libraries.add(builder.library);
+  void _makeDillLoaderLibrariesUpToDateWithBuildersMap() {
+    _dillLoadedData!.loader.libraries.clear();
+    for (LibraryBuilder builder in _dillLoadedData!.loader.libraryBuilders) {
+      _dillLoadedData!.loader.libraries.add(builder.library);
     }
   }
 
@@ -1675,7 +1703,7 @@
   /// [partsUsed] indicates part uris that are used by (other/alive) libraries.
   /// Those parts will not be cleaned up. This is useful when a part has been
   /// "moved" to be part of another library.
-  void cleanupSourcesForBuilder(
+  void _cleanupSourcesForBuilder(
       ReusageResult? reusedResult,
       LibraryBuilder builder,
       UriTranslator uriTranslator,
@@ -1686,15 +1714,15 @@
     uriToSourceExtra?.remove(builder.fileUri);
     Library lib = builder.library;
     for (LibraryPart part in lib.parts) {
-      Uri? partFileUri = getPartFileUri(lib.fileUri, part, uriTranslator);
+      Uri? partFileUri = _getPartFileUri(lib.fileUri, part, uriTranslator);
       if (partsUsed != null && partsUsed.contains(partFileUri)) continue;
 
       // If the builders map contain the "parts" import uri, it's a real library
       // (erroneously) used as a part so we don't want to remove that.
-      if (userCode?.loader != null) {
+      if (_userCode?.loader != null) {
         Uri? partImportUri = uriToSource[partFileUri]?.importUri;
         if (partImportUri != null &&
-            userCode!.loader.containsLibraryBuilder(partImportUri)) {
+            _userCode!.loader.containsLibraryBuilder(partImportUri)) {
           continue;
         }
       } else if (reusedResult != null) {
@@ -1722,30 +1750,30 @@
   /// [partsUsed] indicates part uris that are used by (other/alive) libraries.
   /// Those parts will not be removed from the component problems.
   /// This is useful when a part has been "moved" to be part of another library.
-  void removeLibraryFromRemainingComponentProblems(
+  void _removeLibraryFromRemainingComponentProblems(
       Library lib, UriTranslator uriTranslator,
       [Set<Uri?>? partsUsed]) {
-    remainingComponentProblems.remove(lib.fileUri);
+    _remainingComponentProblems.remove(lib.fileUri);
     // Remove parts too.
     for (LibraryPart part in lib.parts) {
-      Uri? partFileUri = getPartFileUri(lib.fileUri, part, uriTranslator);
-      remainingComponentProblems.remove(partFileUri);
+      Uri? partFileUri = _getPartFileUri(lib.fileUri, part, uriTranslator);
+      _remainingComponentProblems.remove(partFileUri);
     }
   }
 
   /// Internal method.
-  int prepareSummary(List<int>? summaryBytes, UriTranslator uriTranslator,
+  int _prepareSummary(List<int>? summaryBytes, UriTranslator uriTranslator,
       CompilerContext c, IncrementalCompilerData data) {
-    dillLoadedData = new DillTarget(ticker, uriTranslator, c.options.target);
+    _dillLoadedData = new DillTarget(_ticker, uriTranslator, c.options.target);
     int bytesLength = 0;
 
     data.component = c.options.target.configureComponent(new Component());
     if (summaryBytes != null) {
-      ticker.logMs("Read ${c.options.sdkSummary}");
+      _ticker.logMs("Read ${c.options.sdkSummary}");
       new BinaryBuilderWithMetadata(summaryBytes,
               disableLazyReading: false, disableLazyClassReading: true)
           .readComponent(data.component!);
-      ticker.logMs("Deserialized ${c.options.sdkSummary}");
+      _ticker.logMs("Deserialized ${c.options.sdkSummary}");
       bytesLength += summaryBytes.length;
     }
 
@@ -1754,16 +1782,16 @@
 
   /// Internal method.
   // This procedure will try to load the dill file and will crash if it cannot.
-  Future<int> initializeFromDill(UriTranslator uriTranslator, CompilerContext c,
-      IncrementalCompilerData data) async {
+  Future<int> _initializeFromDill(UriTranslator uriTranslator,
+      CompilerContext c, IncrementalCompilerData data) async {
     int bytesLength = 0;
     FileSystemEntity entity =
-        c.options.fileSystem.entityForUri(initializeFromDillUri!);
+        c.options.fileSystem.entityForUri(_initializeFromDillUri!);
     if (await entity.exists()) {
       List<int> initializationBytes = await entity.readAsBytes();
       // ignore: unnecessary_null_comparison
       if (initializationBytes != null && initializationBytes.isNotEmpty) {
-        ticker.logMs("Read $initializeFromDillUri");
+        _ticker.logMs("Read $_initializeFromDillUri");
         data.initializationBytes = initializationBytes;
 
         // We're going to output all we read here so lazy loading it
@@ -1820,20 +1848,20 @@
 
         // Only initialize the incremental serializer when we know we'll
         // actually use the data loaded from dill.
-        initializedIncrementalSerializer =
-            incrementalSerializer?.initialize(initializationBytes, views) ??
+        _initializedIncrementalSerializer =
+            _incrementalSerializer?.initialize(initializationBytes, views) ??
                 false;
 
-        initializedFromDill = true;
+        _initializedFromDill = true;
         bytesLength += initializationBytes.length;
-        saveComponentProblems(data);
+        _saveComponentProblems(data);
       }
     }
     return bytesLength;
   }
 
   /// Internal method.
-  void saveComponentProblems(IncrementalCompilerData data) {
+  void _saveComponentProblems(IncrementalCompilerData data) {
     List<String>? problemsAsJson = data.component!.problemsAsJson;
     _addProblemsAsJsonToRemainingProblems(problemsAsJson);
   }
@@ -1848,7 +1876,7 @@
                 message.involvedFiles!.isNotEmpty));
         if (message.uri != null) {
           List<DiagnosticMessageFromJson> messages =
-              remainingComponentProblems[message.uri!] ??=
+              _remainingComponentProblems[message.uri!] ??=
                   <DiagnosticMessageFromJson>[];
           messages.add(message);
         }
@@ -1859,7 +1887,7 @@
           // only be reported once.
           for (Uri uri in message.involvedFiles!) {
             List<DiagnosticMessageFromJson> messages =
-                remainingComponentProblems[uri] ??=
+                _remainingComponentProblems[uri] ??=
                     <DiagnosticMessageFromJson>[];
             messages.add(message);
           }
@@ -1870,17 +1898,17 @@
 
   /// Internal method.
   // This procedure will set up compiler from [componentToInitializeFrom].
-  void initializeFromComponent(UriTranslator uriTranslator, CompilerContext c,
+  void _initializeFromComponent(UriTranslator uriTranslator, CompilerContext c,
       IncrementalCompilerData data) {
-    ticker.logMs("About to initializeFromComponent");
+    _ticker.logMs("About to initializeFromComponent");
 
-    dillLoadedData = new DillTarget(ticker, uriTranslator, c.options.target);
+    _dillLoadedData = new DillTarget(_ticker, uriTranslator, c.options.target);
     data.component = new Component(
-        libraries: componentToInitializeFrom!.libraries,
-        uriToSource: componentToInitializeFrom!.uriToSource)
-      ..setMainMethodAndMode(componentToInitializeFrom!.mainMethod?.reference,
-          true, componentToInitializeFrom!.mode);
-    saveComponentProblems(data);
+        libraries: _componentToInitializeFrom!.libraries,
+        uriToSource: _componentToInitializeFrom!.uriToSource)
+      ..setMainMethodAndMode(_componentToInitializeFrom!.mainMethod?.reference,
+          true, _componentToInitializeFrom!.mode);
+    _saveComponentProblems(data);
 
     bool foundDartCore = false;
     for (int i = 0; i < data.component!.libraries.length; i++) {
@@ -1897,16 +1925,16 @@
           "tried to initialize from component.");
     }
 
-    ticker.logMs("Ran initializeFromComponent");
+    _ticker.logMs("Ran initializeFromComponent");
   }
 
   /// Internal method.
-  void appendLibraries(IncrementalCompilerData data, int bytesLength) {
+  void _appendLibraries(IncrementalCompilerData data, int bytesLength) {
     if (data.component != null) {
       dillLoadedData!.loader
           .appendLibraries(data.component!, byteCount: bytesLength);
     }
-    ticker.logMs("Appended libraries");
+    _ticker.logMs("Appended libraries");
   }
 
   @override
@@ -1919,12 +1947,12 @@
       {String? className,
       String? methodName,
       bool isStatic = false}) async {
-    assert(dillLoadedData != null && userCode != null);
+    assert(_dillLoadedData != null && _userCode != null);
 
     return await context.runInContext((_) async {
-      LibraryBuilder libraryBuilder = userCode!.loader
-          .read(libraryUri, -1, accessor: userCode!.loader.first);
-      ticker.logMs("Loaded library $libraryUri");
+      LibraryBuilder libraryBuilder = _userCode!.loader
+          .read(libraryUri, -1, accessor: _userCode!.loader.first);
+      _ticker.logMs("Loaded library $libraryUri");
 
       Class? cls;
       if (className != null) {
@@ -1954,11 +1982,11 @@
         }
       }
 
-      userCode!.loader.resetSeenMessages();
+      _userCode!.loader.resetSeenMessages();
 
       for (TypeParameter typeParam in typeDefinitions) {
         if (!isLegalIdentifier(typeParam.name!)) {
-          userCode!.loader.addProblem(
+          _userCode!.loader.addProblem(
               templateIncrementalCompilerIllegalTypeParameter
                   .withArguments('$typeParam'),
               typeParam.fileOffset,
@@ -1975,7 +2003,7 @@
                 !isStatic &&
                 index == 1 &&
                 isExtensionThisName(name)))) {
-          userCode!.loader.addProblem(
+          _userCode!.loader.addProblem(
               templateIncrementalCompilerIllegalParameter.withArguments(name),
               // TODO: pass variable declarations instead of
               // parameter names for proper location detection.
@@ -1992,12 +2020,12 @@
         debugExprUri,
         /*packageUri*/ null,
         new ImplicitLanguageVersion(libraryBuilder.library.languageVersion),
-        userCode!.loader,
+        _userCode!.loader,
         null,
         scope: libraryBuilder.scope.createNestedScope("expression"),
         nameOrigin: libraryBuilder,
       );
-      ticker.logMs("Created debug library");
+      _ticker.logMs("Created debug library");
 
       if (libraryBuilder is DillLibraryBuilder) {
         for (LibraryDependency dependency
@@ -2030,10 +2058,10 @@
         }
 
         debugLibrary.addImportsToScope();
-        ticker.logMs("Added imports");
+        _ticker.logMs("Added imports");
       }
 
-      HybridFileSystem hfs = userCode!.fileSystem as HybridFileSystem;
+      HybridFileSystem hfs = _userCode!.fileSystem as HybridFileSystem;
       MemoryFileSystem fs = hfs.memory;
       fs.entityForUri(debugExprUri).writeAsStringSync(expression);
 
@@ -2061,8 +2089,8 @@
         }
       }
 
-      debugLibrary.build(userCode!.loader.coreLibrary, modifyTarget: false);
-      Expression compiledExpression = await userCode!.loader.buildExpression(
+      debugLibrary.build(_userCode!.loader.coreLibrary, modifyTarget: false);
+      Expression compiledExpression = await _userCode!.loader.buildExpression(
           debugLibrary,
           className ?? extensionName,
           (className != null && !isStatic) || extensionThis != null,
@@ -2080,21 +2108,21 @@
       procedure.fileUri = debugLibrary.fileUri;
       procedure.parent = cls ?? libraryBuilder.library;
 
-      userCode!.uriToSource.remove(debugExprUri);
-      userCode!.loader.sourceBytes.remove(debugExprUri);
+      _userCode!.uriToSource.remove(debugExprUri);
+      _userCode!.loader.sourceBytes.remove(debugExprUri);
 
       // Make sure the library has a canonical name.
       Component c = new Component(libraries: [debugLibrary.library]);
       c.computeCanonicalNames();
-      ticker.logMs("Built debug library");
+      _ticker.logMs("Built debug library");
 
-      userCode!.runProcedureTransformations(procedure);
+      _userCode!.runProcedureTransformations(procedure);
 
       return procedure;
     });
   }
 
-  bool packagesEqual(Package? a, Package? b) {
+  bool _packagesEqual(Package? a, Package? b) {
     if (a == null || b == null) return false;
     if (a.name != b.name) return false;
     if (a.root != b.root) return false;
@@ -2105,16 +2133,16 @@
   }
 
   /// Internal method.
-  ReusageResult computeReusedLibraries(Set<Uri?> invalidatedUris,
+  ReusageResult _computeReusedLibraries(Set<Uri?> invalidatedUris,
       UriTranslator uriTranslator, List<Uri> entryPoints) {
     Set<Uri> seenUris = new Set<Uri>();
     List<LibraryBuilder> reusedLibraries = <LibraryBuilder>[];
-    for (int i = 0; i < platformBuilders!.length; i++) {
-      LibraryBuilder builder = platformBuilders![i];
+    for (int i = 0; i < _platformBuilders!.length; i++) {
+      LibraryBuilder builder = _platformBuilders![i];
       if (!seenUris.add(builder.importUri)) continue;
       reusedLibraries.add(builder);
     }
-    if (userCode == null && userBuilders == null) {
+    if (_userCode == null && _userBuilders == null) {
       return new ReusageResult.reusedLibrariesOnly(reusedLibraries);
     }
     bool invalidatedBecauseOfPackageUpdate = false;
@@ -2134,16 +2162,16 @@
       if (importUri != fileUri && invalidatedUris.contains(fileUri)) {
         return true;
       }
-      if (hasToCheckPackageUris && importUri.scheme == "package") {
+      if (_hasToCheckPackageUris && importUri.scheme == "package") {
         // Get package name, check if the base URI has changed for the package,
         // if it has, translate the URI again,
         // otherwise the URI cannot have changed.
         String path = importUri.path;
         int firstSlash = path.indexOf('/');
         String packageName = path.substring(0, firstSlash);
-        if (previousPackagesMap == null ||
-            !packagesEqual(previousPackagesMap![packageName],
-                currentPackagesMap![packageName])) {
+        if (_previousPackagesMap == null ||
+            !_packagesEqual(_previousPackagesMap![packageName],
+                _currentPackagesMap![packageName])) {
           Uri? newFileUri = uriTranslator.translate(importUri, false);
           if (newFileUri != fileUri) {
             invalidatedBecauseOfPackageUpdate = true;
@@ -2179,7 +2207,7 @@
       } else if (libraryBuilder is DillLibraryBuilder) {
         for (LibraryPart part in libraryBuilder.library.parts) {
           Uri partUri = getPartUri(libraryBuilder.importUri, part);
-          Uri? fileUri = getPartFileUri(
+          Uri? fileUri = _getPartFileUri(
               libraryBuilder.library.fileUri, part, uriTranslator);
           partUriToParent[partUri] = libraryBuilder;
           partUriToParent[fileUri] = libraryBuilder;
@@ -2198,16 +2226,16 @@
       }
     }
 
-    if (userCode != null) {
+    if (_userCode != null) {
       // userCode already contains the builders from userBuilders.
-      for (LibraryBuilder libraryBuilder in userCode!.loader.libraryBuilders) {
+      for (LibraryBuilder libraryBuilder in _userCode!.loader.libraryBuilders) {
         addBuilderAndInvalidateUris(libraryBuilder.importUri, libraryBuilder);
       }
     } else {
       // userCode was null so we explicitly have to add the builders from
       // userBuilders (which cannot be null as we checked initially that one of
       // them was non-null).
-      userBuilders!.forEach(addBuilderAndInvalidateUris);
+      _userBuilders!.forEach(addBuilderAndInvalidateUris);
     }
 
     recordInvalidatedImportUrisForTesting(invalidatedImportUris);
@@ -2286,26 +2314,26 @@
 
   @override
   void invalidate(Uri? uri) {
-    invalidatedUris.add(uri);
+    _invalidatedUris.add(uri);
   }
 
   @override
   void invalidateAllSources() {
-    if (userCode != null) {
-      Set<Uri> uris = new Set<Uri>.from(userCode!.loader.libraryImportUris);
-      uris.removeAll(dillLoadedData!.loader.libraryImportUris);
-      if (previousSourceBuilders != null) {
-        for (Library library in previousSourceBuilders!) {
+    if (_userCode != null) {
+      Set<Uri> uris = new Set<Uri>.from(_userCode!.loader.libraryImportUris);
+      uris.removeAll(_dillLoadedData!.loader.libraryImportUris);
+      if (_previousSourceBuilders != null) {
+        for (Library library in _previousSourceBuilders!) {
           uris.add(library.importUri);
         }
       }
-      invalidatedUris.addAll(uris);
+      _invalidatedUris.addAll(uris);
     }
   }
 
   @override
   void setModulesToLoadOnNextComputeDelta(List<Component> components) {
-    modulesToLoad = components.toList();
+    _modulesToLoad = components.toList();
   }
 
   /// Internal method.
diff --git a/pkg/front_end/test/ast_nodes_has_to_string_test.dart b/pkg/front_end/test/ast_nodes_has_to_string_test.dart
index d9ddaba..de8baa2 100644
--- a/pkg/front_end/test/ast_nodes_has_to_string_test.dart
+++ b/pkg/front_end/test/ast_nodes_has_to_string_test.dart
@@ -5,6 +5,7 @@
 import 'dart:io' show File, Platform, stdin, exitCode;
 
 import 'package:front_end/src/api_prototype/compiler_options.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart';
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart';
 
@@ -26,7 +27,8 @@
     helper.TestIncrementalCompiler compiler =
         new helper.TestIncrementalCompiler(options, input,
             /*Uri initializeFrom*/ null, /*bool outlineOnly*/ true);
-    c = await compiler.computeDelta();
+    IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+    c = compilerResult.component;
     classHierarchy = compiler.getClassHierarchy()!;
     List<Library> libraries = c.libraries
         .where((Library lib) =>
diff --git a/pkg/front_end/test/async_but_no_await_git_test.dart b/pkg/front_end/test/async_but_no_await_git_test.dart
index d83191f..6721ee1 100644
--- a/pkg/front_end/test/async_but_no_await_git_test.dart
+++ b/pkg/front_end/test/async_but_no_await_git_test.dart
@@ -6,6 +6,8 @@
 
 import 'package:_fe_analyzer_shared/src/messages/severity.dart';
 import 'package:front_end/src/api_prototype/compiler_options.dart' as api;
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
 import 'package:front_end/src/base/processed_options.dart';
 import 'package:front_end/src/compute_platform_binaries_location.dart'
     show computePlatformBinariesLocation;
@@ -58,8 +60,8 @@
 
   IncrementalCompiler compiler =
       new IncrementalCompiler(new CompilerContext(options));
-  Component component = await compiler.computeDelta();
-
+  IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+  Component component = compilerResult.component;
   component.accept(new AsyncNoAwaitVisitor());
 
   print("Done in ${stopwatch.elapsedMilliseconds} ms. "
diff --git a/pkg/front_end/test/comments_on_certain_arguments_tool.dart b/pkg/front_end/test/comments_on_certain_arguments_tool.dart
index 49d1ecbe..254ff7d 100644
--- a/pkg/front_end/test/comments_on_certain_arguments_tool.dart
+++ b/pkg/front_end/test/comments_on_certain_arguments_tool.dart
@@ -17,6 +17,8 @@
 
 import 'package:front_end/src/api_prototype/file_system.dart' as api
     show FileSystem;
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
 
 import 'package:front_end/src/base/processed_options.dart'
     show ProcessedOptions;
@@ -81,7 +83,9 @@
   CompilerContext context = new CompilerContext(options);
   IncrementalCompiler incrementalCompiler =
       new TestIncrementalCompiler(context);
-  component = await incrementalCompiler.computeDelta();
+  IncrementalCompilerResult incrementalCompilerResult =
+      await incrementalCompiler.computeDelta();
+  component = incrementalCompilerResult.component;
 
   for (Library library in component.libraries) {
     if (library.importUri.scheme == "dart") continue;
diff --git a/pkg/front_end/test/crashing_test_case_minimizer_impl.dart b/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
index dfd6efa..2991e70 100644
--- a/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
+++ b/pkg/front_end/test/crashing_test_case_minimizer_impl.dart
@@ -34,6 +34,9 @@
 import 'package:front_end/src/api_prototype/file_system.dart'
     show FileSystem, FileSystemEntity, FileSystemException;
 
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
+
 import 'package:front_end/src/base/processed_options.dart'
     show ProcessedOptions;
 import 'package:front_end/src/fasta/builder/library_builder.dart';
@@ -802,7 +805,7 @@
     Uri uriTokenUri = uri.resolve(uriString);
     if (resolvePackage && uriTokenUri.scheme == "package") {
       Package package = _latestCrashingIncrementalCompiler!
-          .currentPackagesMap![uriTokenUri.pathSegments.first]!;
+          .getPackageForPackageName(uriTokenUri.pathSegments.first)!;
       uriTokenUri = package.packageUriRoot
           .resolve(uriTokenUri.pathSegments.skip(1).join("/"));
     }
@@ -1826,7 +1829,9 @@
     }
     incrementalCompiler.invalidate(_mainUri);
     try {
-      _latestComponent = await incrementalCompiler.computeDelta();
+      IncrementalCompilerResult incrementalCompilerResult =
+          await incrementalCompiler.computeDelta();
+      _latestComponent = incrementalCompilerResult.component;
       if (_settings.serialize) {
         // We're asked to serialize, probably because it crashes in
         // serialization.
@@ -1839,7 +1844,9 @@
 
       for (Uri uri in _settings.invalidate) {
         incrementalCompiler.invalidate(uri);
-        Component delta = await incrementalCompiler.computeDelta();
+        IncrementalCompilerResult deltaResult =
+            await incrementalCompiler.computeDelta();
+        Component delta = deltaResult.component;
         if (_settings.serialize) {
           // We're asked to serialize, probably because it crashes in
           // serialization.
@@ -1926,7 +1933,9 @@
   Future<Component> _getInitialComponent() async {
     IncrementalCompiler incrementalCompiler =
         new IncrementalCompiler(_setupCompilerContext());
-    Component originalComponent = await incrementalCompiler.computeDelta();
+    IncrementalCompilerResult incrementalCompilerResult =
+        await incrementalCompiler.computeDelta();
+    Component originalComponent = incrementalCompilerResult.component;
     return originalComponent;
   }
 
diff --git a/pkg/front_end/test/fasta/expression_suite.dart b/pkg/front_end/test/fasta/expression_suite.dart
index bc3fb8e..371e8ef 100644
--- a/pkg/front_end/test/fasta/expression_suite.dart
+++ b/pkg/front_end/test/fasta/expression_suite.dart
@@ -370,8 +370,9 @@
       }
 
       var sourceCompiler = new IncrementalCompiler(context.compilerContext);
-      Component component =
+      var sourceCompilerResult =
           await sourceCompiler.computeDelta(entryPoints: [test.entryPoint!]);
+      Component component = sourceCompilerResult.component;
       var errors = context.takeErrors();
       if (!errors.isEmpty) {
         return fail(tests, "Couldn't compile entry-point: $errors");
@@ -389,8 +390,9 @@
 
       var dillCompiler =
           new IncrementalCompiler(context.compilerContext, dillFileUri);
-      component =
+      var dillCompilerResult =
           await dillCompiler.computeDelta(entryPoints: [test.entryPoint!]);
+      component = dillCompilerResult.component;
       component.computeCanonicalNames();
       await dillFile.delete();
 
diff --git a/pkg/front_end/test/fasta/incremental_dartino_suite.dart b/pkg/front_end/test/fasta/incremental_dartino_suite.dart
index 2f7c9f6..d6483bb 100644
--- a/pkg/front_end/test/fasta/incremental_dartino_suite.dart
+++ b/pkg/front_end/test/fasta/incremental_dartino_suite.dart
@@ -152,8 +152,9 @@
         return edits == 0 ? fail(test, "No sources found") : pass(test);
       }
       var compiler = context.compiler;
-      Component component =
+      var compilerResult =
           await compiler.computeDelta(entryPoints: [entryPoint]);
+      Component component = compilerResult.component;
       List<DiagnosticMessage> errors = context.takeErrors();
       if (test.expectations![edits].hasCompileTimeError) {
         if (errors.isEmpty) {
diff --git a/pkg/front_end/test/fasta/incremental_hello_test.dart b/pkg/front_end/test/fasta/incremental_hello_test.dart
index ea8e04c..125ef12 100644
--- a/pkg/front_end/test/fasta/incremental_hello_test.dart
+++ b/pkg/front_end/test/fasta/incremental_hello_test.dart
@@ -8,6 +8,9 @@
 
 import 'package:expect/expect.dart' show Expect;
 
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
+
 import 'package:kernel/ast.dart' show Component;
 
 import 'package:kernel/target/targets.dart' show TargetFlags;
@@ -58,7 +61,8 @@
   IncrementalCompiler compiler =
       new IncrementalCompiler(new CompilerContext(options));
 
-  Component component = await compiler.computeDelta();
+  IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+  Component component = compilerResult.component;
 
   if (sdkFromSource) {
     // Expect that the new component contains at least the following libraries:
@@ -73,12 +77,14 @@
 
   compiler.invalidate(helloDart);
 
-  component = await compiler.computeDelta(entryPoints: [helloDart]);
+  compilerResult = await compiler.computeDelta(entryPoints: [helloDart]);
+  component = compilerResult.component;
   // Expect that the new component contains exactly hello.dart
   Expect.isTrue(
       component.libraries.length == 1, "${component.libraries.length} != 1");
 
-  component = await compiler.computeDelta(entryPoints: [helloDart]);
+  compilerResult = await compiler.computeDelta(entryPoints: [helloDart]);
+  component = compilerResult.component;
   Expect.isTrue(component.libraries.isEmpty);
 }
 
diff --git a/pkg/front_end/test/fasta/testing/suite.dart b/pkg/front_end/test/fasta/testing/suite.dart
index 722b25f..7a4b070 100644
--- a/pkg/front_end/test/fasta/testing/suite.dart
+++ b/pkg/front_end/test/fasta/testing/suite.dart
@@ -40,6 +40,9 @@
 import 'package:front_end/src/api_prototype/file_system.dart'
     show FileSystem, FileSystemEntity, FileSystemException;
 
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
+
 import 'package:front_end/src/api_prototype/standard_file_system.dart'
     show StandardFileSystem;
 
@@ -1207,7 +1210,9 @@
     IncrementalCompiler incrementalCompiler =
         new IncrementalCompiler.fromComponent(
             new CompilerContext(compilationSetup.options), platform);
-    final Component component = await incrementalCompiler.computeDelta();
+    IncrementalCompilerResult incrementalCompilerResult =
+        await incrementalCompiler.computeDelta();
+    final Component component = incrementalCompilerResult.component;
     if (!canSerialize(component)) {
       return new Result<ComponentResult>(result, semiFuzzFailure,
           "Couldn't serialize initial component for fuzzing");
@@ -1237,8 +1242,9 @@
     compilationSetup.errors.clear();
     for (Uri importUri in userLibraries) {
       incrementalCompiler.invalidate(importUri);
-      final Component newComponent =
+      final IncrementalCompilerResult newResult =
           await incrementalCompiler.computeDelta(fullComponent: true);
+      final Component newComponent = newResult.component;
       if (!canSerialize(newComponent)) {
         return new Result<ComponentResult>(
             result, semiFuzzFailure, "Couldn't serialize fuzzed component");
@@ -1329,7 +1335,9 @@
     IncrementalCompiler incrementalCompiler =
         new IncrementalCompiler.fromComponent(
             new CompilerContext(compilationSetup.options), platform);
-    Component initialComponent = await incrementalCompiler.computeDelta();
+    IncrementalCompilerResult initialResult =
+        await incrementalCompiler.computeDelta();
+    Component initialComponent = initialResult.component;
     if (!canSerialize(initialComponent)) {
       return new Result<ComponentResult>(result, semiFuzzFailure,
           "Couldn't serialize initial component for fuzzing");
@@ -1392,7 +1400,9 @@
         incrementalCompiler = new IncrementalCompiler.fromComponent(
             new CompilerContext(compilationSetup.options), platform);
         try {
-          Component component = await incrementalCompiler.computeDelta();
+          IncrementalCompilerResult incrementalCompilerResult =
+              await incrementalCompiler.computeDelta();
+          Component component = incrementalCompilerResult.component;
           if (!canSerialize(component)) {
             return new Result<ComponentResult>(
                 result, semiFuzzFailure, "Couldn't serialize fuzzed component");
diff --git a/pkg/front_end/test/hot_reload_e2e_test.dart b/pkg/front_end/test/hot_reload_e2e_test.dart
index 105abbc..69069c9 100644
--- a/pkg/front_end/test/hot_reload_e2e_test.dart
+++ b/pkg/front_end/test/hot_reload_e2e_test.dart
@@ -316,7 +316,8 @@
   compiler.invalidate(Uri.parse("org-dartlang-test:///a.dart"));
   compiler.invalidate(Uri.parse("org-dartlang-test:///b.dart"));
   compiler.invalidate(Uri.parse("org-dartlang-test:///c.dart"));
-  var component = await compiler.computeDelta();
+  var compilerResult = await compiler.computeDelta();
+  var component = compilerResult.component;
   if (!component.libraries.isEmpty) {
     await writeProgram(component, outputUri);
     return true;
diff --git a/pkg/front_end/test/incremental_bulk_compiler_full.dart b/pkg/front_end/test/incremental_bulk_compiler_full.dart
index ce9a726..9edfd97 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_full.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_full.dart
@@ -8,7 +8,7 @@
     show CompilerOptions, DiagnosticMessage;
 
 import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
-    show IncrementalKernelGenerator;
+    show IncrementalCompilerResult, IncrementalKernelGenerator;
 
 import 'package:front_end/src/compute_platform_binaries_location.dart'
     show computePlatformBinariesLocation;
@@ -77,7 +77,8 @@
     try {
       IncrementalKernelGenerator compiler =
           new IncrementalKernelGenerator(getOptions(), uri);
-      oneShotSerialized = util.postProcess(await compiler.computeDelta());
+      oneShotSerialized =
+          util.postProcess((await compiler.computeDelta()).component);
     } catch (e) {
       oneShotFailed = true;
     }
@@ -90,8 +91,9 @@
       if (context.compiler == null) {
         context.compiler = new IncrementalKernelGenerator(getOptions(), uri);
       }
-      Component bulkCompiledComponent = await context.compiler!
+      IncrementalCompilerResult compilerResult = await context.compiler!
           .computeDelta(entryPoints: [uri], fullComponent: true);
+      Component bulkCompiledComponent = compilerResult.component;
       bulkSerialized = util.postProcess(bulkCompiledComponent);
     } catch (e) {
       bulkFailed = true;
@@ -106,8 +108,9 @@
       if (context.compiler == null) {
         context.compiler = new IncrementalKernelGenerator(getOptions(), uri);
       }
-      Component bulkCompiledComponent = await context.compiler!
+      IncrementalCompilerResult compilerResult = await context.compiler!
           .computeDelta(entryPoints: [uri], fullComponent: true);
+      Component bulkCompiledComponent = compilerResult.component;
       bulkSerialized2 = util.postProcess(bulkCompiledComponent);
     } catch (e) {
       bulk2Failed = true;
diff --git a/pkg/front_end/test/incremental_dart2js_tester.dart b/pkg/front_end/test/incremental_dart2js_tester.dart
index 9ecdb51..0e6717f 100644
--- a/pkg/front_end/test/incremental_dart2js_tester.dart
+++ b/pkg/front_end/test/incremental_dart2js_tester.dart
@@ -7,6 +7,9 @@
 
 import 'package:front_end/src/api_prototype/compiler_options.dart';
 import 'package:front_end/src/api_prototype/experimental_flags.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
+
 import 'package:front_end/src/fasta/kernel/utils.dart';
 
 import 'package:kernel/kernel.dart'
@@ -89,7 +92,9 @@
     print("Invalidating $uri ($i)");
     compiler.invalidate(uri);
     localStopwatch.reset();
-    Component c2 = await compiler.computeDelta(fullComponent: true);
+    IncrementalCompilerResult compilerResult =
+        await compiler.computeDelta(fullComponent: true);
+    Component c2 = compilerResult.component;
     print("Recompiled in ${localStopwatch.elapsedMilliseconds} ms");
     print("invalidatedImportUrisForTesting: "
         "${compiler.invalidatedImportUrisForTesting}");
@@ -180,7 +185,8 @@
         .alternativeInvalidationStrategy] = useExperimentalInvalidation;
     helper.TestIncrementalCompiler compiler =
         new helper.TestIncrementalCompiler(options, input);
-    Component? c = await compiler.computeDelta();
+    IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+    Component? c = compilerResult.component;
     print("Compiled dart2js to Component with ${c.libraries.length} libraries "
         "in ${stopwatch.elapsedMilliseconds} ms.");
     stopwatch.reset();
diff --git a/pkg/front_end/test/incremental_flutter_tester.dart b/pkg/front_end/test/incremental_flutter_tester.dart
index fc01452..fc572aa3 100644
--- a/pkg/front_end/test/incremental_flutter_tester.dart
+++ b/pkg/front_end/test/incremental_flutter_tester.dart
@@ -7,6 +7,8 @@
 import 'package:front_end/src/api_prototype/compiler_options.dart'
     show CompilerOptions, DiagnosticMessage;
 import 'package:front_end/src/api_prototype/experimental_flags.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
 
 import 'package:front_end/src/fasta/kernel/utils.dart' show serializeComponent;
 
@@ -82,7 +84,8 @@
       .alternativeInvalidationStrategy] = useExperimentalInvalidation;
   helper.TestIncrementalCompiler compiler =
       new helper.TestIncrementalCompiler(options, inputFile.uri);
-  Component? c = await compiler.computeDelta();
+  IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+  Component? c = compilerResult.component;
   print("Compiled to Component with ${c.libraries.length} "
       "libraries in ${stopwatch.elapsedMilliseconds} ms.");
   stopwatch.reset();
@@ -132,7 +135,9 @@
     print("Invalidating $uri ($i)");
     compiler.invalidate(uri);
     localStopwatch.reset();
-    Component c2 = await compiler.computeDelta(fullComponent: true);
+    IncrementalCompilerResult compilerResult =
+        await compiler.computeDelta(fullComponent: true);
+    Component c2 = compilerResult.component;
     print("Recompiled in ${localStopwatch.elapsedMilliseconds} ms");
     print("invalidatedImportUrisForTesting: "
         "${compiler.invalidatedImportUrisForTesting}");
diff --git a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
index 3d96399..1de80e9 100644
--- a/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
+++ b/pkg/front_end/test/incremental_load_from_invalid_dill_test.dart
@@ -17,6 +17,9 @@
 import 'package:front_end/src/api_prototype/experimental_flags.dart'
     show ExperimentalFlag;
 
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
+
 import "package:front_end/src/api_prototype/memory_file_system.dart"
     show MemoryFileSystem;
 
@@ -106,7 +109,8 @@
         new CompilerContext(
             new ProcessedOptions(options: options, inputs: [compileThis])),
         initializeFrom);
-    Component component = await compiler.computeDelta();
+    IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+    Component component = compilerResult.component;
 
     if (compiler.initializedFromDill != initializedFromDill) {
       Expect.fail("Expected initializedFromDill to be $initializedFromDill "
@@ -181,7 +185,9 @@
             new ProcessedOptions(options: options, inputs: [entryPoint])),
         initializeFrom);
 
-    Component componentGood = await compiler.computeDelta();
+    IncrementalCompilerResult compilerGoodResult =
+        await compiler.computeDelta();
+    Component componentGood = compilerGoodResult.component;
     List<int> dataGood = serializeComponent(componentGood);
     fs.entityForUri(initializeFrom).writeAsBytesSync(dataGood);
 
@@ -191,7 +197,9 @@
         new CompilerContext(
             new ProcessedOptions(options: options, inputs: [helper2File])),
         initializeFrom);
-    Component componentHelper = await compiler.computeDelta();
+    IncrementalCompilerResult compilerHelperResult =
+        await compiler.computeDelta();
+    Component componentHelper = compilerHelperResult.component;
     Library helper2Lib = componentHelper.libraries
         .firstWhere((lib) => lib.importUri == helper2File);
     helper2Lib.importUri = new Uri(scheme: "dart", path: "foo");
@@ -214,7 +222,8 @@
 
     // Create a partial dill file.
     compiler.invalidate(entryPoint);
-    component = await compiler.computeDelta();
+    IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+    component = compilerResult.component;
     if (component.libraries.length != 1) {
       Expect.fail("Expected 1 library, got ${component.libraries.length}: "
           "${component.libraries}");
@@ -257,7 +266,9 @@
           new CompilerContext(
               new ProcessedOptions(options: options, inputs: [helper2File])),
           null);
-      Component c = await compiler.computeDelta();
+
+      IncrementalCompilerResult result = await compiler.computeDelta();
+      Component c = result.component;
       c.setMainMethodAndMode(
           null, false, NonNullableByDefaultCompiledMode.Weak);
       mixedPart1 = serializeComponent(c);
@@ -279,7 +290,8 @@
           new CompilerContext(
               new ProcessedOptions(options: options, inputs: [helperFile])),
           null);
-      Component c = await compiler.computeDelta();
+      IncrementalCompilerResult result = await compiler.computeDelta();
+      Component c = result.component;
       c.setMainMethodAndMode(
           null, false, NonNullableByDefaultCompiledMode.Strong);
       mixedPart2 = serializeComponent(c);
diff --git a/pkg/front_end/test/incremental_suite.dart b/pkg/front_end/test/incremental_suite.dart
index 2ce5c81..9c6d54f 100644
--- a/pkg/front_end/test/incremental_suite.dart
+++ b/pkg/front_end/test/incremental_suite.dart
@@ -24,7 +24,8 @@
 
 import 'package:front_end/src/api_prototype/experimental_flags.dart'
     show ExperimentalFlag, experimentEnabledVersion;
-
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
 import "package:front_end/src/api_prototype/memory_file_system.dart"
     show MemoryFileSystem, MemoryFileSystemEntity;
 
@@ -355,7 +356,9 @@
     }
     TestIncrementalCompiler compiler = new TestIncrementalCompiler(
         options, moduleSources.first, /* initializeFrom = */ null, outlineOnly);
-    Component c = await compiler.computeDelta(entryPoints: moduleSources);
+    IncrementalCompilerResult compilerResult =
+        await compiler.computeDelta(entryPoints: moduleSources);
+    Component c = compilerResult.component;
     c.computeCanonicalNames();
     List<Library> wantedLibs = <Library>[];
     for (Library lib in c.libraries) {
@@ -664,11 +667,12 @@
       }
 
       Stopwatch stopwatch = new Stopwatch()..start();
-      component = await compiler!.computeDelta(
+      IncrementalCompilerResult compilerResult = await compiler!.computeDelta(
           entryPoints: entries,
           fullComponent:
               brandNewWorld ? false : (noFullComponent ? false : true),
           simulateTransformer: world["simulateTransformer"]);
+      component = compilerResult.component;
       if (outlineOnly && !skipOutlineBodyCheck) {
         for (Library lib in component!.libraries) {
           for (Class c in lib.classes) {
@@ -934,10 +938,11 @@
 
       if (!noFullComponent) {
         clearPrevErrorsEtc();
-        component2 = await compiler.computeDelta(
+        IncrementalCompilerResult compilerResult2 = await compiler.computeDelta(
             entryPoints: entries,
             fullComponent: true,
             simulateTransformer: world["simulateTransformer"]);
+        component2 = compilerResult2.component;
         Result<TestData>? result = performErrorAndWarningCheck(world, data,
             gotError, formattedErrors, gotWarning, formattedWarnings);
         if (result != null) return result;
@@ -1047,9 +1052,11 @@
         }
 
         Stopwatch stopwatch = new Stopwatch()..start();
-        component3 = await compilerFromScratch.computeDelta(
-            entryPoints: entries,
-            simulateTransformer: world["simulateTransformer"]);
+        IncrementalCompilerResult compilerResult3 =
+            await compilerFromScratch.computeDelta(
+                entryPoints: entries,
+                simulateTransformer: world["simulateTransformer"]);
+        component3 = compilerResult3.component;
         compilerFromScratch = null;
         Result<TestData>? result = performErrorAndWarningCheck(world, data,
             gotError, formattedErrors, gotWarning, formattedWarnings);
@@ -1787,7 +1794,7 @@
     {CompilerOptions? options, IncrementalCompiler? compiler}) async {
   options ??= getOptions();
   compiler ??= new TestIncrementalCompiler(options, input);
-  return await compiler.computeDelta();
+  return (await compiler.computeDelta()).component;
 }
 
 Future<bool> initializedCompile(
@@ -1799,7 +1806,9 @@
   for (Uri invalidateUri in invalidateUris) {
     compiler.invalidate(invalidateUri);
   }
-  Component initializedComponent = await compiler.computeDelta();
+  IncrementalCompilerResult initializedCompilerResult =
+      await compiler.computeDelta();
+  Component initializedComponent = initializedCompilerResult.component;
   util.throwOnEmptyMixinBodies(initializedComponent);
   await util.throwOnInsufficientUriToSource(initializedComponent);
   bool result = compiler.initializedFromDill;
@@ -1814,8 +1823,9 @@
         "got $actuallyInvalidatedCount");
   }
 
-  Component initializedFullComponent =
+  IncrementalCompilerResult initializedFullCompilerResult =
       await compiler.computeDelta(fullComponent: true);
+  Component initializedFullComponent = initializedFullCompilerResult.component;
   util.throwOnEmptyMixinBodies(initializedFullComponent);
   await util.throwOnInsufficientUriToSource(initializedFullComponent);
   Expect.equals(initializedComponent.libraries.length,
@@ -1827,7 +1837,8 @@
     compiler.invalidate(invalidateUri);
   }
 
-  Component partialComponent = await compiler.computeDelta();
+  IncrementalCompilerResult partialResult = await compiler.computeDelta();
+  Component partialComponent = partialResult.component;
   util.throwOnEmptyMixinBodies(partialComponent);
   await util.throwOnInsufficientUriToSource(partialComponent);
   actuallyInvalidatedCount = (compiler
@@ -1839,7 +1850,8 @@
         "got $actuallyInvalidatedCount");
   }
 
-  Component emptyComponent = await compiler.computeDelta();
+  IncrementalCompilerResult emptyResult = await compiler.computeDelta();
+  Component emptyComponent = emptyResult.component;
   util.throwOnEmptyMixinBodies(emptyComponent);
   await util.throwOnInsufficientUriToSource(emptyComponent);
 
@@ -1933,11 +1945,11 @@
   }
 
   @override
-  Future<Component> computeDelta(
+  Future<IncrementalCompilerResult> computeDelta(
       {List<Uri>? entryPoints,
       bool fullComponent = false,
       bool? simulateTransformer}) async {
-    Component result = await super
+    IncrementalCompilerResult result = await super
         .computeDelta(entryPoints: entryPoints, fullComponent: fullComponent);
 
     // We should at least have the SDK builders available. Slight smoke test.
@@ -1949,7 +1961,7 @@
     }
 
     if (simulateTransformer == true) {
-      doSimulateTransformer(result);
+      doSimulateTransformer(result.component);
     }
     return result;
   }
diff --git a/pkg/front_end/test/multiple_simultaneous_compiles_test.dart b/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
index f2ea8f96..85d1d8c 100644
--- a/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
+++ b/pkg/front_end/test/multiple_simultaneous_compiles_test.dart
@@ -4,6 +4,8 @@
 
 import 'dart:io' show File, Platform;
 
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart'
+    show IncrementalCompilerResult;
 import 'package:front_end/src/base/processed_options.dart'
     show ProcessedOptions;
 
@@ -69,7 +71,8 @@
   } else {
     compiler.invalidateAllSources();
   }
-  Component result = await compiler.computeDelta();
+  IncrementalCompilerResult compilerResult = await compiler.computeDelta();
+  Component result = compilerResult.component;
   print("Now compile is done!");
   return result;
 }
diff --git a/pkg/front_end/test/test_generator_test.dart b/pkg/front_end/test/test_generator_test.dart
index 73cd4e9..569620a 100644
--- a/pkg/front_end/test/test_generator_test.dart
+++ b/pkg/front_end/test/test_generator_test.dart
@@ -5,6 +5,7 @@
 import 'dart:io' show exitCode, File, stdout;
 
 import 'package:front_end/src/api_prototype/compiler_options.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart';
 import 'package:front_end/src/api_prototype/memory_file_system.dart';
 import 'package:front_end/src/compute_platform_binaries_location.dart';
 import 'package:front_end/src/fasta/kernel/utils.dart';
@@ -90,7 +91,9 @@
     StringBuffer sb = new StringBuffer();
     fs.entityForUri(testUri).writeAsStringSync(src);
     compiler.invalidate(testUri);
-    Component result = await compiler.computeDelta(entryPoints: [testUri]);
+    IncrementalCompilerResult compilerResult =
+        await compiler.computeDelta(entryPoints: [testUri]);
+    Component result = compilerResult.component;
     Iterator<Code> codeIterator = formattedWarningsCodes.iterator;
     for (String warning in formattedWarnings) {
       codeIterator.moveNext();
diff --git a/pkg/front_end/tool/dart_doctest_impl.dart b/pkg/front_end/tool/dart_doctest_impl.dart
index 1e51b84..a3bcdba 100644
--- a/pkg/front_end/tool/dart_doctest_impl.dart
+++ b/pkg/front_end/tool/dart_doctest_impl.dart
@@ -28,6 +28,7 @@
 
 import 'package:front_end/src/api_prototype/compiler_options.dart';
 import 'package:front_end/src/api_prototype/file_system.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart';
 import 'package:front_end/src/api_prototype/memory_file_system.dart';
 import 'package:front_end/src/api_prototype/standard_file_system.dart';
 import 'package:front_end/src/base/processed_options.dart';
@@ -160,8 +161,9 @@
     incrementalCompiler!.invalidate(processedOpts.packagesUri);
 
     Stopwatch stopwatch = new Stopwatch()..start();
-    kernel.Component component =
+    IncrementalCompilerResult compilerResult =
         await incrementalCompiler!.computeDelta(entryPoints: [uri]);
+    kernel.Component component = compilerResult.component;
     if (errors) {
       _print("Got errors in ${stopwatch.elapsedMilliseconds} ms.");
       return [
@@ -181,8 +183,9 @@
         .writeAsStringSync(mainFileContent);
 
     incrementalCompiler!.invalidate(dartDocMainUri);
-    kernel.Component componentMain = await incrementalCompiler!
+    IncrementalCompilerResult compilerMainResult = await incrementalCompiler!
         .computeDelta(entryPoints: [dartDocMainUri], fullComponent: true);
+    kernel.Component componentMain = compilerMainResult.component;
     if (errors) {
       _print("Got errors in ${stopwatch.elapsedMilliseconds} ms.");
       return [
@@ -806,8 +809,9 @@
       _dartDocTestCode = dartDocTestCode;
 
       invalidate(dartDocTestUri);
-      kernel.Component result = await computeDelta(
+      IncrementalCompilerResult compilerResult = await computeDelta(
           entryPoints: [dartDocTestUri], fullComponent: true);
+      kernel.Component result = compilerResult.component;
       _dartDocTestLibraryBuilder = null;
       _dartDocTestCode = null;
 
diff --git a/pkg/front_end/tool/incremental_perf.dart b/pkg/front_end/tool/incremental_perf.dart
index e3dda75..6b91a96 100644
--- a/pkg/front_end/tool/incremental_perf.dart
+++ b/pkg/front_end/tool/incremental_perf.dart
@@ -125,7 +125,8 @@
   collector.start("Initial compilation");
   var generator = new IncrementalKernelGenerator(compilerOptions, entryUri);
 
-  var component = await generator.computeDelta();
+  var compilerResult = await generator.computeDelta();
+  var component = compilerResult.component;
   collector.stop("Initial compilation");
   if (verbose) {
     print("Libraries changed: ${component.libraries.length}");
@@ -139,7 +140,8 @@
     await applyEdits(
         changeSet.edits, overlayFs, generator, uriTranslator, verbose);
     collector.start(name);
-    component = await generator.computeDelta();
+    compilerResult = await generator.computeDelta();
+    component = compilerResult.component;
     collector.stop(name);
     if (verbose) {
       print("Change '${changeSet.name}' - "
diff --git a/pkg/frontend_server/lib/compute_kernel.dart b/pkg/frontend_server/lib/compute_kernel.dart
index 9b60711..9c08de2 100644
--- a/pkg/frontend_server/lib/compute_kernel.dart
+++ b/pkg/frontend_server/lib/compute_kernel.dart
@@ -15,6 +15,7 @@
 import 'package:build_integration/file_system/multi_root.dart';
 import 'package:compiler/src/kernel/dart2js_target.dart';
 import 'package:dev_compiler/src/kernel/target.dart';
+import 'package:front_end/src/api_prototype/incremental_kernel_generator.dart';
 import 'package:front_end/src/api_unstable/bazel_worker.dart' as fe;
 import 'package:kernel/ast.dart' show Component, Library, Reference;
 import 'package:kernel/target/targets.dart';
@@ -277,8 +278,10 @@
   bool wroteUsedDills = false;
   if (usingIncrementalCompiler) {
     state.options.onDiagnostic = onDiagnostic;
-    Component incrementalComponent = await state.incrementalCompiler
+    IncrementalCompilerResult incrementalCompilerResult = await state
+        .incrementalCompiler
         .computeDelta(entryPoints: sources, fullComponent: true);
+    Component incrementalComponent = incrementalCompilerResult.component;
 
     if (recordUsedInputs) {
       Set<Uri> usedOutlines = {};
diff --git a/pkg/vm/lib/incremental_compiler.dart b/pkg/vm/lib/incremental_compiler.dart
index 3ad1270..2bf3af3 100644
--- a/pkg/vm/lib/incremental_compiler.dart
+++ b/pkg/vm/lib/incremental_compiler.dart
@@ -66,8 +66,9 @@
       _entryPoint = entryPoint ?? _entryPoint;
       List<Uri>? entryPoints;
       if (entryPoint != null) entryPoints = [entryPoint];
-      Component component = await _generator.computeDelta(
+      IncrementalCompilerResult compilerResult = await _generator.computeDelta(
           entryPoints: entryPoints, fullComponent: fullComponent);
+      Component component = compilerResult.component;
       initialized = true;
       fullComponent = false;
       _pendingDeltas.add(component);
diff --git a/tools/VERSION b/tools/VERSION
index c7c5c38..e24496b 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 48
+PRERELEASE 49
 PRERELEASE_PATCH 0
\ No newline at end of file