Version 3.12.0-68.0.dev

Merge 78e254f into dev

Author: Dart CI

pkg/analysis_server/lib/src/services/refactoring/agnostic/change_method_signature.dart

@@ -12,6 +12,7 @@ import 'package:analysis_server/src/services/search/hierarchy.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analysis_server_plugin/edit/correction_utils.dart';
 import 'package:analysis_server_plugin/src/utilities/selection.dart';
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/analysis/results.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ -63,11 +64,48 @@ sealed class Available extends Availability {
 
   Available({required this.refactoringContext});
 
-  bool get hasPositionalParameters;
+  /// Whether there are any positional parameters and, if so, if all of them
+  /// can be converted to named parameters.
+  ///
+  /// Even if a parameter is positional, it may not be convertible if it has a
+  /// private name and isn't in a context where it could become a private named
+  /// parameter. If that case, this returns `false`.
+  bool get hasPositionalParametersToConvertToNamed {
+    var supportsPrivateNamedParameters = refactoringContext
+        .resolvedLibraryResult
+        .element
+        .featureSet
+        .isEnabled(Feature.private_named_parameters);
+
+    var hasPositional = false;
+    for (var parameter in _formalParameters) {
+      if (parameter.isNamed) continue;
+
+      hasPositional = true;
+
+      // If the parameter has a private name, we must be able to convert it to
+      // a private named parameter.
+      if (Identifier.isPrivateName(parameter.name!)) {
+        if (!supportsPrivateNamedParameters) {
+          return false;
+        }
+
+        // TODO(rnystrom): Check for primary constructor declaring parameter
+        // here once those are implemented.
+        if (parameter is! FieldFormalParameterElement) {
+          return false;
+        }
+      }
+    }
+
+    return hasPositional;
+  }
 
   bool get hasSelectedFormalParametersToConvertToNamed => false;
 
   bool get hasSelectedFormalParametersToMoveLeft => false;
+
+  List<FormalParameterElement> get _formalParameters;
 }
 
 /// The supertype return types from [computeSourceChange].
@@ -408,11 +446,6 @@ final class _AvailableWithDeclaration extends Available {
     required this.declaration,
   });
 
-  @override
-  bool get hasPositionalParameters {
-    return declaration.element.formalParameters.any((e) => e.isPositional);
-  }
-
   @override
   bool get hasSelectedFormalParametersToConvertToNamed {
     var selected = declaration.selected;
@@ -472,6 +505,10 @@ final class _AvailableWithDeclaration extends Available {
 
     return true;
   }
+
+  @override
+  List<FormalParameterElement> get _formalParameters =>
+      declaration.element.formalParameters;
 }
 
 final class _AvailableWithExecutableElement extends Available {
@@ -483,9 +520,8 @@ final class _AvailableWithExecutableElement extends Available {
   });
 
   @override
-  bool get hasPositionalParameters {
-    return element.formalParameters.any((e) => e.isPositional);
-  }
+  List<FormalParameterElement> get _formalParameters =>
+      element.formalParameters;
 }
 
 /// The target method declaration.

pkg/analysis_server/lib/src/services/refactoring/convert_all_formal_parameters_to_named.dart

@@ -87,6 +87,7 @@ class ConvertAllFormalParametersToNamed extends RefactoringProducer {
     if (availability is! Available) {
       return false;
     }
-    return availability.hasPositionalParameters;
+
+    return availability.hasPositionalParametersToConvertToNamed;
   }
 }

pkg/analysis_server/lib/src/services/refactoring/framework/write_invocation_arguments.dart

@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:_fe_analyzer_shared/src/scanner/token_impl.dart';
 import 'package:analysis_server/src/services/refactoring/framework/formal_parameter.dart';
 import 'package:analysis_server_plugin/edit/correction_utils.dart';
 import 'package:analyzer/dart/analysis/results.dart';
