Elements. Compute and serialize hasNonFinalField for interfaces.

Compute `InterfaceElementImpl.hasNonFinalField` once during linking and
persist it in summaries for classes and mixins. This replaces the
previous on-demand, tracked getter with a stored boolean initialized via
a recursive walk over the superclass and mixin chain.

Key changes:
- Add `bool hasNonFinalField` to `InterfaceElementImpl`.
- Compute the value in `link.dart::_computeHasNonFinalField()` after
  `_resolveTypes()` and before `_setDefaultSupertypes()`, memoizing to
  avoid recomputation.
- Serialize/deserialize the value in bundle writer/reader for class and
  mixin elements.
- Remove the expensive getter and its requirement recording.
- Bump `DATA_VERSION` to 525.

Why:
- Avoid repeatedly traversing hierarchies at query time.
- Make the property available across library boundaries via summaries.
- Reduce analysis overhead for checks that depend on field mutability
  (e.g., const constructor eligibility).

Impact:
- No intended behavioral change; the result matches the prior logic:
  true if any instance, non-const, non-static, non-synthetic field is
  declared in the class, its supertypes, or applied mixins.
- Older summaries are invalidated by the version bump.

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

Author: scheglov

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

@@ -109,7 +109,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 = 524;
+  static const int DATA_VERSION = 525;
 
   /// 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

@@ -4556,6 +4556,9 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
   /// of this class have been inferred.
   bool hasBeenInferred = false;
 
+  /// Whether the class or its superclass declares a non-final instance field.
+  bool hasNonFinalField = false;
+
   @override
   List<InterfaceTypeImpl> get allSupertypes {
     return _allSupertypes ??= library.session.classHierarchy
@@ -4612,42 +4615,6 @@ abstract class InterfaceElementImpl extends InstanceElementImpl
     ];
   }
 
-  @trackedDirectlyExpensive
-  bool get hasNonFinalField {
-    globalResultRequirements?.record_interfaceElement_hasNonFinalField(
-      element: this,
-    );
-
-    var classesToVisit = <InterfaceElementImpl>[];
-    var visitedClasses = <InterfaceElementImpl>{};
-    classesToVisit.add(this);
-    while (classesToVisit.isNotEmpty) {
-      var currentElement = classesToVisit.removeAt(0);
-      if (visitedClasses.add(currentElement)) {
-        // check fields
-        for (var field in currentElement.fields) {
-          if (!field.isFinal &&
-              !field.isConst &&
-              !field.isStatic &&
-              !field.isSynthetic) {
-            return true;
-          }
-        }
-        // check mixins
-        for (var mixinType in currentElement.mixins) {
-          classesToVisit.add(mixinType.element);
-        }
-        // check super
-        var supertype = currentElement.supertype;
-        if (supertype != null) {
-          classesToVisit.add(supertype.element);
-        }
-      }
-    }
-    // not found
-    return false;
-  }
-
   InheritanceManager3 get inheritanceManager {
     return library.session.inheritanceManager;
   }

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

@@ -1065,12 +1065,6 @@ class RequirementsManifest {
     requirements.requestedConstructors[constructorName] = constructorId;
   }
 
-  void record_interfaceElement_hasNonFinalField({
-    required InterfaceElementImpl element,
-  }) {
-    // TODO(scheglov): implement.
-  }
-
   /// Record that all accessible extensions inside a [LibraryFragmentImpl]
   /// are requested, which means dependency on all extensions exported
   /// from [importedLibraries].

pkg/analyzer/lib/src/summary2/bundle_reader.dart

@@ -266,6 +266,7 @@ class LibraryReader {
       var element = ClassElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
       element.readModifiers(_reader);
+      element.hasNonFinalField = _reader.readBool();
 
       // Configure for reading members lazily.
       _lazyRead((offset) {
@@ -953,6 +954,7 @@ class LibraryReader {
       var element = MixinElementImpl(reference, fragments.first);
       element.linkFragments(fragments);
       element.readModifiers(_reader);
+      element.hasNonFinalField = _reader.readBool();
 
       // TODO(scheglov): consider reading lazily
       for (var fragment in element.fragments) {

pkg/analyzer/lib/src/summary2/bundle_writer.dart

@@ -140,6 +140,7 @@ class BundleWriter {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
       element.writeModifiers(_sink);
+      _sink.writeBool(element.hasNonFinalField);
 
       // We read members lazily.
       _writeForLazyRead(() {
@@ -561,6 +562,7 @@ class BundleWriter {
       _writeReference(element.reference);
       _writeFragments(element.fragments);
       element.writeModifiers(_sink);
+      _sink.writeBool(element.hasNonFinalField);
 
       // TODO(scheglov): consider reading lazily
       _resolutionSink.withTypeParameters(element.typeParameters, () {

pkg/analyzer/lib/src/summary2/link.dart

@@ -232,6 +232,7 @@ class Linker {
 
     _createTypeSystem();
     _resolveTypes();
+    _computeHasNonFinalField();
     _setDefaultSupertypes();
 
     _buildClassSyntheticConstructors();
@@ -265,6 +266,44 @@ class Linker {
     }
   }
 
+  /// Set [InterfaceElementImpl.hasNonFinalField] for classes and mixins.
+  ///
+  /// We actually use it only for classes (which can have `const` constructors),
+  /// but mixins contribute to it.
+  void _computeHasNonFinalField() {
+    var linkingElements =
+        builders.values
+            .expand((builder) => builder.element.children)
+            .whereType<InterfaceElementImpl>()
+            .toSet();
+
+    var alreadyComputed = Set<InterfaceElementImpl>.identity();
+
+    bool computeFor(InterfaceElementImpl element) {
+      if (!linkingElements.contains(element) || !alreadyComputed.add(element)) {
+        return element.hasNonFinalField;
+      }
+
+      var hasNonFinalField = [
+        element.supertype,
+        ...element.mixins,
+      ].nonNulls.any((type) => computeFor(type.element));
+
+      hasNonFinalField |= element.fields.any((field) {
+        return !field.isFinal &&
+            !field.isConst &&
+            !field.isStatic &&
+            !field.isSynthetic;
+      });
+
+      return element.hasNonFinalField = hasNonFinalField;
+    }
+
+    for (var element in linkingElements) {
+      computeFor(element);
+    }
+  }
+
   void _computeLibraryScopes({required OperationPerformanceImpl performance}) {
     globalResultRequirements.untracked(
       reason: 'No complete elements yet',