[DAS] Adds 'Create extension method/operator' fixes

[email protected]

Fixes: #60203
Change-Id: I2527c130dd68cf678ac4529eda42397ef80ca53c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/412060
Commit-Queue: Phil Quitslund <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Auto-Submit: Felipe Morschel <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: FMorschel

pkg/analysis_server/lib/src/services/correction/dart/create_extension_member.dart

@@ -5,14 +5,18 @@
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server_plugin/edit/dart/correction_producer.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element2.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/resolver/applicable_extensions.dart';
 import 'package:analyzer/src/utilities/extensions/ast.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_dart.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:collection/collection.dart';
 
 class CreateExtensionGetter extends _CreateExtensionMember {
   String _getterName = '';
@@ -53,6 +57,8 @@ class CreateExtensionGetter extends _CreateExtensionMember {
       return;
     }
 
+    // TODO(FMorschel): We should take into account if the target type contains
+    // a setter for the same name and stop the fix from being applied.
     // We need the type for the extension.
     var targetType = target.staticType;
     if (targetType == null ||
@@ -67,7 +73,7 @@ class CreateExtensionGetter extends _CreateExtensionMember {
 
     void writeGetter(DartEditBuilder builder) {
       if (fieldType != null) {
-        builder.writeType(fieldType);
+        builder.writeType(fieldType, methodBeingCopied: methodBeingCopied);
         builder.write(' ');
       }
       builder.write('get $_getterName => ');
@@ -89,7 +95,13 @@ class CreateExtensionGetter extends _CreateExtensionMember {
       return;
     }
 
-    await _addNewExtension(builder, targetType, nameNode, writeGetter);
+    await _addNewExtension(
+      builder,
+      targetType,
+      nameNode,
+      writeGetter,
+      involvedTypes: [fieldType],
+    );
   }
 }
 
@@ -137,16 +149,32 @@ class CreateExtensionMethod extends _CreateExtensionMember {
     var returnType = inferUndefinedExpressionType(invocation);
 
     void writeMethod(DartEditBuilder builder) {
-      if (builder.writeType(returnType, groupName: 'RETURN_TYPE')) {
+      if (builder.writeType(
+        returnType,
+        groupName: 'RETURN_TYPE',
+        methodBeingCopied: methodBeingCopied,
+      )) {
         builder.write(' ');
       }
 
       builder.addLinkedEdit('NAME', (builder) {
         builder.write(_methodName);
       });
 
+      builder.writeTypeParameters(
+        [
+              returnType,
+              ...invocation.argumentList.arguments.map((e) => e.staticType),
+            ].typeParameters
+            .whereNot([targetType].typeParameters.contains)
+            .toList(),
+      );
+
       builder.write('(');
-      builder.writeParametersMatchingArguments(invocation.argumentList);
+      builder.writeParametersMatchingArguments(
+        invocation.argumentList,
+        methodBeingCopied: methodBeingCopied,
+      );
       builder.write(') {}');
     }
 
@@ -166,6 +194,136 @@ class CreateExtensionMethod extends _CreateExtensionMember {
   }
 }
 
+class CreateExtensionOperator extends _CreateExtensionMember {
+  String _operator = '';
+
+  CreateExtensionOperator({required super.context});
+
+  @override
+  List<String>? get fixArguments => [_operator];
+
+  @override
+  FixKind get fixKind => DartFixKind.CREATE_EXTENSION_OPERATOR;
+
+  @override
+  Future<void> compute(ChangeBuilder builder) async {
+    bool indexSetter = false;
+    bool innerParameter = true;
+    var node = this.node;
+    if (node is! Expression) {
+      return;
+    }
+
+    Expression? target;
+    DartType? parameterType;
+    DartType? assigningType;
+
+    switch (node) {
+      case IndexExpression(:var parent):
+        if (node.target?.staticType?.element3.declaresIndex ?? true) {
+          return;
+        }
+        target = node.target;
+        _operator = TokenType.INDEX.lexeme;
+        parameterType = node.index.staticType;
+        if (parameterType == null) {
+          return;
+        }
+        if (parent case AssignmentExpression(
+          :var leftHandSide,
+          :var rightHandSide,
+        ) when leftHandSide == node) {
+          assigningType = rightHandSide.staticType;
+          indexSetter = true;
+          _operator = TokenType.INDEX_EQ.lexeme;
+        }
+      case BinaryExpression():
+        target = node.leftOperand;
+        _operator = node.operator.lexeme;
+        parameterType = node.rightOperand.staticType;
+        if (parameterType == null) {
+          return;
+        }
+      case PrefixExpression():
+        target = node.operand;
+        _operator = node.operator.lexeme;
+        innerParameter = false;
+    }
+
+    if (target == null) {
+      return;
+    }
+
+    // We need the type for the extension.
+    var targetType = target.staticType;
+    if (targetType == null ||
+        targetType is DynamicType ||
+        targetType is InvalidType) {
+      return;
+    }
+
+    DartType returnType;
+    // If this is an index setter, the return type must be void.
+    if (indexSetter) {
+      returnType = VoidTypeImpl.instance;
+    } else {
+      // Try to find the return type.
+      returnType = inferUndefinedExpressionType(node) ?? VoidTypeImpl.instance;
+    }
+
+    void writeMethod(DartEditBuilder builder) {
+      if (builder.writeType(
+        returnType,
+        groupName: 'RETURN_TYPE',
+        methodBeingCopied: methodBeingCopied,
+      )) {
+        builder.write(' ');
+      }
+
+      builder.write('operator ');
+      builder.write(_operator);
+
+      builder.write('(');
+      if (innerParameter) {
+        builder.writeFormalParameter(
+          indexSetter ? 'index' : 'other',
+          type: parameterType,
+          methodBeingCopied: methodBeingCopied,
+        );
+      }
+      if (indexSetter) {
+        builder.write(', ');
+        builder.writeFormalParameter(
+          'newValue',
+          type: assigningType,
+          methodBeingCopied: methodBeingCopied,
+        );
+      }
+      builder.write(') {}');
+    }
+
+    var updatedExisting = await _updateExistingExtension(builder, targetType, (
+      extension,
+      builder,
+    ) {
+      builder.insertMethod(extension, (builder) {
+        writeMethod(builder);
+      });
+    });
+    if (updatedExisting) {
+      return;
+    }
+
+    await _addNewExtension(
+      builder,
+      targetType,
+      target,
+      writeMethod,
+      involvedTypes: [parameterType, returnType],
+    );
+  }
+}
+
 class CreateExtensionSetter extends _CreateExtensionMember {
   String _setterName = '';
 
@@ -205,6 +363,8 @@ class CreateExtensionSetter extends _CreateExtensionMember {
       return;
     }
 
+    // TODO(FMorschel): We should take into account if the target type contains
+    // a setter for the same name and stop the fix from being applied.
     // We need the type for the extension.
     var targetType = target.staticType;
     if (targetType == null ||
@@ -223,6 +383,7 @@ class CreateExtensionSetter extends _CreateExtensionMember {
         nameGroupName: 'NAME',
         parameterType: fieldType,
         parameterTypeGroupName: 'TYPE',
+        methodBeingCopied: methodBeingCopied,
       );
     }
 
@@ -238,7 +399,13 @@ class CreateExtensionSetter extends _CreateExtensionMember {
       return;
     }
 
-    await _addNewExtension(builder, targetType, nameNode, writeSetter);
+    await _addNewExtension(
+      builder,
+      targetType,
+      nameNode,
+      writeSetter,
+      involvedTypes: [fieldType],
+    );
   }
 }
 
@@ -251,24 +418,50 @@ abstract class _CreateExtensionMember extends ResolvedCorrectionProducer {
     return CorrectionApplicability.singleLocation;
   }
 
+  ExecutableElement2? get methodBeingCopied =>
+      _enclosingFunction?.declaredFragment?.element;
+
+  FunctionDeclaration? get _enclosingFunction => node.thisOrAncestorOfType();
+
+  /// Creates a change for creating a new extension on the given [targetType].
+  ///
+  /// The new extension should be added after the [nameNode].
+  ///
+  /// The [write] function is used to write the body of the new extension.
+  /// Meaning a method, getter, setter or operator.
+  ///
+  /// The [involvedTypes] are the types that are used in the new extension and
+  /// it's member. This is used to determine the type parameters of the new
+  /// extension.
   Future<void> _addNewExtension(
     ChangeBuilder builder,
     DartType targetType,
-    SimpleIdentifier nameNode,
-    void Function(DartEditBuilder builder) write,
-  ) async {
+    AstNode nameNode,
+    void Function(DartEditBuilder builder) write, {
+    List<DartType?> involvedTypes = const [],
+  }) async {
     // The new extension should be added after it.
     var enclosingUnitChild = nameNode.enclosingUnitChild;
     if (enclosingUnitChild == null) {
       return;
     }
 
+    var extensionTypeParameters = [targetType, ...involvedTypes].typeParameters;
+
     await builder.addDartFileEdit(file, (builder) {
       builder.addInsertion(enclosingUnitChild.end, (builder) {
         builder.writeln();
         builder.writeln();
-        builder.write('extension on ');
-        builder.writeType(targetType);
+        builder.write('extension ');
+        if (extensionTypeParameters.isNotEmpty) {
+          builder.writeTypeParameters(
+            extensionTypeParameters,
+            methodBeingCopied: methodBeingCopied,
+          );
+          builder.write(' ');
+        }
+        builder.write('on ');
+        builder.writeType(targetType, methodBeingCopied: methodBeingCopied);
         builder.writeln(' {');
         builder.write('  ');
         write(builder);
@@ -312,3 +505,50 @@ abstract class _CreateExtensionMember extends ResolvedCorrectionProducer {
     return true;
   }
 }
+
+extension on List<DartType?> {
+  /// Returns a list of type parameters that are used in the types.
+  ///
+  /// Iterates over every type in the list:
+  /// - If it is itself a [TypeParameterType], it is added to the list.
+  /// - If it is itself a [TypeParameterType] and it has a
+  /// [TypeParameterType.bound], we get the type parameters with this getter.
+  /// - If it is an [InterfaceType], we get the [InterfaceType.typeArguments]
+  /// it uses and get any type parameters they use by using this same getter.
+  ///
+  /// These types are added internally to a set so that we don't add duplicates.
+  List<TypeParameterElement2> get typeParameters =>
+      {
+        for (var type in whereType<TypeParameterType>()) ...[
+          type.element3,
+          ...[type.bound].typeParameters,
+        ],
+        for (var type in whereType<InterfaceType>())
+          ...type.typeArguments.typeParameters,
+      }.toList();
+}
+
+extension on Element2? {
+  bool get declaresIndex {
+    var element = this;
+    if (element is! InterfaceElement2) {
+      return false;
+    }
+    var inheritanceManager3 = InheritanceManager3();
+    var interface = inheritanceManager3.getInterface2(element);
+    var bracesGetter =
+        interface.map2[Name.forLibrary(
+          element.library2,
+          TokenType.INDEX.lexeme,
+        )];
+    if (bracesGetter != null) {
+      return true;
+    }
+    var bracesSetter =
+        interface.map2[Name.forLibrary(
+          element.library2,
+          TokenType.INDEX_EQ.lexeme,
+        )];
+    return bracesSetter != null;
+  }
+}

pkg/analysis_server/lib/src/services/correction/fix.dart

@@ -758,6 +758,11 @@ abstract final class DartFixKind {
     DartFixKindPriority.standard - 20,
     "Create extension method '{0}'",
   );
+  static const CREATE_EXTENSION_OPERATOR = FixKind(
+    'dart.fix.create.extension.operator',
+    DartFixKindPriority.standard - 20,
+    "Create extension operator '{0}'",
+  );
   static const CREATE_EXTENSION_SETTER = FixKind(
     'dart.fix.create.extension.setter',
     DartFixKindPriority.standard - 20,