@@ -49,8 +50,11 @@ Future<WriteArgumentsStatus> writeArguments({
               return WriteArgumentsStatusFailure();
             }
             if (update is FormalParameterUpdateExistingNamed) {
+              // If the parameter's name is private, then the argument uses the
+              // corresponding public name.
+              var name = correspondingPublicName(update.name) ?? update.name;
               newArguments.add(
-                _ArgumentAddName(name: update.name, argument: argument),
+                _ArgumentAddName(name: name, argument: argument),
               );
             } else {
               newArguments.add(_ArgumentAsIs(argument: argument));

pkg/analysis_server/test/src/services/refactoring/convert_all_formal_parameters_to_named_test.dart

@@ -155,6 +155,82 @@ void f() {
     await _assertNoRefactoring();
   }
 
+  Future<void> test_private_constructor() async {
+    addTestSource(r'''
+class C {
+  int? _a;
+  int? _b;
+
+  ^C(this._a, {this._b});
+}
+
+void f() {
+  C(0, b: 1);
+}
+''');
+
+    await verifyRefactoring(r'''
+>>>>>>>>>> lib/main.dart
+class C {
+  int? _a;
+  int? _b;
+
+  C({required this._a, this._b});
+}
+
+void f() {
+  C(a: 0, b: 1);
+}
+''');
+  }
+
+  Future<void> test_private_constructor_unsupported() async {
+    addTestSource(r'''
+// @dart=3.10
+class C {
+  int? _a;
+  int? _b;
+
+  ^C(this._a, {int? b}) : _b = b;
+}
+
+void f() {
+  C(0, b: 1);
+}
+''');
+
+    await _assertNoRefactoring();
+  }
+
+  Future<void> test_private_function() async {
+    // Functions can't have private named parameters, so the refactoring can't
+    // be applied.
+    addTestSource(r'''
+^test(int _a, int _b) {}
+
+void f() {
+  test(0, 1);
+}
+''');
+
+    await _assertNoRefactoring();
+  }
+
+  Future<void> test_private_function_unsupported() async {
+    // Functions can't have private named parameters, so the refactoring can't
+    // be applied.
+    addTestSource(r'''
+// @dart=3.10
+^test(int _a, int _b) {}
+
+void f() {
+  test(0, 1);
+}
+''');
+
+    await _assertNoRefactoring();
+  }
+
   Future<void> test_target_methodInvocation_name() async {
     addTestSource(r'''
 void test(int a) {}

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

@@ -37,6 +37,19 @@ class B extends A {}
     );
   }
 
+  test_field_declaredInPrimaryConstructor() async {
+    await assertErrorsInCode(
+      '''
+import 'package:meta/meta.dart';
+
+class A(@mustBeOverridden var int f);
+
+class B(super.f) extends A {}
+''',
+      [error(diag.missingOverrideOfMustBeOverriddenOne, 79, 1)],
+    );
+  }
+
   test_field_method() async {
     await assertErrorsInCode(
       '''
@@ -78,6 +91,19 @@ class B extends A {
 ''');
   }
 
+  test_field_overriddenWithField_inPrimaryConstructor() async {
+    await assertNoErrorsInCode('''
+import 'package:meta/meta.dart';
+
+class A {
+  @mustBeOverridden
+  int f = 0;
+}
+
+class B(var int f) extends A;
+''');
+  }
+
   test_field_overriddenWithGetterSetterPair() async {
     await assertNoErrorsInCode('''
 import 'package:meta/meta.dart';
@@ -159,6 +185,19 @@ class B extends A {
 ''');
   }
 
+  test_getter_overriddenWithField_inPrimaryConstructor() async {
+    await assertNoErrorsInCode('''
+import 'package:meta/meta.dart';
+
+class A {
+  @mustBeOverridden
+  int get f => 0;
+}
+
+class B(var int f) extends A;
+''');
+  }
+
   test_getter_overriddenWithGetter() async {
     await assertNoErrorsInCode('''
 import 'package:meta/meta.dart';

tools/VERSION

@@ -27,5 +27,5 @@ CHANNEL dev
 MAJOR 3
 MINOR 12
 PATCH 0
-PRERELEASE 67
+PRERELEASE 68
 PRERELEASE_PATCH 0