microsoft
diff --git a/‎src/compiler/checker.ts
Copy file name to clipboard
+15-18Lines changed: 15 additions & 18 deletions b/‎src/compiler/checker.ts
Copy file name to clipboard
+15-18Lines changed: 15 additions & 18 deletions
diff --git a/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+1-5Lines changed: 1 addition & 5 deletions b/‎src/compiler/diagnosticMessages.json
Copy file name to clipboard
+1-5Lines changed: 1 addition & 5 deletions
diff --git a/‎src/services/codefixes/returnValueCorrect.ts
Copy file name to clipboard
-2Lines changed: 0 additions & 2 deletions b/‎src/services/codefixes/returnValueCorrect.ts
Copy file name to clipboard
-2Lines changed: 0 additions & 2 deletions
diff --git a/‎tests/baselines/reference/ParameterList5.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎tests/baselines/reference/ParameterList5.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
diff --git a/‎tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎tests/baselines/reference/asyncFunctionDeclaration15_es5.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions b/‎tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt
Copy file name to clipboard
+4-4Lines changed: 4 additions & 4 deletions
diff --git a/‎tests/baselines/reference/controlFlowGenericTypes.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions b/‎tests/baselines/reference/controlFlowGenericTypes.errors.txt
Copy file name to clipboard
+2-2Lines changed: 2 additions & 2 deletions
@@ -35426,10 +35426,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     : neverType; // Normal function
             }
             if (types.length === 0) {
-                // For an async function, the return type will not be void, but rather a Promise for void.
-                return functionFlags & FunctionFlags.Async
-                    ? createPromiseReturnType(func, voidType) // Async function
-                    : voidType; // Normal function
+                // For an async function, the return type will not be void/undefined, but rather a Promise for void/undefined.
+                const contextualReturnType = getContextualReturnType(func, /*contextFlags*/ undefined);
+                const returnType = contextualReturnType && (unwrapReturnType(contextualReturnType, functionFlags) || voidType).flags & TypeFlags.Undefined ? undefinedType : voidType;
+                return functionFlags & FunctionFlags.Async ? createPromiseReturnType(func, returnType) : // Async function
+                    returnType; // Normal function
             }
 
             // Return a union of the return expression types.
@@ -35665,8 +35666,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const functionFlags = getFunctionFlags(func);
             const type = returnType && unwrapReturnType(returnType, functionFlags);
 
-            // Functions with an explicitly specified 'undefined, 'void', 'any' or 'unknown' return type don't need any return expressions.
-            if (type && maybeTypeOfKind(type, TypeFlags.Undefined | TypeFlags.Void | TypeFlags.Any | TypeFlags.Unknown)) {
+            // Functions with an explicitly specified return type that includes `void` or is exactly `any` or `undefined` don't
+            // need any return statements.
+            if (type && (maybeTypeOfKind(type, TypeFlags.Void) || type.flags & (TypeFlags.Any | TypeFlags.Undefined))) {
                 return;
             }
 
@@ -35685,14 +35687,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.
-                if (strictNullChecks) {
-                    error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value);
-                }
-                else {
-                    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) {
+            else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {
                 error(errorNode, Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);
             }
             else if (compilerOptions.noImplicitReturns) {
@@ -35704,7 +35701,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                         return;
                     }
                     const inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));
-                    if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {
+                    if (isUnwrappedReturnTypeUndefinedVoidOrAny(func, inferredReturnType)) {
                         return;
                     }
                 }
@@ -42182,9 +42179,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType;
     }
 
-    function isUnwrappedReturnTypeVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {
-        const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(func));
-        return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, TypeFlags.Void | TypeFlags.AnyOrUnknown);
+    function isUnwrappedReturnTypeUndefinedVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {
+        const type = unwrapReturnType(returnType, getFunctionFlags(func));
+        return !!(type && (maybeTypeOfKind(type, TypeFlags.Void) || type.flags & (TypeFlags.Any | TypeFlags.Undefined)));
     }
 
     function checkReturnStatement(node: ReturnStatement) {
@@ -42232,7 +42229,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 }
             }
         }
-        else if (container.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) {
+        else if (container.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {
             // The function has a return type, but the return statement doesn't have an expression.
             error(node, Diagnostics.Not_all_code_paths_return_a_value);
         }
 
@@ -1880,7 +1880,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
     },
@@ -3615,10 +3615,6 @@
         "category": "Error",
         "code": 2846
     },
-    "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.": {
-        "category": "Error",
-        "code": 2847
-    },
     "The right-hand side of an 'instanceof' expression must not be an instantiation expression.": {
         "category": "Error",
         "code": 2848
 
@@ -51,7 +51,6 @@ 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
@@ -214,7 +213,6 @@ 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);
 
