web hot reload fails to reload changes to mixins and class properties

[drrnbrns]

Steps to reproduce

1. Create a sample app with flutter create --platforms=web sample
2. Create the source files and update main.dart as per code sample below
3. Debug the app in VSCode
4. Modify the sample class and sample mixin with changes

Observed::

• Changes to the returned value from fromMixin are not reflected in the app, unless you later save the sample_class.dart file too
• Changes to fromClass work as expected
• Changes to the properties messageClass and messageMixin are never reflected.

Code sample

Create lib\sample_mixin.dart:

mixin SampleMixin {
  String messageMixin = "SampleMixin";

  String fromMixin() {
    return "From mixin";
  }
}

Create lib\sample_class.dart

import 'sample_mixin.dart';

class SampleClass with SampleMixin {
  String messageClass = "SampleClass";

  String fromClass() {
    return "From class";
  }
}

Replace all of main.dart with the following:

import 'package:flutter/material.dart';
import 'sample_class.dart';

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
      ),
      home: const MyHomePage(),
    );
  }
}

class MyHomePage extends StatefulWidget {
  const MyHomePage({super.key});

  @override
  State<MyHomePage> createState() => _MyHomePageState();
}

class _MyHomePageState extends State<MyHomePage> {
  final messages = SampleClass();


  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text("Class method: ${messages.fromClass()}"),
            Text("Mixin method: ${messages.fromMixin()}"),
            Text("Class property: ${messages.messageClass}"),
            Text("Mixin property: ${messages.messageMixin}"),
          ],
        ),
      ),
    );
  }
}

Flutter version

Flutter 3.35.7 • channel stable • https://github.com/flutter/flutter.git
Framework • revision adc9010625 (8 days ago) • 2025-10-21 14:16:03 -0400
Engine • hash 6b24e1b529bc46df7ff397667502719a2a8b6b72 (revision 035316565a) (8 days ago) • 2025-10-21 14:28:01.000Z
Tools • Dart 3.9.2 • DevTools 2.48.0

[nshahan]

@drrnbrns
Thanks for the reproduction!

@johnniwinther @jensjoha
This issue is very strange. I found that mixin methods with block bodies invalidate a different set of files compared to mixin methods with arrow function bodies. There is a reproduction here: https://dart-review.googlesource.com/c/sdk/+/459343. Note there are also issues with mixin fields not triggering the expected invalidation of the dependency libraries as well.

[jensjoha]

There's a few questions here. I'll try to answer:

