case SyntaxKind.SourceFile:

case SyntaxKind.ModuleDeclaration:

const message = isTypeDeclaration(declaration) ? Diagnostics._0_is_declared_but_never_used : Diagnostics._0_is_declared_but_its_value_is_never_read;

addDiagnostic(UnusedKind.Local, createDiagnosticForNodeSpan(getSourceFileOfNode(declaration), declaration, node, message, name));

function addToGroup<K, V>(map: Map<[K, V[]]>, key: K, value: V, getKey: (key: K) => number | string): void {

const keyString = String(getKey(key));

const group = map.get(keyString);

if (group) {

group[1].push(value);

}

else {

map.set(keyString, [key, [value]]);

}

}

function tryGetRootParameterDeclaration(node: Node): ParameterDeclaration | undefined {

return tryCast(getRootDeclaration(node), isParameter);

}

function checkUnusedLocalsAndParameters(nodeWithLocals: Node, addDiagnostic: AddUnusedDiagnostic): void {

if (nodeWithLocals.flags & NodeFlags.Ambient) return;

// Ideally we could use the ImportClause directly as a key, but must wait until we have full ES6 maps. So must store key along with value.

const unusedImports = createMap<[ImportClause, ImportedDeclaration[]]>();

const unusedDestructures = createMap<[ObjectBindingPattern, BindingElement[]]>();

nodeWithLocals.locals.forEach(local => {

// If it's purely a type parameter, ignore, will be checked in `checkUnusedTypeParameters`.

// If it's a type parameter merged with a parameter, check if the parameter-side is used.

if (local.flags & SymbolFlags.TypeParameter ? !(local.flags & SymbolFlags.Variable && !(local.isReferenced & SymbolFlags.Variable)) : local.isReferenced || local.exportSymbol) {

return;

}

for (const declaration of local.declarations) {

if (isAmbientModule(declaration)) continue;

if (isImportedDeclaration(declaration)) {

addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId);

}

else if (isBindingElement(declaration) && isObjectBindingPattern(declaration.parent)) {

// In `{ a, ...b }, `a` is considered used since it removes a property from `b`. `b` may still be unused though.

const lastElement = last(declaration.parent.elements);

if (declaration === lastElement || !last(declaration.parent.elements).dotDotDotToken) {

addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId);

}

}

else {

const parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration);

if (parameter) {

const name = getNameOfDeclaration(local.valueDeclaration);

if (!isParameterPropertyDeclaration(parameter) && !parameterIsThisKeyword(parameter) && !parameterNameStartsWithUnderscore(name)) {

addDiagnostic(UnusedKind.Parameter, createDiagnosticForNode(name, Diagnostics._0_is_declared_but_its_value_is_never_read, symbolName(local)));

}

});

unusedImports.forEach(([importClause, unuseds]) => {

const importDecl = importClause.parent;

if (forEachImportedDeclaration(importClause, d => !contains(unuseds, d))) {

for (const unused of unuseds) errorUnusedLocal(unused, idText(unused.name), addDiagnostic);

}

else if (unuseds.length === 1) {

addDiagnostic(UnusedKind.Local, createDiagnosticForNode(importDecl, Diagnostics._0_is_declared_but_its_value_is_never_read, idText(first(unuseds).name)));

}

else {

addDiagnostic(UnusedKind.Local, createDiagnosticForNode(importDecl, Diagnostics.All_imports_in_import_declaration_are_unused));

}

});

unusedDestructures.forEach(([bindingPattern, bindingElements]) => {

const kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? UnusedKind.Parameter : UnusedKind.Local;

if (!bindingPattern.elements.every(e => contains(bindingElements, e))) {

for (const e of bindingElements) {

addDiagnostic(kind, createDiagnosticForNode(e, Diagnostics._0_is_declared_but_its_value_is_never_read, getBindingElementNameText(e)));

}

else if (bindingElements.length === 1) {

addDiagnostic(kind, createDiagnosticForNode(bindingPattern, Diagnostics._0_is_declared_but_its_value_is_never_read, getBindingElementNameText(first(bindingElements))));

}

else {

addDiagnostic(kind, createDiagnosticForNode(bindingPattern, Diagnostics.All_destructured_elements_are_unused));

}

});

"All destructured elements are unused.": {

"category": "Error",

"code": 6198,

"reportsUnnecessary": true

},

"Remove destructuring": {

"category": "Message",

"code": 90009

},

Diagnostics.All_destructured_elements_are_unused.code,

const delDestructure = textChanges.ChangeTracker.with(context, t => tryDeleteFullDestructure(t, sourceFile, context.span.start));

if (delDestructure.length) {

return [createCodeFixAction(fixName, delDestructure, Diagnostics.Remove_destructuring, fixIdDelete, Diagnostics.Delete_all_unused_declarations)];

}

if (!tryDeleteFullDestructure(changes, sourceFile, diag.start!)) {

tryDeleteDeclaration(changes, sourceFile, token);

}

function tryDeleteFullDestructure(changes: textChanges.ChangeTracker, sourceFile: SourceFile, pos: number): boolean {

const startToken = getTokenAtPosition(sourceFile, pos, /*includeJsDocComment*/ false);

if (startToken.kind !== SyntaxKind.OpenBraceToken || !isObjectBindingPattern(startToken.parent)) return false;

const decl = startToken.parent.parent;

switch (decl.kind) {

case SyntaxKind.VariableDeclaration:

tryDeleteVariableDeclaration(changes, sourceFile, decl);

break;

case SyntaxKind.Parameter:

changes.deleteNodeInList(sourceFile, decl);

break;

case SyntaxKind.BindingElement:

changes.deleteNode(sourceFile, decl);

break;

default:

return Debug.assertNever(decl);

}

return true;

}

tests/cases/compiler/unusedDestructuring.ts(3,7): error TS6198: All destructured elements are unused.

tests/cases/compiler/unusedDestructuring.ts(4,9): error TS6133: 'c' is declared but its value is never read.

tests/cases/compiler/unusedDestructuring.ts(6,7): error TS6133: 'e' is declared but its value is never read.

tests/cases/compiler/unusedDestructuring.ts(8,1): error TS6133: 'f' is declared but its value is never read.

tests/cases/compiler/unusedDestructuring.ts(8,12): error TS6198: All destructured elements are unused.

tests/cases/compiler/unusedDestructuring.ts(8,24): error TS6133: 'c' is declared but its value is never read.

tests/cases/compiler/unusedDestructuring.ts(8,32): error TS6133: 'e' is declared but its value is never read.

==== tests/cases/compiler/unusedDestructuring.ts (7 errors) ====

export {};

declare const o: any;

const { a, b } = o;

~~~~~~~~

!!! error TS6198: All destructured elements are unused.

const { c, d } = o;

~

!!! error TS6133: 'c' is declared but its value is never read.

d;

const { e } = o;

~~~~~

!!! error TS6133: 'e' is declared but its value is never read.

function f({ a, b }, { c, d }, { e }) {

~~~~~~~~~~

!!! error TS6133: 'f' is declared but its value is never read.

~~~~~~~~

!!! error TS6198: All destructured elements are unused.

~

!!! error TS6133: 'c' is declared but its value is never read.

~~~~~

!!! error TS6133: 'e' is declared but its value is never read.

d;

}

export {};

declare const o: any;

const { a, b } = o;

const { c, d } = o;

const { e } = o;

function f({ a, b }, { c, d }, { e }) {

d;

exports.__esModule = true;

var a = o.a, b = o.b;

var c = o.c, d = o.d;

var e = o.e;

function f(_a, _b, _c) {

var a = _a.a, b = _a.b;

var c = _b.c, d = _b.d;

var e = _c.e;

d;

=== tests/cases/compiler/unusedDestructuring.ts ===

export {};

declare const o: any;

>o : Symbol(o, Decl(unusedDestructuring.ts, 1, 13))

const { a, b } = o;

>a : Symbol(a, Decl(unusedDestructuring.ts, 2, 7))

>b : Symbol(b, Decl(unusedDestructuring.ts, 2, 10))

>o : Symbol(o, Decl(unusedDestructuring.ts, 1, 13))

const { c, d } = o;

>c : Symbol(c, Decl(unusedDestructuring.ts, 3, 7))

>d : Symbol(d, Decl(unusedDestructuring.ts, 3, 10))

>o : Symbol(o, Decl(unusedDestructuring.ts, 1, 13))

d;

>d : Symbol(d, Decl(unusedDestructuring.ts, 3, 10))

const { e } = o;

>e : Symbol(e, Decl(unusedDestructuring.ts, 5, 7))

>o : Symbol(o, Decl(unusedDestructuring.ts, 1, 13))

function f({ a, b }, { c, d }, { e }) {

>f : Symbol(f, Decl(unusedDestructuring.ts, 5, 16))

>a : Symbol(a, Decl(unusedDestructuring.ts, 7, 12))

>b : Symbol(b, Decl(unusedDestructuring.ts, 7, 15))

>c : Symbol(c, Decl(unusedDestructuring.ts, 7, 22))

>d : Symbol(d, Decl(unusedDestructuring.ts, 7, 25))

>e : Symbol(e, Decl(unusedDestructuring.ts, 7, 32))

d;

>d : Symbol(d, Decl(unusedDestructuring.ts, 7, 25))

}