DeCo. Add FieldFormalParameterElement.isDeclaring, ConstructorElement.isDeclaring/isPrimary, FieldElement.declaringFormalParameter

This change introduces new experimental properties to the analyzer
element model to identify elements related to declaring constructors.

The new properties are:
- `ConstructorElement.isDeclaring`: True for a declaring constructor.
- `ConstructorElement.isPrimary`: True if the constructor is primary
  (which implies it is also `isDeclaring`).
- `FieldFormalParameterElement.isDeclaring`: True for a formal
  parameter in a declaring constructor.
- `FieldElement.declaringFormalParameter`: A link from a field back
  to the formal parameter that declared it, if it came from a
  declaring constructor.

This allows other parts of the analyzer and analyzer clients to
understand the origin of these implicitly declared elements.

The change also updates the necessary serialization logic (manifest,
data version) and member proxies to support these new properties.

Bug: #61701
Change-Id: Iedefd6b5584d28a47aea0e90d6aedafaf8aecdef
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/459580
Reviewed-by: Paul Berry <[email protected]>
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

pkg/analyzer/api.txt

@@ -3376,9 +3376,11 @@ package:analyzer/dart/element/element.dart:
     firstFragment (getter: ConstructorFragment)
     fragments (getter: List<ConstructorFragment>)
     isConst (getter: bool)
+    isDeclaring (getter: bool, experimental)
     isDefaultConstructor (getter: bool)
     isFactory (getter: bool)
     isGenerative (getter: bool)
+    isPrimary (getter: bool, experimental)
     name (getter: String?)
     redirectedConstructor (getter: ConstructorElement?)
     returnType (getter: InterfaceType)
@@ -3611,6 +3613,7 @@ package:analyzer/dart/element/element.dart:
   FieldElement (class extends Object implements PropertyInducingElement):
     new (constructor: FieldElement Function())
     baseElement (getter: FieldElement)
+    declaringFormalParameter (getter: FieldFormalParameterElement?, experimental)
     enclosingElement (getter: InstanceElement)
     firstFragment (getter: FieldFragment)
     fragments (getter: List<FieldFragment>)
@@ -3624,6 +3627,7 @@ package:analyzer/dart/element/element.dart:
     field (getter: FieldElement?)
     firstFragment (getter: FieldFormalParameterFragment)
     fragments (getter: List<FieldFormalParameterFragment>)
+    isDeclaring (getter: bool, experimental)
   FieldFormalParameterFragment (class extends Object implements FormalParameterFragment):
     new (constructor: FieldFormalParameterFragment Function())
     element (getter: FieldFormalParameterElement)

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

@@ -59,6 +59,7 @@ import 'package:analyzer/source/line_info.dart';
 import 'package:analyzer/source/source.dart';
 import 'package:analyzer/src/dart/element/inheritance_manager3.dart' show Name;
 import 'package:analyzer/src/dart/resolver/scope.dart';
+import 'package:meta/meta.dart';
 import 'package:pub_semver/pub_semver.dart';
 
 export 'package:analyzer/src/dart/element/inheritance_manager3.dart' show Name;
