diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ba5765c0826a3..336b9b0ed6941 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6406,6 +6406,14 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } return !!annotationType && typeNodeIsEquivalentToType(node, type, annotationType) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type); }, + + isPossiblyReachable(expression) { + const ancestor = findAncestor(expression, canHaveFlowNode); + if (!ancestor) { + return true; + } + return !!ancestor.flowNode && isReachableFlowNode(ancestor.flowNode); + }, }; return { syntacticBuilderResolver, @@ -39217,6 +39225,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const nextTypes: Type[] = []; const isAsync = (getFunctionFlags(func) & FunctionFlags.Async) !== 0; forEachYieldExpression(func.body as Block, yieldExpression => { + const statement = findAncestor(yieldExpression, isStatement)!; + if (canHaveFlowNode(statement) && (!statement.flowNode || !isReachableFlowNode(statement.flowNode))) { + return; + } let yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType; if (yieldExpression.expression && isConstContext(yieldExpression.expression)) { yieldExpressionType = getRegularTypeOfLiteralType(yieldExpressionType); @@ -39336,6 +39348,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return; } + if (!returnStatement.flowNode || !isReachableFlowNode(returnStatement.flowNode)) { + return; + } + let type = checkExpressionCached(expr, checkMode && checkMode & ~CheckMode.SkipGenericFunctions); if (functionFlags & FunctionFlags.Async) { // From within an async function you can return either a non-promise value or a promise. Any @@ -42536,12 +42552,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { checkDecorators(node); checkSignatureDeclaration(node); - if (node.kind === SyntaxKind.GetAccessor) { - if (!(node.flags & NodeFlags.Ambient) && nodeIsPresent(node.body) && (node.flags & NodeFlags.HasImplicitReturn)) { - if (!(node.flags & NodeFlags.HasExplicitReturn)) { - error(node.name, Diagnostics.A_get_accessor_must_return_a_value); - } - } + if ( + node.kind === SyntaxKind.GetAccessor && !(node.flags & NodeFlags.Ambient) && nodeIsPresent(node.body) && + (node.flags & (NodeFlags.HasImplicitReturn | NodeFlags.HasExplicitReturn)) === NodeFlags.HasImplicitReturn && + (!node.type || !(getTypeFromTypeNode(node.type).flags & TypeFlags.Never)) + ) { + error(node.name, Diagnostics.A_get_accessor_must_return_a_value); } // Do not use hasDynamicName here, because that returns false for well known symbols. // We want to perform checkComputedPropertyName for all computed properties, including diff --git a/src/compiler/expressionToTypeNode.ts b/src/compiler/expressionToTypeNode.ts index 0df3a399b8f14..f6bdbc96843a0 100644 --- a/src/compiler/expressionToTypeNode.ts +++ b/src/compiler/expressionToTypeNode.ts @@ -1305,7 +1305,7 @@ export function createSyntacticTypeNodeBuilder( candidateExpr = body; } } - if (candidateExpr) { + if (candidateExpr && resolver.isPossiblyReachable(candidateExpr)) { if (isContextuallyTyped(candidateExpr)) { const type = isJSDocTypeAssertion(candidateExpr) ? getJSDocTypeAssertionType(candidateExpr) : isAsExpression(candidateExpr) || isTypeAssertionExpression(candidateExpr) ? candidateExpr.type : diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 617ec4d8bda75..1725a1044dda7 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -10638,6 +10638,7 @@ export interface SyntacticTypeNodeBuilderResolver { markError(): void; hadError(): boolean; }; + isPossiblyReachable(expression: Expression): boolean; } /** @internal */ diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 23f8d844c9856..20d8b076a1a19 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -3920,9 +3920,8 @@ export class ProjectService { // Create sourceFileLike if (!info.sourceFileLike) { info.sourceFileLike = { - get text() { - Debug.fail("shouldnt need text"); - return ""; + get text(): never { + return Debug.fail("shouldnt need text"); }, getLineAndCharacterOfPosition: pos => { const lineOffset = info.positionToLineOffset(pos); diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types index 38afacec4b0a8..4d240dca86062 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.types +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types @@ -15,8 +15,8 @@ interface IPromise { } function f() { ->f : () => IPromise -> : ^^^^^^^^^^^^^^^^^^^ +>f : () => IPromise +> : ^^^^^^^^^^^^^^^^^^^^ if (true) return b(); >true : true diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types index 5c81cf536b3b4..7f494489d7e11 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types @@ -84,8 +84,8 @@ var r4 = foo4(1); > : ^ function foo5(x) { ->foo5 : (x: any) => 1 | 2 -> : ^ ^^^^^^^^^^^^^^^ +>foo5 : (x: any) => number +> : ^ ^^^^^^^^^^^^^^^^ >x : any if (true) { @@ -105,10 +105,10 @@ function foo5(x) { var r5 = foo5(1); >r5 : number > : ^^^^^^ ->foo5(1) : 1 | 2 -> : ^^^^^ ->foo5 : (x: any) => 1 | 2 -> : ^ ^^^^^^^^^^^^^^^ +>foo5(1) : number +> : ^^^^^^ +>foo5 : (x: any) => number +> : ^ ^^^^^^^^^^^^^^^^ >1 : 1 > : ^ diff --git a/tests/baselines/reference/duplicateLocalVariable1.types b/tests/baselines/reference/duplicateLocalVariable1.types index 30c540696609c..f9d15bf844e0f 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.types +++ b/tests/baselines/reference/duplicateLocalVariable1.types @@ -377,7 +377,7 @@ export var tests: TestRunner = (function () { > : ^^^^^^^^^^^^^^^ >"Test for any error" : "Test for any error" > : ^^^^^^^^^^^^^^^^^^^^ ->function () { throw new Error(); return false; } : () => false +>function () { throw new Error(); return false; } : () => never > : ^^^^^^^^^^^ >new Error() : Error > : ^^^^^ @@ -403,7 +403,7 @@ export var tests: TestRunner = (function () { > : ^^^^^^^^^^^^^^^ >"Test RegEx error message match" : "Test RegEx error message match" > : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ->function () { throw new Error("Should also pass"); return false; } : () => false +>function () { throw new Error("Should also pass"); return false; } : () => never > : ^^^^^^^^^^^ >new Error("Should also pass") : Error > : ^^^^^ diff --git a/tests/baselines/reference/functionImplementationErrors.types b/tests/baselines/reference/functionImplementationErrors.types index 271ed68920ce6..a79142b84ff80 100644 --- a/tests/baselines/reference/functionImplementationErrors.types +++ b/tests/baselines/reference/functionImplementationErrors.types @@ -3,9 +3,9 @@ === functionImplementationErrors.ts === // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { ->f1 : () => "" | 3 +>f1 : () => string > : ^^^^^^^^^^^^ ->function () { return ''; return 3;} : () => "" | 3 +>function () { return ''; return 3;} : () => string > : ^^^^^^^^^^^^ return ''; @@ -18,11 +18,11 @@ var f1 = function () { }; var f2 = function x() { ->f2 : () => "" | 3 +>f2 : () => string > : ^^^^^^^^^^^^ ->function x() { return ''; return 3;} : () => "" | 3 +>function x() { return ''; return 3;} : () => string > : ^^^^^^^^^^^^ ->x : () => "" | 3 +>x : () => string > : ^^^^^^^^^^^^ return ''; @@ -35,9 +35,9 @@ var f2 = function x() { }; var f3 = () => { ->f3 : () => "" | 3 +>f3 : () => string > : ^^^^^^^^^^^^ ->() => { return ''; return 3;} : () => "" | 3 +>() => { return ''; return 3;} : () => string > : ^^^^^^^^^^^^ return ''; @@ -52,10 +52,10 @@ var f3 = () => { // FunctionExpression with no return type annotation with return branch of number[] and other of string[] var f4 = function () { ->f4 : () => string[] | number[] -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->function () { if (true) { return ['']; } else { return [1]; }} : () => string[] | number[] -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f4 : () => string[] +> : ^^^^^^^^^^^^^^ +>function () { if (true) { return ['']; } else { return [1]; }} : () => string[] +> : ^^^^^^^^^^^^^^ if (true) { >true : true @@ -165,8 +165,8 @@ class Derived2 extends Base { private n; } > : ^^^ function f8() { ->f8 : () => Derived1 | Derived2 -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f8 : () => Derived1 +> : ^^^^^^^^^^^^^^ return new Derived1(); >new Derived1() : Derived1 @@ -181,10 +181,10 @@ function f8() { > : ^^^^^^^^^^^^^^^ } var f9 = function () { ->f9 : () => Derived1 | Derived2 -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->function () { return new Derived1(); return new Derived2();} : () => Derived1 | Derived2 -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f9 : () => Derived1 +> : ^^^^^^^^^^^^^^ +>function () { return new Derived1(); return new Derived2();} : () => Derived1 +> : ^^^^^^^^^^^^^^ return new Derived1(); >new Derived1() : Derived1 @@ -200,10 +200,10 @@ var f9 = function () { }; var f10 = () => { ->f10 : () => Derived1 | Derived2 -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->() => { return new Derived1(); return new Derived2();} : () => Derived1 | Derived2 -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f10 : () => Derived1 +> : ^^^^^^^^^^^^^^ +>() => { return new Derived1(); return new Derived2();} : () => Derived1 +> : ^^^^^^^^^^^^^^ return new Derived1(); >new Derived1() : Derived1 @@ -219,8 +219,8 @@ var f10 = () => { }; function f11() { ->f11 : () => Base | AnotherClass -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f11 : () => Base +> : ^^^^^^^^^^ return new Base(); >new Base() : Base @@ -235,10 +235,10 @@ function f11() { > : ^^^^^^^^^^^^^^^^^^^ } var f12 = function () { ->f12 : () => Base | AnotherClass -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->function () { return new Base(); return new AnotherClass();} : () => Base | AnotherClass -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f12 : () => Base +> : ^^^^^^^^^^ +>function () { return new Base(); return new AnotherClass();} : () => Base +> : ^^^^^^^^^^ return new Base(); >new Base() : Base @@ -254,10 +254,10 @@ var f12 = function () { }; var f13 = () => { ->f13 : () => Base | AnotherClass -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ->() => { return new Base(); return new AnotherClass();} : () => Base | AnotherClass -> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>f13 : () => Base +> : ^^^^^^^^^^ +>() => { return new Base(); return new AnotherClass();} : () => Base +> : ^^^^^^^^^^ return new Base(); >new Base() : Base diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types index c07a8e17303ab..cfcf48bb70c11 100644 --- a/tests/baselines/reference/functionImplementations.types +++ b/tests/baselines/reference/functionImplementations.types @@ -233,10 +233,10 @@ var n = function (x: T) { var n = function () { >n : number > : ^^^^^^ ->function () { return 3; return 5;}() : 3 | 5 -> : ^^^^^ ->function () { return 3; return 5;} : () => 3 | 5 -> : ^^^^^^^^^^^ +>function () { return 3; return 5;}() : number +> : ^^^^^^ +>function () { return 3; return 5;} : () => number +> : ^^^^^^^^^^^^ return 3; >3 : 3 @@ -534,8 +534,8 @@ var f10: (x: number) => any = x => { // should be (x: number) => Derived | Deriv > : ^ ^^ ^^^^^ >x : number > : ^^^^^^ ->x => { // should be (x: number) => Derived | Derived1 return new Derived(); return new Derived2();} : (x: number) => Derived | Derived2 -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x => { // should be (x: number) => Derived | Derived1 return new Derived(); return new Derived2();} : (x: number) => Derived +> : ^ ^^^^^^^^^^^^^^^^^^^^ >x : number > : ^^^^^^ @@ -556,8 +556,8 @@ var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherC > : ^ ^^ ^^^^^ >x : number > : ^^^^^^ ->x => { // should be (x: number) => Base | AnotherClass return new Base(); return new AnotherClass();} : (x: number) => Base | AnotherClass -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x => { // should be (x: number) => Base | AnotherClass return new Base(); return new AnotherClass();} : (x: number) => Base +> : ^ ^^^^^^^^^^^^^^^^^ >x : number > : ^^^^^^ @@ -578,8 +578,8 @@ var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherC > : ^ ^^ ^^^^^ >x : number > : ^^^^^^ ->x => { // should be (x: number) => Base | AnotherClass return new Base(); return; // should be ignored return new AnotherClass();} : (x: number) => Base | AnotherClass -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>x => { // should be (x: number) => Base | AnotherClass return new Base(); return; // should be ignored return new AnotherClass();} : (x: number) => Base +> : ^ ^^^^^^^^^^^^^^^^^ >x : number > : ^^^^^^ diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.types b/tests/baselines/reference/functionWithMultipleReturnStatements.types index df2788141d906..24f37f6b74dd4 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.types @@ -5,7 +5,7 @@ // it is an error if there is no single BCT, these are error cases function f1() { ->f1 : () => 1 | "" +>f1 : () => number > : ^^^^^^^^^^^^ if (true) { @@ -24,8 +24,8 @@ function f1() { } function f2() { ->f2 : () => 1 | "" | 2 -> : ^^^^^^^^^^^^^^^^ +>f2 : () => number +> : ^^^^^^^^^^^^ if (true) { >true : true @@ -89,7 +89,7 @@ function f4() { } function f5() { ->f5 : () => 1 | "" +>f5 : () => number > : ^^^^^^^^^^^^ return 1; @@ -102,8 +102,8 @@ function f5() { } function f6(x: T, y:U) { ->f6 : (x: T, y: U) => T | U -> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^ +>f6 : (x: T, y: U) => T +> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^ >x : T > : ^ >y : U @@ -125,7 +125,7 @@ function f6(x: T, y:U) { } function f8(x: T, y: U) { ->f8 : (x: T, y: U) => U +>f8 : (x: T, y: U) => T > : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^ >x : T > : ^ diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.types b/tests/baselines/reference/functionWithMultipleReturnStatements2.types index a6c3495ae7a5d..df76414b454b4 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.types +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.types @@ -22,8 +22,8 @@ function f1() { } function f2() { ->f2 : () => 1 | 2 -> : ^^^^^^^^^^^ +>f2 : () => number +> : ^^^^^^^^^^^^ if (true) { >true : true @@ -69,8 +69,8 @@ function f4() { } function f5() { ->f5 : () => Object | 1 -> : ^^^^^^^^^^^^^^^^ +>f5 : () => number +> : ^^^^^^^^^^^^ return 1; >1 : 1 @@ -128,8 +128,8 @@ var b: { x: number; z?: number }; // returns typeof a function f9() { ->f9 : () => { x: number; y?: number; } | { x: number; z?: number; } -> : ^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^ ^^^^^^ ^^^ +>f9 : () => { x: number; y?: number; } +> : ^^^^^^^^^^^ ^^^^^^ ^^^ if (true) { >true : true @@ -148,8 +148,8 @@ function f9() { // returns typeof b function f10() { ->f10 : () => { x: number; y?: number; } | { x: number; z?: number; } -> : ^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^ ^^^^^^ ^^^ +>f10 : () => { x: number; z?: number; } +> : ^^^^^^^^^^^ ^^^^^^ ^^^ if (true) { >true : true @@ -168,8 +168,8 @@ function f10() { // returns number => void function f11() { ->f11 : () => ((x: number) => void) | ((x: Object) => void) -> : ^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^ +>f11 : () => (x: number) => void +> : ^^^^^^^ ^^ ^^^^^^^^^ if (true) { >true : true @@ -192,8 +192,8 @@ function f11() { // returns Object => void function f12() { ->f12 : () => ((x: Object) => void) | ((x: number) => void) -> : ^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^ +>f12 : () => (x: Object) => void +> : ^^^^^^^ ^^ ^^^^^^^^^ if (true) { >true : true diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.types b/tests/baselines/reference/functionWithNoBestCommonType1.types index eca6f4c1cece6..a125dacef35ed 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.types +++ b/tests/baselines/reference/functionWithNoBestCommonType1.types @@ -2,8 +2,8 @@ === functionWithNoBestCommonType1.ts === function foo() { ->foo : () => true | void -> : ^^^^^^^^^^^^^^^^^ +>foo : () => boolean +> : ^^^^^^^^^^^^^ return true; >true : true diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.types b/tests/baselines/reference/functionWithNoBestCommonType2.types index fca5cc68f2dfc..ec430216760b4 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.types +++ b/tests/baselines/reference/functionWithNoBestCommonType2.types @@ -2,10 +2,10 @@ === functionWithNoBestCommonType2.ts === var v = function () { ->v : () => true | void -> : ^^^^^^^^^^^^^^^^^ ->function () { return true; return bar();} : () => true | void -> : ^^^^^^^^^^^^^^^^^ +>v : () => boolean +> : ^^^^^^^^^^^^^ +>function () { return true; return bar();} : () => boolean +> : ^^^^^^^^^^^^^ return true; >true : true diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types index 4ac3c939797be..180e2ead4ef0c 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.types @@ -2,8 +2,8 @@ === inferredFunctionReturnTypeIsEmptyType.ts === function foo() { ->foo : () => 42 | "42" -> : ^^^^^^^^^^^^^^^ +>foo : () => number +> : ^^^^^^^^^^^^ if (true) { >true : true diff --git a/tests/baselines/reference/narrowingInCaseClauseAfterCaseClauseWithReturn.types b/tests/baselines/reference/narrowingInCaseClauseAfterCaseClauseWithReturn.types index bee05ff1bf3e1..e0422d6cc66fb 100644 --- a/tests/baselines/reference/narrowingInCaseClauseAfterCaseClauseWithReturn.types +++ b/tests/baselines/reference/narrowingInCaseClauseAfterCaseClauseWithReturn.types @@ -94,7 +94,7 @@ function test1(arg: string | undefined) { } function test2(arg: string | undefined) { ->test2 : (arg: string | undefined) => "Not A, B, C or D" | "D" | "A, B or C" +>test2 : (arg: string | undefined) => "D" | "Not A, B, C or D" | "A, B or C" > : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >arg : string | undefined > : ^^^^^^^^^^^^^^^^^^ diff --git a/tests/baselines/reference/null.types b/tests/baselines/reference/null.types index 8887c02ac6ed9..ed0570da68f2f 100644 --- a/tests/baselines/reference/null.types +++ b/tests/baselines/reference/null.types @@ -28,8 +28,8 @@ class C { > : ^ } function f() { ->f : () => C -> : ^^^^^^^ +>f : () => any +> : ^^^^^^^^^ return null; return new C(); @@ -39,8 +39,8 @@ function f() { > : ^^^^^^^^ } function g() { ->g : () => number -> : ^^^^^^^^^^^^ +>g : () => any +> : ^^^^^^^^^ return null; return 3; diff --git a/tests/baselines/reference/plainJSBinderErrors.types b/tests/baselines/reference/plainJSBinderErrors.types index eef0f6d68a9de..74df8994b8c50 100644 --- a/tests/baselines/reference/plainJSBinderErrors.types +++ b/tests/baselines/reference/plainJSBinderErrors.types @@ -117,8 +117,8 @@ class C { } } label() { ->label : () => number -> : ^^^^^^^^^^^^ +>label : () => void +> : ^^^^^^^^^^ for(;;) { label: var x = 1 diff --git a/tests/baselines/reference/recursiveNamedLambdaCall.types b/tests/baselines/reference/recursiveNamedLambdaCall.types index 9a7886bf70d59..500d761befb8c 100644 --- a/tests/baselines/reference/recursiveNamedLambdaCall.types +++ b/tests/baselines/reference/recursiveNamedLambdaCall.types @@ -22,14 +22,14 @@ var promise = function( obj ) { > : ^^^ (function doScrollCheck() { ->(function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } })() : any -> : ^^^ ->(function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } }) : () => any -> : ^^^^^^^^^ ->function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } } : () => any -> : ^^^^^^^^^ ->doScrollCheck : () => any -> : ^^^^^^^^^ +>(function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } })() : void +> : ^^^^ +>(function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } }) : () => void +> : ^^^^^^^^^^ +>function doScrollCheck() { if ( false ) { try { top.doScroll("left"); } catch(e) { return setTimeout( doScrollCheck, 50 ); } // detach all dom ready events detach(); } } : () => void +> : ^^^^^^^^^^ +>doScrollCheck : () => void +> : ^^^^^^^^^^ if ( false ) { >false : false @@ -57,8 +57,8 @@ var promise = function( obj ) { > : ^^^ >setTimeout : any > : ^^^ ->doScrollCheck : () => any -> : ^^^^^^^^^ +>doScrollCheck : () => void +> : ^^^^^^^^^^ >50 : 50 > : ^^ } diff --git a/tests/baselines/reference/unreachableGetterReturns1.errors.txt b/tests/baselines/reference/unreachableGetterReturns1.errors.txt new file mode 100644 index 0000000000000..35dfcba5b9416 --- /dev/null +++ b/tests/baselines/reference/unreachableGetterReturns1.errors.txt @@ -0,0 +1,59 @@ +unreachableGetterReturns1.ts(4,7): error TS2378: A 'get' accessor must return a value. +unreachableGetterReturns1.ts(27,7): error TS2322: Type 'void' is not assignable to type 'number'. +unreachableGetterReturns1.ts(27,7): error TS2378: A 'get' accessor must return a value. + + +==== unreachableGetterReturns1.ts (3 errors) ==== + declare function assert(cond: unknown): asserts cond; + + const obj1 = { + get prop() { + ~~~~ +!!! error TS2378: A 'get' accessor must return a value. + assert(false); + }, + }; + + const obj2 = { + get prop(): never { + assert(false); + }, + }; + + const obj3 = { + get prop() { + if (Math.random()) { + assert(false); + } + return 42; + }, + }; + + type Obj = { prop: number }; + + const obj4: Obj = { + get prop() { + ~~~~ +!!! error TS2322: Type 'void' is not assignable to type 'number'. +!!! related TS6500 unreachableGetterReturns1.ts:24:14: The expected type comes from property 'prop' which is declared here on type 'Obj' + ~~~~ +!!! error TS2378: A 'get' accessor must return a value. + assert(false); + }, + }; + + const obj5: Obj = { + get prop(): never { + assert(false); + }, + }; + + const obj6: Obj = { + get prop() { + if (Math.random()) { + assert(false); + } + return 42; + }, + }; + \ No newline at end of file diff --git a/tests/baselines/reference/unreachableGetterReturns1.symbols b/tests/baselines/reference/unreachableGetterReturns1.symbols new file mode 100644 index 0000000000000..667e0eab2c23f --- /dev/null +++ b/tests/baselines/reference/unreachableGetterReturns1.symbols @@ -0,0 +1,99 @@ +//// [tests/cases/compiler/unreachableGetterReturns1.ts] //// + +=== unreachableGetterReturns1.ts === +declare function assert(cond: unknown): asserts cond; +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) +>cond : Symbol(cond, Decl(unreachableGetterReturns1.ts, 0, 24)) +>cond : Symbol(cond, Decl(unreachableGetterReturns1.ts, 0, 24)) + +const obj1 = { +>obj1 : Symbol(obj1, Decl(unreachableGetterReturns1.ts, 2, 5)) + + get prop() { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 2, 14)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + + }, +}; + +const obj2 = { +>obj2 : Symbol(obj2, Decl(unreachableGetterReturns1.ts, 8, 5)) + + get prop(): never { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 8, 14)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + + }, +}; + +const obj3 = { +>obj3 : Symbol(obj3, Decl(unreachableGetterReturns1.ts, 14, 5)) + + get prop() { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 14, 14)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + } + return 42; + }, +}; + +type Obj = { prop: number }; +>Obj : Symbol(Obj, Decl(unreachableGetterReturns1.ts, 21, 2)) +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 23, 12)) + +const obj4: Obj = { +>obj4 : Symbol(obj4, Decl(unreachableGetterReturns1.ts, 25, 5)) +>Obj : Symbol(Obj, Decl(unreachableGetterReturns1.ts, 21, 2)) + + get prop() { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 25, 19)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + + }, +}; + +const obj5: Obj = { +>obj5 : Symbol(obj5, Decl(unreachableGetterReturns1.ts, 31, 5)) +>Obj : Symbol(Obj, Decl(unreachableGetterReturns1.ts, 21, 2)) + + get prop(): never { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 31, 19)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + + }, +}; + +const obj6: Obj = { +>obj6 : Symbol(obj6, Decl(unreachableGetterReturns1.ts, 37, 5)) +>Obj : Symbol(Obj, Decl(unreachableGetterReturns1.ts, 21, 2)) + + get prop() { +>prop : Symbol(prop, Decl(unreachableGetterReturns1.ts, 37, 19)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + assert(false); +>assert : Symbol(assert, Decl(unreachableGetterReturns1.ts, 0, 0)) + } + return 42; + }, +}; + diff --git a/tests/baselines/reference/unreachableGetterReturns1.types b/tests/baselines/reference/unreachableGetterReturns1.types new file mode 100644 index 0000000000000..9adcce1af1f04 --- /dev/null +++ b/tests/baselines/reference/unreachableGetterReturns1.types @@ -0,0 +1,169 @@ +//// [tests/cases/compiler/unreachableGetterReturns1.ts] //// + +=== unreachableGetterReturns1.ts === +declare function assert(cond: unknown): asserts cond; +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>cond : unknown +> : ^^^^^^^ + +const obj1 = { +>obj1 : { readonly prop: void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^ +>{ get prop() { assert(false); },} : { readonly prop: void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + + get prop() { +>prop : void +> : ^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + + }, +}; + +const obj2 = { +>obj2 : { readonly prop: never; } +> : ^^^^^^^^^^^^^^^^^ ^^^ +>{ get prop(): never { assert(false); },} : { readonly prop: never; } +> : ^^^^^^^^^^^^^^^^^ ^^^ + + get prop(): never { +>prop : never +> : ^^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + + }, +}; + +const obj3 = { +>obj3 : { readonly prop: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ get prop() { if (Math.random()) { assert(false); } return 42; },} : { readonly prop: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ + + get prop() { +>prop : number +> : ^^^^^^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + } + return 42; +>42 : 42 +> : ^^ + + }, +}; + +type Obj = { prop: number }; +>Obj : Obj +> : ^^^ +>prop : number +> : ^^^^^^ + +const obj4: Obj = { +>obj4 : Obj +> : ^^^ +>{ get prop() { assert(false); },} : { readonly prop: void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^ + + get prop() { +>prop : void +> : ^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + + }, +}; + +const obj5: Obj = { +>obj5 : Obj +> : ^^^ +>{ get prop(): never { assert(false); },} : { readonly prop: never; } +> : ^^^^^^^^^^^^^^^^^ ^^^ + + get prop(): never { +>prop : never +> : ^^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + + }, +}; + +const obj6: Obj = { +>obj6 : Obj +> : ^^^ +>{ get prop() { if (Math.random()) { assert(false); } return 42; },} : { readonly prop: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ + + get prop() { +>prop : number +> : ^^^^^^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + assert(false); +>assert(false) : void +> : ^^^^ +>assert : (cond: unknown) => asserts cond +> : ^ ^^ ^^^^^ +>false : false +> : ^^^^^ + } + return 42; +>42 : 42 +> : ^^ + + }, +}; + diff --git a/tests/baselines/reference/unreachableJavascriptChecked.types b/tests/baselines/reference/unreachableJavascriptChecked.types index a230632638e57..34c4e5f69d9e5 100644 --- a/tests/baselines/reference/unreachableJavascriptChecked.types +++ b/tests/baselines/reference/unreachableJavascriptChecked.types @@ -2,8 +2,8 @@ === unreachable.js === function unreachable() { ->unreachable : () => void | 2 | 3 | 4 -> : ^^^^^^^^^^^^^^^^^^^^^^ +>unreachable : () => void +> : ^^^^^^^^^^ return f(); >f() : void diff --git a/tests/baselines/reference/unreachableJavascriptUnchecked.types b/tests/baselines/reference/unreachableJavascriptUnchecked.types index d32d119deac75..153c9f14637c0 100644 --- a/tests/baselines/reference/unreachableJavascriptUnchecked.types +++ b/tests/baselines/reference/unreachableJavascriptUnchecked.types @@ -2,8 +2,8 @@ === unreachable.js === function unreachable() { ->unreachable : () => 1 | 2 -> : ^^^^^^^^^^^ +>unreachable : () => number +> : ^^^^^^^^^^^^ return 1; >1 : 1 diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).errors.txt b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).errors.txt new file mode 100644 index 0000000000000..aaa2ad3ee3651 --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).errors.txt @@ -0,0 +1,70 @@ +unreachableReturnStatementsVsInferredReturnTypes.ts(5,3): error TS7027: Unreachable code detected. +unreachableReturnStatementsVsInferredReturnTypes.ts(10,3): error TS7027: Unreachable code detected. +unreachableReturnStatementsVsInferredReturnTypes.ts(20,3): error TS7027: Unreachable code detected. +unreachableReturnStatementsVsInferredReturnTypes.ts(30,3): error TS7027: Unreachable code detected. +unreachableReturnStatementsVsInferredReturnTypes.ts(34,7): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +unreachableReturnStatementsVsInferredReturnTypes.ts(38,5): error TS7027: Unreachable code detected. +unreachableReturnStatementsVsInferredReturnTypes.ts(38,12): error TS7005: Variable 'x' implicitly has an 'any' type. + + +==== unreachableReturnStatementsVsInferredReturnTypes.ts (7 errors) ==== + export function g() { + let x; + x = 1; + return x; + return x; + ~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function h() { + return 1; + let y; + ~~~~~~ + y = 1; + ~~~~~~~~ + return y; + ~~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function i() { + let x: string | number | boolean; + x = 1; + return x; + + x = "foo"; + ~~~~~~~~~~ + return x; + ~~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + function throws(): never { + throw new Error(); + } + + export function foo() { + throws(); + return 42; + ~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function bar() { + var x; + ~ +!!! error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. + x = 1; + if (Math.random()) { + throws(); + return x; + ~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + ~ +!!! error TS7005: Variable 'x' implicitly has an 'any' type. + } + x = 2; + return x; + } + \ No newline at end of file diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).js b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).js new file mode 100644 index 0000000000000..8d24a07692d5f --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).js @@ -0,0 +1,99 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +//// [unreachableReturnStatementsVsInferredReturnTypes.ts] +export function g() { + let x; + x = 1; + return x; + return x; +} + +export function h() { + return 1; + let y; + y = 1; + return y; +} + +export function i() { + let x: string | number | boolean; + x = 1; + return x; + + x = "foo"; + return x; +} + +function throws(): never { + throw new Error(); +} + +export function foo() { + throws(); + return 42; +} + +export function bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + return x; + } + x = 2; + return x; +} + + +//// [unreachableReturnStatementsVsInferredReturnTypes.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.g = g; +exports.h = h; +exports.i = i; +exports.foo = foo; +exports.bar = bar; +function g() { + var x; + x = 1; + return x; + return x; +} +function h() { + return 1; + var y; + y = 1; + return y; +} +function i() { + var x; + x = 1; + return x; + x = "foo"; + return x; +} +function throws() { + throw new Error(); +} +function foo() { + throws(); + return 42; +} +function bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + return x; + } + x = 2; + return x; +} + + +//// [unreachableReturnStatementsVsInferredReturnTypes.d.ts] +export declare function g(): number; +export declare function h(): number; +export declare function i(): number; +export declare function foo(): void; +export declare function bar(): number; diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).symbols b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).symbols new file mode 100644 index 0000000000000..dfcf144a267cc --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).symbols @@ -0,0 +1,95 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +=== unreachableReturnStatementsVsInferredReturnTypes.ts === +export function g() { +>g : Symbol(g, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 0, 0)) + + let x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) +} + +export function h() { +>h : Symbol(h, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 5, 1)) + + return 1; + let y; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) + + return y; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) +} + +export function i() { +>i : Symbol(i, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 12, 1)) + + let x: string | number | boolean; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + x = "foo"; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) +} + +function throws(): never { +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} + +export function foo() { +>foo : Symbol(foo, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 25, 1)) + + throws(); +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + return 42; +} + +export function bar() { +>bar : Symbol(bar, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 30, 1)) + + var x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + throws(); +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + } + x = 2; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) +} + diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).types b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).types new file mode 100644 index 0000000000000..22374e6b57e93 --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=false).types @@ -0,0 +1,161 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +=== unreachableReturnStatementsVsInferredReturnTypes.ts === +export function g() { +>g : () => number +> : ^^^^^^^^^^^^ + + let x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + return x; +>x : number +> : ^^^^^^ + + return x; +>x : any +> : ^^^ +} + +export function h() { +>h : () => number +> : ^^^^^^^^^^^^ + + return 1; +>1 : 1 +> : ^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + return y; +>y : any +> : ^^^ +} + +export function i() { +>i : () => number +> : ^^^^^^^^^^^^ + + let x: string | number | boolean; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + return x; +>x : number +> : ^^^^^^ + + x = "foo"; +>x = "foo" : "foo" +> : ^^^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>"foo" : "foo" +> : ^^^^^ + + return x; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function throws(): never { +>throws : () => never +> : ^^^^^^ + + throw new Error(); +>new Error() : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +} + +export function foo() { +>foo : () => void +> : ^^^^^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + return 42; +>42 : 42 +> : ^^ +} + +export function bar() { +>bar : () => number +> : ^^^^^^^^^^^^ + + var x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + return x; +>x : any +> : ^^^ + } + x = 2; +>x = 2 : 2 +> : ^ +>x : any +> : ^^^ +>2 : 2 +> : ^ + + return x; +>x : number +> : ^^^^^^ +} + diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).errors.txt b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).errors.txt new file mode 100644 index 0000000000000..2528f611d115c --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).errors.txt @@ -0,0 +1,52 @@ +unreachableReturnStatementsVsInferredReturnTypes.ts(34,7): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +unreachableReturnStatementsVsInferredReturnTypes.ts(38,12): error TS7005: Variable 'x' implicitly has an 'any' type. + + +==== unreachableReturnStatementsVsInferredReturnTypes.ts (2 errors) ==== + export function g() { + let x; + x = 1; + return x; + return x; + } + + export function h() { + return 1; + let y; + y = 1; + return y; + } + + export function i() { + let x: string | number | boolean; + x = 1; + return x; + + x = "foo"; + return x; + } + + function throws(): never { + throw new Error(); + } + + export function foo() { + throws(); + return 42; + } + + export function bar() { + var x; + ~ +!!! error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. + x = 1; + if (Math.random()) { + throws(); + return x; + ~ +!!! error TS7005: Variable 'x' implicitly has an 'any' type. + } + x = 2; + return x; + } + \ No newline at end of file diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).js b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).js new file mode 100644 index 0000000000000..8d24a07692d5f --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).js @@ -0,0 +1,99 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +//// [unreachableReturnStatementsVsInferredReturnTypes.ts] +export function g() { + let x; + x = 1; + return x; + return x; +} + +export function h() { + return 1; + let y; + y = 1; + return y; +} + +export function i() { + let x: string | number | boolean; + x = 1; + return x; + + x = "foo"; + return x; +} + +function throws(): never { + throw new Error(); +} + +export function foo() { + throws(); + return 42; +} + +export function bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + return x; + } + x = 2; + return x; +} + + +//// [unreachableReturnStatementsVsInferredReturnTypes.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.g = g; +exports.h = h; +exports.i = i; +exports.foo = foo; +exports.bar = bar; +function g() { + var x; + x = 1; + return x; + return x; +} +function h() { + return 1; + var y; + y = 1; + return y; +} +function i() { + var x; + x = 1; + return x; + x = "foo"; + return x; +} +function throws() { + throw new Error(); +} +function foo() { + throws(); + return 42; +} +function bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + return x; + } + x = 2; + return x; +} + + +//// [unreachableReturnStatementsVsInferredReturnTypes.d.ts] +export declare function g(): number; +export declare function h(): number; +export declare function i(): number; +export declare function foo(): void; +export declare function bar(): number; diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).symbols b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).symbols new file mode 100644 index 0000000000000..dfcf144a267cc --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).symbols @@ -0,0 +1,95 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +=== unreachableReturnStatementsVsInferredReturnTypes.ts === +export function g() { +>g : Symbol(g, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 0, 0)) + + let x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 1, 5)) +} + +export function h() { +>h : Symbol(h, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 5, 1)) + + return 1; + let y; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) + + return y; +>y : Symbol(y, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 9, 5)) +} + +export function i() { +>i : Symbol(i, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 12, 1)) + + let x: string | number | boolean; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + x = "foo"; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 15, 5)) +} + +function throws(): never { +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) +} + +export function foo() { +>foo : Symbol(foo, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 25, 1)) + + throws(); +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + return 42; +} + +export function bar() { +>bar : Symbol(bar, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 30, 1)) + + var x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + throws(); +>throws : Symbol(throws, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 21, 1)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + } + x = 2; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) + + return x; +>x : Symbol(x, Decl(unreachableReturnStatementsVsInferredReturnTypes.ts, 33, 5)) +} + diff --git a/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).types b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).types new file mode 100644 index 0000000000000..22374e6b57e93 --- /dev/null +++ b/tests/baselines/reference/unreachableReturnStatementsVsInferredReturnTypes(allowunreachablecode=true).types @@ -0,0 +1,161 @@ +//// [tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts] //// + +=== unreachableReturnStatementsVsInferredReturnTypes.ts === +export function g() { +>g : () => number +> : ^^^^^^^^^^^^ + + let x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + return x; +>x : number +> : ^^^^^^ + + return x; +>x : any +> : ^^^ +} + +export function h() { +>h : () => number +> : ^^^^^^^^^^^^ + + return 1; +>1 : 1 +> : ^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + return y; +>y : any +> : ^^^ +} + +export function i() { +>i : () => number +> : ^^^^^^^^^^^^ + + let x: string | number | boolean; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + return x; +>x : number +> : ^^^^^^ + + x = "foo"; +>x = "foo" : "foo" +> : ^^^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>"foo" : "foo" +> : ^^^^^ + + return x; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function throws(): never { +>throws : () => never +> : ^^^^^^ + + throw new Error(); +>new Error() : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +} + +export function foo() { +>foo : () => void +> : ^^^^^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + return 42; +>42 : 42 +> : ^^ +} + +export function bar() { +>bar : () => number +> : ^^^^^^^^^^^^ + + var x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + return x; +>x : any +> : ^^^ + } + x = 2; +>x = 2 : 2 +> : ^ +>x : any +> : ^^^ +>2 : 2 +> : ^ + + return x; +>x : number +> : ^^^^^^ +} + diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).errors.txt b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).errors.txt new file mode 100644 index 0000000000000..b49285b11ff56 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).errors.txt @@ -0,0 +1,84 @@ +unreachableYieldExpressionsVsInferredYieldTypes.ts(6,3): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(11,3): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(19,3): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(30,3): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(40,3): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(44,7): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +unreachableYieldExpressionsVsInferredYieldTypes.ts(48,5): error TS7027: Unreachable code detected. +unreachableYieldExpressionsVsInferredYieldTypes.ts(48,11): error TS7005: Variable 'x' implicitly has an 'any' type. + + +==== unreachableYieldExpressionsVsInferredYieldTypes.ts (8 errors) ==== + export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; + ~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function* h() { + return 'foo'; + let y; + ~~~~~~ + y = 1; + ~~~~~~~~ + yield y; + ~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function* i() { + yield true; + return 'foo'; + let y; + ~~~~~~ + y = 1; + ~~~~~~~~ + yield y; + ~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function* j() { + let x: string | number | boolean; + x = 1; + yield x; + return true; + + x = "foo"; + ~~~~~~~~~~ + yield x; + ~~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + function throws(): never { + throw new Error(); + } + + export function* foo() { + throws(); + yield 42; + ~~~~~~~~~ +!!! error TS7027: Unreachable code detected. + } + + export function* bar() { + var x; + ~ +!!! error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. + x = 1; + if (Math.random()) { + throws(); + yield x; + ~~~~~~~~ +!!! error TS7027: Unreachable code detected. + ~ +!!! error TS7005: Variable 'x' implicitly has an 'any' type. + } + x = 2; + yield x; + } \ No newline at end of file diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).js b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).js new file mode 100644 index 0000000000000..ac709f04e975b --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +//// [unreachableYieldExpressionsVsInferredYieldTypes.ts] +export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; +} + +export function* h() { + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* j() { + let x: string | number | boolean; + x = 1; + yield x; + return true; + + x = "foo"; + yield x; +} + +function throws(): never { + throw new Error(); +} + +export function* foo() { + throws(); + yield 42; +} + +export function* bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + yield x; + } + x = 2; + yield x; +} + +//// [unreachableYieldExpressionsVsInferredYieldTypes.js] +export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; +} +export function* h() { + return 'foo'; + let y; + y = 1; + yield y; +} +export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; +} +export function* j() { + let x; + x = 1; + yield x; + return true; + x = "foo"; + yield x; +} +function throws() { + throw new Error(); +} +export function* foo() { + throws(); + yield 42; +} +export function* bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + yield x; + } + x = 2; + yield x; +} + + +//// [unreachableYieldExpressionsVsInferredYieldTypes.d.ts] +export declare function g(): Generator; +export declare function h(): Generator; +export declare function i(): Generator; +export declare function j(): Generator; +export declare function foo(): Generator; +export declare function bar(): Generator; diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).symbols b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).symbols new file mode 100644 index 0000000000000..6e3974de20717 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).symbols @@ -0,0 +1,112 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +=== unreachableYieldExpressionsVsInferredYieldTypes.ts === +export function* g() { +>g : Symbol(g, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 0, 0)) + + let x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + return 'foo'; + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) +} + +export function* h() { +>h : Symbol(h, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 6, 1)) + + return 'foo'; + let y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) + + yield y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) +} + +export function* i() { +>i : Symbol(i, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 13, 1)) + + yield true; + return 'foo'; + let y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) + + yield y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) +} + +export function* j() { +>j : Symbol(j, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 21, 1)) + + let x: string | number | boolean; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + return true; + + x = "foo"; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) +} + +function throws(): never { +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) +} + +export function* foo() { +>foo : Symbol(foo, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 35, 1)) + + throws(); +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + yield 42; +} + +export function* bar() { +>bar : Symbol(bar, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 40, 1)) + + var x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.float16.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + throws(); +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + } + x = 2; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) +} diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).types b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).types new file mode 100644 index 0000000000000..531e3eb3e47a3 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=false).types @@ -0,0 +1,217 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +=== unreachableYieldExpressionsVsInferredYieldTypes.ts === +export function* g() { +>g : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : any +> : ^^^ +} + +export function* h() { +>h : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + yield y; +>yield y : any +> : ^^^ +>y : any +> : ^^^ +} + +export function* i() { +>i : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + yield true; +>yield true : any +> : ^^^ +>true : true +> : ^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + yield y; +>yield y : any +> : ^^^ +>y : any +> : ^^^ +} + +export function* j() { +>j : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let x: string | number | boolean; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ + + return true; +>true : true +> : ^^^^ + + x = "foo"; +>x = "foo" : "foo" +> : ^^^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>"foo" : "foo" +> : ^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function throws(): never { +>throws : () => never +> : ^^^^^^ + + throw new Error(); +>new Error() : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +} + +export function* foo() { +>foo : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + yield 42; +>yield 42 : any +> : ^^^ +>42 : 42 +> : ^^ +} + +export function* bar() { +>bar : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + var x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : any +> : ^^^ + } + x = 2; +>x = 2 : 2 +> : ^ +>x : any +> : ^^^ +>2 : 2 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ +} diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).errors.txt b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).errors.txt new file mode 100644 index 0000000000000..396dc10f12174 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).errors.txt @@ -0,0 +1,61 @@ +unreachableYieldExpressionsVsInferredYieldTypes.ts(44,7): error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. +unreachableYieldExpressionsVsInferredYieldTypes.ts(48,11): error TS7005: Variable 'x' implicitly has an 'any' type. + + +==== unreachableYieldExpressionsVsInferredYieldTypes.ts (2 errors) ==== + export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; + } + + export function* h() { + return 'foo'; + let y; + y = 1; + yield y; + } + + export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; + } + + export function* j() { + let x: string | number | boolean; + x = 1; + yield x; + return true; + + x = "foo"; + yield x; + } + + function throws(): never { + throw new Error(); + } + + export function* foo() { + throws(); + yield 42; + } + + export function* bar() { + var x; + ~ +!!! error TS7034: Variable 'x' implicitly has type 'any' in some locations where its type cannot be determined. + x = 1; + if (Math.random()) { + throws(); + yield x; + ~ +!!! error TS7005: Variable 'x' implicitly has an 'any' type. + } + x = 2; + yield x; + } \ No newline at end of file diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).js b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).js new file mode 100644 index 0000000000000..ac709f04e975b --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).js @@ -0,0 +1,111 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +//// [unreachableYieldExpressionsVsInferredYieldTypes.ts] +export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; +} + +export function* h() { + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* j() { + let x: string | number | boolean; + x = 1; + yield x; + return true; + + x = "foo"; + yield x; +} + +function throws(): never { + throw new Error(); +} + +export function* foo() { + throws(); + yield 42; +} + +export function* bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + yield x; + } + x = 2; + yield x; +} + +//// [unreachableYieldExpressionsVsInferredYieldTypes.js] +export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; +} +export function* h() { + return 'foo'; + let y; + y = 1; + yield y; +} +export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; +} +export function* j() { + let x; + x = 1; + yield x; + return true; + x = "foo"; + yield x; +} +function throws() { + throw new Error(); +} +export function* foo() { + throws(); + yield 42; +} +export function* bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + yield x; + } + x = 2; + yield x; +} + + +//// [unreachableYieldExpressionsVsInferredYieldTypes.d.ts] +export declare function g(): Generator; +export declare function h(): Generator; +export declare function i(): Generator; +export declare function j(): Generator; +export declare function foo(): Generator; +export declare function bar(): Generator; diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).symbols b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).symbols new file mode 100644 index 0000000000000..6e3974de20717 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).symbols @@ -0,0 +1,112 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +=== unreachableYieldExpressionsVsInferredYieldTypes.ts === +export function* g() { +>g : Symbol(g, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 0, 0)) + + let x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) + + return 'foo'; + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 1, 5)) +} + +export function* h() { +>h : Symbol(h, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 6, 1)) + + return 'foo'; + let y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) + + yield y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 10, 5)) +} + +export function* i() { +>i : Symbol(i, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 13, 1)) + + yield true; + return 'foo'; + let y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) + + y = 1; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) + + yield y; +>y : Symbol(y, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 18, 5)) +} + +export function* j() { +>j : Symbol(j, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 21, 1)) + + let x: string | number | boolean; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + return true; + + x = "foo"; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 24, 5)) +} + +function throws(): never { +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2022.error.d.ts, --, --)) +} + +export function* foo() { +>foo : Symbol(foo, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 35, 1)) + + throws(); +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + yield 42; +} + +export function* bar() { +>bar : Symbol(bar, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 40, 1)) + + var x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + x = 1; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + if (Math.random()) { +>Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.esnext.float16.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --)) + + throws(); +>throws : Symbol(throws, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 31, 1)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + } + x = 2; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) + + yield x; +>x : Symbol(x, Decl(unreachableYieldExpressionsVsInferredYieldTypes.ts, 43, 5)) +} diff --git a/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).types b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).types new file mode 100644 index 0000000000000..531e3eb3e47a3 --- /dev/null +++ b/tests/baselines/reference/unreachableYieldExpressionsVsInferredYieldTypes(allowunreachablecode=true).types @@ -0,0 +1,217 @@ +//// [tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts] //// + +=== unreachableYieldExpressionsVsInferredYieldTypes.ts === +export function* g() { +>g : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : any +> : ^^^ +} + +export function* h() { +>h : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + yield y; +>yield y : any +> : ^^^ +>y : any +> : ^^^ +} + +export function* i() { +>i : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + yield true; +>yield true : any +> : ^^^ +>true : true +> : ^^^^ + + return 'foo'; +>'foo' : "foo" +> : ^^^^^ + + let y; +>y : any +> : ^^^ + + y = 1; +>y = 1 : 1 +> : ^ +>y : any +> : ^^^ +>1 : 1 +> : ^ + + yield y; +>yield y : any +> : ^^^ +>y : any +> : ^^^ +} + +export function* j() { +>j : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + let x: string | number | boolean; +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>1 : 1 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ + + return true; +>true : true +> : ^^^^ + + x = "foo"; +>x = "foo" : "foo" +> : ^^^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>"foo" : "foo" +> : ^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : string | number | boolean +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +function throws(): never { +>throws : () => never +> : ^^^^^^ + + throw new Error(); +>new Error() : Error +> : ^^^^^ +>Error : ErrorConstructor +> : ^^^^^^^^^^^^^^^^ +} + +export function* foo() { +>foo : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + yield 42; +>yield 42 : any +> : ^^^ +>42 : 42 +> : ^^ +} + +export function* bar() { +>bar : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + var x; +>x : any +> : ^^^ + + x = 1; +>x = 1 : 1 +> : ^ +>x : any +> : ^^^ +>1 : 1 +> : ^ + + if (Math.random()) { +>Math.random() : number +> : ^^^^^^ +>Math.random : () => number +> : ^^^^^^ +>Math : Math +> : ^^^^ +>random : () => number +> : ^^^^^^ + + throws(); +>throws() : never +> : ^^^^^ +>throws : () => never +> : ^^^^^^ + + yield x; +>yield x : any +> : ^^^ +>x : any +> : ^^^ + } + x = 2; +>x = 2 : 2 +> : ^ +>x : any +> : ^^^ +>2 : 2 +> : ^ + + yield x; +>yield x : any +> : ^^^ +>x : number +> : ^^^^^^ +} diff --git a/tests/cases/compiler/unreachableGetterReturns1.ts b/tests/cases/compiler/unreachableGetterReturns1.ts new file mode 100644 index 0000000000000..ca7a67fb323ec --- /dev/null +++ b/tests/cases/compiler/unreachableGetterReturns1.ts @@ -0,0 +1,48 @@ +// @strict: true +// @noEmit: true + +declare function assert(cond: unknown): asserts cond; + +const obj1 = { + get prop() { + assert(false); + }, +}; + +const obj2 = { + get prop(): never { + assert(false); + }, +}; + +const obj3 = { + get prop() { + if (Math.random()) { + assert(false); + } + return 42; + }, +}; + +type Obj = { prop: number }; + +const obj4: Obj = { + get prop() { + assert(false); + }, +}; + +const obj5: Obj = { + get prop(): never { + assert(false); + }, +}; + +const obj6: Obj = { + get prop() { + if (Math.random()) { + assert(false); + } + return 42; + }, +}; diff --git a/tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts b/tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts new file mode 100644 index 0000000000000..c818532bbb6c6 --- /dev/null +++ b/tests/cases/compiler/unreachableReturnStatementsVsInferredReturnTypes.ts @@ -0,0 +1,46 @@ +// @strict: true +// @allowUnreachableCode: true, false +// @declaration: true + +export function g() { + let x; + x = 1; + return x; + return x; +} + +export function h() { + return 1; + let y; + y = 1; + return y; +} + +export function i() { + let x: string | number | boolean; + x = 1; + return x; + + x = "foo"; + return x; +} + +function throws(): never { + throw new Error(); +} + +export function foo() { + throws(); + return 42; +} + +export function bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + return x; + } + x = 2; + return x; +} diff --git a/tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts b/tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts new file mode 100644 index 0000000000000..af500c54b8ed3 --- /dev/null +++ b/tests/cases/compiler/unreachableYieldExpressionsVsInferredYieldTypes.ts @@ -0,0 +1,58 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @allowUnreachableCode: true, false +// @declaration: true + +export function* g() { + let x; + x = 1; + yield x; + return 'foo'; + yield x; +} + +export function* h() { + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* i() { + yield true; + return 'foo'; + let y; + y = 1; + yield y; +} + +export function* j() { + let x: string | number | boolean; + x = 1; + yield x; + return true; + + x = "foo"; + yield x; +} + +function throws(): never { + throw new Error(); +} + +export function* foo() { + throws(); + yield 42; +} + +export function* bar() { + var x; + x = 1; + if (Math.random()) { + throws(); + yield x; + } + x = 2; + yield x; +} \ No newline at end of file