[front_end] Add option for expanded invalidation

In this mode when an edit only touches the body of a mixin
(not the public API) libraries that apply the mixin will also
be invalidated.

Add mixin invalidation test.

Issue: #61864
Change-Id: Id4dde67364dcef958ae1e0e0bbf124cec389f5f0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/459343
Commit-Queue: Nicholas Shahan <nshahan@google.com>
Reviewed-by: Jens Johansen <jensj@google.com>

Author: nshahan

pkg/dev_compiler/lib/src/kernel/target.dart

@@ -328,6 +328,15 @@ class DevCompilerTarget extends Target {
   @override
   DartLibrarySupport get dartLibrarySupport =>
       const DevCompilerDartLibrarySupport();
+
+  // For correctness the DDC runtime needs to reevaluate libraries that contain
+  // mixin applications when the mixin was edited. If the edit was only within
+  // the body of a mixin member the experimental invalidation logic would only
+  // invalidate that library. This enables a search for applications of the
+  // mixin in other libraries adds them to the invalidated set.
+  @override
+  bool get incrementalCompilerIncludeMixinApplicationInvalidatedLibraries =>
+      true;
 }
 
 class DevCompilerDartLibrarySupport extends CustomizedDartLibrarySupport {

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

@@ -332,6 +332,10 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
             reusedResult,
             c,
             uriTranslator,
+            context
+                .options
+                .target
+                .incrementalCompilerIncludeMixinApplicationInvalidatedLibraries,
           );
       recorderForTesting?.recordRebuildBodiesCount(
         experimentalInvalidation?.missingSources.length ?? 0,
@@ -528,6 +532,14 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
             c,
             cleanedUpBuilders: cleanedUpBuilders,
           );
+      if (experimentalInvalidation != null &&
+          experimentalInvalidation.invalidatedMixinApplicationLibraries !=
+              null) {
+        outputLibraries = {
+          ...outputLibraries,
+          ...experimentalInvalidation.invalidatedMixinApplicationLibraries!,
+        }.toList();
+      }
       List<String> problemsAsJson = _componentProblems.reissueProblems(
         context,
         currentKernelTarget,
@@ -1118,6 +1130,7 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
     ReusageResult reusedResult,
     CompilerContext c,
     UriTranslator uriTranslator,
+    bool collectMixinsToo,
   ) async {
     Set<DillLibraryBuilder>? rebuildBodies;
     Set<DillLibraryBuilder> originalNotReusedLibraries;
@@ -1232,6 +1245,7 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
     // procedures, if the changed file is used as a mixin anywhere else
     // we can't only recompile the changed file.
     // TODO(jensj): Check for mixins in a smarter and faster way.
+    Set<Library>? invalidatedMixinApplicationLibraries;
     if (!skipExperimentalInvalidationChecksForTesting) {
       for (LibraryBuilder builder in reusedResult.notReusedLibraries) {
         if (missingSources!.contains(builder.fileUri)) {
@@ -1256,6 +1270,13 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
               return null;
             }
           }
+          if (collectMixinsToo &&
+              c.mixedInClass != null &&
+              missingSources.contains(c.mixedInClass!.fileUri)) {
+            (invalidatedMixinApplicationLibraries ??= {}).add(
+              c.enclosingLibrary,
+            );
+          }
         }
       }
 
@@ -1324,6 +1345,7 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
       rebuildBodies,
       originalNotReusedLibraries,
       missingSources,
+      invalidatedMixinApplicationLibraries,
     );
   }
 
@@ -2727,11 +2749,13 @@ class ExperimentalInvalidation {
   final Set<DillLibraryBuilder> rebuildBodies;
   final Set<DillLibraryBuilder> originalNotReusedLibraries;
   final Set<Uri> missingSources;
+  final Set<Library>? invalidatedMixinApplicationLibraries;
 
   ExperimentalInvalidation(
     this.rebuildBodies,
     this.originalNotReusedLibraries,
     this.missingSources,
+    this.invalidatedMixinApplicationLibraries,
   );
 }
 

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart

@@ -0,0 +1,3 @@
+import 'main_lib1.dart';
+
+C c = new C();

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.strong.expect

