Fix errors when type is future of required type

[email protected]

Fixes #50461

Change-Id: I03664df4f3fe3464344079f37a2ea00fa881fffc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/388040
Reviewed-by: Brian Wilkerson <[email protected]>
Auto-Submit: Felipe Morschel <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>
Commit-Queue: Samuel Rawlins <[email protected]>

Author: FMorschel

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

@@ -4,15 +4,21 @@
 
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analysis_server_plugin/edit/dart/correction_producer.dart';
-import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 
 class AddAwait extends ResolvedCorrectionProducer {
   /// The kind of correction to be made.
   final _CorrectionKind _correctionKind;
 
+  AddAwait.argumentType({required super.context})
+      : _correctionKind = _CorrectionKind.argumentType;
+
+  AddAwait.assignment({required super.context})
+      : _correctionKind = _CorrectionKind.invalidAssignment;
+
   AddAwait.nonBool({required super.context})
       : _correctionKind = _CorrectionKind.nonBool;
 
@@ -33,13 +39,23 @@ class AddAwait extends ResolvedCorrectionProducer {
 
   @override
   Future<void> compute(ChangeBuilder builder) async {
-    if (_correctionKind == _CorrectionKind.unawaited) {
-      if (node.parent is CascadeExpression) {
-        return;
-      }
-      await _addAwait(builder);
-    } else if (_correctionKind == _CorrectionKind.nonBool) {
-      await _computeNonBool(builder);
+    switch (_correctionKind) {
+      case _CorrectionKind.argumentType:
+        if (_isValidType(expectedTypeFromExp: (exp) => exp.argumentType)) {
+          await _addAwait(builder);
+        }
+      case _CorrectionKind.invalidAssignment:
+        if (_isValidType(expectedTypeFromExp: (exp) => exp.assignmentType)) {
+          await _addAwait(builder);
+        }
+      case _CorrectionKind.nonBool:
+        if (_isValidType(isValid: (type) => type.isDartCoreBool)) {
+          await _addAwait(builder);
+        }
+      case _CorrectionKind.unawaited:
+        if (node.parent is! CascadeExpression) {
+          await _addAwait(builder);
+        }
     }
   }
 
@@ -49,21 +65,71 @@ class AddAwait extends ResolvedCorrectionProducer {
     });
   }
 
-  Future<void> _computeNonBool(ChangeBuilder builder) async {
+  /// If the expression is not a future it is not valid.
+  /// If the expression is a future, we check if the type of the future is
+  /// assignable to the expected type using either [isValid] or
+  /// [expectedTypeFromExp].
+  /// If [isValid] is provided, it is used to check if the future's type is
+  /// valid.
+  /// If [expectedTypeFromExp] is provided the return type should be the
+  /// underlying expected type of the expression. The future type will then be
+  /// checked if it is assignable to it.
+  bool _isValidType(
+      {DartType? Function(Expression expr)? expectedTypeFromExp,
+      bool Function(DartType type)? isValid}) {
+    assert((isValid != null) ^ (expectedTypeFromExp != null),
+        'Use either isValid or expectedTypeFromExp, but not both');
     var expr = node;
-    if (expr is! Expression) return;
+    if (expr is! Expression) {
+      return false;
+    }
     var staticType = expr.staticType;
-    if (staticType is! ParameterizedType) return;
+    if (staticType is! InterfaceType) {
+      return false;
+    }
+    if (!staticType.isDartAsyncFuture) {
+      return false;
+    }
+
+    var typeArg = expectedTypeFromExp?.call(expr);
+    if (typeArg == null && isValid == null) {
+      return false;
+    }
 
-    if (staticType.isDartAsyncFuture &&
-        staticType.typeArguments.firstOrNull?.isDartCoreBool == true) {
-      await _addAwait(builder);
+    var type = staticType.typeArguments.first;
+    if (typeArg == null) {
+      return isValid!(type);
+    } else {
+      return typeSystem.isAssignableTo(type, typeArg);
     }
   }
 }
 
 /// The kinds of corrections supported by [AddAwait].
 enum _CorrectionKind {
-  unawaited,
+  argumentType,
+  invalidAssignment,
   nonBool,
+  unawaited,
+}
+
+extension on Expression {
+  DartType? get argumentType {
+    var expr = this;
+    if (parent case NamedExpression named) {
+      expr = named;
+    }
+    if (expr.parent is ArgumentList) {
+      return expr.correspondingParameter?.type;
+    }
+    return null;
+  }
+
+  DartType? get assignmentType {
+    return switch (parent) {
+      VariableDeclarationImpl variableDeclaration => variableDeclaration.type,
+      AssignmentExpression assignment => assignment.writeType,
+      _ => null
+    };
+  }
 }

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

@@ -941,6 +941,7 @@ final _builtInNonLintProducers = <ErrorCode, List<ProducerGenerator>>{
     AddExplicitCast.new,
     AddNullCheck.new,
     WrapInText.new,
+    AddAwait.argumentType,
   ],
   CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT: [
     AddAsync.new,
@@ -1104,6 +1105,7 @@ final _builtInNonLintProducers = <ErrorCode, List<ProducerGenerator>>{
     AddNullCheck.new,
     ChangeTypeAnnotation.new,
     MakeVariableNullable.new,
+    AddAwait.assignment,
   ],
   CompileTimeErrorCode.INVALID_CONSTANT: [
     RemoveConst.new,

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

@@ -4,6 +4,7 @@
 
 import 'package:analysis_server/src/services/correction/fix.dart';
 import 'package:analyzer/src/dart/error/syntactic_errors.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
 import 'package:linter/src/lint_names.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -13,6 +14,7 @@ import 'fix_processor.dart';
 void main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(AddAwaitTest);
+    defineReflectiveTests(AddAwaitTestArgumentAndAssignment);
   });
 }
 
@@ -104,3 +106,135 @@ Future<void> f() async {
     await assertNoFix();
   }
 }
