tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-unused.d.ts

@@ -0,0 +1,19 @@
+import { type Node, type SourceFile } from './ast.js';
+import { type Checker } from './checker.js';
+import { type Symbol } from './symbol.js';
+import type { Type } from './checker-types.js';
+/** Whether `node` is only written, as the target of `=` or of a for-in/of initializer. */
+export declare function isWriteOnlyAccess(node: Node): boolean;
+/** Whether `node` is written, possibly also read. */
+export declare function isWriteAccess(node: Node): boolean;
+/** Whether `name` refers to the class or object `parent` itself, as `this` or its own name does. */
+export declare function isSelfTypeAccess(c: Checker, name: Node, parent: Symbol | undefined): boolean;
+/**
+ * Records a use of a private class member. Writes don't count, except to setters, and neither do
+ * uses of a method from inside itself.
+ */
+export declare function markPropertyAsReferenced(c: Checker, prop: Symbol, nodeForCheckWriteOnly: Node | undefined, isSelfTypeAccess: boolean): void;
+/** Marks the property a destructuring name selects from `objectType` as referenced. */
+export declare function markDestructuredPropertyAsReferenced(c: Checker, objectType: Type, name: Node, location: Node | undefined, isSelfTypeAccess: boolean): void;
+/** Reports the unused identifiers of a checked file; declaration files have none. */
+export declare function checkUnusedIdentifiers(c: Checker, file: SourceFile): void;

package/dist/api/compiler/checker-unused.js

