diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index f133d503c6f4f..c1118e5bdf3ef 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -10219,6 +10219,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // Use type from type annotation if one is present const declaredType = tryGetTypeFromEffectiveTypeNode(declaration); + if (!declaredType && isCatchClauseVariableDeclarationOrBindingElement(declaration)) { + // If the catch clause is not explicitly annotated, treat it as though it were explicitly + // annotated with unknown or any, depending on useUnknownInCatchVariables. + return useUnknownInCatchVariables ? unknownType : anyType; + } if (declaredType) { return addOptionality(declaredType, isProperty, isOptional); } @@ -10877,18 +10882,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { members.set("exports" as __String, result); return createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray); } - // Handle catch clause variables Debug.assertIsDefined(symbol.valueDeclaration); const declaration = symbol.valueDeclaration; - if (isCatchClauseVariableDeclarationOrBindingElement(declaration)) { - const typeNode = getEffectiveTypeAnnotationNode(declaration); - if (typeNode === undefined) { - return useUnknownInCatchVariables ? unknownType : anyType; - } - const type = getTypeOfNode(typeNode); - // an errorType will make `checkTryStatement` issue an error - return isTypeAny(type) || type === unknownType ? type : errorType; - } // Handle export default expressions if (isSourceFile(declaration) && isJsonSourceFile(declaration)) { if (!declaration.statements.length) { @@ -27079,6 +27074,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { isFunctionLike(node) && !getImmediatelyInvokedFunctionExpression(node) || node.kind === SyntaxKind.ModuleBlock || node.kind === SyntaxKind.SourceFile || + node.kind === SyntaxKind.CatchClause || node.kind === SyntaxKind.PropertyDeclaration)!; } @@ -27451,6 +27447,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const isParameter = getRootDeclaration(declaration).kind === SyntaxKind.Parameter; const declarationContainer = getControlFlowContainer(declaration); let flowContainer = getControlFlowContainer(node); + const isCatch = flowContainer.kind === SyntaxKind.CatchClause; const isOuterVariable = flowContainer !== declarationContainer; const isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent); const isModuleExports = symbol.flags & SymbolFlags.ModuleExports; @@ -27465,7 +27462,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // We only look for uninitialized variables in strict null checking mode, and only when we can analyze // the entire control flow graph from the variable's declaration (i.e. when the flow container and // declaration container are the same). - const assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || + const assumeInitialized = isParameter || isCatch || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (TypeFlags.AnyOrUnknown | TypeFlags.Void)) !== 0 || isInTypeQuery(node) || isInAmbientOrTypeNode(node) || node.parent.kind === SyntaxKind.ExportSpecifier) || node.parent.kind === SyntaxKind.NonNullExpression || @@ -41230,14 +41227,8 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // Grammar checking if (catchClause.variableDeclaration) { const declaration = catchClause.variableDeclaration; - const typeNode = getEffectiveTypeAnnotationNode(getRootDeclaration(declaration)); - if (typeNode) { - const type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false, CheckMode.Normal); - if (type && !(type.flags & TypeFlags.AnyOrUnknown)) { - grammarErrorOnFirstToken(typeNode, Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified); - } - } - else if (declaration.initializer) { + checkVariableLikeDeclaration(declaration); + if (declaration.initializer) { grammarErrorOnFirstToken(declaration.initializer, Diagnostics.Catch_clause_variable_cannot_have_an_initializer); } else { diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index f10f21178d994..d472ff5bef98b 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -607,10 +607,6 @@ "category": "Error", "code": 1195 }, - "Catch clause variable type annotation must be 'any' or 'unknown' if specified.": { - "category": "Error", - "code": 1196 - }, "Catch clause variable cannot have an initializer.": { "category": "Error", "code": 1197 diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.errors.txt b/tests/baselines/reference/catchClauseWithTypeAnnotation.errors.txt index 870a7cf87080a..936b5134d35b6 100644 --- a/tests/baselines/reference/catchClauseWithTypeAnnotation.errors.txt +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.errors.txt @@ -1,14 +1,15 @@ tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(17,36): error TS2339: Property 'foo' does not exist on type 'unknown'. tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(18,37): error TS2339: Property 'foo' does not exist on type 'unknown'. -tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(19,23): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. -tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(20,23): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. +tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(25,23): error TS2339: Property 'toLowerCase' does not exist on type 'number'. tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(29,29): error TS2492: Cannot redeclare identifier 'x' in catch clause. tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(30,29): error TS2403: Subsequent variable declarations must have the same type. Variable 'x' must be of type 'boolean', but here has type 'string'. -tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(38,27): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. -tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(39,27): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. +tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(36,22): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(37,22): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(38,22): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts(39,22): error TS2339: Property 'x' does not exist on type 'Error'. -==== tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts (8 errors) ==== +==== tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts (9 errors) ==== type any1 = any; type unknown1 = unknown; @@ -32,16 +33,14 @@ tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.t ~~~ !!! error TS2339: Property 'foo' does not exist on type 'unknown'. try { } catch (x: Error) { } // error in the type - ~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. try { } catch (x: object) { } // error in the type - ~~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. try { console.log(); } // @ts-ignore catch (e: number) { // e should not be a `number` console.log(e.toLowerCase()); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toLowerCase' does not exist on type 'number'. } // minor bug: shows that the `catch` argument is skipped when checking scope @@ -57,13 +56,17 @@ tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.t try { } catch ({ x }) { } // should be OK try { } catch ({ x }: any) { x.foo; } // should be OK try { } catch ({ x }: any1) { x.foo;} // should be OK - try { } catch ({ x }: unknown) { console.log(x); } // should be OK - try { } catch ({ x }: unknown1) { console.log(x); } // should be OK + try { } catch ({ x }: unknown) { console.log(x); } // error in the destructure + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + try { } catch ({ x }: unknown1) { console.log(x); } // error in the destructure + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. try { } catch ({ x }: object) { } // error in the type - ~~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. try { } catch ({ x }: Error) { } // error in the type - ~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. + ~ +!!! error TS2339: Property 'x' does not exist on type 'Error'. } \ No newline at end of file diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.js b/tests/baselines/reference/catchClauseWithTypeAnnotation.js index 0337d65b43713..06de0b2667287 100644 --- a/tests/baselines/reference/catchClauseWithTypeAnnotation.js +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.js @@ -34,8 +34,8 @@ function fn(x: boolean) { try { } catch ({ x }) { } // should be OK try { } catch ({ x }: any) { x.foo; } // should be OK try { } catch ({ x }: any1) { x.foo;} // should be OK - try { } catch ({ x }: unknown) { console.log(x); } // should be OK - try { } catch ({ x }: unknown1) { console.log(x); } // should be OK + try { } catch ({ x }: unknown) { console.log(x); } // error in the destructure + try { } catch ({ x }: unknown1) { console.log(x); } // error in the destructure try { } catch ({ x }: object) { } // error in the type try { } catch ({ x }: Error) { } // error in the type } @@ -124,12 +124,12 @@ function fn(x) { catch (_d) { var x_5 = _d.x; console.log(x_5); - } // should be OK + } // error in the destructure try { } catch (_e) { var x_6 = _e.x; console.log(x_6); - } // should be OK + } // error in the destructure try { } catch (_f) { var x_7 = _f.x; diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols b/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols index 08eaec37b70e9..062d98db83d8b 100644 --- a/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.symbols @@ -112,14 +112,14 @@ function fn(x: boolean) { >any1 : Symbol(any1, Decl(catchClauseWithTypeAnnotation.ts, 0, 0)) >x : Symbol(x, Decl(catchClauseWithTypeAnnotation.ts, 34, 20)) - try { } catch ({ x }: unknown) { console.log(x); } // should be OK + try { } catch ({ x }: unknown) { console.log(x); } // error in the destructure >x : Symbol(x, Decl(catchClauseWithTypeAnnotation.ts, 35, 20)) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >console : Symbol(console, Decl(lib.dom.d.ts, --, --)) >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >x : Symbol(x, Decl(catchClauseWithTypeAnnotation.ts, 35, 20)) - try { } catch ({ x }: unknown1) { console.log(x); } // should be OK + try { } catch ({ x }: unknown1) { console.log(x); } // error in the destructure >x : Symbol(x, Decl(catchClauseWithTypeAnnotation.ts, 36, 20)) >unknown1 : Symbol(unknown1, Decl(catchClauseWithTypeAnnotation.ts, 0, 16)) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) diff --git a/tests/baselines/reference/catchClauseWithTypeAnnotation.types b/tests/baselines/reference/catchClauseWithTypeAnnotation.types index d0de759bbbd79..97f320292c027 100644 --- a/tests/baselines/reference/catchClauseWithTypeAnnotation.types +++ b/tests/baselines/reference/catchClauseWithTypeAnnotation.types @@ -72,10 +72,10 @@ function fn(x: boolean) { >foo : any try { } catch (x: Error) { } // error in the type ->x : any +>x : Error try { } catch (x: object) { } // error in the type ->x : any +>x : object try { console.log(); } >console.log() : void @@ -85,7 +85,7 @@ function fn(x: boolean) { // @ts-ignore catch (e: number) { // e should not be a `number` ->e : any +>e : number console.log(e.toLowerCase()); >console.log(e.toLowerCase()) : void @@ -94,7 +94,7 @@ function fn(x: boolean) { >log : (...data: any[]) => void >e.toLowerCase() : any >e.toLowerCase : any ->e : any +>e : number >toLowerCase : any } @@ -126,7 +126,7 @@ function fn(x: boolean) { >x : any >foo : any - try { } catch ({ x }: unknown) { console.log(x); } // should be OK + try { } catch ({ x }: unknown) { console.log(x); } // error in the destructure >x : any >console.log(x) : void >console.log : (...data: any[]) => void @@ -134,7 +134,7 @@ function fn(x: boolean) { >log : (...data: any[]) => void >x : any - try { } catch ({ x }: unknown1) { console.log(x); } // should be OK + try { } catch ({ x }: unknown1) { console.log(x); } // error in the destructure >x : any >console.log(x) : void >console.log : (...data: any[]) => void diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).errors.txt b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).errors.txt new file mode 100644 index 0000000000000..d12b90899b81a --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).errors.txt @@ -0,0 +1,60 @@ +tests/cases/compiler/destructureCatchClause.ts(26,17): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(27,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(29,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(30,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(32,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(33,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(35,17): error TS2339: Property 'a' does not exist on type '{}'. + + +==== tests/cases/compiler/destructureCatchClause.ts (7 errors) ==== + // These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. + try {} catch ({ x }) { x } + try {} catch ([ x ]) { x } + + try {} catch ({ a: { x } }) { x } + try {} catch ({ a: [ x ] }) { x } + + try {} catch ([{ x }]) { x } + try {} catch ([[ x ]]) { x } + + try {} catch ({ a: { b: { c: { x }} }}) { x } + + + try {} catch ({ x }: any) { x } + try {} catch ([ x ]: any) { x } + + try {} catch ({ a: { x } }: any) { x } + try {} catch ({ a: [ x ] }: any) { x } + + try {} catch ([{ x }]: any) { x } + try {} catch ([[ x ]]: any) { x } + + try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + + try {} catch ({ x }: unknown) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + try {} catch ([ x ]: unknown) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + try {} catch ({ a: [ x ] }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + + try {} catch ([{ x }]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + \ No newline at end of file diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).js b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).js new file mode 100644 index 0000000000000..3ed7d276575d4 --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).js @@ -0,0 +1,145 @@ +//// [destructureCatchClause.ts] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +try {} catch ([ x ]) { x } + +try {} catch ({ a: { x } }) { x } +try {} catch ({ a: [ x ] }) { x } + +try {} catch ([{ x }]) { x } +try {} catch ([[ x ]]) { x } + +try {} catch ({ a: { b: { c: { x }} }}) { x } + + +try {} catch ({ x }: any) { x } +try {} catch ([ x ]: any) { x } + +try {} catch ({ a: { x } }: any) { x } +try {} catch ({ a: [ x ] }: any) { x } + +try {} catch ([{ x }]: any) { x } +try {} catch ([[ x ]]: any) { x } + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + +try {} catch ({ x }: unknown) { x } +try {} catch ([ x ]: unknown) { x } + +try {} catch ({ a: { x } }: unknown) { x } +try {} catch ({ a: [ x ] }: unknown) { x } + +try {} catch ([{ x }]: unknown) { x } +try {} catch ([[ x ]]: unknown) { x } + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + + +//// [destructureCatchClause.js] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try { } +catch (_a) { + var x = _a.x; + x; +} +try { } +catch (_b) { + var x = _b[0]; + x; +} +try { } +catch (_c) { + var x = _c.a.x; + x; +} +try { } +catch (_d) { + var x = _d.a[0]; + x; +} +try { } +catch (_e) { + var x = _e[0].x; + x; +} +try { } +catch (_f) { + var x = _f[0][0]; + x; +} +try { } +catch (_g) { + var x = _g.a.b.c.x; + x; +} +try { } +catch (_h) { + var x = _h.x; + x; +} +try { } +catch (_j) { + var x = _j[0]; + x; +} +try { } +catch (_k) { + var x = _k.a.x; + x; +} +try { } +catch (_l) { + var x = _l.a[0]; + x; +} +try { } +catch (_m) { + var x = _m[0].x; + x; +} +try { } +catch (_o) { + var x = _o[0][0]; + x; +} +try { } +catch (_p) { + var x = _p.a.b.c.x; + x; +} +try { } +catch (_q) { + var x = _q.x; + x; +} +try { } +catch (_r) { + var x = _r[0]; + x; +} +try { } +catch (_s) { + var x = _s.a.x; + x; +} +try { } +catch (_t) { + var x = _t.a[0]; + x; +} +try { } +catch (_u) { + var x = _u[0].x; + x; +} +try { } +catch (_v) { + var x = _v[0][0]; + x; +} +try { } +catch (_w) { + var x = _w.a.b.c.x; + x; +} diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).symbols b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).symbols new file mode 100644 index 0000000000000..2960cf2258d0a --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).symbols @@ -0,0 +1,88 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) + +try {} catch ([ x ]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) + +try {} catch ({ a: { x } }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) + +try {} catch ({ a: [ x ] }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) + +try {} catch ([{ x }]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) + +try {} catch ([[ x ]]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) + + +try {} catch ({ x }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) + +try {} catch ([ x ]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) + +try {} catch ({ a: { x } }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) + +try {} catch ({ a: [ x ] }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) + +try {} catch ([{ x }]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) + +try {} catch ([[ x ]]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) + + +try {} catch ({ x }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) + +try {} catch ([ x ]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) + +try {} catch ({ a: { x } }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) + +try {} catch ({ a: [ x ] }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) + +try {} catch ([{ x }]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) + +try {} catch ([[ x ]]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) + diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).types b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).types new file mode 100644 index 0000000000000..4dd4691a22d4b --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=false).types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : any +>x : any + +try {} catch ([ x ]) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]) { x } +>x : any +>x : any + +try {} catch ([[ x ]]) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: any) { x } +>x : any +>x : any + +try {} catch ([ x ]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: any) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: unknown) { x } +>x : any +>x : any + +try {} catch ([ x ]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: unknown) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).errors.txt b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).errors.txt new file mode 100644 index 0000000000000..ba5cff5148ec4 --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).errors.txt @@ -0,0 +1,81 @@ +tests/cases/compiler/destructureCatchClause.ts(2,17): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(3,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(5,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(6,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(8,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(9,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(11,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(26,17): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(27,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(29,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(30,17): error TS2339: Property 'a' does not exist on type '{}'. +tests/cases/compiler/destructureCatchClause.ts(32,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(33,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(35,17): error TS2339: Property 'a' does not exist on type '{}'. + + +==== tests/cases/compiler/destructureCatchClause.ts (14 errors) ==== + // These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. + try {} catch ({ x }) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + try {} catch ([ x ]) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + try {} catch ({ a: [ x ] }) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + + try {} catch ([{ x }]) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + + + try {} catch ({ x }: any) { x } + try {} catch ([ x ]: any) { x } + + try {} catch ({ a: { x } }: any) { x } + try {} catch ({ a: [ x ] }: any) { x } + + try {} catch ([{ x }]: any) { x } + try {} catch ([[ x ]]: any) { x } + + try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + + try {} catch ({ x }: unknown) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + try {} catch ([ x ]: unknown) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + try {} catch ({ a: [ x ] }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + + try {} catch ([{ x }]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type '{}'. + \ No newline at end of file diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).js b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).js new file mode 100644 index 0000000000000..3ed7d276575d4 --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).js @@ -0,0 +1,145 @@ +//// [destructureCatchClause.ts] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +try {} catch ([ x ]) { x } + +try {} catch ({ a: { x } }) { x } +try {} catch ({ a: [ x ] }) { x } + +try {} catch ([{ x }]) { x } +try {} catch ([[ x ]]) { x } + +try {} catch ({ a: { b: { c: { x }} }}) { x } + + +try {} catch ({ x }: any) { x } +try {} catch ([ x ]: any) { x } + +try {} catch ({ a: { x } }: any) { x } +try {} catch ({ a: [ x ] }: any) { x } + +try {} catch ([{ x }]: any) { x } +try {} catch ([[ x ]]: any) { x } + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + +try {} catch ({ x }: unknown) { x } +try {} catch ([ x ]: unknown) { x } + +try {} catch ({ a: { x } }: unknown) { x } +try {} catch ({ a: [ x ] }: unknown) { x } + +try {} catch ([{ x }]: unknown) { x } +try {} catch ([[ x ]]: unknown) { x } + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + + +//// [destructureCatchClause.js] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try { } +catch (_a) { + var x = _a.x; + x; +} +try { } +catch (_b) { + var x = _b[0]; + x; +} +try { } +catch (_c) { + var x = _c.a.x; + x; +} +try { } +catch (_d) { + var x = _d.a[0]; + x; +} +try { } +catch (_e) { + var x = _e[0].x; + x; +} +try { } +catch (_f) { + var x = _f[0][0]; + x; +} +try { } +catch (_g) { + var x = _g.a.b.c.x; + x; +} +try { } +catch (_h) { + var x = _h.x; + x; +} +try { } +catch (_j) { + var x = _j[0]; + x; +} +try { } +catch (_k) { + var x = _k.a.x; + x; +} +try { } +catch (_l) { + var x = _l.a[0]; + x; +} +try { } +catch (_m) { + var x = _m[0].x; + x; +} +try { } +catch (_o) { + var x = _o[0][0]; + x; +} +try { } +catch (_p) { + var x = _p.a.b.c.x; + x; +} +try { } +catch (_q) { + var x = _q.x; + x; +} +try { } +catch (_r) { + var x = _r[0]; + x; +} +try { } +catch (_s) { + var x = _s.a.x; + x; +} +try { } +catch (_t) { + var x = _t.a[0]; + x; +} +try { } +catch (_u) { + var x = _u[0].x; + x; +} +try { } +catch (_v) { + var x = _v[0][0]; + x; +} +try { } +catch (_w) { + var x = _w.a.b.c.x; + x; +} diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).symbols b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).symbols new file mode 100644 index 0000000000000..2960cf2258d0a --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).symbols @@ -0,0 +1,88 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) + +try {} catch ([ x ]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) + +try {} catch ({ a: { x } }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) + +try {} catch ({ a: [ x ] }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) + +try {} catch ([{ x }]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) + +try {} catch ([[ x ]]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) + + +try {} catch ({ x }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) + +try {} catch ([ x ]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) + +try {} catch ({ a: { x } }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) + +try {} catch ({ a: [ x ] }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) + +try {} catch ([{ x }]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) + +try {} catch ([[ x ]]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) + + +try {} catch ({ x }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) + +try {} catch ([ x ]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) + +try {} catch ({ a: { x } }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) + +try {} catch ({ a: [ x ] }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) + +try {} catch ([{ x }]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) + +try {} catch ([[ x ]]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) + diff --git a/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).types b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).types new file mode 100644 index 0000000000000..4dd4691a22d4b --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=false,useunknownincatchvariables=true).types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : any +>x : any + +try {} catch ([ x ]) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]) { x } +>x : any +>x : any + +try {} catch ([[ x ]]) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: any) { x } +>x : any +>x : any + +try {} catch ([ x ]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: any) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: unknown) { x } +>x : any +>x : any + +try {} catch ([ x ]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: unknown) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).errors.txt b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).errors.txt new file mode 100644 index 0000000000000..4abdc153ef7f3 --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).errors.txt @@ -0,0 +1,60 @@ +tests/cases/compiler/destructureCatchClause.ts(26,17): error TS2339: Property 'x' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(27,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(29,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(30,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(32,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(33,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(35,17): error TS2339: Property 'a' does not exist on type 'unknown'. + + +==== tests/cases/compiler/destructureCatchClause.ts (7 errors) ==== + // These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. + try {} catch ({ x }) { x } + try {} catch ([ x ]) { x } + + try {} catch ({ a: { x } }) { x } + try {} catch ({ a: [ x ] }) { x } + + try {} catch ([{ x }]) { x } + try {} catch ([[ x ]]) { x } + + try {} catch ({ a: { b: { c: { x }} }}) { x } + + + try {} catch ({ x }: any) { x } + try {} catch ([ x ]: any) { x } + + try {} catch ({ a: { x } }: any) { x } + try {} catch ({ a: [ x ] }: any) { x } + + try {} catch ([{ x }]: any) { x } + try {} catch ([[ x ]]: any) { x } + + try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + + try {} catch ({ x }: unknown) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type 'unknown'. + try {} catch ([ x ]: unknown) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + try {} catch ({ a: [ x ] }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + + try {} catch ([{ x }]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + \ No newline at end of file diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).js b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).js new file mode 100644 index 0000000000000..3bc5c8c19a1ed --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).js @@ -0,0 +1,146 @@ +//// [destructureCatchClause.ts] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +try {} catch ([ x ]) { x } + +try {} catch ({ a: { x } }) { x } +try {} catch ({ a: [ x ] }) { x } + +try {} catch ([{ x }]) { x } +try {} catch ([[ x ]]) { x } + +try {} catch ({ a: { b: { c: { x }} }}) { x } + + +try {} catch ({ x }: any) { x } +try {} catch ([ x ]: any) { x } + +try {} catch ({ a: { x } }: any) { x } +try {} catch ({ a: [ x ] }: any) { x } + +try {} catch ([{ x }]: any) { x } +try {} catch ([[ x ]]: any) { x } + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + +try {} catch ({ x }: unknown) { x } +try {} catch ([ x ]: unknown) { x } + +try {} catch ({ a: { x } }: unknown) { x } +try {} catch ({ a: [ x ] }: unknown) { x } + +try {} catch ([{ x }]: unknown) { x } +try {} catch ([[ x ]]: unknown) { x } + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + + +//// [destructureCatchClause.js] +"use strict"; +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try { } +catch (_a) { + var x = _a.x; + x; +} +try { } +catch (_b) { + var x = _b[0]; + x; +} +try { } +catch (_c) { + var x = _c.a.x; + x; +} +try { } +catch (_d) { + var x = _d.a[0]; + x; +} +try { } +catch (_e) { + var x = _e[0].x; + x; +} +try { } +catch (_f) { + var x = _f[0][0]; + x; +} +try { } +catch (_g) { + var x = _g.a.b.c.x; + x; +} +try { } +catch (_h) { + var x = _h.x; + x; +} +try { } +catch (_j) { + var x = _j[0]; + x; +} +try { } +catch (_k) { + var x = _k.a.x; + x; +} +try { } +catch (_l) { + var x = _l.a[0]; + x; +} +try { } +catch (_m) { + var x = _m[0].x; + x; +} +try { } +catch (_o) { + var x = _o[0][0]; + x; +} +try { } +catch (_p) { + var x = _p.a.b.c.x; + x; +} +try { } +catch (_q) { + var x = _q.x; + x; +} +try { } +catch (_r) { + var x = _r[0]; + x; +} +try { } +catch (_s) { + var x = _s.a.x; + x; +} +try { } +catch (_t) { + var x = _t.a[0]; + x; +} +try { } +catch (_u) { + var x = _u[0].x; + x; +} +try { } +catch (_v) { + var x = _v[0][0]; + x; +} +try { } +catch (_w) { + var x = _w.a.b.c.x; + x; +} diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).symbols b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).symbols new file mode 100644 index 0000000000000..2960cf2258d0a --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).symbols @@ -0,0 +1,88 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) + +try {} catch ([ x ]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) + +try {} catch ({ a: { x } }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) + +try {} catch ({ a: [ x ] }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) + +try {} catch ([{ x }]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) + +try {} catch ([[ x ]]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) + + +try {} catch ({ x }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) + +try {} catch ([ x ]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) + +try {} catch ({ a: { x } }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) + +try {} catch ({ a: [ x ] }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) + +try {} catch ([{ x }]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) + +try {} catch ([[ x ]]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) + + +try {} catch ({ x }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) + +try {} catch ([ x ]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) + +try {} catch ({ a: { x } }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) + +try {} catch ({ a: [ x ] }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) + +try {} catch ([{ x }]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) + +try {} catch ([[ x ]]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) + diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).types b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).types new file mode 100644 index 0000000000000..4dd4691a22d4b --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=false).types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : any +>x : any + +try {} catch ([ x ]) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]) { x } +>x : any +>x : any + +try {} catch ([[ x ]]) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: any) { x } +>x : any +>x : any + +try {} catch ([ x ]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: any) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: unknown) { x } +>x : any +>x : any + +try {} catch ([ x ]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: unknown) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).errors.txt b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).errors.txt new file mode 100644 index 0000000000000..e4bde57c99f32 --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).errors.txt @@ -0,0 +1,81 @@ +tests/cases/compiler/destructureCatchClause.ts(2,17): error TS2339: Property 'x' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(3,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(5,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(6,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(8,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(9,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(11,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(26,17): error TS2339: Property 'x' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(27,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(29,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(30,17): error TS2339: Property 'a' does not exist on type 'unknown'. +tests/cases/compiler/destructureCatchClause.ts(32,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(33,15): error TS2461: Type 'unknown' is not an array type. +tests/cases/compiler/destructureCatchClause.ts(35,17): error TS2339: Property 'a' does not exist on type 'unknown'. + + +==== tests/cases/compiler/destructureCatchClause.ts (14 errors) ==== + // These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. + try {} catch ({ x }) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type 'unknown'. + try {} catch ([ x ]) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + try {} catch ({ a: [ x ] }) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + + try {} catch ([{ x }]) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + + + try {} catch ({ x }: any) { x } + try {} catch ([ x ]: any) { x } + + try {} catch ({ a: { x } }: any) { x } + try {} catch ({ a: [ x ] }: any) { x } + + try {} catch ([{ x }]: any) { x } + try {} catch ([[ x ]]: any) { x } + + try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + + try {} catch ({ x }: unknown) { x } + ~ +!!! error TS2339: Property 'x' does not exist on type 'unknown'. + try {} catch ([ x ]: unknown) { x } + ~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { x } }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + try {} catch ({ a: [ x ] }: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + + try {} catch ([{ x }]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + try {} catch ([[ x ]]: unknown) { x } + ~~~~~~~ +!!! error TS2461: Type 'unknown' is not an array type. + + try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + ~ +!!! error TS2339: Property 'a' does not exist on type 'unknown'. + \ No newline at end of file diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).js b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).js new file mode 100644 index 0000000000000..3bc5c8c19a1ed --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).js @@ -0,0 +1,146 @@ +//// [destructureCatchClause.ts] +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +try {} catch ([ x ]) { x } + +try {} catch ({ a: { x } }) { x } +try {} catch ({ a: [ x ] }) { x } + +try {} catch ([{ x }]) { x } +try {} catch ([[ x ]]) { x } + +try {} catch ({ a: { b: { c: { x }} }}) { x } + + +try {} catch ({ x }: any) { x } +try {} catch ([ x ]: any) { x } + +try {} catch ({ a: { x } }: any) { x } +try {} catch ({ a: [ x ] }: any) { x } + +try {} catch ([{ x }]: any) { x } +try {} catch ([[ x ]]: any) { x } + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + +try {} catch ({ x }: unknown) { x } +try {} catch ([ x ]: unknown) { x } + +try {} catch ({ a: { x } }: unknown) { x } +try {} catch ({ a: [ x ] }: unknown) { x } + +try {} catch ([{ x }]: unknown) { x } +try {} catch ([[ x ]]: unknown) { x } + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } + + +//// [destructureCatchClause.js] +"use strict"; +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try { } +catch (_a) { + var x = _a.x; + x; +} +try { } +catch (_b) { + var x = _b[0]; + x; +} +try { } +catch (_c) { + var x = _c.a.x; + x; +} +try { } +catch (_d) { + var x = _d.a[0]; + x; +} +try { } +catch (_e) { + var x = _e[0].x; + x; +} +try { } +catch (_f) { + var x = _f[0][0]; + x; +} +try { } +catch (_g) { + var x = _g.a.b.c.x; + x; +} +try { } +catch (_h) { + var x = _h.x; + x; +} +try { } +catch (_j) { + var x = _j[0]; + x; +} +try { } +catch (_k) { + var x = _k.a.x; + x; +} +try { } +catch (_l) { + var x = _l.a[0]; + x; +} +try { } +catch (_m) { + var x = _m[0].x; + x; +} +try { } +catch (_o) { + var x = _o[0][0]; + x; +} +try { } +catch (_p) { + var x = _p.a.b.c.x; + x; +} +try { } +catch (_q) { + var x = _q.x; + x; +} +try { } +catch (_r) { + var x = _r[0]; + x; +} +try { } +catch (_s) { + var x = _s.a.x; + x; +} +try { } +catch (_t) { + var x = _t.a[0]; + x; +} +try { } +catch (_u) { + var x = _u[0].x; + x; +} +try { } +catch (_v) { + var x = _v[0][0]; + x; +} +try { } +catch (_w) { + var x = _w.a.b.c.x; + x; +} diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).symbols b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).symbols new file mode 100644 index 0000000000000..2960cf2258d0a --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).symbols @@ -0,0 +1,88 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 1, 15)) + +try {} catch ([ x ]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 2, 15)) + +try {} catch ({ a: { x } }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 4, 20)) + +try {} catch ({ a: [ x ] }) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 5, 20)) + +try {} catch ([{ x }]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 7, 16)) + +try {} catch ([[ x ]]) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 8, 16)) + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 10, 30)) + + +try {} catch ({ x }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 13, 15)) + +try {} catch ([ x ]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 14, 15)) + +try {} catch ({ a: { x } }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 16, 20)) + +try {} catch ({ a: [ x ] }: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 17, 20)) + +try {} catch ([{ x }]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 19, 16)) + +try {} catch ([[ x ]]: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 20, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 22, 30)) + + +try {} catch ({ x }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 25, 15)) + +try {} catch ([ x ]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 26, 15)) + +try {} catch ({ a: { x } }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 28, 20)) + +try {} catch ({ a: [ x ] }: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 29, 20)) + +try {} catch ([{ x }]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 31, 16)) + +try {} catch ([[ x ]]: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 32, 16)) + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) +>x : Symbol(x, Decl(destructureCatchClause.ts, 34, 30)) + diff --git a/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).types b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).types new file mode 100644 index 0000000000000..4dd4691a22d4b --- /dev/null +++ b/tests/baselines/reference/destructureCatchClause(strict=true,useunknownincatchvariables=true).types @@ -0,0 +1,103 @@ +=== tests/cases/compiler/destructureCatchClause.ts === +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +>x : any +>x : any + +try {} catch ([ x ]) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]) { x } +>x : any +>x : any + +try {} catch ([[ x ]]) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: any) { x } +>x : any +>x : any + +try {} catch ([ x ]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: any) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: any) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: any) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + + +try {} catch ({ x }: unknown) { x } +>x : any +>x : any + +try {} catch ([ x ]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { x } }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ({ a: [ x ] }: unknown) { x } +>a : any +>x : any +>x : any + +try {} catch ([{ x }]: unknown) { x } +>x : any +>x : any + +try {} catch ([[ x ]]: unknown) { x } +>x : any +>x : any + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } +>a : any +>b : any +>c : any +>x : any +>x : any + diff --git a/tests/baselines/reference/destructuringCatch.symbols b/tests/baselines/reference/destructuringCatch.symbols index a78beb8d776de..d11e899fa67a6 100644 --- a/tests/baselines/reference/destructuringCatch.symbols +++ b/tests/baselines/reference/destructuringCatch.symbols @@ -31,7 +31,6 @@ try { >z : Symbol(z, Decl(destructuringCatch.ts, 15, 20)) } catch ([{x: [y], z}]) { ->x : Symbol(x) >y : Symbol(y, Decl(destructuringCatch.ts, 17, 13)) >z : Symbol(z, Decl(destructuringCatch.ts, 17, 16)) diff --git a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.errors.txt b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.errors.txt index ee77d6e3decb9..432599f734d4d 100644 --- a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.errors.txt +++ b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.errors.txt @@ -1,13 +1,14 @@ tests/cases/conformance/jsdoc/foo.js(20,54): error TS2339: Property 'foo' does not exist on type 'unknown'. tests/cases/conformance/jsdoc/foo.js(21,54): error TS2339: Property 'foo' does not exist on type 'unknown'. -tests/cases/conformance/jsdoc/foo.js(22,31): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. -tests/cases/conformance/jsdoc/foo.js(23,31): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. +tests/cases/conformance/jsdoc/foo.js(28,25): error TS2339: Property 'toLowerCase' does not exist on type 'number'. tests/cases/conformance/jsdoc/foo.js(35,7): error TS2492: Cannot redeclare identifier 'err' in catch clause. -tests/cases/conformance/jsdoc/foo.js(48,31): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. -tests/cases/conformance/jsdoc/foo.js(49,31): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. +tests/cases/conformance/jsdoc/foo.js(46,45): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/conformance/jsdoc/foo.js(47,45): error TS2339: Property 'x' does not exist on type '{}'. +tests/cases/conformance/jsdoc/foo.js(48,43): error TS2339: Property 'x' does not exist on type 'Error'. +tests/cases/conformance/jsdoc/foo.js(49,44): error TS2339: Property 'x' does not exist on type '{}'. -==== tests/cases/conformance/jsdoc/foo.js (7 errors) ==== +==== tests/cases/conformance/jsdoc/foo.js (8 errors) ==== /** * @typedef {any} Any */ @@ -34,16 +35,14 @@ tests/cases/conformance/jsdoc/foo.js(49,31): error TS1196: Catch clause variable ~~~ !!! error TS2339: Property 'foo' does not exist on type 'unknown'. try { } catch (/** @type {Error} */ err) { } // error in the type - ~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. try { } catch (/** @type {object} */ err) { } // error in the type - ~~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. try { console.log(); } // @ts-ignore catch (/** @type {number} */ err) { // e should not be a `number` console.log(err.toLowerCase()); + ~~~~~~~~~~~ +!!! error TS2339: Property 'toLowerCase' does not exist on type 'number'. } // minor bug: shows that the `catch` argument is skipped when checking scope @@ -63,13 +62,17 @@ tests/cases/conformance/jsdoc/foo.js(49,31): error TS1196: Catch clause variable try { } catch ({ x }) { } // should be OK try { } catch (/** @type {any} */ { x }) { x.foo; } // should be OK try { } catch (/** @type {Any} */ { x }) { x.foo;} // should be OK - try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // should be OK - try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // error in the destructure + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. + try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // error in the destructure + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. try { } catch (/** @type {Error} */ { x }) { } // error in the type - ~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. + ~ +!!! error TS2339: Property 'x' does not exist on type 'Error'. try { } catch (/** @type {object} */ { x }) { } // error in the type - ~~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. + ~ +!!! error TS2339: Property 'x' does not exist on type '{}'. } \ No newline at end of file diff --git a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.js b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.js index ce948d9011690..a40d78cc084d0 100644 --- a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.js +++ b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.js @@ -44,8 +44,8 @@ function fn() { try { } catch ({ x }) { } // should be OK try { } catch (/** @type {any} */ { x }) { x.foo; } // should be OK try { } catch (/** @type {Any} */ { x }) { x.foo;} // should be OK - try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // should be OK - try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // error in the destructure + try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // error in the destructure try { } catch (/** @type {Error} */ { x }) { } // error in the type try { } catch (/** @type {object} */ { x }) { } // error in the type } @@ -132,11 +132,11 @@ function fn() { try { } catch ( /** @type {unknown} */{ x }) { console.log(x); - } // should be OK + } // error in the destructure try { } catch ( /** @type {Unknown} */{ x }) { console.log(x); - } // should be OK + } // error in the destructure try { } catch ( /** @type {Error} */{ x }) { } // error in the type try { } diff --git a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.symbols b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.symbols index 5b722006126c2..f6758e368eb11 100644 --- a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.symbols +++ b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.symbols @@ -110,14 +110,14 @@ function fn() { >x : Symbol(x, Decl(foo.js, 44, 39)) >x : Symbol(x, Decl(foo.js, 44, 39)) - try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // error in the destructure >x : Symbol(x, Decl(foo.js, 45, 43)) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >console : Symbol(console, Decl(lib.dom.d.ts, --, --)) >log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >x : Symbol(x, Decl(foo.js, 45, 43)) - try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // error in the destructure >x : Symbol(x, Decl(foo.js, 46, 43)) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) >console : Symbol(console, Decl(lib.dom.d.ts, --, --)) diff --git a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.types b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.types index f79e074df4cc2..9501346e8cb2e 100644 --- a/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.types +++ b/tests/baselines/reference/jsdocCatchClauseWithTypeAnnotation.types @@ -72,10 +72,10 @@ function fn() { >foo : any try { } catch (/** @type {Error} */ err) { } // error in the type ->err : any +>err : Error try { } catch (/** @type {object} */ err) { } // error in the type ->err : any +>err : object try { console.log(); } >console.log() : void @@ -85,7 +85,7 @@ function fn() { // @ts-ignore catch (/** @type {number} */ err) { // e should not be a `number` ->err : any +>err : number console.log(err.toLowerCase()); >console.log(err.toLowerCase()) : void @@ -94,7 +94,7 @@ function fn() { >log : (...data: any[]) => void >err.toLowerCase() : any >err.toLowerCase : any ->err : any +>err : number >toLowerCase : any } @@ -131,7 +131,7 @@ function fn() { >x : any >foo : any - try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // error in the destructure >x : any >console.log(x) : void >console.log : (...data: any[]) => void @@ -139,7 +139,7 @@ function fn() { >log : (...data: any[]) => void >x : any - try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // error in the destructure >x : any >console.log(x) : void >console.log : (...data: any[]) => void diff --git a/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.errors.txt b/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.errors.txt deleted file mode 100644 index f16fb86f50be6..0000000000000 --- a/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.errors.txt +++ /dev/null @@ -1,10 +0,0 @@ -tests/cases/conformance/parser/ecmascript5/CatchClauses/parserCatchClauseWithTypeAnnotation1.ts(2,13): error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. - - -==== tests/cases/conformance/parser/ecmascript5/CatchClauses/parserCatchClauseWithTypeAnnotation1.ts (1 errors) ==== - try { - } catch (e: Error) { - ~~~~~ -!!! error TS1196: Catch clause variable type annotation must be 'any' or 'unknown' if specified. - } - \ No newline at end of file diff --git a/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.types b/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.types index 1c6e61257e13d..87d186921fe92 100644 --- a/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.types +++ b/tests/baselines/reference/parserCatchClauseWithTypeAnnotation1.types @@ -1,6 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/CatchClauses/parserCatchClauseWithTypeAnnotation1.ts === try { } catch (e: Error) { ->e : any +>e : Error } diff --git a/tests/baselines/reference/redeclareParameterInCatchBlock.symbols b/tests/baselines/reference/redeclareParameterInCatchBlock.symbols index 8885cf240e5b0..2ac579f8b990d 100644 --- a/tests/baselines/reference/redeclareParameterInCatchBlock.symbols +++ b/tests/baselines/reference/redeclareParameterInCatchBlock.symbols @@ -31,9 +31,7 @@ try { try { } catch ({ a: x, b: x }) { ->a : Symbol(a) >x : Symbol(x, Decl(redeclareParameterInCatchBlock.ts, 20, 10)) ->b : Symbol(b) >x : Symbol(x, Decl(redeclareParameterInCatchBlock.ts, 20, 16)) } diff --git a/tests/baselines/reference/tsserver/plugins/getSupportedCodeFixes-can-be-proxied.js b/tests/baselines/reference/tsserver/plugins/getSupportedCodeFixes-can-be-proxied.js index 855976efc5b99..47c4131d460be 100644 --- a/tests/baselines/reference/tsserver/plugins/getSupportedCodeFixes-can-be-proxied.js +++ b/tests/baselines/reference/tsserver/plugins/getSupportedCodeFixes-can-be-proxied.js @@ -553,7 +553,6 @@ Info 32 [00:01:13.000] response: "1193", "1194", "1195", - "1196", "1197", "1198", "1199", @@ -1888,7 +1887,6 @@ Info 38 [00:01:19.000] response: "1193", "1194", "1195", - "1196", "1197", "1198", "1199", @@ -3135,7 +3133,6 @@ Info 40 [00:01:21.000] response: "1193", "1194", "1195", - "1196", "1197", "1198", "1199", diff --git a/tests/cases/compiler/destructureCatchClause.ts b/tests/cases/compiler/destructureCatchClause.ts new file mode 100644 index 0000000000000..4a8a18d12e69c --- /dev/null +++ b/tests/cases/compiler/destructureCatchClause.ts @@ -0,0 +1,38 @@ +// @strict: true, false +// @useUnknownInCatchVariables: true, false + +// These are okay with useUnknownInCatchVariables=false, but not okay with useUnknownInCatchVariables=true. +try {} catch ({ x }) { x } +try {} catch ([ x ]) { x } + +try {} catch ({ a: { x } }) { x } +try {} catch ({ a: [ x ] }) { x } + +try {} catch ([{ x }]) { x } +try {} catch ([[ x ]]) { x } + +try {} catch ({ a: { b: { c: { x }} }}) { x } + + +try {} catch ({ x }: any) { x } +try {} catch ([ x ]: any) { x } + +try {} catch ({ a: { x } }: any) { x } +try {} catch ({ a: [ x ] }: any) { x } + +try {} catch ([{ x }]: any) { x } +try {} catch ([[ x ]]: any) { x } + +try {} catch ({ a: { b: { c: { x }} }}: any) { x } + + +try {} catch ({ x }: unknown) { x } +try {} catch ([ x ]: unknown) { x } + +try {} catch ({ a: { x } }: unknown) { x } +try {} catch ({ a: [ x ] }: unknown) { x } + +try {} catch ([{ x }]: unknown) { x } +try {} catch ([[ x ]]: unknown) { x } + +try {} catch ({ a: { b: { c: { x }} }}: unknown) { x } diff --git a/tests/cases/conformance/jsdoc/jsdocCatchClauseWithTypeAnnotation.ts b/tests/cases/conformance/jsdoc/jsdocCatchClauseWithTypeAnnotation.ts index 1b9982073f2ec..b47776eb1d9c4 100644 --- a/tests/cases/conformance/jsdoc/jsdocCatchClauseWithTypeAnnotation.ts +++ b/tests/cases/conformance/jsdoc/jsdocCatchClauseWithTypeAnnotation.ts @@ -50,8 +50,8 @@ function fn() { try { } catch ({ x }) { } // should be OK try { } catch (/** @type {any} */ { x }) { x.foo; } // should be OK try { } catch (/** @type {Any} */ { x }) { x.foo;} // should be OK - try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // should be OK - try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // should be OK + try { } catch (/** @type {unknown} */ { x }) { console.log(x); } // error in the destructure + try { } catch (/** @type {Unknown} */ { x }) { console.log(x); } // error in the destructure try { } catch (/** @type {Error} */ { x }) { } // error in the type try { } catch (/** @type {object} */ { x }) { } // error in the type } diff --git a/tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts b/tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts index d7517e021d1fc..6f3bd6a4c15db 100644 --- a/tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts +++ b/tests/cases/conformance/statements/tryStatements/catchClauseWithTypeAnnotation.ts @@ -33,8 +33,8 @@ function fn(x: boolean) { try { } catch ({ x }) { } // should be OK try { } catch ({ x }: any) { x.foo; } // should be OK try { } catch ({ x }: any1) { x.foo;} // should be OK - try { } catch ({ x }: unknown) { console.log(x); } // should be OK - try { } catch ({ x }: unknown1) { console.log(x); } // should be OK + try { } catch ({ x }: unknown) { console.log(x); } // error in the destructure + try { } catch ({ x }: unknown1) { console.log(x); } // error in the destructure try { } catch ({ x }: object) { } // error in the type try { } catch ({ x }: Error) { } // error in the type }