+
+@reflectiveTest
+class AddAwaitTestArgumentAndAssignment extends FixProcessorTest {
+  @override
+  FixKind get kind => DartFixKind.ADD_AWAIT;
+
+  Future<void> test_stringNamedParameter_futureInt() async {
+    await resolveTestCode('''
+void foo({required String s}) {}
+
+Future<int> bar() async => 0;
+
+void baz() {
+  foo(s: bar());
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_stringNamedParameter_futureString() async {
+    await resolveTestCode('''
+void foo({required String s}) {}
+
+Future<String> bar() async => '';
+
+void baz() {
+  foo(s: bar());
+}
+''');
+    await assertHasFix('''
+void foo({required String s}) {}
+
+Future<String> bar() async => '';
+
+void baz() {
+  foo(s: await bar());
+}
+''');
+  }
+
+  Future<void> test_stringParameter_futureInt() async {
+    await resolveTestCode('''
+void foo(String s) {}
+
+Future<int> bar() async => 0;
+
+void baz() {
+  foo(bar());
+}
+''');
+    await assertNoFix();
+  }
+
+  Future<void> test_stringParameter_futureString() async {
+    await resolveTestCode('''
+void foo(String s) {}
+
+Future<String> bar() async => '';
+
+void baz() {
+  foo(bar());
+}
+''');
+    await assertHasFix('''
+void foo(String s) {}
+
+Future<String> bar() async => '';
+
+void baz() {
+  foo(await bar());
+}
+''');
+  }
+
+  Future<void> test_stringVariable_assignment_futureString() async {
+    await resolveTestCode('''
+Future<String> bar() async => '';
+
+void baz() {
+  String? variable;
+  variable = bar();
+}
+''');
+    await assertHasFix(
+      '''
+Future<String> bar() async => '';
+
+void baz() {
+  String? variable;
+  variable = await bar();
+}
+''',
+      errorFilter: (error) =>
+          error.errorCode == CompileTimeErrorCode.INVALID_ASSIGNMENT,
+    );
+  }
+
+  Future<void> test_stringVariable_futureInt() async {
+    await resolveTestCode('''
+Future<int> bar() async => 0;
+
+void baz() {
+  String variable = bar();
+}
+''');
+    await assertNoFix(
+      errorFilter: (error) =>
+          error.errorCode == CompileTimeErrorCode.INVALID_ASSIGNMENT,
+    );
+  }
+
+  Future<void> test_stringVariable_futureString() async {
+    await resolveTestCode('''
+Future<String> bar() async => '';
+
+void baz() {
+  String variable = bar();
+}
+''');
+    await assertHasFix(
+      '''
+Future<String> bar() async => '';
+
+void baz() {
+  String variable = await bar();
+}
+''',
+      errorFilter: (error) =>
+          error.errorCode == CompileTimeErrorCode.INVALID_ASSIGNMENT,
+    );
+  }
+}