[DAS] Add fix for swapping division operators when undefined

[email protected]

Fixes #55512

Change-Id: Ifb8822f98483e68afa21b3a5a49045149604fa55
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/388074
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/use_different_division_operator.dart

@@ -0,0 +1,145 @@
+// Copyright (c) 2024, the Dart project authors. Please see the AUTHORS file
+// 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:analysis_server/src/services/correction/fix.dart';
+import 'package:analysis_server/src/utilities/extensions/element.dart';
+import 'package:analysis_server_plugin/edit/dart/correction_producer.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/element/inheritance_manager3.dart';
+import 'package:analyzer/src/dart/resolver/applicable_extensions.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+
+class UseDifferentDivisionOperator extends MultiCorrectionProducer {
+  UseDifferentDivisionOperator({required super.context});
+
+  @override
+  Future<List<ResolvedCorrectionProducer>> get producers async {
+    var exp = node;
+    if (exp case BinaryExpression _) {
+      return switch (exp.operator.type) {
+        TokenType.SLASH => [
+            _UseDifferentDivisionOperator(
+                context: context,
+                fixKind: DartFixKind.USE_EFFECTIVE_INTEGER_DIVISION)
+          ],
+        TokenType.TILDE_SLASH => [
+            _UseDifferentDivisionOperator(
+                context: context, fixKind: DartFixKind.USE_DIVISION)
+          ],
+        _ => const []
+      };
+    } else if (exp case AssignmentExpression _) {
+      return switch (exp.operator.type) {
+        TokenType.SLASH_EQ => [
+            _UseDifferentDivisionOperator(
+                context: context,
+                fixKind: DartFixKind.USE_EFFECTIVE_INTEGER_DIVISION)
+          ],
+        TokenType.TILDE_SLASH_EQ => [
+            _UseDifferentDivisionOperator(
+                context: context, fixKind: DartFixKind.USE_DIVISION)
+          ],
+        _ => const []
+      };
+    }
+    return const [];
+  }
+}
+
+enum _DivisionOperator {
+  division,
+  effectiveIntegerDivision,
+}
+
+class _UseDifferentDivisionOperator extends ResolvedCorrectionProducer {
+  @override
+  final FixKind fixKind;
+  final CorrectionProducerContext _context;
+
+  _UseDifferentDivisionOperator({required super.context, required this.fixKind})
+      : _context = context;
+
+  @override
+  CorrectionApplicability get applicability =>
+      CorrectionApplicability.singleLocation;
+
+  @override
+  Future<void> compute(ChangeBuilder builder) async {
+    var exp = node;
+    DartType? leftType;
+    Token operator;
+    if (exp case BinaryExpression _) {
+      leftType = exp.leftOperand.staticType;
+      operator = exp.operator;
+    } else if (exp case AssignmentExpression _) {
+      leftType = exp.writeType;
+      operator = exp.operator;
+    } else {
+      return;
+    }
+    if (leftType == null) {
+      return;
+    }
+    var operators = leftType.divisionOperators;
+    var otherOperator = switch (operator.type) {
+      TokenType.SLASH => TokenType.TILDE_SLASH,
+      TokenType.TILDE_SLASH => TokenType.SLASH,
+      TokenType.SLASH_EQ => TokenType.TILDE_SLASH_EQ,
+      TokenType.TILDE_SLASH_EQ => TokenType.SLASH_EQ,
+      _ => null,
+    };
+    if (otherOperator == null) {
+      return;
+    }
+    // All extensions available in the current scope for the left operand that
+    // define the other division operator.
+    var name = Name(
+        _context.dartFixContext!.resolvedResult.libraryElement.source.uri,
+        otherOperator.lexeme);
+    var hasNoExtensionWithOtherDivisionOperator = await _context.dartFixContext!
+        .librariesWithExtensions(otherOperator.lexeme)
+        .where((library) {
+      return library.exportedExtensions
+          .havingMemberWithBaseName(name)
+          .applicableTo(targetLibrary: libraryElement, targetType: leftType!)
+          .isNotEmpty;
+    }).isEmpty;
+    if (hasNoExtensionWithOtherDivisionOperator && operators.isEmpty) {
+      return;
+    }
+    if (operators.length > 1) {
+      return;
+    }
+    await builder.addDartFileEdit(file, (builder) {
+      builder.addSimpleReplacement(range.token(operator), otherOperator.lexeme);
+    });
+  }
+}
+
+extension on DartType {
+  Set<_DivisionOperator> get divisionOperators {
+    // See operators defined for this type element.
+    if (element case InterfaceElement interfaceElement) {
+      return {
+        for (var method in interfaceElement.methods)
+          // No need to test for eq operators, as they are not explicitly defined.
+          if (method.name == TokenType.SLASH.lexeme)
+            _DivisionOperator.division
+          else if (method.name == TokenType.TILDE_SLASH.lexeme)
+            _DivisionOperator.effectiveIntegerDivision,
+        ...interfaceElement.allSupertypes
+            .expand((type) => type.divisionOperators)
+      };
+    } else if (element case TypeParameterElement typeParameterElement) {
+      return typeParameterElement.bound?.divisionOperators ?? const {};
+    }
+
+    return const {};
+  }
+}

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

@@ -1969,6 +1969,11 @@ abstract final class DartFixKind {
     DartFixKindPriority.standard,
     'Update the SDK constraints',
   );
+  static const USE_DIVISION = FixKind(
+    'dart.fix.use.division',
+    DartFixKindPriority.standard,
+    'Use / instead of undefined ~/',
+  );
   static const USE_EFFECTIVE_INTEGER_DIVISION = FixKind(
     'dart.fix.use.effectiveIntegerDivision',
     DartFixKindPriority.standard,

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

@@ -233,6 +233,7 @@ import 'package:analysis_server/src/services/correction/dart/split_multiple_decl
 import 'package:analysis_server/src/services/correction/dart/surround_with_parentheses.dart';
 import 'package:analysis_server/src/services/correction/dart/update_sdk_constraints.dart';
 import 'package:analysis_server/src/services/correction/dart/use_curly_braces.dart';
+import 'package:analysis_server/src/services/correction/dart/use_different_division_operator.dart';
 import 'package:analysis_server/src/services/correction/dart/use_effective_integer_division.dart';
 import 'package:analysis_server/src/services/correction/dart/use_eq_eq_null.dart';
 import 'package:analysis_server/src/services/correction/dart/use_is_not_empty.dart';
@@ -881,6 +882,7 @@ final _builtInNonLintMultiProducers = {
   ],
   CompileTimeErrorCode.UNDEFINED_OPERATOR: [
     ImportLibrary.forExtensionMember,
+    UseDifferentDivisionOperator.new,
   ],
   CompileTimeErrorCode.UNDEFINED_PREFIXED_NAME: [
     DataDriven.new,

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

@@ -291,6 +291,8 @@ import 'split_multiple_declarations_test.dart'
 import 'surround_with_parentheses_test.dart' as surround_with_parentheses;
 import 'update_sdk_constraints_test.dart' as update_sdk_constraints;
 import 'use_curly_braces_test.dart' as use_curly_braces;
+import 'use_different_division_operator_test.dart'
+    as use_different_division_operator;
 import 'use_effective_integer_division_test.dart'
     as use_effective_integer_division;
 import 'use_eq_eq_null_test.dart' as use_eq_eq_null;
@@ -549,6 +551,7 @@ void main() {
     surround_with_parentheses.main();
     update_sdk_constraints.main();
     use_curly_braces.main();
+    use_different_division_operator.main();
     use_effective_integer_division.main();
     use_eq_eq_null.main();
     use_is_not_empty.main();