@@ -1,12 +1,12 @@
-tests/cases/compiler/ParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/ParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/compiler/ParameterList5.ts(1,16): error TS2369: A parameter property is only allowed in a constructor implementation.
 tests/cases/compiler/ParameterList5.ts(1,29): error TS2304: Cannot find name 'C'.
 
 
 ==== tests/cases/compiler/ParameterList5.ts (3 errors) ====
     function A(): (public B) => C {
                   ~~~~~~~~~~~~~~~
-!!! 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.
                    ~~~~~~~~
 !!! error TS2369: A parameter property is only allowed in a constructor implementation.
                                 ~
 
@@ -1,8 +1,8 @@
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(6,23): error TS1055: Type '{}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
-tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(6,23): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(6,23): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(7,23): error TS1055: Type 'any' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(8,23): error TS1055: Type 'number' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
-tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(8,23): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(8,23): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(9,23): error TS1055: Type 'PromiseLike' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration15_es5.ts(10,23): error TS1055: Type 'typeof Thenable' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
   Construct signature return types 'Thenable' and 'PromiseLike<T>' are incompatible.
@@ -22,15 +22,15 @@ tests/cases/conformance/async/es5/functionDeclarations/asyncFunctionDeclaration1
                           ~~~
 !!! error TS1055: Type '{}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
                           ~~~
-!!! 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.
     async function fn3(): any { } // error
                           ~~~
 !!! error TS1055: Type 'any' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
     async function fn4(): number { } // error
                           ~~~~~~
 !!! error TS1055: Type 'number' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
                           ~~~~~~
-!!! 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.
     async function fn5(): PromiseLike<void> { } // error
                           ~~~~~~~~~~~~~~~~~
 !!! error TS1055: Type 'PromiseLike' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value.
 
@@ -1,8 +1,8 @@
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,23): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{}>'?
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,23): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,23): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,23): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<any>'?
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,23): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<number>'?
-tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,23): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,23): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,23): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<void>'?
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,23): error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<void>'?
 tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1058: The return type of an async function must either be a valid promise or must not contain a callable 'then' member.
@@ -19,15 +19,15 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1
                           ~~~
 !!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<{}>'?
                           ~~~
-!!! 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.
     async function fn3(): any { } // error
                           ~~~
 !!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<any>'?
     async function fn4(): number { } // error
                           ~~~~~~
 !!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<number>'?
                           ~~~~~~
-!!! 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.
     async function fn5(): PromiseLike<void> { } // error
                           ~~~~~~~~~~~~~~~~~
 !!! error TS1064: The return type of an async function or method must be the global Promise<T> type. Did you mean to write 'Promise<void>'?
 
@@ -1,10 +1,10 @@
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(1,5): error TS2300: Duplicate identifier 'foo'.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,10): error TS2300: Duplicate identifier 'foo'.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,10): error TS2393: Duplicate function implementation.
-tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,17): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,10): error TS2300: Duplicate identifier 'foo'.
 tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,10): error TS2393: Duplicate function implementation.
-tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
+tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 
 
 ==== tests/cases/compiler/conflictingTypeAnnotatedVar.ts (7 errors) ====
@@ -17,11 +17,11 @@ tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A funct
              ~~~
 !!! error TS2393: Duplicate function implementation.
                     ~~~~~~
-!!! 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.
     function foo(): number { }
              ~~~
 !!! error TS2300: Duplicate identifier 'foo'.
              ~~~
 !!! error TS2393: Duplicate function implementation.
                     ~~~~~~
-!!! 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.
@@ -2,7 +2,7 @@ tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(49,15): error TS2
 tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(55,15): error TS2345: Argument of type 'undefined' is not assignable to parameter of type 'Box<unknown>'.
 tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(81,11): error TS2339: Property 'foo' does not exist on type 'MyUnion'.
   Property 'foo' does not exist on type 'AA'.
-tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(90,44): error TS2847: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(90,44): error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
 tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(91,11): error TS2339: Property 'foo' does not exist on type 'MyUnion'.
   Property 'foo' does not exist on type 'AA'.
 tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(156,16): error TS18048: 'obj' is possibly 'undefined'.
