Fine. Track hasNonFinalField in manifests and requirements.

Persist and track `hasNonFinalField` for interface-like elements so
fine- grained dependencies can invalidate precisely when a class (or its
supertypes) declares a non-final instance field.

What’s changed
- Store `hasNonFinalField` on manifest items for classes, enums,
  extension types, and mixins. The flag is serialized/deserialized and
  printed in dumps.
- Add a tracked getter on `InterfaceElementImpl` that records a
  dependency when `hasNonFinalField` is queried; use a private backing
  field with a setter.
- Extend requirements schema with an optional `hasNonFinalField` entry
  and record it when requested.
- Validate the requirement via a new
  `InterfaceHasNonFinalFieldMismatch` failure.
- Exclude `hasNonFinalField` from item identity matching; it is enforced
  via requirements instead of forcing new IDs.
- Bump `AnalysisDriver.DATA_VERSION` to 541 for the format change.

Why
- Consumers that depend on mutability of instance fields (directly or
  through inheritance) now get targeted invalidation without unnecessary
  ID churn, improving both correctness and incremental performance.

Implementation notes
- LibraryManifestBuilder copies `element.hasNonFinalField` into item
  instances.
- Manifest read/write gains a boolean field on `InterfaceItem` (and
  subclasses) and helpers to encode/decode optional booleans in the
  requirements stream.
- Result printer includes `hasNonFinalField` in interface requirement
  dumps.

Change-Id: Ib132dca582f77df87f995920dd9b73784a4eeefd
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/448444
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>

Author: scheglov

pkg/analyzer/lib/src/dart/analysis/driver.dart

@@ -106,7 +106,7 @@ testFineAfterLibraryAnalyzerHook;
 // TODO(scheglov): Clean up the list of implicitly analyzed files.
 class AnalysisDriver {
   /// The version of data format, should be incremented on every format change.
-  static const int DATA_VERSION = 539;
+  static const int DATA_VERSION = 541;
 
   /// The number of exception contexts allowed to write. Once this field is
   /// zero, we stop writing any new exception contexts in this process.

pkg/analyzer/lib/src/dart/element/element.dart

@@ -4646,8 +4646,8 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
   List<InterfaceTypeImpl>? Function(InterfaceElementImpl)?
   mixinInferenceCallback;
 
-  /// Whether the class or its superclass declares a non-final instance field.
-  bool hasNonFinalField = false;
+  /// Storage for [hasNonFinalField].
+  bool _hasNonFinalField = false;
 
   @override
   List<InterfaceTypeImpl> get allSupertypes {
@@ -4705,6 +4705,19 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
     ];
   }
 
+  /// Whether the class or its superclass declares a non-final instance field.
+  @trackedDirectly
+  bool get hasNonFinalField {
+    globalResultRequirements?.record_interfaceElement_hasNonFinalField(
+      element: this,
+    );
+    return _hasNonFinalField;
+  }
+
+  set hasNonFinalField(bool value) {
+    _hasNonFinalField = value;
+  }
+
   InheritanceManager3 get inheritanceManager {
     return library.session.inheritanceManager;
   }

pkg/analyzer/lib/src/fine/library_manifest.dart

@@ -216,6 +216,7 @@ class LibraryManifestBuilder {
         element: element,
       );
     });
+    classItem.hasNonFinalField = element.hasNonFinalField;
     newItems[lookupName] = classItem;
 
     encodingContext.withTypeParameters(element.typeParameters, (
@@ -301,6 +302,7 @@ class LibraryManifestBuilder {
         element: element,
       );
     });
+    enumItem.hasNonFinalField = element.hasNonFinalField;
     newItems[lookupName] = enumItem;
 
     encodingContext.withTypeParameters(element.typeParameters, (
@@ -380,6 +382,7 @@ class LibraryManifestBuilder {
         element: element,
       );
     });
+    extensionTypeItem.hasNonFinalField = element.hasNonFinalField;
     newItems[lookupName] = extensionTypeItem;
 
     encodingContext.withTypeParameters(element.typeParameters, (
@@ -577,6 +580,7 @@ class LibraryManifestBuilder {
         element: element,
       );
     });