@@ -0,0 +1,524 @@
+// Unused identifiers: locals, parameters, imports, private class members and type parameters that
+// are declared but never referenced. Errors under noUnusedLocals/noUnusedParameters, suggestions
+// otherwise. References are recorded in `SymbolLinks.referenceKinds` by name resolution and by
+// `markPropertyAsReferenced`.
+import { NodeVisitor, getBody, getDotDotDotToken, getElements, getExpression, getLocals, getMembers, getName, getParameters, getPropertyName, getSymbol, getText, getTypeParameters, } from './ast.js';
+import { isAmbientModule, isAssignmentOperator, isGlobalScopeAugmentation, isTypeDeclaration, } from './ast-utilities.js';
+import { getCombinedNodeFlags, getModifierFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isExternalOrCommonJSModule, isParameterPropertyDeclaration, } from './binder-utilities.js';
+import { createDiagnosticForNode } from './checker.js';
+import { Diagnostic } from './diagnostics.js';
+import { getSymbolId } from './symbol.js';
+import { getMergedSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { getResolvedSymbol } from './checker-expressions.js';
+import { skipTrivia } from './scanner.js';
+import { getContainingFunctionOrClassStaticBlock } from './checker-grammar.js';
+import { nodeCanBeDecorated } from './checker-decorators.js';
+import { symbolToString } from './type-printer.js';
+import { getLiteralTypeFromPropertyName } from './checker-type-operators.js';
+import { getPropertyOfType } from './checker-members.js';
+import { getPropertyNameFromType, isTypeUsableAsPropertyName } from './checker-utilities.js';
+// ---- References
+/** Whether `node` is only written, as the target of `=` or of a for-in/of initializer. */
+export function isWriteOnlyAccess(node) {
+    return accessKind(node) === 1 /* AccessKind.Write */;
+}
+/** Whether `node` is written, possibly also read. */
+export function isWriteAccess(node) {
+    return accessKind(node) !== 0 /* AccessKind.Read */;
+}
+function accessKind(node) {
+    const parent = node.parent;
+    if (parent === undefined)
+        return 0 /* AccessKind.Read */;
+    switch (parent.kind) {
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+            return accessKind(parent);
+        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PostfixUnaryExpression */: {
+            const operator = parent.kind === 225 /* SyntaxKind.PrefixUnaryExpression */
+                ? parent.operator
+                : parent.operator;
+            return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */
+                ? 2 /* AccessKind.ReadWrite */
+                : 0 /* AccessKind.Read */;
+        }
+        case 227 /* SyntaxKind.BinaryExpression */: {
+            const binary = parent;
+            if (binary.left !== node || !isAssignmentOperator(binary.operatorToken.kind))
+                return 0 /* AccessKind.Read */;
+            return binary.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ ? 1 /* AccessKind.Write */ : 2 /* AccessKind.ReadWrite */;
+        }
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+            return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent);
+        case 303 /* SyntaxKind.PropertyAssignment */: {
+            const parentAccess = accessKind(parent.parent);
+            // In `({ x: name } = { x: 1 })`, the left `x` is a read and `name` a write.
+            return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess;
+        }
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+            // The local variable is the one accessed: public properties aren't checked for use.
+            return node === parent.objectAssignmentInitializer
+                ? 0 /* AccessKind.Read */
+                : accessKind(parent.parent);
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            return node === parent.initializer ? 1 /* AccessKind.Write */ : 0 /* AccessKind.Read */;
+    }
+    return 0 /* AccessKind.Read */;
+}
+function reverseAccessKind(kind) {
+    switch (kind) {
+        case 0 /* AccessKind.Read */:
+            return 1 /* AccessKind.Write */;
+        case 1 /* AccessKind.Write */:
+            return 0 /* AccessKind.Read */;
+    }
+    return 2 /* AccessKind.ReadWrite */;
+}
+/** Whether `name` refers to the class or object `parent` itself, as `this` or its own name does. */
+export function isSelfTypeAccess(c, name, parent) {
+    if (name.kind === 109 /* SyntaxKind.ThisKeyword */)
+        return true;
+    if (parent === undefined || !isEntityNameExpression(name))
+        return false;
+    return parent === getResolvedSymbol(c, getFirstIdentifierOfExpression(name));
+}
+function isEntityNameExpression(node) {
+    let current = node;
+    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        if (getName(current).kind !== 79 /* SyntaxKind.Identifier */)
+            return false;
+        current = current.expression;
+    }
+    return current.kind === 79 /* SyntaxKind.Identifier */;
+}
+function getFirstIdentifierOfExpression(node) {
+    let current = node;
+    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        current = current.expression;
+    return current;
+}
+/**
+ * Records a use of a private class member. Writes don't count, except to setters, and neither do
+ * uses of a method from inside itself.
+ */
+export function markPropertyAsReferenced(c, prop, nodeForCheckWriteOnly, isSelfTypeAccess) {
+    const declaration = prop.valueDeclaration;
+    if ((prop.flags & 106500 /* SymbolFlags.ClassMember */) === 0 || declaration === undefined)
+        return;
+    const name = getName(declaration);
+    if (!hasSyntacticModifier(declaration, 2 /* ModifierFlags.Private */) &&
+        (name === undefined || name.kind !== 80 /* SyntaxKind.PrivateIdentifier */))
+        return;
+    if (nodeForCheckWriteOnly !== undefined &&
+        isWriteOnlyAccess(nodeForCheckWriteOnly) &&
+        (prop.flags & 65536 /* SymbolFlags.SetAccessor */) === 0)
+        return;
+    if (isSelfTypeAccess && nodeForCheckWriteOnly !== undefined) {
+        // A method, getter or setter using itself through `this` doesn't count.
+        let containingMethod = nodeForCheckWriteOnly;
+        while (containingMethod !== undefined && !isFunctionLikeDeclaration(containingMethod))
+            containingMethod = containingMethod.parent;
+        if (containingMethod !== undefined && getSymbol(containingMethod) === prop)
+            return;
+    }
+    const target = (prop.checkFlags & 1 /* CheckFlags.Instantiated */) !== 0 ? c.symbolTargets.get(getSymbolId(prop)) : prop;
+    const id = getSymbolId(target);
+    c.symbolReferenceKinds.set(id, c.symbolReferenceKinds.get(id) | 1073741823 /* SymbolFlags.All */);
+}
+/** Marks the property a destructuring name selects from `objectType` as referenced. */
+export function markDestructuredPropertyAsReferenced(c, objectType, name, location, isSelfTypeAccess) {
+    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        return;
+    const nameType = getLiteralTypeFromPropertyName(c, name);
+    if (nameType === undefined || !isTypeUsableAsPropertyName(nameType))
+        return;
+    const prop = getPropertyOfType(c, objectType, getPropertyNameFromType(nameType));
+    if (prop !== undefined)
+        markPropertyAsReferenced(c, prop, location, isSelfTypeAccess);
+}
+function isFunctionLikeDeclaration(node) {
+    switch (node.kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return true;
+    }
+    return false;
+}
+// ---- Checks
+/** Reports the unused identifiers of a checked file; declaration files have none. */
+export function checkUnusedIdentifiers(c, file) {
+    if (file.isDeclarationFile)
+        return;
+    const collector = new PotentiallyUnusedCollector(c.legacyDecorators);
+    collector.visitNode(file);
+    for (const node of collector.nodes)
+        checkUnusedIdentifiersOfNode(c, node);
+}
+/** The checked declarations and scopes that can declare unused identifiers. */
+class PotentiallyUnusedCollector extends NodeVisitor {
+    nodes = [];
+    legacyDecorators;
+    constructor(legacyDecorators) {
+        super();
+        this.legacyDecorators = legacyDecorators;
+    }
+    visitNode(node) {
+        // The body of a `with` statement isn't checked.
+        if (node.kind === 255 /* SyntaxKind.WithStatement */)
+            this.visitNode(getExpression(node));
+        else if (!this.isUnchecked(node))
+            node.forEachChild(this);
+        if (isPotentiallyUnusedContainer(node))
+            this.nodes.push(node);
+        return false;
+    }
+    /**
+     * Whether the checker skips the children of `node`: a `return` outside a function body, or in a class
+     * static block, and a decorator of a declaration that can't be decorated, are reported as errors and
+     * not checked further.
+     */
+    isUnchecked(node) {
+        if (node.kind === 254 /* SyntaxKind.ReturnStatement */) {
+            const container = getContainingFunctionOrClassStaticBlock(node);
+            return container === undefined || container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */;
+        }
+        if (node.kind === 171 /* SyntaxKind.Decorator */) {
+            const declaration = node.parent;
+            return !nodeCanBeDecorated(this.legacyDecorators, declaration, declaration.parent, declaration.parent?.parent);
+        }
+        return false;
+    }
+}
+function isPotentiallyUnusedContainer(node) {
+    switch (node.kind) {
+        case 307 /* SyntaxKind.SourceFile */:
+            return isExternalOrCommonJSModule(node);
+        case 242 /* SyntaxKind.Block */:
+        case 270 /* SyntaxKind.CaseBlock */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */: {
+            const locals = getLocals(node);
+            return locals !== undefined && locals.size !== 0;
+        }
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            return getBody(node) !== undefined && !isGlobalScopeAugmentation(node);
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */: {
+            const type = node.type;
+            return type === undefined || type.kind !== 141 /* SyntaxKind.IntrinsicKeyword */;
+        }
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 196 /* SyntaxKind.InferType */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return true;
+    }
+    return false;
+}
+function checkUnusedIdentifiersOfNode(c, node) {
+    switch (node.kind) {
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 232 /* SyntaxKind.ClassExpression */:
+            checkUnusedClassMembers(c, node);
+            checkUnusedTypeParameters(c, node);
+            return;
+        case 307 /* SyntaxKind.SourceFile */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 242 /* SyntaxKind.Block */:
+        case 270 /* SyntaxKind.CaseBlock */:
+        case 249 /* SyntaxKind.ForStatement */:
+        case 250 /* SyntaxKind.ForInStatement */:
+        case 251 /* SyntaxKind.ForOfStatement */:
+            checkUnusedLocalsAndParameters(c, node);
+            return;
+        case 177 /* SyntaxKind.Constructor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+            // Parameters are reported on implementations only, not overloads.
+            if (getBody(node) !== undefined)
+                checkUnusedLocalsAndParameters(c, node);
+            checkUnusedTypeParameters(c, node);
+            return;
+        case 196 /* SyntaxKind.InferType */:
+            checkUnusedInferTypeParameter(c, node);
+            return;
+    }
+    checkUnusedTypeParameters(c, node);
+}
+function isReferenced(c, symbol) {
+    return c.symbolReferenceKinds.get(getSymbolId(symbol)) !== 0;
+}
+function referenceKindsOfDeclaration(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    return symbol === undefined ? 0 /* SymbolFlags.None */ : c.symbolReferenceKinds.get(getSymbolId(symbol));
+}
+function reportUnused(c, location, kind, diagnostic) {
+    if ((location.flags & (8388608 /* NodeFlags.Ambient */ | 131072 /* NodeFlags.ThisNodeOrAnySubNodesHasError */)) !== 0)
+        return;
+    const options = c.compilerOptions;
+    const isError = kind === 0 /* UnusedKind.Local */ ? options.noUnusedLocals === true : options.noUnusedParameters === true;
+    if (!isError)
+        diagnostic.category = 2 /* DiagnosticCategory.Suggestion */;
+    c.addErrorOrSuggestion(isError, diagnostic);
+}
+function reportUnusedVariable(c, location, diagnostic) {
+    let current = location;
+    while (current.kind === 209 /* SyntaxKind.BindingElement */ ||
+        current.kind === 207 /* SyntaxKind.ObjectBindingPattern */ ||
+        current.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        current = current.parent;
+    reportUnused(c, current, current.kind === 170 /* SyntaxKind.Parameter */ ? 1 /* UnusedKind.Parameter */ : 0 /* UnusedKind.Local */, diagnostic);
+}
+function checkUnusedClassMembers(c, node) {
+    for (const member of getMembers(node).nodes) {
+        switch (member.kind) {
+            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.SetAccessor */: {
+                // An unused accessor pair is reported on the getter.
+                if (member.kind === 179 /* SyntaxKind.SetAccessor */ && (getSymbol(member).flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
+                    break;
+                const symbol = getSymbolOfDeclaration(c, member);
+                const name = getName(member);
+                if (!isReferenced(c, symbol) &&
+                    ((getModifierFlags(member) & 2 /* ModifierFlags.Private */) !== 0 ||
+                        (name !== undefined && name.kind === 80 /* SyntaxKind.PrivateIdentifier */)) &&
+                    (member.flags & 8388608 /* NodeFlags.Ambient */) === 0)
+                    reportUnused(c, member, 0 /* UnusedKind.Local */, createDiagnosticForNode(name, 1298 /* Diagnostics.X_0_is_declared_but_its_value_is_never_read */, [
+                        symbolToString(c, symbol),
+                    ]));
+                break;
+            }
+            case 177 /* SyntaxKind.Constructor */:
+                for (const parameter of getParameters(member).nodes) {
+                    const symbol = getSymbol(parameter);
+                    if (symbol !== undefined &&
+                        !isReferenced(c, symbol) &&
+                        hasSyntacticModifier(parameter, 2 /* ModifierFlags.Private */))
+                        reportUnused(c, parameter, 0 /* UnusedKind.Local */, createDiagnosticForNode(getName(parameter), 1303 /* Diagnostics.Property_0_is_declared_but_its_value_is_never_read */, [symbol.name]));
+                }
+                break;
+        }
+    }
+}
+function checkUnusedLocalsAndParameters(c, node) {
+    const locals = getLocals(node);
+    if (locals === undefined)
+        return;
+    const variableParents = new Set();
+    const importClauses = new Map();
+    for (const local of locals.values()) {
+        const referenceKinds = c.symbolReferenceKinds.get(getSymbolId(local));
+        if ((local.flags & 262144 /* SymbolFlags.TypeParameter */) !== 0) {
+            if ((local.flags & 3 /* SymbolFlags.Variable */) === 0 || (referenceKinds & 3 /* SymbolFlags.Variable */) !== 0)
+                continue;
+        }
+        else if (referenceKinds !== 0 ||
+            local.exportSymbol !== undefined ||
+            (local.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0)
+            continue;
+        for (const declaration of local.declarations) {
+            switch (declaration.kind) {
+                case 261 /* SyntaxKind.VariableDeclaration */:
+                case 170 /* SyntaxKind.Parameter */:
+                case 209 /* SyntaxKind.BindingElement */:
+                    variableParents.add(getRootDeclaration(declaration).parent);
+                    break;
+                case 274 /* SyntaxKind.ImportClause */:
+                case 277 /* SyntaxKind.ImportSpecifier */:
+                case 275 /* SyntaxKind.NamespaceImport */:
+                    if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
+                        const importClause = importClauseFromImported(declaration);
+                        const unuseds = importClauses.get(importClause);
+                        if (unuseds === undefined)
+                            importClauses.set(importClause, [declaration]);
+                        else
+                            unuseds.push(declaration);
+                    }
+                    break;
+                default:
+                    if (declaration.kind !== 169 /* SyntaxKind.TypeParameter */ && !isAmbientModule(declaration))
+                        reportUnusedLocal(c, declaration, local.name);
+            }
+        }
+    }
+    for (const declaration of variableParents) {
+        if (declaration.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+            reportUnusedVariables(c, declaration, declaration.declarations.nodes);
+        else
+            reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
+    }
+    for (const [declaration, unuseds] of importClauses)
+        reportUnusedImports(c, declaration, unuseds);
+}
+function reportUnusedLocal(c, node, name) {
+    const message = isTypeDeclaration(node)
+        ? 1349 /* Diagnostics.X_0_is_declared_but_never_used */
+        : 1298 /* Diagnostics.X_0_is_declared_but_its_value_is_never_read */;
+    reportUnused(c, node, 0 /* UnusedKind.Local */, createDiagnosticForNode(getName(node) ?? node, message, [name]));
+}
+function reportUnusedVariables(c, node, declarations) {
+    if (declarations.length > 1 && areUnreferencedVariableDeclarations(c, declarations))
+        reportUnusedVariable(c, node, createDiagnosticForNode(node, 1352 /* Diagnostics.All_variables_are_unused */, []));
+    else
+        reportUnusedVariableDeclarations(c, declarations);
+}
+function reportUnusedBindingElements(c, node) {
+    const declarations = getElements(node).nodes;
+    if (declarations.length > 1 && areUnreferencedVariableDeclarations(c, declarations))
+        reportUnusedVariable(c, node, createDiagnosticForNode(node, 1351 /* Diagnostics.All_destructured_elements_are_unused */, []));
+    else
+        reportUnusedVariableDeclarations(c, declarations);
+}
+function reportUnusedVariableDeclarations(c, declarations) {
+    for (const declaration of declarations) {
+        const name = getName(declaration);
+        if (name === undefined ||
+            isParameterPropertyDeclaration(declaration, declaration.parent) ||
+            isThisParameter(declaration))
+            continue;
+        if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+            reportUnusedBindingElements(c, name);
+        else if (isUnreferencedVariableDeclaration(c, declaration))
+            reportUnusedVariable(c, declaration, createDiagnosticForNode(name, 1298 /* Diagnostics.X_0_is_declared_but_its_value_is_never_read */, [getText(name)]));
+    }
+}
+function isThisParameter(node) {
+    if (node.kind !== 170 /* SyntaxKind.Parameter */)
+        return false;
+    const name = getName(node);
+    return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this';
+}
+function areUnreferencedVariableDeclarations(c, declarations) {
+    for (const d of declarations)
+        if (!isUnreferencedVariableDeclaration(c, d))
+            return false;
+    return true;
+}
+function isUnreferencedVariableDeclaration(c, node) {
+    const name = getName(node);
+    if (name === undefined)
+        return true;
+    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        return areUnreferencedVariableDeclarations(c, getElements(name).nodes);
+    if ((referenceKindsOfDeclaration(c, node) & 3 /* SymbolFlags.Variable */) !== 0)
+        return false;
+    const parent = node.parent;
+    if (node.kind === 209 /* SyntaxKind.BindingElement */ && parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */) {
+        // In `{ a, ...b }`, `a` counts as used: it removes a property from `b`.
+        const elements = getElements(parent).nodes;
+        const lastElement = elements[elements.length - 1];
+        if (node !== lastElement && getDotDotDotToken(lastElement) !== undefined)
+            return false;
+    }
+    const underscoreExempt = node.kind === 170 /* SyntaxKind.Parameter */ ||
+        (node.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+            (isForInOrOfStatement(parent.parent) || (getCombinedNodeFlags(node) & 4 /* NodeFlags.Using */) !== 0)) ||
+        (node.kind === 209 /* SyntaxKind.BindingElement */ &&
+            !(parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */ && getPropertyName(node) === undefined));
+    return !(underscoreExempt && isIdentifierThatStartsWithUnderscore(name));
+}
+function isForInOrOfStatement(node) {
+    return node.kind === 250 /* SyntaxKind.ForInStatement */ || node.kind === 251 /* SyntaxKind.ForOfStatement */;
+}
+function reportUnusedImports(c, node, unuseds) {
+    let declarationCount = node.name !== undefined ? 1 : 0;
+    const namedBindings = node.namedBindings;
+    if (namedBindings !== undefined) {
+        if (namedBindings.kind === 275 /* SyntaxKind.NamespaceImport */)
+            declarationCount++;
+        else
+            declarationCount += getElements(namedBindings).nodes.length;
+    }
+    if (declarationCount > 1 && declarationCount === unuseds.length)
+        reportUnused(c, node, 0 /* UnusedKind.Local */, createDiagnosticForNode(node.parent, 1345 /* Diagnostics.All_imports_in_import_declaration_are_unused */, []));
+    else
+        for (const unused of unuseds)
+            reportUnusedLocal(c, unused, getText(getName(unused)));
+}
+function isIdentifierThatStartsWithUnderscore(node) {
+    return node !== undefined && node.kind === 79 /* SyntaxKind.Identifier */ && getText(node).charCodeAt(0) === 0x5f;
+}
+function importClauseFromImported(node) {
+    switch (node.kind) {
+        case 274 /* SyntaxKind.ImportClause */:
+            return node;
+        case 275 /* SyntaxKind.NamespaceImport */:
+            return node.parent;
+    }
+    return node.parent.parent;
+}
+function checkUnusedInferTypeParameter(c, node) {
+    const typeParameter = node.typeParameter;
+    if (isUnreferencedTypeParameter(c, typeParameter))
+        reportUnused(c, node, 1 /* UnusedKind.Parameter */, createDiagnosticForNode(typeParameter.name, 1349 /* Diagnostics.X_0_is_declared_but_never_used */, [
+            getText(typeParameter.name),
+        ]));
+}
+function areUnreferencedTypeParameters(c, typeParameters) {
+    for (const p of typeParameters)
+        if (!isUnreferencedTypeParameter(c, p))
+            return false;
+    return true;
+}
+function checkUnusedTypeParameters(c, node) {
+    const symbol = getSymbolOfDeclaration(c, node);
+    if (symbol !== undefined && !allDeclarationsInSameSourceFile(symbol))
+        return;
+    const typeParameterList = getTypeParameters(node);
+    if (typeParameterList === undefined)
+        return;
+    const typeParameters = typeParameterList.nodes;
+    if (typeParameters.length > 1 && areUnreferencedTypeParameters(c, typeParameters)) {
+        const file = getSourceFileOfNode(node);
+        const text = file.text;
+        const end = Math.min(text.length, skipTrivia(text, typeParameterList.end) + 1);
+        reportUnused(c, node, 1 /* UnusedKind.Parameter */, new Diagnostic(file.diagnosticFile(), typeParameterList.pos - 1, end, 1358 /* Diagnostics.All_type_parameters_are_unused */));
+        return;
+    }
+    for (const typeParameter of typeParameters)
+        if (isUnreferencedTypeParameter(c, typeParameter))
+            reportUnused(c, node, 1 /* UnusedKind.Parameter */, createDiagnosticForNode(typeParameter, 1349 /* Diagnostics.X_0_is_declared_but_never_used */, [
+                getText(getName(typeParameter)),
+            ]));
+}
+function isUnreferencedTypeParameter(c, typeParameter) {
+    const symbol = getSymbol(typeParameter);
+    const referenceKinds = symbol === undefined ? 0 : c.symbolReferenceKinds.get(getSymbolId(getMergedSymbol(c, symbol)));
+    return ((referenceKinds & 262144 /* SymbolFlags.TypeParameter */) === 0 && !isIdentifierThatStartsWithUnderscore(getName(typeParameter)));
+}
+function allDeclarationsInSameSourceFile(symbol) {
+    const declarations = symbol.declarations;
+    if (declarations.length <= 1)
+        return true;
+    const file = getSourceFileOfNode(declarations[0]);
+    for (let i = 1; i < declarations.length; i++)
+        if (getSourceFileOfNode(declarations[i]) !== file)
+            return false;
+    return true;
+}

package/dist/api/compiler/checker-utilities.d.ts

@@ -0,0 +1,33 @@
+import { type Node } from './ast.js';
+import type { Checker } from './checker.js';
+import { type Type, TypeFlags } from './checker-types.js';
+export declare function isTypeUsableAsPropertyName(t: Type): boolean;
+/** The member name a literal or unique symbol type denotes. */
+export declare function getPropertyNameFromType(t: Type): string;
+/** Whether `ToString(ToNumber(name))` is `name`; true for Infinity, -Infinity and NaN. */
+export declare function isNumericLiteralName(name: string): boolean;
+/** Names of members keyed by unique symbols. */
+export declare function isLateBoundName(name: string): boolean;
+export declare function maybeTypeOfKind(t: Type, kind: TypeFlags): boolean;
+export declare function isValidIndexKeyType(c: Checker, t: Type): boolean;
+/** A computed name of entity-name form whose type is a literal or unique symbol. */
+export declare function hasLateBindableName(c: Checker, node: Node): boolean;
+/** Whether a computed name or `F[name]` target has a unique symbol or literal type. */
+export declare function isLateBindableName(c: Checker, name: Node): boolean;
+/** The name of a member, or the `F[name]` target of a JavaScript element access assignment. */
+export declare function getLateBindableNameOfDeclaration(node: Node): Node | undefined;
+export declare function hasLateBindableIndexSignature(c: Checker, node: Node): boolean;
+/** Whether a declaration's name is a computed name that isn't a literal. */
+export declare function hasDynamicName(node: Node): boolean;
+export declare const enum FunctionFlags {
+    Normal = 0,
+    Generator = 1,
+    Async = 2,
+    Invalid = 4,
+    AsyncGenerator = 3
+}
+/** Whether a function-like declaration is async and/or a generator. */
+export declare function getFunctionFlags(node: Node | undefined): FunctionFlags;
+export declare function isBindingPattern(node: Node | undefined): boolean;
+/** The index of the node with `node`'s range among `nodes`, which are in source order; -1 if none. */
+export declare function indexOfNode(nodes: readonly Node[], node: Node): number;