@@ -109,7 +109,7 @@ tests/cases/conformance/controlFlow/controlFlowGenericTypes.ts(168,9): error TS1
 
     const fn2 = <T extends MyUnion>(value: T): MyUnion => {
                                                ~~~~~~~
-!!! error TS2847: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
+!!! error TS2355: A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value.
         value.foo;  // Error
               ~~~
 !!! error TS2339: Property 'foo' does not exist on type 'MyUnion'.
Original file line number	Diff line number	Diff line change
`@@ -35426,10 +35426,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`35426`	`35426`	`: neverType; // Normal function`
`35427`	`35427`	`}`
`35428`	`35428`	`if (types.length === 0) {`
`35429`		`- // For an async function, the return type will not be void, but rather a Promise for void.`
`35430`		`- return functionFlags & FunctionFlags.Async`
`35431`		`- ? createPromiseReturnType(func, voidType) // Async function`
`35432`		`- : voidType; // Normal function`
	`35429`	`+ // For an async function, the return type will not be void/undefined, but rather a Promise for void/undefined.`
	`35430`	`+ const contextualReturnType = getContextualReturnType(func, /contextFlags/ undefined);`
	`35431`	`+ const returnType = contextualReturnType && (unwrapReturnType(contextualReturnType, functionFlags) \|\| voidType).flags & TypeFlags.Undefined ? undefinedType : voidType;`
	`35432`	`+ return functionFlags & FunctionFlags.Async ? createPromiseReturnType(func, returnType) : // Async function`
	`35433`	`+ returnType; // Normal function`
`35433`	`35434`	`}`
`35434`	`35435`
`35435`	`35436`	`// Return a union of the return expression types.`
`@@ -35665,8 +35666,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`35665`	`35666`	`const functionFlags = getFunctionFlags(func);`
`35666`	`35667`	`const type = returnType && unwrapReturnType(returnType, functionFlags);`
`35667`	`35668`
`35668`		`- // Functions with an explicitly specified 'undefined, 'void', 'any' or 'unknown' return type don't need any return expressions.`
`35669`		`- if (type && maybeTypeOfKind(type, TypeFlags.Undefined \| TypeFlags.Void \| TypeFlags.Any \| TypeFlags.Unknown)) {`
	`35669`	+ // Functions with an explicitly specified return type that includes `void` or is exactly `any` or `undefined` don't
	`35670`	`+ // need any return statements.`
	`35671`	`+ if (type && (maybeTypeOfKind(type, TypeFlags.Void) \|\| type.flags & (TypeFlags.Any \| TypeFlags.Undefined))) {`
`35670`	`35672`	`return;`
`35671`	`35673`	`}`
`35672`	`35674`
`@@ -35685,14 +35687,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`35685`	`35687`	`else if (type && !hasExplicitReturn) {`
`35686`	`35688`	`// minimal check: function has syntactic return type annotation and no explicit return statements in the body`
`35687`	`35689`	`// this function does not conform to the specification.`
`35688`		`- if (strictNullChecks) {`
`35689`		`- error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value);`
`35690`		`- }`
`35691`		`- else {`
`35692`		`- error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value);`
`35693`		`- }`
	`35690`	`+ error(errorNode, Diagnostics.A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value);`
`35694`	`35691`	`}`
`35695`		`- else if (type && strictNullChecks) {`
	`35692`	`+ else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) {`
`35696`	`35693`	`error(errorNode, Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined);`
`35697`	`35694`	`}`
`35698`	`35695`	`else if (compilerOptions.noImplicitReturns) {`
`@@ -35704,7 +35701,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`35704`	`35701`	`return;`
`35705`	`35702`	`}`
`35706`	`35703`	`const inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func));`
`35707`		`- if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) {`
	`35704`	`+ if (isUnwrappedReturnTypeUndefinedVoidOrAny(func, inferredReturnType)) {`
`35708`	`35705`	`return;`
`35709`	`35706`	`}`
`35710`	`35707`	`}`
`@@ -42182,9 +42179,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`42182`	`42179`	`return isAsync ? getAwaitedTypeNoAlias(returnType) \|\| errorType : returnType;`
`42183`	`42180`	`}`
`42184`	`42181`
`42185`		`- function isUnwrappedReturnTypeVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {`
`42186`		`- const unwrappedReturnType = unwrapReturnType(returnType, getFunctionFlags(func));`
`42187`		`- return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, TypeFlags.Void \| TypeFlags.AnyOrUnknown);`
	`42182`	`+ function isUnwrappedReturnTypeUndefinedVoidOrAny(func: SignatureDeclaration, returnType: Type): boolean {`
	`42183`	`+ const type = unwrapReturnType(returnType, getFunctionFlags(func));`
	`42184`	`+ return !!(type && (maybeTypeOfKind(type, TypeFlags.Void) \|\| type.flags & (TypeFlags.Any \| TypeFlags.Undefined)));`
`42188`	`42185`	`}`
`42189`	`42186`
`42190`	`42187`	`function checkReturnStatement(node: ReturnStatement) {`
`@@ -42232,7 +42229,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {`
`42232`	`42229`	`}`
`42233`	`42230`	`}`
`42234`	`42231`	`}`
`42235`		`- else if (container.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) {`
	`42232`	`+ else if (container.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeUndefinedVoidOrAny(container, returnType)) {`
`42236`	`42233`	`// The function has a return type, but the return statement doesn't have an expression.`
`42237`	`42234`	`error(node, Diagnostics.Not_all_code_paths_return_a_value);`
`42238`	`42235`	`}`