DeCo. Build extension type primary constructors like regular ones.

Previously, the AST builder enforced strict constraints on extension
type primary constructors during parsing, often discarding or
transforming invalid parameters (e.g., multiple, optional, or named
parameters) to force a valid representation field structure. This
limited recovery and resulted in inaccurate element models for invalid
code.

This change updates the AST builder to parse and build elements for the
primary constructor's formal parameters exactly as written. The
validation logic ensuring a single, positional representation field has
been moved to `ErrorVerifier`.

To maintain the invariant that an extension type has a representation, a
synthetic "recovery" representation field is now added to the element
model if the parsed parameters do not provide a valid one.

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

Author: scheglov

pkg/analysis_server/test/services/completion/dart/location/extension_type_declaration_test.dart

@@ -72,6 +72,20 @@ class C0 {}
 suggestions
   C0
     kind: class
+  covariant
+    kind: keyword
+  dynamic
+    kind: keyword
+  final
+    kind: keyword
+  super
+    kind: keyword
+  this
+    kind: keyword
+  var
+    kind: keyword
+  void
+    kind: keyword
 ''');
   }
 

pkg/analysis_server/test/src/services/correction/fix/remove_comma_test.dart

@@ -62,9 +62,11 @@ f() {
 
   Future<void> test_representationFieldTrailingComma() async {
     await resolveTestCode('''
+// @dart = 3.10
 extension type A(int i,) {}
 ''');
     await assertHasFix('''
