[wildcards] fix super formal positional param handling

Fixes `co19/src/LanguageFeatures/Wildcards/super_parameters_A04_t02.dart`

```
class A {
  final int x, y;
  A(this.x, [this.y = 0]);
}

class C extends A {
  final int _;
  String log = "";
  C(this._, super._, [super._]) {
    log = "_=$_, x=$x, y=$y";
  }
  C.n(this._, super._, [super._ = 1]) {
    log = "_=$_, x=$x, y=$y";
  }
}

main() {
  Expect.equals("_=1, x=2, y=3", C(1, 2, 3).log);
  Expect.equals("_=1, x=2, y=0", C(1, 2).log);
  Expect.equals("_=1, x=2, y=1", C.n(1, 2).log);
}
```

See: #55680



Change-Id: Ia87ae6a73816a08ca83d77c7f077e9ed7c153ebb
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/380883
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Phil Quitslund <[email protected]>

Author: pq

pkg/analyzer/lib/src/error/duplicate_definition_verifier.dart

@@ -4,6 +4,7 @@
 
 import 'dart:collection';
 
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/error/error.dart';
@@ -71,14 +72,10 @@ class DuplicateDefinitionVerifier {
         // function type.
 
         // Skip wildcard `super._`.
-        if (parameter is SuperFormalParameter &&
-            identifier.lexeme == '_' &&
-            _currentLibrary.hasWildcardVariablesFeatureEnabled) {
-          continue;
+        if (!_isSuperFormalWildcard(parameter, identifier)) {
+          _checkDuplicateIdentifier(definedNames, identifier,
+              element: parameter.declaredElement!);
         }
-
-        _checkDuplicateIdentifier(definedNames, identifier,
-            element: parameter.declaredElement!);
       }
     }
   }
@@ -266,6 +263,15 @@ class DuplicateDefinitionVerifier {
     }
   }
 
+  bool _isSuperFormalWildcard(FormalParameter parameter, Token identifier) {
+    if (parameter is DefaultFormalParameter) {
+      parameter = parameter.parameter;
+    }
+    return parameter is SuperFormalParameter &&
+        identifier.lexeme == '_' &&
+        _currentLibrary.featureSet.isEnabled(Feature.wildcard_variables);
+  }
+
   bool _isWildCardFunction(FunctionDeclarationStatement statement) =>
       statement.functionDeclaration.name.lexeme == '_' &&
       _currentLibrary.hasWildcardVariablesFeatureEnabled;

pkg/analyzer/lib/src/generated/error_verifier.dart

@@ -6230,15 +6230,17 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
                       .MISSING_DEFAULT_VALUE_FOR_PARAMETER_WITH_ANNOTATION,
                 );
               } else {
-                errorReporter.atEntity(
-                  errorTarget,
-                  parameterElement.isPositional
-                      ? CompileTimeErrorCode
-                          .MISSING_DEFAULT_VALUE_FOR_PARAMETER_POSITIONAL
-                      : CompileTimeErrorCode
-                          .MISSING_DEFAULT_VALUE_FOR_PARAMETER,
-                  arguments: [parameterName?.lexeme ?? '?'],
-                );
+                if (!_isWildcardSuperFormalPositionalParameter(parameter)) {
+                  errorReporter.atEntity(
+                    errorTarget,
+                    parameterElement.isPositional
+                        ? CompileTimeErrorCode
+                            .MISSING_DEFAULT_VALUE_FOR_PARAMETER_POSITIONAL
+                        : CompileTimeErrorCode
+                            .MISSING_DEFAULT_VALUE_FOR_PARAMETER,
+                    arguments: [parameterName?.lexeme ?? '?'],
+                  );
+                }
               }
             }
           }
@@ -6381,6 +6383,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     return false;
   }
 
+  bool _isWildcardSuperFormalPositionalParameter(
+          DefaultFormalParameter parameter) =>
+      parameter.parameter is SuperFormalParameter &&
+      parameter.isPositional &&
+      parameter.name?.lexeme == '_' &&
+      _currentLibrary.featureSet.isEnabled(Feature.wildcard_variables);
+
   /// Checks whether a `final`, `base` or `interface` modifier can be ignored.
   ///
   /// Checks whether a subclass in the current library

pkg/analyzer/test/src/diagnostics/duplicate_definition_test.dart

@@ -2715,6 +2715,23 @@ class B extends A {
     ]);
   }
 
+  test_parameters_constructor_this_super_wildcard() async {
+    await assertErrorsInCode(r'''
+class A {
+  final int x, y;
+  A(this.x, [this.y = 0]);
+}
+
+class C extends A {
+  final int _;
+
+  C(this._, super._, [super._]);
+}
+''', [
+      error(WarningCode.UNUSED_FIELD, 90, 1),
+    ]);
+  }
+
   test_parameters_functionTypeAlias() async {
     await assertErrorsInCode(r'''
 typedef void F(int a, double a);

pkg/analyzer/test/src/diagnostics/missing_default_value_for_parameter_test.dart

@@ -720,6 +720,20 @@ class A<T extends Object?> {
           43, 1),
     ]);
   }
+
+  test_super_forward_wildcards() async {
+    await assertNoErrorsInCode('''
+class A {
+  final int x, y;
+  A(this.x, [this.y = 0]);
+}
+
+class C extends A {
+  final int c;
+  C(this.c, super._, [super._]);
+}
+''');
+  }
 }
 
 @reflectiveTest