From 6133470cdd09d1f3adc879c984b3b2baa9421e4d Mon Sep 17 00:00:00 2001 From: Matt McCutchen Date: Fri, 12 Jan 2018 10:57:02 -0500 Subject: [PATCH] Unused type parameters should be checked by --noUnusedParameters, not --noUnusedLocals. Fixes #20568. --- src/compiler/checker.ts | 4 +-- ...tersCheckedByNoUnusedParameters.errors.txt | 33 +++++++++++++++++++ ...peParametersCheckedByNoUnusedParameters.js | 25 ++++++++++++++ ...ametersCheckedByNoUnusedParameters.symbols | 27 +++++++++++++++ ...arametersCheckedByNoUnusedParameters.types | 28 ++++++++++++++++ ...ypeParametersNotCheckedByNoUnusedLocals.js | 25 ++++++++++++++ ...rametersNotCheckedByNoUnusedLocals.symbols | 27 +++++++++++++++ ...ParametersNotCheckedByNoUnusedLocals.types | 28 ++++++++++++++++ ...sedTypeParametersWithUnderscore.errors.txt | 14 ++++++-- .../unusedTypeParametersWithUnderscore.js | 8 ++++- ...unusedTypeParametersWithUnderscore.symbols | 14 +++++++- .../unusedTypeParametersWithUnderscore.types | 15 ++++++++- ...peParametersCheckedByNoUnusedParameters.ts | 13 ++++++++ ...ypeParametersNotCheckedByNoUnusedLocals.ts | 13 ++++++++ .../unusedTypeParametersWithUnderscore.ts | 8 +++-- .../fourslash/unusedTypeParametersInClass1.ts | 2 +- .../fourslash/unusedTypeParametersInClass2.ts | 2 +- .../fourslash/unusedTypeParametersInClass3.ts | 2 +- .../unusedTypeParametersInFunction1.ts | 2 +- .../unusedTypeParametersInFunction2.ts | 2 +- .../unusedTypeParametersInFunction3.ts | 2 +- .../unusedTypeParametersInLambda4.ts | 2 +- .../unusedTypeParametersInMethod1.ts | 2 +- .../unusedTypeParametersInMethod2.ts | 2 +- .../unusedTypeParametersInMethods1.ts | 2 +- 25 files changed, 283 insertions(+), 19 deletions(-) create mode 100644 tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.errors.txt create mode 100644 tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.js create mode 100644 tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.symbols create mode 100644 tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types create mode 100644 tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.js create mode 100644 tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.symbols create mode 100644 tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types create mode 100644 tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts create mode 100644 tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index d402f344d60eb..4c27bb650dde5 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21389,7 +21389,7 @@ namespace ts { error(name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolName(local)); } } - else if (compilerOptions.noUnusedLocals) { + else if (local.flags & SymbolFlags.TypeParameter ? compilerOptions.noUnusedParameters : compilerOptions.noUnusedLocals) { forEach(local.declarations, d => errorUnusedLocal(d, symbolName(local))); } } @@ -21463,7 +21463,7 @@ namespace ts { } function checkUnusedTypeParameters(node: ClassDeclaration | ClassExpression | FunctionDeclaration | MethodDeclaration | FunctionExpression | ArrowFunction | ConstructorDeclaration | SignatureDeclaration | InterfaceDeclaration | TypeAliasDeclaration) { - if (compilerOptions.noUnusedLocals && !(node.flags & NodeFlags.Ambient)) { + if (compilerOptions.noUnusedParameters && !(node.flags & NodeFlags.Ambient)) { if (node.typeParameters) { // Only report errors on the last declaration for the type parameter container; // this ensures that all uses have been accounted for. diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.errors.txt b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.errors.txt new file mode 100644 index 0000000000000..e5bc774b706c5 --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.errors.txt @@ -0,0 +1,33 @@ +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(1,12): error TS6133: 'T' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(3,8): error TS6133: 'T' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(5,13): error TS6133: 'T' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(7,9): error TS6133: 'T' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(8,14): error TS6133: 'V' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts(11,10): error TS6133: 'T' is declared but its value is never read. + + +==== tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts (6 errors) ==== + function f() { } + ~ +!!! error TS6133: 'T' is declared but its value is never read. + + type T = { }; + ~ +!!! error TS6133: 'T' is declared but its value is never read. + + interface I { }; + ~ +!!! error TS6133: 'T' is declared but its value is never read. + + class C { + ~ +!!! error TS6133: 'T' is declared but its value is never read. + public m() { } + ~ +!!! error TS6133: 'V' is declared but its value is never read. + }; + + let l = () => { }; + ~ +!!! error TS6133: 'T' is declared but its value is never read. + \ No newline at end of file diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.js b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.js new file mode 100644 index 0000000000000..50a7dfcfeac5e --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.js @@ -0,0 +1,25 @@ +//// [unusedTypeParametersCheckedByNoUnusedParameters.ts] +function f() { } + +type T = { }; + +interface I { }; + +class C { + public m() { } +}; + +let l = () => { }; + + +//// [unusedTypeParametersCheckedByNoUnusedParameters.js] +function f() { } +; +var C = /** @class */ (function () { + function C() { + } + C.prototype.m = function () { }; + return C; +}()); +; +var l = function () { }; diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.symbols b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.symbols new file mode 100644 index 0000000000000..916329800efb5 --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts === +function f() { } +>f : Symbol(f, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 0, 0)) +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 0, 11)) + +type T = { }; +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 0, 19)) +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 2, 7)) + +interface I { }; +>I : Symbol(I, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 2, 16)) +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 4, 12)) + +class C { +>C : Symbol(C, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 4, 19)) +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 6, 8)) + + public m() { } +>m : Symbol(C.m, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 6, 12)) +>V : Symbol(V, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 7, 13)) + +}; + +let l = () => { }; +>l : Symbol(l, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 10, 3)) +>T : Symbol(T, Decl(unusedTypeParametersCheckedByNoUnusedParameters.ts, 10, 9)) + diff --git a/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types new file mode 100644 index 0000000000000..eb49d0a731f5b --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersCheckedByNoUnusedParameters.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts === +function f() { } +>f : () => void +>T : T + +type T = { }; +>T : {} +>T : T + +interface I { }; +>I : I +>T : T + +class C { +>C : C +>T : T + + public m() { } +>m : () => void +>V : V + +}; + +let l = () => { }; +>l : () => void +>() => { } : () => void +>T : T + diff --git a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.js b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.js new file mode 100644 index 0000000000000..2b215504bda3d --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.js @@ -0,0 +1,25 @@ +//// [unusedTypeParametersNotCheckedByNoUnusedLocals.ts] +function f() { } + +type T = { }; + +interface I { }; + +class C { + public m() { } +}; + +let l = () => { }; + + +//// [unusedTypeParametersNotCheckedByNoUnusedLocals.js] +function f() { } +; +var C = /** @class */ (function () { + function C() { + } + C.prototype.m = function () { }; + return C; +}()); +; +var l = function () { }; diff --git a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.symbols b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.symbols new file mode 100644 index 0000000000000..27bc52564d56a --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts === +function f() { } +>f : Symbol(f, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 0, 0)) +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 0, 11)) + +type T = { }; +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 0, 19)) +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 2, 7)) + +interface I { }; +>I : Symbol(I, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 2, 16)) +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 4, 12)) + +class C { +>C : Symbol(C, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 4, 19)) +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 6, 8)) + + public m() { } +>m : Symbol(C.m, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 6, 12)) +>V : Symbol(V, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 7, 13)) + +}; + +let l = () => { }; +>l : Symbol(l, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 10, 3)) +>T : Symbol(T, Decl(unusedTypeParametersNotCheckedByNoUnusedLocals.ts, 10, 9)) + diff --git a/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types new file mode 100644 index 0000000000000..bed3e964d2cee --- /dev/null +++ b/tests/baselines/reference/unusedTypeParametersNotCheckedByNoUnusedLocals.types @@ -0,0 +1,28 @@ +=== tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts === +function f() { } +>f : () => void +>T : T + +type T = { }; +>T : {} +>T : T + +interface I { }; +>I : I +>T : T + +class C { +>C : C +>T : T + + public m() { } +>m : () => void +>V : V + +}; + +let l = () => { }; +>l : () => void +>() => { } : () => void +>T : T + diff --git a/tests/baselines/reference/unusedTypeParametersWithUnderscore.errors.txt b/tests/baselines/reference/unusedTypeParametersWithUnderscore.errors.txt index cd44a68b78c22..b41b62694f898 100644 --- a/tests/baselines/reference/unusedTypeParametersWithUnderscore.errors.txt +++ b/tests/baselines/reference/unusedTypeParametersWithUnderscore.errors.txt @@ -2,9 +2,11 @@ tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(1,16): error TS6133: tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(3,12): error TS6133: 'U' is declared but its value is never read. tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(5,17): error TS6133: 'U' is declared but its value is never read. tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(7,13): error TS6133: 'U' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(8,18): error TS6133: 'W' is declared but its value is never read. +tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(11,14): error TS6133: 'U' is declared but its value is never read. -==== tests/cases/compiler/unusedTypeParametersWithUnderscore.ts (4 errors) ==== +==== tests/cases/compiler/unusedTypeParametersWithUnderscore.ts (6 errors) ==== function f<_T, U>() { } ~ !!! error TS6133: 'U' is declared but its value is never read. @@ -17,7 +19,15 @@ tests/cases/compiler/unusedTypeParametersWithUnderscore.ts(7,13): error TS6133: ~ !!! error TS6133: 'U' is declared but its value is never read. - class C<_T, U> { }; + class C<_T, U> { ~ !!! error TS6133: 'U' is declared but its value is never read. + public m<_V, W>() { } + ~ +!!! error TS6133: 'W' is declared but its value is never read. + }; + + let l = <_T, U>() => { }; + ~ +!!! error TS6133: 'U' is declared but its value is never read. \ No newline at end of file diff --git a/tests/baselines/reference/unusedTypeParametersWithUnderscore.js b/tests/baselines/reference/unusedTypeParametersWithUnderscore.js index 095cf2da85f3e..bade5f6f95f27 100644 --- a/tests/baselines/reference/unusedTypeParametersWithUnderscore.js +++ b/tests/baselines/reference/unusedTypeParametersWithUnderscore.js @@ -5,7 +5,11 @@ type T<_T, U> = { }; interface I<_T, U> { }; -class C<_T, U> { }; +class C<_T, U> { + public m<_V, W>() { } +}; + +let l = <_T, U>() => { }; //// [unusedTypeParametersWithUnderscore.js] @@ -14,6 +18,8 @@ function f() { } var C = /** @class */ (function () { function C() { } + C.prototype.m = function () { }; return C; }()); ; +var l = function () { }; diff --git a/tests/baselines/reference/unusedTypeParametersWithUnderscore.symbols b/tests/baselines/reference/unusedTypeParametersWithUnderscore.symbols index 4429bc1bd2544..3f8444d70694b 100644 --- a/tests/baselines/reference/unusedTypeParametersWithUnderscore.symbols +++ b/tests/baselines/reference/unusedTypeParametersWithUnderscore.symbols @@ -14,8 +14,20 @@ interface I<_T, U> { }; >_T : Symbol(_T, Decl(unusedTypeParametersWithUnderscore.ts, 4, 12)) >U : Symbol(U, Decl(unusedTypeParametersWithUnderscore.ts, 4, 15)) -class C<_T, U> { }; +class C<_T, U> { >C : Symbol(C, Decl(unusedTypeParametersWithUnderscore.ts, 4, 23)) >_T : Symbol(_T, Decl(unusedTypeParametersWithUnderscore.ts, 6, 8)) >U : Symbol(U, Decl(unusedTypeParametersWithUnderscore.ts, 6, 11)) + public m<_V, W>() { } +>m : Symbol(C.m, Decl(unusedTypeParametersWithUnderscore.ts, 6, 16)) +>_V : Symbol(_V, Decl(unusedTypeParametersWithUnderscore.ts, 7, 13)) +>W : Symbol(W, Decl(unusedTypeParametersWithUnderscore.ts, 7, 16)) + +}; + +let l = <_T, U>() => { }; +>l : Symbol(l, Decl(unusedTypeParametersWithUnderscore.ts, 10, 3)) +>_T : Symbol(_T, Decl(unusedTypeParametersWithUnderscore.ts, 10, 9)) +>U : Symbol(U, Decl(unusedTypeParametersWithUnderscore.ts, 10, 12)) + diff --git a/tests/baselines/reference/unusedTypeParametersWithUnderscore.types b/tests/baselines/reference/unusedTypeParametersWithUnderscore.types index bfafa3c9b382e..9fbb3b974dfcc 100644 --- a/tests/baselines/reference/unusedTypeParametersWithUnderscore.types +++ b/tests/baselines/reference/unusedTypeParametersWithUnderscore.types @@ -14,8 +14,21 @@ interface I<_T, U> { }; >_T : _T >U : U -class C<_T, U> { }; +class C<_T, U> { >C : C<_T, U> >_T : _T +>U : U + + public m<_V, W>() { } +>m : <_V, W>() => void +>_V : _V +>W : W + +}; + +let l = <_T, U>() => { }; +>l : <_T, U>() => void +><_T, U>() => { } : <_T, U>() => void +>_T : _T >U : U diff --git a/tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts b/tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts new file mode 100644 index 0000000000000..b2c132a399e49 --- /dev/null +++ b/tests/cases/compiler/unusedTypeParametersCheckedByNoUnusedParameters.ts @@ -0,0 +1,13 @@ +//@noUnusedParameters:true + +function f() { } + +type T = { }; + +interface I { }; + +class C { + public m() { } +}; + +let l = () => { }; diff --git a/tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts b/tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts new file mode 100644 index 0000000000000..b305f7a8d7234 --- /dev/null +++ b/tests/cases/compiler/unusedTypeParametersNotCheckedByNoUnusedLocals.ts @@ -0,0 +1,13 @@ +//@noUnusedLocals:true + +function f() { } + +type T = { }; + +interface I { }; + +class C { + public m() { } +}; + +let l = () => { }; diff --git a/tests/cases/compiler/unusedTypeParametersWithUnderscore.ts b/tests/cases/compiler/unusedTypeParametersWithUnderscore.ts index dc66534118fca..ed4c23411db8f 100644 --- a/tests/cases/compiler/unusedTypeParametersWithUnderscore.ts +++ b/tests/cases/compiler/unusedTypeParametersWithUnderscore.ts @@ -1,4 +1,4 @@ -//@noUnusedLocals:true +//@noUnusedParameters:true function f<_T, U>() { } @@ -6,4 +6,8 @@ type T<_T, U> = { }; interface I<_T, U> { }; -class C<_T, U> { }; +class C<_T, U> { + public m<_V, W>() { } +}; + +let l = <_T, U>() => { }; diff --git a/tests/cases/fourslash/unusedTypeParametersInClass1.ts b/tests/cases/fourslash/unusedTypeParametersInClass1.ts index 327558922e7e2..86beb10a445af 100644 --- a/tests/cases/fourslash/unusedTypeParametersInClass1.ts +++ b/tests/cases/fourslash/unusedTypeParametersInClass1.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true ////[|class greeter |] { ////} diff --git a/tests/cases/fourslash/unusedTypeParametersInClass2.ts b/tests/cases/fourslash/unusedTypeParametersInClass2.ts index 4f78aa3fbe9d9..23a4c39602d86 100644 --- a/tests/cases/fourslash/unusedTypeParametersInClass2.ts +++ b/tests/cases/fourslash/unusedTypeParametersInClass2.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true ////[|class greeter |] { //// public a: X; ////} diff --git a/tests/cases/fourslash/unusedTypeParametersInClass3.ts b/tests/cases/fourslash/unusedTypeParametersInClass3.ts index f0b12f868f13b..8312830407b3d 100644 --- a/tests/cases/fourslash/unusedTypeParametersInClass3.ts +++ b/tests/cases/fourslash/unusedTypeParametersInClass3.ts @@ -1,7 +1,7 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true ////[|class greeter |] { //// public a: X; //// public b: Z; diff --git a/tests/cases/fourslash/unusedTypeParametersInFunction1.ts b/tests/cases/fourslash/unusedTypeParametersInFunction1.ts index a33ecf60ea605..686ced265034c 100644 --- a/tests/cases/fourslash/unusedTypeParametersInFunction1.ts +++ b/tests/cases/fourslash/unusedTypeParametersInFunction1.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// [|function f1() {}|] verify.codeFix({ diff --git a/tests/cases/fourslash/unusedTypeParametersInFunction2.ts b/tests/cases/fourslash/unusedTypeParametersInFunction2.ts index 9c0d9e7b0988e..87d7e90207b18 100644 --- a/tests/cases/fourslash/unusedTypeParametersInFunction2.ts +++ b/tests/cases/fourslash/unusedTypeParametersInFunction2.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// [|function f1(a: X) {a}|] verify.codeFix({ diff --git a/tests/cases/fourslash/unusedTypeParametersInFunction3.ts b/tests/cases/fourslash/unusedTypeParametersInFunction3.ts index 0c8ea449731d7..0a3bc6bb79b96 100644 --- a/tests/cases/fourslash/unusedTypeParametersInFunction3.ts +++ b/tests/cases/fourslash/unusedTypeParametersInFunction3.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// [|function f1(a: X) {a;var b:Z;b}|] verify.codeFix({ diff --git a/tests/cases/fourslash/unusedTypeParametersInLambda4.ts b/tests/cases/fourslash/unusedTypeParametersInLambda4.ts index b3e3f4b11f35d..b9a258bac3dc6 100644 --- a/tests/cases/fourslash/unusedTypeParametersInLambda4.ts +++ b/tests/cases/fourslash/unusedTypeParametersInLambda4.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// class A { //// public x: T; //// } diff --git a/tests/cases/fourslash/unusedTypeParametersInMethod1.ts b/tests/cases/fourslash/unusedTypeParametersInMethod1.ts index 260a9399650b3..a3afd76251d1c 100644 --- a/tests/cases/fourslash/unusedTypeParametersInMethod1.ts +++ b/tests/cases/fourslash/unusedTypeParametersInMethod1.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// class C1 { //// [|f1()|] {} //// } diff --git a/tests/cases/fourslash/unusedTypeParametersInMethod2.ts b/tests/cases/fourslash/unusedTypeParametersInMethod2.ts index 377642c5bd537..3ca7a0f8a873e 100644 --- a/tests/cases/fourslash/unusedTypeParametersInMethod2.ts +++ b/tests/cases/fourslash/unusedTypeParametersInMethod2.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// class C1 { //// [|f1(a: U)|] {a;} //// } diff --git a/tests/cases/fourslash/unusedTypeParametersInMethods1.ts b/tests/cases/fourslash/unusedTypeParametersInMethods1.ts index 4a538fb4b3975..d394d9af7723a 100644 --- a/tests/cases/fourslash/unusedTypeParametersInMethods1.ts +++ b/tests/cases/fourslash/unusedTypeParametersInMethods1.ts @@ -1,6 +1,6 @@ /// -// @noUnusedLocals: true +// @noUnusedParameters: true //// class A { //// [|public f1(a: X)|] { a; var b: Z; b } //// }