Fine. Record default values of formal parameters.

Fine-grained manifests now capture more information about function and
constructor parameters so the analyzer can detect semantically relevant
changes.

What’s changed
- Record the default value of optional named and positional parameters as
  a `ManifestNode`, and include it in matching/serialization logic.
- Track whether a parameter is an initializing formal (`this`) or a super
  formal (`super`) and persist these flags in manifests.
- Add a `never_` entry to `ManifestAstElementKind` and collect
  `NeverElementImpl` so const initializers that reference `Never` are
  represented correctly.
- Enhance result printing to display `this`/`super` markers, default
  values, and decode `Never` in element indices.
- Bump `AnalysisDriver.DATA_VERSION` to 552 to invalidate stale caches.

Why Previously, default parameter values and formal origin
(`this`/`super`) were not part of the manifest. Changing them could
leave linked data unchanged, producing stale analysis results. By
encoding these details (and handling `Never`), we ensure manifest
matching reflects the true API surface and triggers re-linking when
defaults or formal kinds change.

Change-Id: Icae8281f923879574fdc6143fd2c9d6018f4d48f
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/449363
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Johnni Winther <[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 = 550;
+  static const int DATA_VERSION = 552;
 
   /// 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/fine/manifest_ast.dart

@@ -22,6 +22,7 @@ enum ManifestAstElementKind {
   dynamic_,
   formalParameter,
   importPrefix,
+  never_,
   typeParameter,
   regular,
   multiplyDefined;
@@ -441,6 +442,9 @@ class _ElementCollector extends GeneralizingAstVisitor<void> {
       case DynamicElementImpl():
         kind = ManifestAstElementKind.dynamic_;
         rawIndex = 0;
+      case NeverElementImpl():
+        kind = ManifestAstElementKind.never_;
+        rawIndex = 0;
       case MultiplyDefinedElementImpl():
         kind = ManifestAstElementKind.multiplyDefined;
         rawIndex = 0;

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

@@ -9,8 +9,10 @@ import 'package:analyzer/dart/element/nullability_suffix.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/binary/binary_reader.dart';
 import 'package:analyzer/src/binary/binary_writer.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
+import 'package:analyzer/src/fine/manifest_ast.dart';
 import 'package:analyzer/src/fine/manifest_context.dart';
 import 'package:analyzer/src/fine/manifest_item.dart';
 import 'package:analyzer/src/utilities/extensions/collection.dart';
@@ -35,14 +37,40 @@ sealed class ManifestFunctionFormalParameter {
   final ManifestMetadata metadata;
   final bool isRequired;
   final bool isCovariant;
+  final bool isInitializingFormal;
+  final bool isSuperFormal;
   final ManifestType type;
+  final ManifestNode? defaultValue;
 
   ManifestFunctionFormalParameter({
     required this.metadata,
     required this.isRequired,
     required this.isCovariant,
+    required this.isInitializingFormal,
+    required this.isSuperFormal,
     required this.type,
+    required this.defaultValue,
   });
+
+  bool match(MatchContext context, InternalFormalParameterElement element) {
+    return metadata.match(context, element.metadata) &&
+        element.isRequired == isRequired &&
+        element.isCovariant == isCovariant &&
+        element.isInitializingFormal == isInitializingFormal &&
+        element.isSuperFormal == isSuperFormal &&
+        type.match(context, element.type) &&
+        defaultValue.match(context, element.constantInitializer);
+  }
+
+  void write(BufferedSink sink) {
+    metadata.write(sink);
+    sink.writeBool(isRequired);
+    sink.writeBool(isCovariant);
+    sink.writeBool(isInitializingFormal);
+    sink.writeBool(isSuperFormal);
+    type.write(sink);
+    defaultValue.writeOptional(sink);
+  }
 }
 
 class ManifestFunctionNamedFormalParameter
@@ -57,7 +85,10 @@ class ManifestFunctionNamedFormalParameter
       metadata: ManifestMetadata.encode(context, element.metadata),
       isRequired: element.isRequired,
       isCovariant: element.isCovariant,
+      isInitializingFormal: element.isInitializingFormal,
+      isSuperFormal: element.isSuperFormal,
       type: element.type.encode(context),
+      defaultValue: element.constantInitializer?.encode(context),
       name: element.name ?? '',
     );
   }
@@ -67,7 +98,10 @@ class ManifestFunctionNamedFormalParameter
       metadata: ManifestMetadata.read(reader),
       isRequired: reader.readBool(),
       isCovariant: reader.readBool(),
+      isInitializingFormal: reader.readBool(),
+      isSuperFormal: reader.readBool(),
       type: ManifestType.read(reader),
+      defaultValue: ManifestNode.readOptional(reader),
       name: reader.readStringUtf8(),
     );
   }