Q: Differences between block bodies and arrow function bodies
A: This is the textual outline removing the data between the braces, but not removing the expression in the arrow function (e.g. foo() { bla; } becomes foo() {} whereas bar() => bla; does not change. I think I have a todo somewhere to fix this.

Q: Not getting importers invalidated.
A: This seems to be working as intended from the incremental compilers point of view. From the test linked the main.dart and class.dart looks like this:

main = main::main;
library from "package:hello/main.dart" as main {

  import "package:hello/class.dart";

  static final field cla::C c = new cla::C::•();
  static method main() → dynamic {
    core::print(main::c.{cla::_C&Object&M::fn}(){() → core::String});
    core::print(main::c.{cla::_C&Object&M::gn}(){() → core::String});
  }
}
library from "package:hello/class.dart" as cla {

  import "package:hello/mixin.dart";

  class C extends cla::_C&Object&M {
    synthetic constructor •() → cla::C
      : super cla::_C&Object&M::•()
      ;
    static synthetic method _#new#tearOff() → cla::C
      return new cla::C::•();
  }
  abstract class _C&Object&M = core::Object with mix::M /*isAnonymousMixin,hasConstConstructor*/  {
    const synthetic constructor •() → cla::_C&Object&M
      : super core::Object::•()
      ;
    synthetic mixin-super-stub method fn() → core::String
      return super.{mix::M::fn}();
    synthetic mixin-super-stub method gn() → core::String
      return super.{mix::M::gn}();
  }
}

and that doesn't change because of changed bodies in mixin.dart.
As such it only recompiles mixin.dart and returns that. Depending on what the caller (DDC in this case) does with this it seems it might have to look at other stuff too? (or am I misreading something?)

As an additional detail the VM has a mixin transformation which eliminates mixins and instead copies the mixin bodies into the other libraries and they will thus have to be recompiled when a mixin changes.

If I'm wrong or I missed some questions please call me out :)

[nshahan]

This is the textual outline removing the data between the braces, but not removing the expression in the arrow function (e.g. foo() { bla; } becomes foo() {} whereas bar() => bla; does not change. I think I have a todo somewhere to fix this.

"Fix this" meaning avoid including the arrow function body expression in the kernel outline and avoid invalidating importing libraries when the body expression changes? This doesn't sound preferable to me.

This seems to be working as intended from the incremental compilers point of view.

I was afraid of this. The mixin feature really doesn't pair well with the fully modular compilation strategy that DDC was built around. Currently DDC compiles mixin applications into instructions associated to the target class definition that will perform the application at the correct location in the class hierarchy. The mixin definition has no knowledge where it will be applied so a mixin definition changing without invalidating the importing libraries is causing the bug we are observing here.

My hope is that in the future we can move to a mode where all mixin bodies are present in the outline so they can be applied statically at compile time in a transformation similar to the VM approach. A larger set of invalidated libraries would be a side effect of this but that seems comparable to the invalidation on the VM as well.

In the short term, are there any special case mechanisms to trigger invalidation we can apply to changes in the mixin bodies? This feels appropriate to me since the bodies aren't entirely encapsulated in the library as they are intended to be applied into other classes and the changes need to be propagated outside of the library. WDYT?

If expanding the invalidation isn't feasible, I think my only alternative is to somehow know where to apply the change to a mixin body outside of the library that defines it. This might be possible but it requires some careful planning to reverse the import direction and safely access libraries backwards through their imports at runtime.

[jensjoha]

"Fix this" meaning avoid including the arrow function body expression in the kernel outline and avoid invalidating importing libraries when the body expression changes? This doesn't sound preferable to me.

Yes. I'd say that compiling less is generally a good thing.

In the short term, are there any special case mechanisms to trigger invalidation we can apply to changes in the mixin bodies? This feels appropriate to me since the bodies aren't entirely encapsulated in the library as they are intended to be applied into other classes and the changes need to be propagated outside of the library. WDYT?

How about something like this (patch on top of the linked CL):

diff --git a/pkg/dev_compiler/lib/src/kernel/target.dart b/pkg/dev_compiler/lib/src/kernel/target.dart
index b45b6208a7b..24da5a59aa9 100644
--- a/pkg/dev_compiler/lib/src/kernel/target.dart
+++ b/pkg/dev_compiler/lib/src/kernel/target.dart
@@ -328,6 +328,9 @@ class DevCompilerTarget extends Target {
   @override
   DartLibrarySupport get dartLibrarySupport =>
       const DevCompilerDartLibrarySupport();
+
+  @override
+  bool get incrementalCompilerIncludeWouldHaveInvalidatedLibraries => true;
 }
 
 class DevCompilerDartLibrarySupport extends CustomizedDartLibrarySupport {
diff --git a/pkg/front_end/lib/src/base/incremental_compiler.dart b/pkg/front_end/lib/src/base/incremental_compiler.dart
index 91742e4d9f7..352e9c973db 100644
--- a/pkg/front_end/lib/src/base/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/base/incremental_compiler.dart
@@ -526,6 +526,19 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
             c,
             cleanedUpBuilders: cleanedUpBuilders,
           );
+      if (context
+              .options
+              .target
+              .incrementalCompilerIncludeWouldHaveInvalidatedLibraries &&
+          experimentalInvalidation != null &&
+          experimentalInvalidation.originalNotReusedLibraries.isNotEmpty) {
+        Set<Library> includingWouldHaveInvalidated = Set.of(outputLibraries);
+        for (DillLibraryBuilder lib
+            in experimentalInvalidation.originalNotReusedLibraries) {
+          includingWouldHaveInvalidated.add(lib.library);
+        }
+        outputLibraries = includingWouldHaveInvalidated.toList();
+      }
       List<String> problemsAsJson = _componentProblems.reissueProblems(
         context,
         currentKernelTarget,
diff --git a/pkg/frontend_server/test/frontend_server_test.dart b/pkg/frontend_server/test/frontend_server_test.dart
index dd243523d08..fc82b092a5d 100644
--- a/pkg/frontend_server/test/frontend_server_test.dart
+++ b/pkg/frontend_server/test/frontend_server_test.dart
@@ -2789,8 +2789,15 @@ e() {
         new File('${tempDir.path}/main.dart')
           ..createSync()
           ..writeAsStringSync("import 'class.dart';\n"
+              "import 'helper.dart';\n"
+              "final h = new Helper();\n"
               "final c = new C();\n"
-              "main() { print(c.fn()); print(c.gn());}\n");
+              "main() { print(c.fn()); print(c.gn()); print(h.x());}\n");
+        new File('${tempDir.path}/helper.dart')
+          ..createSync()
+          ..writeAsStringSync("class Helper {\n"
+              "  String x() { return 'Helper'; }\n"
+              "}\n");
         new File('${tempDir.path}/class.dart')
           ..createSync()
           ..writeAsStringSync("import 'mixin.dart';\n"
@@ -2849,6 +2856,7 @@ e() {
                 manifest.keys,
                 containsAll([
                   '/packages/hello/main.dart.lib.js',
+                  '/packages/hello/helper.dart.lib.js',
                   '/packages/hello/class.dart.lib.js',
                   '/packages/hello/mixin.dart.lib.js'
                 ]));
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index add0eba0640..080c8e9c6e9 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -555,6 +555,10 @@ abstract class Target {
 
   /// Should this target-specific pragma be recognized by annotation parsers?
   bool isSupportedPragma(String pragmaName) => false;
+
+  /// If the incremental compiler should include the libraries that would have
+  /// been invalidated, if it had invalidated the transitive import graph.
+  bool get incrementalCompilerIncludeWouldHaveInvalidatedLibraries => false;
 }
 
 class NoneConstantsBackend extends ConstantsBackend {

This will keep not compiling unneeded stuff, but return to DDC also the libraries that would have been recompiled if the "advanced invalidation" wasn't a thing.

I'm guessing that fixes (or allows you to fix if there's still something about identity in maps or whatnot?) the mixin method issue --- but still leaves the fields not updating because of caching which seems unrelated to me.

[nshahan]

@jensjoha
Thanks for this diff! That gave me something to ponder and I modified your change a little to get the invalidation that I'm looking for. I updated my change https://dart-review.googlesource.com/c/sdk/+/459343 to grow the invalidated libraries to include those that have any mixin applications where the mixin was defined in the minimal set of libraries that the experimental invalidation found. This will further reduce the number of libraries we will need to reload in the browser. Any thoughts on this approach? Is there a place in the invalidation logic where this might be even easier to determine?

I think the original bug will still be present if a library with language version < 3.0.0 mixes in a class that isn't defined with the mixin keyword. I could probably expand the search for those classes as well if the logic is reasonable.

[jensjoha]

I've added a few comments on the CL.
It leaves me wondering how much needs to be included though if there's more mixins involved. Say we have this diff instead (with a changed test):

diff --git a/pkg/dev_compiler/lib/src/kernel/target.dart b/pkg/dev_compiler/lib/src/kernel/target.dart
index b45b6208a7b..aa1357a671e 100644
--- a/pkg/dev_compiler/lib/src/kernel/target.dart
+++ b/pkg/dev_compiler/lib/src/kernel/target.dart
@@ -328,6 +328,9 @@ class DevCompilerTarget extends Target {
   @override
   DartLibrarySupport get dartLibrarySupport =>
       const DevCompilerDartLibrarySupport();
+
+  @override
+  bool get incrementalCompilerIncludeMixinApplicationInvalidatedLibraries => true;
 }
 
 class DevCompilerDartLibrarySupport extends CustomizedDartLibrarySupport {
diff --git a/pkg/front_end/lib/src/base/incremental_compiler.dart b/pkg/front_end/lib/src/base/incremental_compiler.dart
index 91742e4d9f7..241f78872bc 100644
--- a/pkg/front_end/lib/src/base/incremental_compiler.dart
+++ b/pkg/front_end/lib/src/base/incremental_compiler.dart
@@ -330,6 +330,10 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
             reusedResult,
             c,
             uriTranslator,
+            context
+                .options
+                .target
+                .incrementalCompilerIncludeMixinApplicationInvalidatedLibraries,
           );
       recorderForTesting?.recordRebuildBodiesCount(
         experimentalInvalidation?.missingSources.length ?? 0,
@@ -526,6 +530,13 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
             c,
             cleanedUpBuilders: cleanedUpBuilders,
           );
+      if (experimentalInvalidation != null &&
+          experimentalInvalidation.collectedMixinLibraries != null) {
+        outputLibraries = {
+          ...outputLibraries,
+          ...experimentalInvalidation.collectedMixinLibraries!,
+        }.toList();
+      }
       List<String> problemsAsJson = _componentProblems.reissueProblems(
         context,
         currentKernelTarget,
@@ -1116,6 +1127,7 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
     ReusageResult reusedResult,
     CompilerContext c,
     UriTranslator uriTranslator,
+    bool collectMixinsToo,
   ) async {
     Set<DillLibraryBuilder>? rebuildBodies;
     Set<DillLibraryBuilder> originalNotReusedLibraries;
@@ -1230,6 +1242,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.
+    List<Library>? collectedMixinLibraries;
     if (!skipExperimentalInvalidationChecksForTesting) {
       for (LibraryBuilder builder in reusedResult.notReusedLibraries) {
         if (missingSources!.contains(builder.fileUri)) {
@@ -1254,6 +1267,13 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
               return null;
             }
           }
+
+          if (collectMixinsToo) {
+            if (c.mixedInClass != null &&
+                missingSources.contains(c.mixedInClass!.fileUri)) {
+              (collectedMixinLibraries ??= []).add(c.enclosingLibrary);
+            }
+          }
         }
       }
 
@@ -1322,6 +1342,7 @@ class IncrementalCompiler implements IncrementalKernelGenerator {
       rebuildBodies,
       originalNotReusedLibraries,
       missingSources,
+      collectedMixinLibraries,
     );
   }
 
@@ -2682,11 +2703,13 @@ class ExperimentalInvalidation {
   final Set<DillLibraryBuilder> rebuildBodies;
   final Set<DillLibraryBuilder> originalNotReusedLibraries;
   final Set<Uri> missingSources;
+  final List<Library>? collectedMixinLibraries;
 
   ExperimentalInvalidation(
     this.rebuildBodies,
     this.originalNotReusedLibraries,
     this.missingSources,
+    this.collectedMixinLibraries,
   );
 }
 
diff --git a/pkg/frontend_server/test/frontend_server_test.dart b/pkg/frontend_server/test/frontend_server_test.dart
index dd243523d08..a3dfd6746c1 100644
--- a/pkg/frontend_server/test/frontend_server_test.dart
+++ b/pkg/frontend_server/test/frontend_server_test.dart
@@ -2788,18 +2788,44 @@ e() {
           {required String moduleFormat, bool canary = false}) async {
         new File('${tempDir.path}/main.dart')
           ..createSync()
-          ..writeAsStringSync("import 'class.dart';\n"
-              "final c = new C();\n"
-              "main() { print(c.fn()); print(c.gn());}\n");
-        new File('${tempDir.path}/class.dart')
-          ..createSync()
-          ..writeAsStringSync("import 'mixin.dart';\n"
-              "class C with M {}\n");
-        new File('${tempDir.path}/mixin.dart')
-          ..createSync()
-          ..writeAsStringSync("mixin M {\n"
-              "  String fn() { return 'hello'; }\n"
-              "  String gn() => 'hello';\n"
+          ..writeAsStringSync("""
+import 'class2.dart';
+import 'helper.dart';
+final h = new Helper();
+final c = new C2();
+main() {
+  print(c.fn1());
+  print(c.gn1());
+  print(c.fn2());
+  print(c.gn2());
+  print(h.x());
+}
+""");
+        new File('${tempDir.path}/helper.dart')
+          ..createSync()
+          ..writeAsStringSync("class Helper {\n"
+              "  String x() { return 'Helper'; }\n"
+              "}\n");
+        new File('${tempDir.path}/class2.dart')
+          ..createSync()
+          ..writeAsStringSync("import 'mixin2.dart';\n"
+              "import 'class1.dart';\n"
+              "class C2 extends C1 with M2 {}\n");
+        new File('${tempDir.path}/class1.dart')
+          ..createSync()
+          ..writeAsStringSync("import 'mixin1.dart';\n"
+              "class C1 with M1 {}\n");
+        new File('${tempDir.path}/mixin1.dart')
+          ..createSync()
+          ..writeAsStringSync("mixin M1 {\n"
+              "  String fn1() { return 'hello'; }\n"
+              "  String gn1() => 'hello';\n"
+              "}\n");
+        new File('${tempDir.path}/mixin2.dart')
+          ..createSync()
+          ..writeAsStringSync("mixin M2 {\n"
+              "  String fn2() { return 'hello'; }\n"
+              "  String gn2() => 'hello';\n"
               "}\n");
         File packageConfig =
             new File('${tempDir.path}/.dart_tool/package_config.json')
@@ -2837,8 +2863,6 @@ e() {
         frontendServer.listen((Result compiledResult) {
           if (count == 0) {
             compiledResult.expectNoErrors(filename: dillFile.path);
-            // Find three compiled files for main.dart, class.dart, and
-            // mixin.dart.
             final File manifestFile = new File('${dillFile.path}.json');
             expect(manifestFile.existsSync(), true);
             frontendServer.accept();
@@ -2849,14 +2873,17 @@ e() {
                 manifest.keys,
                 containsAll([
                   '/packages/hello/main.dart.lib.js',
-                  '/packages/hello/class.dart.lib.js',
-                  '/packages/hello/mixin.dart.lib.js'
+                  '/packages/hello/helper.dart.lib.js',
+                  '/packages/hello/class1.dart.lib.js',
+                  '/packages/hello/mixin1.dart.lib.js',
+                  '/packages/hello/class2.dart.lib.js',
+                  '/packages/hello/mixin2.dart.lib.js',
                 ]));
-            final File mixinFile = new File('${tempDir.path}/mixin.dart')
+            final File mixinFile = new File('${tempDir.path}/mixin1.dart')
               ..createSync()
-              ..writeAsStringSync("mixin M {\n"
-                  "  String fn() { return 'hello'; }\n"
-                  "  String gn() => 'goodbye';\n"
+              ..writeAsStringSync("mixin M1 {\n"
+                  "  String fn1() { return 'hello'; }\n"
+                  "  String gn1() => 'goodbye';\n"
                   "}\n");
 
             frontendServer.recompile(mixinFile.uri, entryPoint: entrypoint);
@@ -2874,14 +2901,15 @@ e() {
                 manifest.keys,
                 containsAll([
                   '/packages/hello/main.dart.lib.js',
-                  '/packages/hello/class.dart.lib.js',
-                  '/packages/hello/mixin.dart.lib.js'
+                  '/packages/hello/class1.dart.lib.js',
+                  '/packages/hello/mixin1.dart.lib.js',
+                  '/packages/hello/class2.dart.lib.js',
                 ]));
-            final File mixinFile = new File('${tempDir.path}/mixin.dart')
+            final File mixinFile = new File('${tempDir.path}/mixin1.dart')
               ..createSync()
-              ..writeAsStringSync("mixin M {\n"
-                  "  String fn() { return 'goodbye'; }\n"
-                  "  String gn() => 'goodbye';\n"
+              ..writeAsStringSync("mixin M1 {\n"
+                  "  String fn1() { return 'goodbye'; }\n"
+                  "  String gn1() => 'goodbye';\n"
                   "}\n");
 
             frontendServer.recompile(mixinFile.uri, entryPoint: entrypoint);
@@ -2898,9 +2926,8 @@ e() {
             expect(
                 manifest.keys,
                 containsAll([
-                  '/packages/hello/main.dart.lib.js',
-                  '/packages/hello/class.dart.lib.js',
-                  '/packages/hello/mixin.dart.lib.js'
+                  '/packages/hello/class1.dart.lib.js',
+                  '/packages/hello/mixin1.dart.lib.js'
                 ]));
             frontendServer.quit();
             expectationCompleter.complete(true);
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index add0eba0640..658ed02ed3b 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -555,6 +555,12 @@ abstract class Target {
 
   /// Should this target-specific pragma be recognized by annotation parsers?
   bool isSupportedPragma(String pragmaName) => false;
+
+  /// If the incremental compiler should include the libraries that would have
+  /// been invalidated, if it had invalidated the transitive import graph,
+  /// if it includes a mixin application from on of the invalidated libraries.
+  bool get incrementalCompilerIncludeMixinApplicationInvalidatedLibraries =>
+      false;
 }
 
 class NoneConstantsBackend extends ConstantsBackend {

is the returned stuff here enough (mixin1.dart and class1.dart) or would it need class2.dart too?