Allow implicit return with explicit undefined return type

src/compiler/checker.ts

@@ -35469,8 +35469,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const functionFlags = getFunctionFlags(func);
             const type = returnType && unwrapReturnType(returnType, functionFlags);
 
-            // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions.
-            if (type && maybeTypeOfKind(type, TypeFlags.Any | TypeFlags.Void)) {
+            // Functions with an explicitly specified 'undefined, 'void' or 'any' return type don't need any return expressions.
+            if (type && maybeTypeOfKind(type, TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Any)) {
                 return;
             }
 
@@ -35489,9 +35489,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             else if (type && !hasExplicitReturn) {
                 // minimal check: function has syntactic return type annotation and no explicit return statements in the body
                 // this function does not conform to the specification.
-                error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);
+                error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value);
             }
-            else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
+            else if (type && strictNullChecks) {
                 error(errorNode, Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
             }
             else if (compilerOptions.noImplicitReturns) {

src/compiler/diagnosticMessages.json

@@ -1868,7 +1868,7 @@
         "category": "Error",
         "code": 2354
     },
-    "A function whose declared type is neither 'void' nor 'any' must return a value.": {
+    "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.": {
         "category": "Error",
         "code": 2355
     },
@@ -6706,7 +6706,7 @@
         "category": "Suggestion",
         "code": 80010
     },
-    
+
     "Add missing 'super()' call": {
         "category": "Message",
         "code": 90001

src/services/codefixes/returnValueCorrect.ts

@@ -51,7 +51,7 @@ const fixIdAddReturnStatement = "fixAddReturnStatement";
 const fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody";
 const fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen";
 const errorCodes = [
-    Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code,
+    Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value.code,
     Diagnostics.Type_0_is_not_assignable_to_type_1.code,
     Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code
 ];
@@ -213,7 +213,7 @@ function getInfo(checker: TypeChecker, sourceFile: SourceFile, position: number,
 
     const declaration = findAncestor(node.parent, isFunctionLikeDeclaration);
     switch (errorCode) {
-        case Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code:
+        case Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value.code:
             if (!declaration || !declaration.body || !declaration.type || !rangeContainsRange(declaration.type, node)) return undefined;
             return getFixInfo(checker, declaration, checker.getTypeFromTypeNode(declaration.type), /* isFunctionType */ false);
         case Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code:

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt

@@ -1,14 +1,15 @@
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(1,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(99,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(104,16): error TS2378: A 'get' accessor must return a value.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(126,15): error TS18050: The value 'undefined' cannot be used here.
-tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): error TS1003: Identifier expected.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(1,16): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(99,17): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(107,17): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(112,16): error TS2378: A 'get' accessor must return a value.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(134,15): error TS18050: The value 'undefined' cannot be used here.
+tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(135,5): error TS1003: Identifier expected.
 
 
-==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ====
+==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (6 errors) ====
     function f1(): string {
                    ~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+!!! error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
         // errors because there are no return statements
     }
 
@@ -40,12 +41,12 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): e
         return null;
     }
 
-    function f8(): void {
+    function f8(): any {
         // Fine since are typed any.
         return;
     }
 
-    function f9(): void {
+    function f9(): any {
         // Fine since we are typed any and return undefined
         return undefined;
     }
@@ -108,10 +109,20 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): e
 
     function f21(): number | string {
                     ~~~~~~~~~~~~~~~
-!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+!!! error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
         // Not okay; union does not contain void or any
     }
 
+    function f22(): undefined {
+        // Okay; return type allows implicit return of undefined
+    }
+
+    function f23(): undefined | number {
+                    ~~~~~~~~~~~~~~~~~~
+!!! error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+        // Error; because `undefined | number` becomes `number` without strictNullChecks.
+    }
+
     class C {
         public get m1() {
                    ~~
@@ -143,4 +154,5 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(127,5): e
         }
         ~
 !!! error TS1003: Identifier expected.
-    }
+    }
+

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js

@@ -31,12 +31,12 @@ function f7(): void {
     return null;
 }
 
-function f8(): void {
+function f8(): any {
     // Fine since are typed any.
     return;
 }
 
-function f9(): void {
+function f9(): any {
     // Fine since we are typed any and return undefined
     return undefined;
 }
@@ -101,6 +101,14 @@ function f21(): number | string {
     // Not okay; union does not contain void or any
 }
 
+function f22(): undefined {
+    // Okay; return type allows implicit return of undefined
+}
+
+function f23(): undefined | number {
+    // Error; because `undefined | number` becomes `number` without strictNullChecks.
+}
+
 class C {
     public get m1() {
         // Errors; get accessors must return a value.
@@ -126,7 +134,8 @@ class C {
         throw null;
         throw undefined.
     }
-}
+}
+
 
 //// [functionsMissingReturnStatementsAndExpressions.js]
 function f1() {
@@ -209,6 +218,12 @@ function f20() {
 function f21() {
     // Not okay; union does not contain void or any
 }
+function f22() {
+    // Okay; return type allows implicit return of undefined
+}
+function f23() {
+    // Error; because `undefined | number` becomes `number` without strictNullChecks.
+}
 var C = /** @class */ (function () {
     function C() {
     }

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.symbols

@@ -46,14 +46,14 @@ function f7(): void {
     return null;
 }
 
-function f8(): void {
+function f8(): any {
 >f8 : Symbol(f8, Decl(functionsMissingReturnStatementsAndExpressions.ts, 30, 1))
 
     // Fine since are typed any.
     return;
 }
 
-function f9(): void {
+function f9(): any {
 >f9 : Symbol(f9, Decl(functionsMissingReturnStatementsAndExpressions.ts, 35, 1))
 
     // Fine since we are typed any and return undefined
@@ -152,37 +152,49 @@ function f21(): number | string {
     // Not okay; union does not contain void or any
 }
 
+function f22(): undefined {
+>f22 : Symbol(f22, Decl(functionsMissingReturnStatementsAndExpressions.ts, 100, 1))
+
+    // Okay; return type allows implicit return of undefined
+}
+
+function f23(): undefined | number {
+>f23 : Symbol(f23, Decl(functionsMissingReturnStatementsAndExpressions.ts, 104, 1))
+
+    // Error; because `undefined | number` becomes `number` without strictNullChecks.
+}
+
 class C {
->C : Symbol(C, Decl(functionsMissingReturnStatementsAndExpressions.ts, 100, 1))
+>C : Symbol(C, Decl(functionsMissingReturnStatementsAndExpressions.ts, 108, 1))
 
     public get m1() {
->m1 : Symbol(C.m1, Decl(functionsMissingReturnStatementsAndExpressions.ts, 102, 9))
+>m1 : Symbol(C.m1, Decl(functionsMissingReturnStatementsAndExpressions.ts, 110, 9))
 
         // Errors; get accessors must return a value.
     }
 
     public get m2() {
->m2 : Symbol(C.m2, Decl(functionsMissingReturnStatementsAndExpressions.ts, 105, 5))
+>m2 : Symbol(C.m2, Decl(functionsMissingReturnStatementsAndExpressions.ts, 113, 5))
 
         // Permissible; returns undefined.
         return;
     }
 
     public get m3() {
->m3 : Symbol(C.m3, Decl(functionsMissingReturnStatementsAndExpressions.ts, 110, 5))
+>m3 : Symbol(C.m3, Decl(functionsMissingReturnStatementsAndExpressions.ts, 118, 5))
 
         return "Okay, because this is a return expression.";
     }
 
     public get m4() {
->m4 : Symbol(C.m4, Decl(functionsMissingReturnStatementsAndExpressions.ts, 114, 5))
+>m4 : Symbol(C.m4, Decl(functionsMissingReturnStatementsAndExpressions.ts, 122, 5))
 
         // Fine since this consists of a single throw statement.
         throw null;
     }
 
     public get m5() {
->m5 : Symbol(C.m5, Decl(functionsMissingReturnStatementsAndExpressions.ts, 119, 5))
+>m5 : Symbol(C.m5, Decl(functionsMissingReturnStatementsAndExpressions.ts, 127, 5))
 
         // Not fine, since we can *only* consist of a single throw statement
         // if no return statements are present but we are a get accessor.
@@ -191,3 +203,4 @@ class C {
 >undefined : Symbol(undefined)
     }
 }
+

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.types

@@ -48,15 +48,15 @@ function f7(): void {
 >null : null
 }
 
-function f8(): void {
->f8 : () => void
+function f8(): any {
+>f8 : () => any
 
     // Fine since are typed any.
     return;
 }
 
-function f9(): void {
->f9 : () => void
+function f9(): any {
+>f9 : () => any
 
     // Fine since we are typed any and return undefined
     return undefined;
@@ -159,6 +159,18 @@ function f21(): number | string {
     // Not okay; union does not contain void or any
 }
 
+function f22(): undefined {
+>f22 : () => undefined
+
+    // Okay; return type allows implicit return of undefined
+}
+
+function f23(): undefined | number {
+>f23 : () => undefined | number
+
+    // Error; because `undefined | number` becomes `number` without strictNullChecks.
+}
+
 class C {
 >C : C
 
@@ -204,3 +216,4 @@ class C {
     }
 > : any
 }
+

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions2.js

@@ -0,0 +1,10 @@
+//// [functionsMissingReturnStatementsAndExpressions2.ts]
+function f1(): undefined | number {
+    // Okay; return type allows implicit return of undefined
+}
+
+
+//// [functionsMissingReturnStatementsAndExpressions2.js]
+function f1() {
+    // Okay; return type allows implicit return of undefined
+}

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions2.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions2.ts ===
+function f1(): undefined | number {
+>f1 : Symbol(f1, Decl(functionsMissingReturnStatementsAndExpressions2.ts, 0, 0))
+
+    // Okay; return type allows implicit return of undefined
+}
+

tests/baselines/reference/functionsMissingReturnStatementsAndExpressions2.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions2.ts ===
+function f1(): undefined | number {
+>f1 : () => undefined | number
+
+    // Okay; return type allows implicit return of undefined
+}
+

tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts

@@ -34,12 +34,12 @@ function f7(): void {
     return null;
 }
 
-function f8(): void {
+function f8(): any {
     // Fine since are typed any.
     return;
 }
 
-function f9(): void {
+function f9(): any {
     // Fine since we are typed any and return undefined
     return undefined;
 }
@@ -104,6 +104,14 @@ function f21(): number | string {
     // Not okay; union does not contain void or any
 }
 
+function f22(): undefined {
+    // Okay; return type allows implicit return of undefined
+}
+
+function f23(): undefined | number {
+    // Error; because `undefined | number` becomes `number` without strictNullChecks.
+}
+
 class C {
     public get m1() {
         // Errors; get accessors must return a value.
@@ -129,4 +137,4 @@ class C {
         throw null;
         throw undefined.
     }
-}
+}

tests/cases/compiler/functionsMissingReturnStatementsAndExpressions2.ts

@@ -0,0 +1,8 @@
+// @allowUnreachableCode: true
+// @strictNullChecks: true
+
+// @target: es5
+
+function f1(): undefined | number {
+    // Okay; return type allows implicit return of undefined
+}

tests/cases/fourslash/codeFixCorrectReturnValue6.ts

@@ -4,6 +4,4 @@
 ////     undefined
 //// }
 
-verify.codeFixAvailable([
-    { description: 'Add a return statement' },
-]);
+verify.not.codeFixAvailable();