@@ -76,24 +110,23 @@ class ManifestFunctionNamedFormalParameter
     required super.metadata,
     required super.isRequired,
     required super.isCovariant,
+    required super.isInitializingFormal,
+    required super.isSuperFormal,
     required super.type,
+    required super.defaultValue,
     required this.name,
   });
 
+  @override
   bool match(MatchContext context, InternalFormalParameterElement element) {
     return element.isNamed &&
-        metadata.match(context, element.metadata) &&
-        element.isRequired == isRequired &&
-        element.isCovariant == isCovariant &&
-        type.match(context, element.type) &&
+        super.match(context, element) &&
         element.name == name;
   }
 
+  @override
   void write(BufferedSink sink) {
-    metadata.write(sink);
-    sink.writeBool(isRequired);
-    sink.writeBool(isCovariant);
-    type.write(sink);
+    super.write(sink);
     sink.writeStringUtf8(name);
   }
 }
@@ -108,7 +141,10 @@ class ManifestFunctionPositionalFormalParameter
       metadata: ManifestMetadata.encode(context, element.metadata),
       isRequired: element.isRequiredPositional,
       isCovariant: element.isCovariant,
+      isInitializingFormal: element.isInitializingFormal,
+      isSuperFormal: element.isSuperFormal,
       type: element.type.encode(context),
+      defaultValue: element.constantInitializer?.encode(context),
     );
   }
 
@@ -119,30 +155,26 @@ class ManifestFunctionPositionalFormalParameter
       metadata: ManifestMetadata.read(reader),
       isRequired: reader.readBool(),
       isCovariant: reader.readBool(),
+      isInitializingFormal: reader.readBool(),
+      isSuperFormal: reader.readBool(),
       type: ManifestType.read(reader),
+      defaultValue: ManifestNode.readOptional(reader),
     );
   }
 
   ManifestFunctionPositionalFormalParameter._({
     required super.metadata,
     required super.isRequired,
     required super.isCovariant,
+    required super.isInitializingFormal,
+    required super.isSuperFormal,
     required super.type,
+    required super.defaultValue,
   });
 
+  @override
   bool match(MatchContext context, InternalFormalParameterElement element) {
-    return element.isPositional &&
-        metadata.match(context, element.metadata) &&
-        element.isRequired == isRequired &&
-        element.isCovariant == isCovariant &&
-        type.match(context, element.type);
-  }
-
-  void write(BufferedSink sink) {
-    metadata.write(sink);
-    sink.writeBool(isRequired);
-    sink.writeBool(isCovariant);
-    type.write(sink);
+    return element.isPositional && super.match(context, element);
   }
 }
 
@@ -742,3 +774,9 @@ extension ManifestTypeOrNullExtension on ManifestType? {
     sink.writeOptionalObject(this, (x) => x.write(sink));
   }
 }
+
+extension _AstNodeExtension on AstNode {
+  ManifestNode encode(EncodeContext context) {
+    return ManifestNode.encode(context, this);
+  }
+}