@@ -0,0 +1,44 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+
+static field mai::C c = new mai::C::•();
+
+library;
+import self as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib2.dart";
+
+class C extends mai::_C&Object&M {
+  synthetic constructor •() → mai::C
+    : super mai::_C&Object&M::•()
+    ;
+  static synthetic method _#new#tearOff() → mai::C
+    return new mai::C::•();
+}
+abstract class _C&Object&M = core::Object with mai2::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → mai::_C&Object&M
+    : super core::Object::•()
+    ;
+  synthetic mixin-super-stub method m1() → core::String
+    return super.{mai2::M::m1}();
+  synthetic mixin-super-stub method m2() → core::String
+    return super.{mai2::M::m2}();
+}
+
+library;
+import self as mai2;
+import "dart:core" as core;
+
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+  method m1() → core::String {
+    return "hello";
+  }
+  method m2() → core::String {
+    return "hello";
+  }
+}

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.strong.modular.expect

@@ -0,0 +1,44 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+
+static field mai::C c = new mai::C::•();
+
+library;
+import self as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib2.dart";
+
+class C extends mai::_C&Object&M {
+  synthetic constructor •() → mai::C
+    : super mai::_C&Object&M::•()
+    ;
+  static synthetic method _#new#tearOff() → mai::C
+    return new mai::C::•();
+}
+abstract class _C&Object&M = core::Object with mai2::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → mai::_C&Object&M
+    : super core::Object::•()
+    ;
+  synthetic mixin-super-stub method m1() → core::String
+    return super.{mai2::M::m1}();
+  synthetic mixin-super-stub method m2() → core::String
+    return super.{mai2::M::m2}();
+}
+
+library;
+import self as mai2;
+import "dart:core" as core;
+
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+  method m1() → core::String {
+    return "hello";
+  }
+  method m2() → core::String {
+    return "hello";
+  }
+}

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.strong.outline.expect

@@ -0,0 +1,41 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+
+static field mai::C c;
+
+library;
+import self as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib2.dart";
+
+class C extends mai::_C&Object&M {
+  synthetic constructor •() → mai::C
+    ;
+  static synthetic method _#new#tearOff() → mai::C
+    return new mai::C::•();
+}
+abstract class _C&Object&M = core::Object with mai2::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → mai::_C&Object&M
+    : super core::Object::•()
+    ;
+  synthetic mixin-super-stub method m1() → core::String
+    return super.{mai2::M::m1}();
+  synthetic mixin-super-stub method m2() → core::String
+    return super.{mai2::M::m2}();
+}
+
+library;
+import self as mai2;
+import "dart:core" as core;
+
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+  method m1() → core::String
+    ;
+  method m2() → core::String
+    ;
+}

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.strong.transformed.expect

@@ -0,0 +1,44 @@
+library;
+import self as self;
+import "main_lib1.dart" as mai;
+
+import "org-dartlang-testcase:///main_lib1.dart";
+
+static field mai::C c = new mai::C::•();
+
+library;
+import self as mai;
+import "dart:core" as core;
+import "main_lib2.dart" as mai2;
+
+import "org-dartlang-testcase:///main_lib2.dart";
+
+class C extends mai::_C&Object&M {
+  synthetic constructor •() → mai::C
+    : super mai::_C&Object&M::•()
+    ;
+  static synthetic method _#new#tearOff() → mai::C
+    return new mai::C::•();
+}
+abstract class _C&Object&M = core::Object with mai2::M /*isAnonymousMixin,hasConstConstructor*/  {
+  const synthetic constructor •() → mai::_C&Object&M
+    : super core::Object::•()
+    ;
+  synthetic mixin-super-stub method m1() → core::String
+    return super.{mai2::M::m1}();
+  synthetic mixin-super-stub method m2() → core::String
+    return super.{mai2::M::m2}();
+}
+
+library;
+import self as mai2;
+import "dart:core" as core;
+
+abstract class M extends core::Object /*isMixinDeclaration*/  {
+  method m1() → core::String {
+    return "hello";
+  }
+  method m2() → core::String {
+    return "hello";
+  }
+}

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.textual_outline.expect

@@ -0,0 +1,3 @@
+import 'main_lib1.dart';
+
+C c = new C();

pkg/front_end/testcases/dartdevc/mixin_collection/main.dart.textual_outline_modelled.expect

@@ -0,0 +1,3 @@
+import 'main_lib1.dart';
+
+C c = new C();

pkg/front_end/testcases/dartdevc/mixin_collection/main_lib1.dart

@@ -0,0 +1,3 @@
+import 'main_lib2.dart';
+
+class C with M {}