+// @dart = 3.10
 extension type A(int i) {}
 ''');
   }

pkg/analyzer/api.txt

@@ -3652,6 +3652,7 @@ package:analyzer/dart/element/element.dart:
     isExternal (getter: bool)
     isOriginDeclaringFormalParameter (getter: bool)
     isOriginEnumValues (getter: bool)
+    isOriginExtensionTypeRecoveryRepresentation (getter: bool)
     isPromotable (getter: bool)
   FieldFormalParameterElement (class extends Object implements FormalParameterElement):
     new (constructor: FieldFormalParameterElement Function())

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

@@ -1289,6 +1289,10 @@ abstract class FieldElement implements PropertyInducingElement {
   /// and [isOriginDeclaringFormalParameter] are `false`.
   bool get isOriginEnumValues;
 
+  /// Whether the field is an extension type representation field, created only
+  /// for recovery purposes, and does not correspond to a formal parameter.
+  bool get isOriginExtensionTypeRecoveryRepresentation;
+
   /// Whether the field can be type promoted.
   bool get isPromotable;
 }

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

@@ -108,7 +108,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 = 597;
+  static const int DATA_VERSION = 598;
 
   /// 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/ast/ast.dart

@@ -9015,12 +9015,51 @@ final class ExtensionTypeDeclarationImpl
   @Deprecated('Use primaryConstructor instead')
   @override
   RepresentationDeclarationImpl get representation {
-    var formal = primaryConstructor.formalParameters.parameters.first;
-    formal as SimpleFormalParameterImpl;
+    Token syntheticName() {
+      return StringToken(TokenType.IDENTIFIER, '', 0);
+    }
+
+    TypeAnnotationImpl syntheticType() {
+      return NamedTypeImpl(
+        importPrefix: null,
+        name: StringToken(TokenType.IDENTIFIER, 'InvalidType', 0),
+        question: null,
+        typeArguments: null,
+      );
+    }
+
+    var parameters = primaryConstructor.formalParameters.parameters;
+    var formal = parameters.firstOrNull;
+    if (formal is DefaultFormalParameterImpl) {
+      formal = formal.parameter;
+    }
 
     var representation = _representation;
     if (representation == null) {
       var constructorName = primaryConstructor.constructorName;
+
+      if (formal is DefaultFormalParameterImpl) {
+        formal = formal.parameter;
+      }
+
+      TypeAnnotationImpl fieldType;
+      Token fieldName;
+      List<AnnotationImpl> fieldMetadata;
+
+      if (formal is SimpleFormalParameterImpl) {
+        fieldType = formal.type ?? syntheticType();
+        fieldName = formal.name ?? syntheticName();
+        fieldMetadata = formal.metadata;
+      } else if (formal is FieldFormalParameterImpl) {
+        fieldType = formal.type ?? syntheticType();
+        fieldName = formal.name;
+        fieldMetadata = formal.metadata;
+      } else {
+        fieldType = syntheticType();
+        fieldName = formal?.name ?? syntheticName();
+        fieldMetadata = formal?.metadata ?? const [];
+      }
+
       representation = RepresentationDeclarationImpl(
         constructorName: constructorName != null
             ? RepresentationConstructorNameImpl(
@@ -9029,19 +9068,19 @@ final class ExtensionTypeDeclarationImpl
               )
             : null,
         leftParenthesis: primaryConstructor.formalParameters.leftParenthesis,
-        fieldMetadata: formal.metadata,
-        fieldType: formal.type!,
-        fieldName: formal.name!,
+        fieldMetadata: fieldMetadata,
+        fieldType: fieldType,
+        fieldName: fieldName,
         rightParenthesis: primaryConstructor.formalParameters.rightParenthesis,
       );
       _representation = _becomeParentOf(representation);
     }
-    representation.fieldFragment =
-        (formal.declaredFragment as FieldFormalParameterFragmentImpl?)
-            ?.element
-            .field
-            ?.firstFragment;
-    representation.constructorFragment = declaredFragment?.constructors.first;
+    representation.constructorFragment = primaryConstructor.declaredFragment;
+    if (declaredFragment case var declaredFragment?) {
+      representation.fieldFragment = declaredFragment.fields
+          .where((f) => !f.isStatic)
+          .firstOrNull;
+    }
     return representation;
   }
 

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

@@ -2874,6 +2874,12 @@ class FieldElementImpl extends PropertyInducingElementImpl
     return _firstFragment.isOriginEnumValues;
   }
 
+  @override
+  @trackedIncludedInId
+  bool get isOriginExtensionTypeRecoveryRepresentation {
+    return _firstFragment.isOriginExtensionTypeRecoveryRepresentation;
+  }
+
   @override
   @trackedIncludedInId
   bool get isPromotable => _firstFragment.isPromotable;
@@ -8186,6 +8192,12 @@ enum Modifier {
   /// Whether the field is the `values` field of an enum.
   ORIGIN_ENUM_VALUES,
 
+  /// Indicates that the element is an extension type representation field,
+  /// created only for recovery purposes, and does not correspond to a formal
+  /// parameter.
+  ORIGIN_EXTENSION_TYPE_RECOVERY_REPRESENTATION,
+
+
   /// Whether the property inducing element is from a getter or setter.
   ORIGIN_GETTER_SETTER,
 
@@ -10612,6 +10624,7 @@ enum _FieldFragmentImplModifiers {
   isEnumConstant,
   isOriginDeclaringFormalParameter,
   isOriginEnumValues,
+  isOriginExtensionTypeRecoveryRepresentation,
   isPromotable,
 }
 

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

@@ -260,6 +260,14 @@ mixin _FieldFragmentImplMixin {
     setModifier(Modifier.ORIGIN_ENUM_VALUES, value);
   }
 
+  bool get isOriginExtensionTypeRecoveryRepresentation {
+    return hasModifier(Modifier.ORIGIN_EXTENSION_TYPE_RECOVERY_REPRESENTATION);
+  }
+
+  set isOriginExtensionTypeRecoveryRepresentation(bool value) {
+    setModifier(Modifier.ORIGIN_EXTENSION_TYPE_RECOVERY_REPRESENTATION, value);
+  }
+
   bool get isPromotable {
     return hasModifier(Modifier.PROMOTABLE);
   }

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

@@ -471,6 +471,10 @@ class SubstitutedFieldElementImpl extends SubstitutedVariableElementImpl
   @override
   bool get isOriginEnumValues => baseElement.isOriginEnumValues;
 
+  @override
+  bool get isOriginExtensionTypeRecoveryRepresentation =>
+      baseElement.isOriginExtensionTypeRecoveryRepresentation;
+
   @override
   bool get isOriginGetterSetter => baseElement.isOriginGetterSetter;