[cfe] Infer Null from implicit return in function literal type inference

Closes #42743

Change-Id: I7aca374894704cdc002d927aef9ea72cbabd12e6
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155606
Reviewed-by: Dmitry Stefantsov <[email protected]>

Author: johnniwinther

pkg/front_end/lib/src/fasta/type_inference/closure_context.dart

@@ -303,7 +303,15 @@ class _SyncClosureContext implements ClosureContext {
     assert(_needToInferReturnType);
     assert(hasImplicitReturn != null);
     DartType inferredType;
-    if (_returnStatements.isNotEmpty) {
+    if (inferrer.isNonNullableByDefault) {
+      if (hasImplicitReturn) {
+        // No explicit returns we have an implicit `return null`.
+        inferredType = inferrer.typeSchemaEnvironment.nullType;
+      } else {
+        // No explicit return and the function doesn't complete normally; that
+        // is, it throws.
+        inferredType = new NeverType(inferrer.library.nonNullable);
+      }
       // Use the types seen from the explicit return statements.
       for (int i = 0; i < _returnStatements.length; i++) {
         ReturnStatement statement = _returnStatements[i];
@@ -322,15 +330,32 @@ class _SyncClosureContext implements ClosureContext {
               inferredType, type, inferrer.library.library);
         }
       }
-    } else if (hasImplicitReturn) {
-      // No explicit returns we have an implicit `return null`.
-      inferredType = inferrer.typeSchemaEnvironment.nullType;
     } else {
-      // No explicit return and the function doesn't complete normally; that is,
-      // it throws.
-      if (inferrer.isNonNullableByDefault) {
-        inferredType = new NeverType(inferrer.library.nonNullable);
+      if (_returnStatements.isNotEmpty) {
+        // Use the types seen from the explicit return statements.
+        for (int i = 0; i < _returnStatements.length; i++) {
+          ReturnStatement statement = _returnStatements[i];
+          DartType type = _returnExpressionTypes[i];
+          // The return expression has to be assignable to the return type
+          // expectation from the downwards inference context.
+          if (statement.expression != null) {
+            if (!inferrer.isAssignable(_returnContext, type)) {
+              type = inferrer.computeGreatestClosure(_returnContext);
+            }
+          }
+          if (inferredType == null) {
+            inferredType = type;
+          } else {
+            inferredType = inferrer.typeSchemaEnvironment.getStandardUpperBound(
+                inferredType, type, inferrer.library.library);
+          }
+        }
+      } else if (hasImplicitReturn) {
+        // No explicit returns we have an implicit `return null`.
+        inferredType = inferrer.typeSchemaEnvironment.nullType;
       } else {
+        // No explicit return and the function doesn't complete normally; that
+        // is, it throws.
         inferredType = inferrer.typeSchemaEnvironment.nullType;
       }
     }
@@ -649,23 +674,20 @@ class _AsyncClosureContext implements ClosureContext {
     assert(_needToInferReturnType);
     assert(hasImplicitReturn != null);
     DartType inferredType;
-    if (_returnStatements.isNotEmpty) {
+
+    if (inferrer.isNonNullableByDefault) {
+      if (hasImplicitReturn) {
+        // No explicit returns we have an implicit `return null`.
+        inferredType = inferrer.typeSchemaEnvironment.nullType;
+      } else {
+        // No explicit return and the function doesn't complete normally; that
+        // is, it throws.
+        inferredType = new NeverType(inferrer.library.nonNullable);
+      }
       // Use the types seen from the explicit return statements.
       for (int i = 0; i < _returnStatements.length; i++) {
-        ReturnStatement statement = _returnStatements[i];
         DartType type = _returnExpressionTypes[i];
 
-        // The return expression has to be assignable to the return type
-        // expectation from the downwards inference context.
-        if (!inferrer.isNonNullableByDefault) {
-          if (statement.expression != null) {
-            if (!inferrer.isAssignable(
-                computeAssignableType(inferrer, _returnContext, type), type)) {
-              // Not assignable, use the expectation.
-              type = inferrer.computeGreatestClosure(_returnContext);
-            }
-          }
-        }
         DartType unwrappedType = inferrer.typeSchemaEnvironment.flatten(type);
         if (inferredType == null) {
           inferredType = unwrappedType;
@@ -674,20 +696,6 @@ class _AsyncClosureContext implements ClosureContext {
               inferredType, unwrappedType, inferrer.library.library);
         }
       }
-    } else if (hasImplicitReturn) {
-      // No explicit returns we have an implicit `return null`.
-      inferredType = inferrer.typeSchemaEnvironment.nullType;
-    } else {
-      // No explicit return and the function doesn't complete normally; that is,
-      // it throws.
-      if (inferrer.isNonNullableByDefault) {
-        inferredType = new NeverType(inferrer.library.nonNullable);
-      } else {
-        inferredType = inferrer.typeSchemaEnvironment.nullType;
-      }
-    }
-
-    if (inferrer.isNonNullableByDefault) {
       if (!inferrer.typeSchemaEnvironment.isSubtypeOf(
           inferredType, _returnContext, SubtypeCheckMode.withNullabilities)) {
         // If the inferred return type isn't a subtype of the context, we use
@@ -698,6 +706,37 @@ class _AsyncClosureContext implements ClosureContext {
           inferrer.typeSchemaEnvironment.flatten(inferredType),
           inferrer.library.nonNullable);
     } else {
+      if (_returnStatements.isNotEmpty) {
+        // Use the types seen from the explicit return statements.
+        for (int i = 0; i < _returnStatements.length; i++) {
+          ReturnStatement statement = _returnStatements[i];
+          DartType type = _returnExpressionTypes[i];
+
+          // The return expression has to be assignable to the return type
+          // expectation from the downwards inference context.
+          if (statement.expression != null) {
+            if (!inferrer.isAssignable(
+                computeAssignableType(inferrer, _returnContext, type), type)) {
+              // Not assignable, use the expectation.
+              type = inferrer.computeGreatestClosure(_returnContext);
+            }
+          }
+          DartType unwrappedType = inferrer.typeSchemaEnvironment.flatten(type);
+          if (inferredType == null) {
+            inferredType = unwrappedType;
+          } else {
+            inferredType = inferrer.typeSchemaEnvironment.getStandardUpperBound(
+                inferredType, unwrappedType, inferrer.library.library);
+          }
+        }
+      } else if (hasImplicitReturn) {
+        // No explicit returns we have an implicit `return null`.
+        inferredType = inferrer.typeSchemaEnvironment.nullType;
+      } else {
+        // No explicit return and the function doesn't complete normally;
+        // that is, it throws.
+        inferredType = inferrer.typeSchemaEnvironment.nullType;
+      }
       inferredType =
           inferrer.wrapFutureType(inferredType, inferrer.library.nonNullable);
 

pkg/front_end/testcases/nnbd/issue41156.dart.strong.expect

@@ -6,31 +6,31 @@ library /*isNonNullableByDefault*/;
 //   String Function(int) x2 = (int v) /* error */ {
 //                             ^
 //
-// pkg/front_end/testcases/nnbd/issue41156.dart:44:29: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+// pkg/front_end/testcases/nnbd/issue41156.dart:44:29: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   String Function(int) x3 = (int v) /* error */ {
 //                             ^
 //
 // pkg/front_end/testcases/nnbd/issue41156.dart:49:29: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   String Function(int) x5 = (int v) /* error */ {
 //                             ^
 //
-// pkg/front_end/testcases/nnbd/issue41156.dart:54:29: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+// pkg/front_end/testcases/nnbd/issue41156.dart:54:29: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   String Function(int) x6 = (int v) /* error */ {
 //                             ^
 //
 // pkg/front_end/testcases/nnbd/issue41156.dart:59:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   Future<String> Function(int) y2 = (int v) async /* error */ {
 //                                     ^
 //
-// pkg/front_end/testcases/nnbd/issue41156.dart:64:37: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+// pkg/front_end/testcases/nnbd/issue41156.dart:64:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   Future<String> Function(int) y3 = (int v) async /* error */ {
 //                                     ^
 //
 // pkg/front_end/testcases/nnbd/issue41156.dart:69:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   Future<String> Function(int) y5 = (int v) async /* error */ {
 //                                     ^
 //
-// pkg/front_end/testcases/nnbd/issue41156.dart:74:37: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+// pkg/front_end/testcases/nnbd/issue41156.dart:74:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
 //   Future<String> Function(int) y6 = (int v) async /* error */ {
 //                                     ^
 //
@@ -81,13 +81,13 @@ static method errors() → void async {
   String Function(int) x2 = (int v) /* error */ {
                             ^" in null;
   };
-  (core::int) → core::String x3 = (core::int v) → Never {
+  (core::int) → core::String x3 = (core::int v) → core::String {
     try {
       return throw v;
     }
     on core::Object catch(final core::Object _) {
     }
-    return let final<BottomType> #t2 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:44:29: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+    return let final<BottomType> #t2 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:44:29: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
   String Function(int) x3 = (int v) /* error */ {
                             ^" in null;
   };
@@ -101,13 +101,13 @@ static method errors() → void async {
   String Function(int) x5 = (int v) /* error */ {
                             ^" in null;
   };
-  (core::int) → core::String x6 = (core::int v) → Never {
+  (core::int) → core::String x6 = (core::int v) → core::String {
     try {
       return self::throwing();
     }
     on core::Object catch(final core::Object _) {
     }
-    return let final<BottomType> #t4 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:54:29: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+    return let final<BottomType> #t4 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:54:29: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
   String Function(int) x6 = (int v) /* error */ {
                             ^" in null;
   };
@@ -121,13 +121,13 @@ static method errors() → void async {
   Future<String> Function(int) y2 = (int v) async /* error */ {
                                     ^" in null;
   };
-  (core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<Never> async {
+  (core::int) → asy::Future<core::String> y3 = (core::int v) → asy::Future<core::String> async {
     try {
       return throw v;
     }
     on core::Object catch(final core::Object _) {
     }
-    return let final<BottomType> #t6 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:64:37: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+    return let final<BottomType> #t6 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:64:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
   Future<String> Function(int) y3 = (int v) async /* error */ {
                                     ^" in null;
   };
@@ -141,13 +141,13 @@ static method errors() → void async {
   Future<String> Function(int) y5 = (int v) async /* error */ {
                                     ^" in null;
   };
-  (core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<Never> async {
+  (core::int) → asy::Future<core::String> y6 = (core::int v) → asy::Future<core::String> async {
     try {
       return self::throwing();
     }
     on core::Object catch(final core::Object _) {
     }
-    return let final<BottomType> #t8 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:74:37: Error: A non-null value must be returned since the return type 'Never' doesn't allow null.
+    return let final<BottomType> #t8 = invalid-expression "pkg/front_end/testcases/nnbd/issue41156.dart:74:37: Error: A non-null value must be returned since the return type 'String' doesn't allow null.
   Future<String> Function(int) y6 = (int v) async /* error */ {
                                     ^" in null;
   };