Reapply "[kernel/cfe/etc] Split outline transformation into performOutlineTransformations and performOutlineComponentOperations"

This reverts commit 264098c.

Currently outline transformations aren't run via the incremental
compiler which causes problems in
https://dart-review.googlesource.com/c/sdk/+/491702 which fixes it by
calling the current transformation in the incremental compiler. This
calls it twice though (because it's run again in
`frontend_server/lib/compute_kernel.dart`, but removing it there doesn't
work because a filtering is done which doesn't apply through the
incremental compiler.

This CL splits up the outline transformation stage into a call that can
actually transform the libraries and one that can do the filtering,
which should fix the issue.

Original CL was reverted because it caused errors in google3. The
original CL is in patchset 1. The error has been reproduced and
recreated in a test added in patchset 2. The fix is in patchset 3.

The dwds failure @
https://github.com/dart-lang/webdev/actions/runs/24516059718/job/71660245069
has been verified as fixed as well.

The problem was this:

Previously outline transformations were not run by the incremental
compiler, but only outside. When it was moved to the incremental
compiler it had on old - outdated - `target` which for the ddc/dart2js
summary target would hold a list of source files that it was initially
created with, not the ones currently being compiled. This meant that the
transformation step that removed "unrelated" libraries actually removed
the newly compiled libraries instead. It could cause one of two issues:
1) Empty output: With no overlap between the combined output of the
   compile and the sources of the first compile (i.e. the ones in the
   outdated `target`) all libraries were filtered out. If a later
   compile was given this as a summary input the compile could fail with
   a file not found error because the given summary - which should
   contain the missing library didn't.
2) Non-empty output: With an overlap between the combined output of the
   compile and the sources of the first compile only the overlap would
   be included. In practise this would mean that the output would be a
   (potentially partial) copy of the first compile. If then a later
   compile was given both the summary from the first compile and the
   output with the copy it would throw when loading because it got the
   same library from two different summaries.

Change-Id: If712663acdbd7d25ccb3beab54a7efac0c0b0568
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/496181
Reviewed-by: Nicholas Shahan <nshahan@google.com>
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Jens Johansen <jensj@google.com>

Author: jensjoha

pkg/compiler/lib/src/kernel/dart2js_target.dart

@@ -361,6 +361,20 @@ class Dart2jsSummaryTarget extends Dart2jsTarget with SummaryMixin {
     this.excludeNonSources,
     TargetFlags targetFlags,
   ) : super(name, targetFlags);
+
+  @override
+  bool isModularlyCompatibleWith(Target other) {
+    if (other is! Dart2jsSummaryTarget) return false;
+    if (excludeNonSources != other.excludeNonSources) return false;
+    return true;
+  }
+
+  @override
+  void updateModularCompatibilityAs(Target other) {
+    assert(other is Dart2jsSummaryTarget);
+    sources.clear();
+    sources.addAll((other as Dart2jsSummaryTarget).sources);
+  }
 }
 
 class Dart2jsConstantsBackend extends ConstantsBackend {

pkg/front_end/lib/src/api_unstable/modular_incremental_compilation.dart

@@ -83,7 +83,9 @@ Future<InitializedCompilerState> initializeIncrementalCompiler(
           !equalSets(oldState.tags, tags) ||
           (sdkSummary != null &&
               (cachedSdkInput == null ||
-                  !digestsEqual(cachedSdkInput.digest, sdkDigest)))) {
+                  !digestsEqual(cachedSdkInput.digest, sdkDigest))) ||
+          (oldState.options.target == null ||
+              !oldState.options.target!.isModularlyCompatibleWith(target))) {
         // No - or immediately not correct - previous state.
         // We'll load a new sdk, anything loaded already will have a wrong root.
         workerInputCache.clear();
@@ -148,6 +150,7 @@ Future<InitializedCompilerState> initializeIncrementalCompiler(
         options.packagesFileUri = packagesFile;
         options.fileSystem = fileSystem;
         processedOpts.clearFileSystemCache();
+        options.target!.updateModularCompatibilityAs(target);
       }
 
       // Then read all the input summary components.

pkg/front_end/lib/src/base/incremental_compiler.dart

@@ -441,6 +441,10 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
         );
         componentWithDill = buildResult.component;
       }
+      // Coverage-ignore(suite): Not run.
+      else if (componentWithDill != null) {
+        context.options.target.performOutlineTransformations(componentWithDill);
+      }
 
       _benchmarker
       // Coverage-ignore(suite): Not run.
@@ -578,6 +582,11 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
       // about other libraries.
       result.metadata.addAll(componentWithDill.metadata);
 
+      if (outlineOnly) {
+        // Coverage-ignore-block(suite): Not run.
+        context.options.target.performOutlineComponentOperations(result);
+      }
+
       // We're now done. Allow any waiting compile to start.
       Completer<dynamic> currentlyCompilingLocal = _currentlyCompiling!;
       _currentlyCompiling = null;

pkg/front_end/lib/src/kernel_generator_impl.dart

@@ -224,6 +224,7 @@ Future<InternalCompilerResult> _buildInternal(
     // the only need we have for these transformations).
     if (!buildComponent) {
       options.target.performOutlineTransformations(trimmedSummaryComponent);
+      options.target.performOutlineComponentOperations(trimmedSummaryComponent);
       options.ticker.logMs("Transformed outline");
     }
     if (serializeIfBuildingSummary) {

pkg/frontend_server/lib/compute_kernel.dart

@@ -392,7 +392,11 @@ Future<ComputeKernelResult> computeKernel(
       previousState,
       {
         "target=$targetName",
+        // trackWidgetCreation is in TargetFlags.
         "trackWidgetCreation=$trackWidgetCreation",
+        // includeUnsupportedPlatformLibraryStubs is in TargetFlags.
+        "includeUnsupportedPlatformLibraryStubs="
+            "$includeUnsupportedPlatformLibraryStubs",
         "multiRootScheme=${mrfs.markerScheme}",
         "multiRootRoots=${mrfs.roots}",
       },
@@ -483,7 +487,6 @@ Future<ComputeKernelResult> computeKernel(
         incrementalComponent.uriToSource.clear();
         incrementalComponent.problemsAsJson = null;
         incrementalComponent.setMainMethodAndMode(null, true);
-        target.performOutlineTransformations(incrementalComponent);
         makeStable(incrementalComponent);
         return new Future.value(
           fe.serializeComponent(
@@ -615,6 +618,20 @@ class DevCompilerSummaryTarget extends DevCompilerTarget with SummaryMixin {
     this.excludeNonSources,
     TargetFlags targetFlags,
   ) : super(targetFlags);
+
+  @override
+  bool isModularlyCompatibleWith(Target other) {
+    if (other is! DevCompilerSummaryTarget) return false;
+    if (excludeNonSources != other.excludeNonSources) return false;
+    return true;
+  }
+
+  @override
+  void updateModularCompatibilityAs(Target other) {
+    assert(other is DevCompilerSummaryTarget);
+    sources.clear();
+    sources.addAll((other as DevCompilerSummaryTarget).sources);
+  }
 }
 
 Uri? toUriNullable(String? uriString) {