Implement changes to return type verification.

#41803
https://dart-review.googlesource.com/c/sdk/+/149163
dart-lang/language#989

Change-Id: I13caf53a3e96c7b266dd3b3bf511002addcf83b6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/149373
Commit-Queue: Konstantin Shcheglov <[email protected]>
Reviewed-by: Brian Wilkerson <[email protected]>

Author: scheglov

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

@@ -142,8 +142,6 @@ int main() async {
 library main;
 Future<int> main() async {
 }
-''', errorFilter: (error) {
-      return error.errorCode == StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE;
-    });
+''');
   }
 }

pkg/analyzer/lib/src/dart/resolver/body_inference_context.dart

@@ -188,10 +188,10 @@ class BodyInferenceContext {
       }
     }
 
-    // Otherwise the context type is `FutureOr<flatten(T)>` where `T` is the
-    // imposed return type.
+    // Otherwise the context type is `FutureOr<futureValueTypeSchema(S)>`,
+    // where `S` is the imposed return type.
     return typeSystem.typeProvider.futureOrType2(
-      typeSystem.flatten(imposedType),
+      typeSystem.futureValueType(imposedType),
     );
   }
 }

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

@@ -126,6 +126,14 @@ class ReturnTypeVerifier {
       return;
     }
 
+    if (_typeSystem.isNonNullableByDefault) {
+      _checkReturnExpression_nullSafety(expression);
+    } else {
+      _checkReturnExpression_legacy(expression);
+    }
+  }
+
+  void _checkReturnExpression_legacy(Expression expression) {
     // `T` is the declared return type.
     // `S` is the static type of the expression.
     var T = enclosingExecutable.returnType;
@@ -188,6 +196,11 @@ class ReturnTypeVerifier {
       var flatten_S = _typeSystem.flatten(S);
       // It is a compile-time error if `T` is `void`,
       // and `flatten(S)` is neither `void`, `dynamic`, nor `Null`.
+      //
+      // Note, the specification was not implemented correctly, and
+      // implementing it now would be a breaking change. So, the code below
+      // intentionally does not implement the specification.
+      // https://github.com/dart-lang/sdk/issues/41803#issuecomment-635852474
       if (T.isVoid) {
         if (!_isVoidDynamicOrNull(flatten_S)) {
           reportTypeError();
@@ -216,12 +229,117 @@ class ReturnTypeVerifier {
     }
   }
 
-  void _checkReturnWithoutValue(ReturnStatement statement) {
-    var returnType = _flattenedReturnType;
-    if (_isVoidDynamicOrNull(returnType)) {
+  void _checkReturnExpression_nullSafety(Expression expression) {
+    // `T` is the declared return type.
+    // `S` is the static type of the expression.
+    var T = enclosingExecutable.returnType;
+    var S = getStaticType(expression);
+
+    void reportTypeError() {
+      String displayName = enclosingExecutable.element.displayName;
+      if (displayName.isEmpty) {
+        _errorReporter.reportErrorForNode(
+          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE,
+          expression,
+          [S, T],
+        );
+      } else if (enclosingExecutable.isMethod) {
+        _errorReporter.reportErrorForNode(
+          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_METHOD,
+          expression,
+          [S, T, displayName],
+        );
+      } else {
+        _errorReporter.reportErrorForNode(
+          StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_FUNCTION,
+          expression,
+          [S, T, displayName],
+        );
+      }
+    }
+
+    if (enclosingExecutable.isSynchronous) {
+      // It is a compile-time error if `T` is `void`,
+      // and `S` is neither `void`, `dynamic`, nor `Null`.
+      if (T.isVoid) {
+        if (!_isVoidDynamicOrNull(S)) {
+          reportTypeError();
+          return;
+        }
+      }
+      // It is a compile-time error if `S` is `void`,
+      // and `T` is neither `void` nor `dynamic`.
+      if (S.isVoid) {
+        if (!_isVoidDynamic(T)) {
+          reportTypeError();
+          return;
+        }
+      }
+      // It is a compile-time error if `S` is not `void`,
+      // and `S` is not assignable to `T`.
+      if (!S.isVoid) {
+        if (!_typeSystem.isAssignableTo2(S, T)) {
+          reportTypeError();
+          return;
+        }
+      }
+      // OK
       return;
     }
 
+    if (enclosingExecutable.isAsynchronous) {
+      var T_v = _typeSystem.futureValueType(T);
+      var flatten_S = _typeSystem.flatten(S);
+      // It is a compile-time error if `flatten(T)` is `void`,
+      // and `flatten(S)` is neither `void`, `dynamic`, nor `Null`.
+      if (T_v.isVoid) {
+        if (!_isVoidDynamicOrNull(flatten_S)) {
+          reportTypeError();
+          return;
+        }
+      }
+      // It is a compile-time error if `flatten(S)` is `void`,
+      // and `flatten(T)` is neither `void`, `dynamic`.
+      if (flatten_S.isVoid) {
+        if (!_isVoidDynamic(T_v)) {
+          reportTypeError();
+          return;
+        }
+      }
+      // It is a compile-time error if `flatten(S)` is not `void`,
+      // and `Future<flatten(S)>` is not assignable to `T`.
+      if (!flatten_S.isVoid) {
+        if (!_typeSystem.isAssignableTo2(S, T_v) &&
+            !_typeSystem.isSubtypeOf2(flatten_S, T_v)) {
+          reportTypeError();
+          return;
+        }
+        // OK
+        return;
+      }
+    }
+  }
+
+  void _checkReturnWithoutValue(ReturnStatement statement) {
+    if (_typeSystem.isNonNullableByDefault) {
+      var T = enclosingExecutable.returnType;
+      if (enclosingExecutable.isSynchronous) {
+        if (_isVoidDynamicOrNull(T)) {
+          return;
+        }
+      } else {
+        var T_v = _typeSystem.futureValueType(T);
+        if (_isVoidDynamicOrNull(T_v)) {
+          return;
+        }
+      }
+    } else {
+      var returnType = _flattenedReturnType;
+      if (_isVoidDynamicOrNull(returnType)) {
+        return;
+      }
+    }
+
     _errorReporter.reportErrorForToken(
       StaticWarningCode.RETURN_WITHOUT_VALUE,
       statement.returnKeyword,
@@ -268,6 +386,10 @@ class ReturnTypeVerifier {
     return type;
   }
 
+  static bool _isVoidDynamic(DartType type) {
+    return type.isVoid || type.isDynamic;
+  }
+
   static bool _isVoidDynamicOrNull(DartType type) {
     return type.isVoid || type.isDynamic || type.isDartCoreNull;
   }

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

@@ -655,6 +655,11 @@ class TypeSystemImpl extends TypeSystem {
       }
     }
 
+    // futureValueType(`dynamic`) = `dynamic`.
+    if (identical(T, DynamicTypeImpl.instance)) {
+      return T;
+    }
+
     // futureValueType(`void`) = `void`.
     if (identical(T, VoidTypeImpl.instance)) {
       return T;

pkg/analyzer/test/src/dart/element/future_value_type_test.dart

@@ -16,6 +16,11 @@ main() {
 
 @reflectiveTest
 class FutureValueTypeTest extends AbstractTypeSystemNullSafetyTest {
+  /// futureValueType(`dynamic`) = `dynamic`.
+  test_dynamic() {
+    _check(dynamicNone, 'dynamic');
+  }
+
   /// futureValueType(Future<`S`>) = `S`, for all `S`.
   test_future() {
     void check(DartType S, String expected) {

pkg/analyzer/test/src/dart/resolution/type_inference/function_expression_test.dart

@@ -50,11 +50,24 @@ T foo<T>() => throw 0;
 
 Object Function() v = () async => foo();
 ''');
+
     assertTypeArgumentTypes(
       findNode.methodInvocation('foo();'),
-      ['FutureOr<Object>'],
+      [
+        typeStringByNullability(
+          nullable: 'FutureOr<Object?>',
+          legacy: 'FutureOr<Object>',
+        ),
+      ],
+    );
+
+    _assertReturnType(
+      '() async => foo',
+      typeStringByNullability(
+        nullable: 'Future<Object?>',
+        legacy: 'Future<Object>',
+      ),
     );
-    _assertReturnType('() async => foo', 'Future<Object>');
   }
 
   test_contextFunctionType_returnType_asyncStar_blockBody() async {

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

@@ -20,7 +20,6 @@ class IllegalAsyncReturnTypeTest extends DriverResolutionTest {
 int f() async {}
 ''', [
       error(StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, 0, 3),
-      error(HintCode.MISSING_RETURN, 4, 1),
     ]);
   }
 
@@ -52,7 +51,6 @@ class C {
   int m() async {}
 }
 ''', [
-      error(HintCode.MISSING_RETURN, 16, 1),
       error(StaticTypeWarningCode.ILLEGAL_ASYNC_RETURN_TYPE, 12, 3),
     ]);
   }