@@ -228,6 +229,10 @@ abstract class ConstructorElement implements ExecutableElement {
   /// Whether the constructor is a const constructor.
   bool get isConst;
 
+  /// Whether this is a declaring constructor.
+  @experimental
+  bool get isDeclaring;
+
   /// Whether the constructor can be used as a default constructor - unnamed,
   /// and has no required parameters.
   bool get isDefaultConstructor;
@@ -238,6 +243,11 @@ abstract class ConstructorElement implements ExecutableElement {
   /// Whether the constructor represents a generative constructor.
   bool get isGenerative;
 
+  /// Whether this is a primary constructor.
+  /// When `true`, [isDeclaring] is also `true`.
+  @experimental
+  bool get isPrimary;
+
   /// The name of this constructor.
   ///
   /// The name of the unnamed constructor is `new`.
@@ -1193,6 +1203,10 @@ abstract class FieldElement implements PropertyInducingElement {
   @override
   FieldElement get baseElement;
 
+  /// The declaring formal parameter, if created from one.
+  @experimental
+  FieldFormalParameterElement? get declaringFormalParameter;
+
   @override
   InstanceElement get enclosingElement;
 
@@ -1235,6 +1249,10 @@ abstract class FieldFormalParameterElement implements FormalParameterElement {
 
   @override
   List<FieldFormalParameterFragment> get fragments;
+
+  /// Whether this is a declaring formal parameter.
+  @experimental
+  bool get isDeclaring;
 }
 
 /// The portion of a [FieldFormalParameterElement] contributed by a single

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 = 582;
+  static const int DATA_VERSION = 583;
 
   /// 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

@@ -701,6 +701,10 @@ class ConstructorElementImpl extends ExecutableElementImpl
   @trackedIncludedInId
   bool get isConst => _firstFragment.isConst;
 
+  @override
+  @trackedIncludedInId
+  bool get isDeclaring => _firstFragment.isDeclaring;
+
   @override
   @trackedIndirectly
   bool get isDefaultConstructor => _firstFragment.isDefaultConstructor;
@@ -713,6 +717,10 @@ class ConstructorElementImpl extends ExecutableElementImpl
   @trackedIndirectly
   bool get isGenerative => !isFactory;
 
+  @override
+  @trackedIncludedInId
+  bool get isPrimary => _firstFragment.isPrimary;
+
   @override
   @trackedIncludedInId
   ElementKind get kind => ElementKind.CONSTRUCTOR;
@@ -2627,6 +2635,22 @@ class FieldElementImpl extends PropertyInducingElementImpl
   @trackedIncludedInId
   FieldElementImpl get baseElement => this;
 
+  @override
+  @trackedIndirectly
+  FieldFormalParameterElementImpl? get declaringFormalParameter {
+    if (enclosingElement case InterfaceElementImpl enclosingElement) {
+      var declaringConstructor = enclosingElement.constructors.firstWhereOrNull(
+        (constructor) => constructor.isDeclaring,
+      );
+      return declaringConstructor?.formalParameters
+          .whereType<FieldFormalParameterElementImpl>()
+          .firstWhereOrNull((f) {
+            return f.isDeclaring && f.field == this;
+          });
+    }
+    return null;
+  }
+
   @override
   @trackedIncludedInId
   InstanceElementImpl get enclosingElement {
@@ -2828,12 +2852,17 @@ class FieldFormalParameterElementImpl extends FormalParameterElementImpl
     ];
   }
 
+  @override
+  bool get isDeclaring => _firstFragment.isDeclaring;
+
   @override
   FieldFormalParameterFragmentImpl get _firstFragment =>
       super._firstFragment as FieldFormalParameterFragmentImpl;
 }
 
+@GenerateFragmentImpl(modifiers: _FieldFormalParameterFragmentModifiers.values)
 class FieldFormalParameterFragmentImpl extends FormalParameterFragmentImpl
+    with _FieldFormalParameterFragmentImplMixin
     implements FieldFormalParameterFragment {
   /// Initialize a newly created parameter element to have the given [name] and
   /// [nameOffset].
@@ -7754,7 +7783,12 @@ enum Modifier {
   /// Indicates that the class is `Object` from `dart:core`.
   DART_CORE_OBJECT,
 
-  /// Indicates that the import element represents a deferred library.
+  /// Indicates that the element is either:
+  /// 1. Declaring formal parameters.
+  /// 2. Declaring constructor.
+  DECLARING,
+
+  /// Indicates that the element is a declaring formal parameter.
   DEFERRED,
 
   /// Indicates that a class element was defined by an enum declaration.
@@ -7822,6 +7856,10 @@ enum Modifier {
   /// enclosing element. This includes not only explicitly specified type
   /// annotations, but also inferred types.
   NO_ENCLOSING_TYPE_PARAMETER_REFERENCE,
+
+  /// Whether the constructor is primary.
+  PRIMARY,
+
   PROMOTABLE,
 
   /// Indicates whether the type of a [PropertyInducingFragmentImpl] should be
@@ -10053,7 +10091,12 @@ enum _ClassFragmentImplModifiers {
   isSealed,
 }
 
-enum _ConstructorFragmentImplModifiers { isConst, isFactory }
+enum _ConstructorFragmentImplModifiers {
+  isConst,
+  isDeclaring,
+  isFactory,
+  isPrimary,
+}
 
 enum _ExecutableFragmentImplModifiers {
   hasImplicitReturnType,
@@ -10073,6 +10116,8 @@ enum _ExecutableFragmentImplModifiers {
   isStatic,
 }
 
+enum _FieldFormalParameterFragmentModifiers { isDeclaring }
+
 enum _FieldFragmentImplModifiers {
   /// Whether the field was explicitly marked as being covariant.
   isExplicitlyCovariant,

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

@@ -91,6 +91,14 @@ mixin _ConstructorFragmentImplMixin {
     setModifier(Modifier.CONST, value);
   }
 
+  bool get isDeclaring {
+    return hasModifier(Modifier.DECLARING);
+  }
+
+  set isDeclaring(bool value) {
+    setModifier(Modifier.DECLARING, value);
+  }
+
   bool get isFactory {
     return hasModifier(Modifier.FACTORY);
   }
@@ -99,6 +107,14 @@ mixin _ConstructorFragmentImplMixin {
     setModifier(Modifier.FACTORY, value);
   }
 
+  bool get isPrimary {
+    return hasModifier(Modifier.PRIMARY);
+  }
+
+  set isPrimary(bool value) {
+    setModifier(Modifier.PRIMARY, value);
+  }
+
   bool hasModifier(Modifier modifier);
 
   void setModifier(Modifier modifier, bool value);
@@ -172,6 +188,20 @@ mixin _ExecutableFragmentImplMixin {
   void setModifier(Modifier modifier, bool value);
 }
 
+mixin _FieldFormalParameterFragmentImplMixin {
+  bool get isDeclaring {
+    return hasModifier(Modifier.DECLARING);
+  }
+
+  set isDeclaring(bool value) {
+    setModifier(Modifier.DECLARING, value);
+  }
+
+  bool hasModifier(Modifier modifier);
+
+  void setModifier(Modifier modifier, bool value);
+}
+
 mixin _FieldFragmentImplMixin {
   bool get isEnumConstant {
     return hasModifier(Modifier.ENUM_CONSTANT);

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

@@ -49,6 +49,9 @@ class SubstitutedConstructorElementImpl extends SubstitutedExecutableElementImpl
   @override
   bool get isConst => baseElement.isConst;
 
+  @override
+  bool get isDeclaring => baseElement.isDeclaring;
+
   @override
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
@@ -58,6 +61,9 @@ class SubstitutedConstructorElementImpl extends SubstitutedExecutableElementImpl
   @override
   bool get isGenerative => baseElement.isGenerative;
 
+  @override
+  bool get isPrimary => baseElement.isPrimary;
+
   @override
   LibraryElementImpl get library => baseElement.library;
 
@@ -399,6 +405,11 @@ class SubstitutedFieldElementImpl extends SubstitutedVariableElementImpl
   @override
   List<Element> get children => const [];
 
+  @override
+  FieldFormalParameterElementImpl? get declaringFormalParameter {
+    return baseElement.declaringFormalParameter;
+  }
+
   @override
   String? get documentationComment => baseElement.documentationComment;
 
@@ -541,6 +552,9 @@ class SubstitutedFieldFormalParameterElementImpl
 
   @override
   bool get isCovariant => baseElement.isCovariant;
+
+  @override
+  bool get isDeclaring => baseElement.isDeclaring;
 }
 
 /// A parameter element defined in a parameterized type where the values of the

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

@@ -183,7 +183,9 @@ class ConstructorItem extends ExecutableItem<ConstructorElementImpl> {
     return context.withFormalParameters(element.formalParameters, () {
       return super.match(context, element) &&
           flags.isConst == element.isConst &&
+          flags.isDeclaring == element.isDeclaring &&
           flags.isFactory == element.isFactory &&
+          flags.isPrimary == element.isPrimary &&
           constantInitializers.match(context, element.constantInitializers) &&
           redirectedConstructor.match(context, element.redirectedConstructor) &&
           superConstructor.match(context, element.superConstructor);
@@ -1584,7 +1586,7 @@ enum _ClassItemFlag {
   isSealed,
 }
 
-enum _ConstructorItemFlag { isConst, isFactory }
+enum _ConstructorItemFlag { isConst, isDeclaring, isFactory, isPrimary }
 
 enum _ExecutableItemFlag {
   hasEnclosingTypeParameterReference,
@@ -1720,9 +1722,15 @@ extension type _ConstructorItemFlags._(int _bits)
     if (element.isConst) {
       bits |= _maskFor(_ConstructorItemFlag.isConst);
     }
+    if (element.isDeclaring) {
+      bits |= _maskFor(_ConstructorItemFlag.isDeclaring);
+    }
     if (element.isFactory) {
       bits |= _maskFor(_ConstructorItemFlag.isFactory);
     }
+    if (element.isPrimary) {
+      bits |= _maskFor(_ConstructorItemFlag.isPrimary);
+    }
     return _ConstructorItemFlags._(bits);
   }
 
@@ -1734,10 +1742,18 @@ extension type _ConstructorItemFlags._(int _bits)
     return _has(_ConstructorItemFlag.isConst);
   }
 
+  bool get isDeclaring {
+    return _has(_ConstructorItemFlag.isDeclaring);
+  }
+
   bool get isFactory {
     return _has(_ConstructorItemFlag.isFactory);
   }
 
+  bool get isPrimary {
+    return _has(_ConstructorItemFlag.isPrimary);
+  }
+
   void write(BinaryWriter writer) {
     writer.writeUint30(_bits);
   }