Infer void return type for FunctionExpression.

dart-lang/language#1092

Bug: #42720

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

Author: scheglov

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

@@ -92,13 +92,7 @@ class BodyInferenceContext {
       endOfBlockIsReachable: endOfBlockIsReachable,
     );
 
-    DartType clampedReturnedType;
-    if (contextType == null ||
-        _typeSystem.isSubtypeOf2(actualReturnedType, contextType)) {
-      clampedReturnedType = actualReturnedType;
-    } else {
-      clampedReturnedType = nonNullifyType(_typeSystem, contextType);
-    }
+    var clampedReturnedType = _clampToContextType(actualReturnedType);
 
     if (_isGenerator) {
       if (_isAsynchronous) {
@@ -117,6 +111,35 @@ class BodyInferenceContext {
     }
   }
 
+  /// Let `T` be the **actual returned type** of a function literal.
+  DartType _clampToContextType(DartType T) {
+    // Let `R` be the greatest closure of the typing context `K`.
+    var R = contextType;
+    if (R == null) {
+      return T;
+    }
+
+    // If `R` is `void`, or the function literal is marked `async` and `R` is
+    // `FutureOr<void>`, let `S` be `void`.
+    if (_typeSystem.isNonNullableByDefault) {
+      if (R.isVoid ||
+          _isAsynchronous &&
+              R is InterfaceType &&
+              R.isDartAsyncFutureOr &&
+              R.typeArguments[0].isVoid) {
+        return VoidTypeImpl.instance;
+      }
+    }
+
+    // Otherwise, if `T <: R` then let `S` be `T`.
+    if (_typeSystem.isSubtypeOf2(T, R)) {
+      return T;
+    }
+
+    // Otherwise, let `S` be `R`.
+    return nonNullifyType(_typeSystem, R);
+  }
+
   DartType _computeActualReturnedType({
     @required bool endOfBlockIsReachable,
   }) {

pkg/analyzer/test/generated/resolver_test.dart

@@ -501,20 +501,6 @@ main() {
     assertType(findNode.simple('v; // return'), 'int');
   }
 
-  test_functionExpression_asInvocationArgument_notSubtypeOfStaticType() async {
-    await assertErrorsInCode(r'''
-class A {
-  m(void f(int i)) {}
-}
-x() {
-  A a = new A();
-  a.m(() => 0);
-}''', [
-      error(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, 63, 7),
-    ]);
-    assertType(findNode.functionExpression('() => 0'), 'int Function()');
-  }
-
   test_initializer_hasStaticType() async {
     await resolveTestCode(r'''
 f() {

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

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/analysis/features.dart';
+import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -17,6 +18,50 @@ main() {
 
 @reflectiveTest
 class FunctionExpressionTest extends DriverResolutionTest {
+  test_contextFunctionType_returnType_async_blockBody_futureOrVoid() async {
+    var expectedErrors = expectedErrorsByNullability(
+      nullable: [
+        error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE, 72, 1),
+      ],
+      legacy: [],
+    );
+    await assertErrorsInCode('''
+import 'dart:async';
+
+FutureOr<void> Function() v = () async {
+  return 0;
+};
+''', expectedErrors);
+    _assertReturnType(
+      '() async {',
+      typeStringByNullability(
+        nullable: 'Future<void>',
+        legacy: 'Future<int>',
+      ),
+    );
+  }
+
+  test_contextFunctionType_returnType_async_blockBody_futureVoid() async {
+    var expectedErrors = expectedErrorsByNullability(
+      nullable: [
+        error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE, 48, 1),
+      ],
+      legacy: [],
+    );
+    await assertErrorsInCode('''
+Future<void> Function() v = () async {
+  return 0;
+};
+''', expectedErrors);
+    _assertReturnType(
+      '() async {',
+      typeStringByNullability(
+        nullable: 'Future<void>',
+        legacy: 'Future<int>',
+      ),
+    );
+  }
+
   test_contextFunctionType_returnType_async_expressionBody() async {
     await assertNoErrorsInCode('''
 Future<num> Function() v = () async => 0;
@@ -118,6 +163,24 @@ int Function() v = () {
     _assertReturnType('() {', 'int');
   }
 
+  test_contextFunctionType_returnType_sync_blockBody_void() async {
+    var expectedErrors = expectedErrorsByNullability(nullable: [
+      error(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE_FROM_CLOSURE, 34, 1),
+    ], legacy: []);
+    await assertErrorsInCode('''
+void Function() v = () {
+  return 0;
+};
+''', expectedErrors);
+    _assertReturnType(
+      '() {',
+      typeStringByNullability(
+        nullable: 'void',
+        legacy: 'int',
+      ),
+    );
+  }
+
   test_contextFunctionType_returnType_sync_expressionBody() async {
     await assertNoErrorsInCode('''
 num Function() v = () => 0;

tests/language/type/implicit_error_test.dart

@@ -29,7 +29,6 @@ void main() {
 
   Expect.throws<TypeError>(() {
     int x = wrap(noToString); // Implicit cast should throw
-    return x;
   }, (e) {
     e.toString(); // Should not throw.
     return true;