+    mixinItem.hasNonFinalField = element.hasNonFinalField;
     newItems[lookupName] = mixinItem;
 
     encodingContext.withTypeParameters(element.typeParameters, (

pkg/analyzer/lib/src/fine/manifest_item.dart

@@ -37,6 +37,7 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
     required super.declaredMethods,
     required super.declaredConstructors,
     required super.inheritedConstructors,
+    required super.hasNonFinalField,
     required super.supertype,
     required super.mixins,
     required super.interfaces,
@@ -69,6 +70,7 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
         declaredMethods: {},
         declaredConstructors: {},
         inheritedConstructors: {},
+        hasNonFinalField: element.hasNonFinalField,
         supertype: element.supertype?.encode(context),
         mixins: element.mixins.encode(context),
         interfaces: element.interfaces.encode(context),
@@ -98,6 +100,7 @@ class ClassItem extends InterfaceItem<ClassElementImpl> {
       declaredMethods: InstanceItemMethodItem.readMap(reader),
       declaredConstructors: InterfaceItemConstructorItem.readMap(reader),
       inheritedConstructors: reader.readLookupNameToIdMap(),
+      hasNonFinalField: reader.readBool(),
       supertype: ManifestType.readOptional(reader),
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),
@@ -151,6 +154,7 @@ class EnumItem extends InterfaceItem<EnumElementImpl> {
     required super.declaredMethods,
     required super.declaredConstructors,
     required super.inheritedConstructors,
+    required super.hasNonFinalField,
     required super.interface,
     required super.supertype,
     required super.mixins,
@@ -176,6 +180,7 @@ class EnumItem extends InterfaceItem<EnumElementImpl> {
         declaredMethods: {},
         declaredConstructors: {},
         inheritedConstructors: {},
+        hasNonFinalField: element.hasNonFinalField,
         interface: ManifestInterface.empty(),
         supertype: element.supertype?.encode(context),
         mixins: element.mixins.encode(context),
@@ -198,6 +203,7 @@ class EnumItem extends InterfaceItem<EnumElementImpl> {
       declaredMethods: InstanceItemMethodItem.readMap(reader),
       declaredConstructors: InterfaceItemConstructorItem.readMap(reader),
       inheritedConstructors: reader.readLookupNameToIdMap(),
+      hasNonFinalField: reader.readBool(),
       supertype: ManifestType.readOptional(reader),
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),
@@ -300,6 +306,7 @@ class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl> {
     required super.declaredMethods,
     required super.declaredConstructors,
     required super.inheritedConstructors,
+    required super.hasNonFinalField,
     required super.interface,
     required super.supertype,
     required super.mixins,
@@ -329,6 +336,7 @@ class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl> {
         declaredMethods: {},
         declaredConstructors: {},
         inheritedConstructors: {},
+        hasNonFinalField: element.hasNonFinalField,
         interface: ManifestInterface.empty(),
         supertype: element.supertype?.encode(context),
         mixins: element.mixins.encode(context),
@@ -355,6 +363,7 @@ class ExtensionTypeItem extends InterfaceItem<ExtensionTypeElementImpl> {
       declaredMethods: InstanceItemMethodItem.readMap(reader),
       declaredConstructors: InterfaceItemConstructorItem.readMap(reader),
       inheritedConstructors: reader.readLookupNameToIdMap(),
+      hasNonFinalField: reader.readBool(),
       supertype: ManifestType.readOptional(reader),
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),
@@ -951,6 +960,7 @@ class InstanceItemSetterItem extends InstanceItemMemberItem<SetterElementImpl> {
 /// The item for [InterfaceElementImpl].
 sealed class InterfaceItem<E extends InterfaceElementImpl>
     extends InstanceItem<E> {
+  bool hasNonFinalField;
   final ManifestType? supertype;
   final List<ManifestType> interfaces;
   final List<ManifestType> mixins;
@@ -969,6 +979,7 @@ sealed class InterfaceItem<E extends InterfaceElementImpl>
     required super.declaredMethods,
     required super.declaredConstructors,
     required super.inheritedConstructors,
+    required this.hasNonFinalField,
     required this.supertype,
     required this.mixins,
     required this.interfaces,
@@ -979,6 +990,8 @@ sealed class InterfaceItem<E extends InterfaceElementImpl>
     return interface.map[name];
   }
 
+  /// Intentionally omits [hasNonFinalField], which is tracked as a separate
+  /// requirement.
   @override
   bool match(MatchContext context, E element) {
     return super.match(context, element) &&
@@ -990,6 +1003,7 @@ sealed class InterfaceItem<E extends InterfaceElementImpl>
   @override
   void write(BufferedSink sink) {
     super.write(sink);
+    sink.writeBool(hasNonFinalField);
     supertype.writeOptional(sink);
     mixins.writeList(sink);
     interfaces.writeList(sink);
@@ -1286,6 +1300,7 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
     required super.declaredSetters,
     required super.declaredConstructors,
     required super.inheritedConstructors,
+    required super.hasNonFinalField,
     required super.interface,
     required this.isBase,
     required this.superclassConstraints,
@@ -1313,6 +1328,7 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
         declaredMethods: {},
         declaredConstructors: {},
         inheritedConstructors: {},
+        hasNonFinalField: element.hasNonFinalField,
         interface: ManifestInterface.empty(),
         supertype: element.supertype?.encode(context),
         mixins: element.mixins.encode(context),
@@ -1340,6 +1356,7 @@ class MixinItem extends InterfaceItem<MixinElementImpl> {
       declaredMethods: InstanceItemMethodItem.readMap(reader),
       declaredConstructors: InterfaceItemConstructorItem.readMap(reader),
       inheritedConstructors: reader.readLookupNameToIdMap(),
+      hasNonFinalField: reader.readBool(),
       supertype: ManifestType.readOptional(reader),
       mixins: ManifestType.readList(reader),
       interfaces: ManifestType.readList(reader),

pkg/analyzer/lib/src/fine/requirement_failure.dart

@@ -206,6 +206,28 @@ class InterfaceConstructorIdMismatch extends RequirementFailure {
   }
 }
 
+class InterfaceHasNonFinalFieldMismatch extends RequirementFailure {
+  final Uri libraryUri;
+  final LookupName interfaceName;
+  final bool expected;
+  final bool actual;
+
+  InterfaceHasNonFinalFieldMismatch({
+    required this.libraryUri,
+    required this.interfaceName,
+    required this.expected,
+    required this.actual,
+  });
+
+  @override
+  String toString() {
+    return 'InterfaceHasNonFinalFieldMismatch(libraryUri: $libraryUri, '
+        'interfaceName: ${interfaceName.asString}, '
+        'expected: $expected, '
+        'actual: $actual)';
+  }
+}
+
 class InterfaceIdMismatch extends RequirementFailure {
   final Uri libraryUri;
   final LookupName interfaceName;

pkg/analyzer/lib/src/fine/requirements.dart

@@ -263,6 +263,9 @@ class InterfaceItemRequirements {
   /// If the element was asked for its full interface.
   ManifestItemId? interfaceId;
 
+  /// The value of `hasNonFinalField`, if it was requested.
+  bool? hasNonFinalField;
+
   /// Set if [InstanceElementImpl.constructors] is invoked.
   ManifestItemIdList? allConstructors;
 
@@ -274,6 +277,7 @@ class InterfaceItemRequirements {
 
   InterfaceItemRequirements({
     required this.interfaceId,
+    required this.hasNonFinalField,
     required this.allConstructors,
     required this.requestedConstructors,
     required this.methods,
@@ -282,6 +286,7 @@ class InterfaceItemRequirements {
   factory InterfaceItemRequirements.empty() {
     return InterfaceItemRequirements(
       interfaceId: null,
+      hasNonFinalField: null,
       allConstructors: null,
       requestedConstructors: {},
       methods: {},
@@ -291,6 +296,7 @@ class InterfaceItemRequirements {
   factory InterfaceItemRequirements.read(SummaryDataReader reader) {
     return InterfaceItemRequirements(
       interfaceId: ManifestItemId.readOptional(reader),
+      hasNonFinalField: reader.readOptionalBool(),
       allConstructors: ManifestItemIdList.readOptional(reader),
       requestedConstructors: reader.readNameToOptionalIdMap(),
       methods: reader.readNameToOptionalIdMap(),
@@ -299,6 +305,7 @@ class InterfaceItemRequirements {
 
   void write(BufferedSink sink) {
     interfaceId.writeOptional(sink);
+    sink.writeOptionalBool(hasNonFinalField);
     allConstructors.writeOptional(sink);
     sink.writeNameToIdMap(requestedConstructors);
     sink.writeNameToIdMap(methods);
@@ -724,6 +731,18 @@ class RequirementsManifest {
           }
         }
 
+        if (interfaceRequirements.hasNonFinalField case var expected?) {
+          var actual = interfaceItem.hasNonFinalField;
+          if (expected != actual) {
+            return InterfaceHasNonFinalFieldMismatch(
+              libraryUri: libraryUri,
+              interfaceName: interfaceName,
+              expected: expected,
+              actual: actual,
+            );
+          }
+        }
+
         if (interfaceRequirements.allConstructors case var required?) {
           var actualItems = interfaceItem.declaredConstructors.values;
           var actualIds = actualItems.map((item) => item.id);
@@ -1065,6 +1084,20 @@ class RequirementsManifest {
     requirements.requestedConstructors[constructorName] = constructorId;
   }
 
+  void record_interfaceElement_hasNonFinalField({
+    required InterfaceElementImpl element,
+  }) {
+    var itemRequirements = _getInterfaceItem(element);
+    if (itemRequirements == null) {
+      return;
+    }
+
+    var item = itemRequirements.item;
+    var requirements = itemRequirements.requirements;
+
+    requirements.hasNonFinalField = item.hasNonFinalField;
+  }
+
   /// Record that all accessible extensions inside a [LibraryFragmentImpl]
   /// are requested, which means dependency on all extensions exported
   /// from [importedLibraries].
@@ -1389,6 +1422,15 @@ extension _BufferedSinkExtension on BufferedSink {
       writeValue: (id) => id.writeOptional(this),
     );
   }
+
+  void writeOptionalBool(bool? value) {
+    if (value == null) {
+      writeBool(false);
+    } else {
+      writeBool(true);
+      writeBool(value);
+    }
+  }
 }
 
 extension _SummaryDataReaderExtension on SummaryDataReader {
@@ -1398,4 +1440,12 @@ extension _SummaryDataReaderExtension on SummaryDataReader {
       readValue: () => ManifestItemId.readOptional(this),
     );
   }
+
+  bool? readOptionalBool() {
+    if (readBool()) {
+      return readBool();
+    } else {
+      return null;
+    }
+  }
 }