tsc-ts 0.0.9 → 0.1.0

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

@@ -10,7 +10,6 @@ import { Diagnostic } from './diagnostics.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';
@@ -31,38 +30,38 @@ function accessKind(node) {
     if (parent === undefined)
         return 0 /* AccessKind.Read */;
     switch (parent.kind) {
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return accessKind(parent);
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
-        case 226 /* SyntaxKind.PostfixUnaryExpression */: {
-            const operator = parent.kind === 225 /* SyntaxKind.PrefixUnaryExpression */
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */: {
+            const operator = parent.kind === 226 /* 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 */: {
+        case 228 /* 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 */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent);
-        case 303 /* SyntaxKind.PropertyAssignment */: {
+        case 304 /* 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 */:
+        case 305 /* 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 */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
             return node === parent.initializer ? 1 /* AccessKind.Write */ : 0 /* AccessKind.Read */;
     }
     return 0 /* AccessKind.Read */;
@@ -86,7 +85,7 @@ export function isSelfTypeAccess(c, name, parent) {
 }
 function isEntityNameExpression(node) {
     let current = node;
-    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    while (current.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         if (getName(current).kind !== 79 /* SyntaxKind.Identifier */)
             return false;
         current = current.expression;
@@ -95,7 +94,7 @@ function isEntityNameExpression(node) {
 }
 function getFirstIdentifierOfExpression(node) {
     let current = node;
-    while (current.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+    while (current.kind === 213 /* SyntaxKind.PropertyAccessExpression */)
         current = current.expression;
     return current;
 }
@@ -129,7 +128,7 @@ export function markPropertyAsReferenced(c, prop, nodeForCheckWriteOnly, isSelfT
 }
 /** 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 */)
+    if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
         return;
     const nameType = getLiteralTypeFromPropertyName(c, name);
     if (nameType === undefined || !isTypeUsableAsPropertyName(nameType))
@@ -140,13 +139,13 @@ export function markDestructuredPropertyAsReferenced(c, objectType, name, locati
 }
 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 */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return true;
     }
     return false;
@@ -171,7 +170,7 @@ class PotentiallyUnusedCollector extends NodeVisitor {
     }
     visitNode(node) {
         // The body of a `with` statement isn't checked.
-        if (node.kind === 255 /* SyntaxKind.WithStatement */)
+        if (node.kind === 256 /* SyntaxKind.WithStatement */)
             this.visitNode(getExpression(node));
         else if (!this.isUnchecked(node))
             node.forEachChild(this);
@@ -180,90 +179,87 @@ class PotentiallyUnusedCollector extends NodeVisitor {
         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.
+     * Whether the checker skips the children of `node`: a decorator of a declaration that can't be decorated
+     * is reported as an error and not checked further. (The expression of a `return` outside a function
+     * body, or in a class static block, is still checked.)
      */
     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;
+        if (node.kind !== 172 /* SyntaxKind.Decorator */)
+            return false;
+        const declaration = node.parent;
+        return !nodeCanBeDecorated(this.legacyDecorators, declaration, declaration.parent, declaration.parent?.parent);
     }
 }
 function isPotentiallyUnusedContainer(node) {
     switch (node.kind) {
-        case 307 /* SyntaxKind.SourceFile */:
+        case 308 /* 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 */: {
+        case 243 /* SyntaxKind.Block */:
+        case 271 /* SyntaxKind.CaseBlock */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */: {
             const locals = getLocals(node);
             return locals !== undefined && locals.size !== 0;
         }
-        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
             return getBody(node) !== undefined && !isGlobalScopeAugmentation(node);
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */: {
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* 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 */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* SyntaxKind.ClassExpression */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 197 /* SyntaxKind.InferType */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* SyntaxKind.SetAccessor */:
+        case 175 /* SyntaxKind.MethodSignature */:
+        case 181 /* SyntaxKind.CallSignature */:
+        case 182 /* SyntaxKind.ConstructSignature */:
+        case 186 /* SyntaxKind.FunctionType */:
+        case 187 /* SyntaxKind.ConstructorType */:
             return true;
     }
     return false;
 }
 function checkUnusedIdentifiersOfNode(c, node) {
     switch (node.kind) {
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 233 /* 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 */:
+        case 308 /* SyntaxKind.SourceFile */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 243 /* SyntaxKind.Block */:
+        case 271 /* SyntaxKind.CaseBlock */:
+        case 250 /* SyntaxKind.ForStatement */:
+        case 251 /* SyntaxKind.ForInStatement */:
+        case 252 /* SyntaxKind.ForOfStatement */:
+        case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
             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 */:
+        case 178 /* SyntaxKind.Constructor */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 221 /* SyntaxKind.ArrowFunction */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
+        case 179 /* SyntaxKind.GetAccessor */:
+        case 180 /* 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 */:
+        case 197 /* SyntaxKind.InferType */:
             checkUnusedInferTypeParameter(c, node);
             return;
     }
@@ -287,21 +283,21 @@ function reportUnused(c, location, kind, 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 */)
+    while (current.kind === 210 /* SyntaxKind.BindingElement */ ||
+        current.kind === 208 /* SyntaxKind.ObjectBindingPattern */ ||
+        current.kind === 209 /* SyntaxKind.ArrayBindingPattern */)
         current = current.parent;
-    reportUnused(c, current, current.kind === 170 /* SyntaxKind.Parameter */ ? 1 /* UnusedKind.Parameter */ : 0 /* UnusedKind.Local */, diagnostic);
+    reportUnused(c, current, current.kind === 171 /* 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 */: {
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */: {
                 // An unused accessor pair is reported on the getter.
-                if (member.kind === 179 /* SyntaxKind.SetAccessor */ && (getSymbol(member).flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
+                if (member.kind === 180 /* SyntaxKind.SetAccessor */ && (getSymbol(member).flags & 32768 /* SymbolFlags.GetAccessor */) !== 0)
                     break;
                 const symbol = getSymbolOfDeclaration(c, member);
                 const name = getName(member);
@@ -309,18 +305,18 @@ function checkUnusedClassMembers(c, node) {
                     ((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 */, [
+                    reportUnused(c, member, 0 /* UnusedKind.Local */, createDiagnosticForNode(name, 1309 /* Diagnostics.X_0_is_declared_but_its_value_is_never_read */, [
                         symbolToString(c, symbol),
                     ]));
                 break;
             }
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* 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]));
+                        reportUnused(c, parameter, 0 /* UnusedKind.Local */, createDiagnosticForNode(getName(parameter), 1314 /* Diagnostics.Property_0_is_declared_but_its_value_is_never_read */, [symbol.name]));
                 }
                 break;
         }
@@ -344,14 +340,14 @@ function checkUnusedLocalsAndParameters(c, node) {
             continue;
         for (const declaration of getDeclarations(local)) {
             switch (declaration.kind) {
-                case 261 /* SyntaxKind.VariableDeclaration */:
-                case 170 /* SyntaxKind.Parameter */:
-                case 209 /* SyntaxKind.BindingElement */:
+                case 262 /* SyntaxKind.VariableDeclaration */:
+                case 171 /* SyntaxKind.Parameter */:
+                case 210 /* SyntaxKind.BindingElement */:
                     variableParents.add(getRootDeclaration(declaration).parent);
                     break;
-                case 274 /* SyntaxKind.ImportClause */:
-                case 277 /* SyntaxKind.ImportSpecifier */:
-                case 275 /* SyntaxKind.NamespaceImport */:
+                case 275 /* SyntaxKind.ImportClause */:
+                case 278 /* SyntaxKind.ImportSpecifier */:
+                case 276 /* SyntaxKind.NamespaceImport */:
                     if (!isIdentifierThatStartsWithUnderscore(getName(declaration))) {
                         const importClause = importClauseFromImported(declaration);
                         const unuseds = importClauses.get(importClause);
@@ -362,13 +358,13 @@ function checkUnusedLocalsAndParameters(c, node) {
                     }
                     break;
                 default:
-                    if (declaration.kind !== 169 /* SyntaxKind.TypeParameter */ && !isAmbientModule(declaration))
+                    if (declaration.kind !== 170 /* SyntaxKind.TypeParameter */ && !isAmbientModule(declaration))
                         reportUnusedLocal(c, declaration, local.name);
             }
         }
     }
     for (const declaration of variableParents) {
-        if (declaration.kind === 262 /* SyntaxKind.VariableDeclarationList */)
+        if (declaration.kind === 263 /* SyntaxKind.VariableDeclarationList */)
             reportUnusedVariables(c, declaration, declaration.declarations.nodes);
         else
             reportUnusedVariableDeclarations(c, getParameters(declaration).nodes);
@@ -378,20 +374,20 @@ function checkUnusedLocalsAndParameters(c, node) {
 }
 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 */;
+        ? 1360 /* Diagnostics.X_0_is_declared_but_never_used */
+        : 1309 /* 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 */, []));
+        reportUnusedVariable(c, node, createDiagnosticForNode(node, 1363 /* 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 */, []));
+        reportUnusedVariable(c, node, createDiagnosticForNode(node, 1362 /* Diagnostics.All_destructured_elements_are_unused */, []));
     else
         reportUnusedVariableDeclarations(c, declarations);
 }
@@ -402,14 +398,14 @@ function reportUnusedVariableDeclarations(c, declarations) {
             isParameterPropertyDeclaration(declaration, declaration.parent) ||
             isThisParameter(declaration))
             continue;
-        if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+        if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* 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)]));
+            reportUnusedVariable(c, declaration, createDiagnosticForNode(name, 1309 /* Diagnostics.X_0_is_declared_but_its_value_is_never_read */, [getText(name)]));
     }
 }
 function isThisParameter(node) {
-    if (node.kind !== 170 /* SyntaxKind.Parameter */)
+    if (node.kind !== 171 /* SyntaxKind.Parameter */)
         return false;
     const name = getName(node);
     return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && getText(name) === 'this';
@@ -424,39 +420,39 @@ function isUnreferencedVariableDeclaration(c, node) {
     const name = getName(node);
     if (name === undefined)
         return true;
-    if (name.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 208 /* SyntaxKind.ArrayBindingPattern */)
+    if (name.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || name.kind === 209 /* 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 */) {
+    if (node.kind === 210 /* SyntaxKind.BindingElement */ && parent.kind === 208 /* 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 */ &&
+    const underscoreExempt = node.kind === 171 /* SyntaxKind.Parameter */ ||
+        (node.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
             (isForInOrOfStatement(parent.parent) || (getCombinedNodeFlags(node) & 4 /* NodeFlags.Using */) !== 0)) ||
-        (node.kind === 209 /* SyntaxKind.BindingElement */ &&
-            !(parent.kind === 207 /* SyntaxKind.ObjectBindingPattern */ && getPropertyName(node) === undefined));
+        (node.kind === 210 /* SyntaxKind.BindingElement */ &&
+            !(parent.kind === 208 /* SyntaxKind.ObjectBindingPattern */ && getPropertyName(node) === undefined));
     return !(underscoreExempt && isIdentifierThatStartsWithUnderscore(name));
 }
 function isForInOrOfStatement(node) {
-    return node.kind === 250 /* SyntaxKind.ForInStatement */ || node.kind === 251 /* SyntaxKind.ForOfStatement */;
+    return node.kind === 251 /* SyntaxKind.ForInStatement */ || node.kind === 252 /* 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 */)
+        if (namedBindings.kind === 276 /* 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 */, []));
+        reportUnused(c, node, 0 /* UnusedKind.Local */, createDiagnosticForNode(node.parent, 1356 /* Diagnostics.All_imports_in_import_declaration_are_unused */, []));
     else
         for (const unused of unuseds)
             reportUnusedLocal(c, unused, getText(getName(unused)));
@@ -466,9 +462,9 @@ function isIdentifierThatStartsWithUnderscore(node) {
 }
 function importClauseFromImported(node) {
     switch (node.kind) {
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return node;
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return node.parent;
     }
     return node.parent.parent;
@@ -476,7 +472,7 @@ function importClauseFromImported(node) {
 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 */, [
+        reportUnused(c, node, 1 /* UnusedKind.Parameter */, createDiagnosticForNode(typeParameter.name, 1360 /* Diagnostics.X_0_is_declared_but_never_used */, [
             getText(typeParameter.name),
         ]));
 }
@@ -498,12 +494,12 @@ function checkUnusedTypeParameters(c, node) {
         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 */));
+        reportUnused(c, node, 1 /* UnusedKind.Parameter */, new Diagnostic(file.diagnosticFile(), typeParameterList.pos - 1, end, 1369 /* 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 */, [
+            reportUnused(c, node, 1 /* UnusedKind.Parameter */, createDiagnosticForNode(typeParameter, 1360 /* Diagnostics.X_0_is_declared_but_never_used */, [
                 getText(getName(typeParameter)),
             ]));
 }

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

@@ -45,7 +45,7 @@ export function isValidIndexKeyType(c, t) {
 function isEntityNameExpression(node) {
     if (node.kind === 79 /* SyntaxKind.Identifier */)
         return true;
-    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+    if (node.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
         const name = getName(node);
         return name !== undefined && name.kind === 79 /* SyntaxKind.Identifier */ && isEntityNameExpression(getExpression(node));
     }
@@ -53,9 +53,9 @@ function isEntityNameExpression(node) {
 }
 function isLateBindableAST(node) {
     let expr;
-    if (node.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (node.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         expr = getExpression(node);
-    else if (node.kind === 213 /* SyntaxKind.ElementAccessExpression */)
+    else if (node.kind === 214 /* SyntaxKind.ElementAccessExpression */)
         expr = node.argumentExpression;
     return expr !== undefined && isEntityNameExpression(expr);
 }
@@ -68,7 +68,7 @@ export function hasLateBindableName(c, node) {
 export function isLateBindableName(c, name) {
     if (!isLateBindableAST(name))
         return false;
-    if (name.kind === 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name.kind === 169 /* SyntaxKind.ComputedPropertyName */)
         return isTypeUsableAsPropertyName(checkComputedPropertyName(c, name));
     return isTypeUsableAsPropertyName(checkExpressionCached(c, name.argumentExpression));
 }
@@ -78,14 +78,14 @@ export function getLateBindableNameOfDeclaration(node) {
 }
 export function hasLateBindableIndexSignature(c, node) {
     const name = getName(node);
-    if (name === undefined || !isLateBindableAST(name) || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name === undefined || !isLateBindableAST(name) || name.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
         return false;
     return isTypeAssignableTo(c, checkComputedPropertyName(c, name), c.stringNumberSymbolType);
 }
 /** Whether a declaration's name is a computed name that isn't a literal. */
 export function hasDynamicName(node) {
     const name = getName(node);
-    if (name === undefined || name.kind !== 168 /* SyntaxKind.ComputedPropertyName */)
+    if (name === undefined || name.kind !== 169 /* SyntaxKind.ComputedPropertyName */)
         return false;
     const e = getExpression(name);
     return !(e.kind === 10 /* SyntaxKind.StringLiteral */ ||
@@ -98,15 +98,15 @@ export function getFunctionFlags(node) {
         return 4 /* FunctionFlags.Invalid */;
     let flags = 0 /* FunctionFlags.Normal */;
     switch (node.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             if (getAsteriskToken(node) !== undefined)
                 flags |= 1 /* FunctionFlags.Generator */;
             if (hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */))
                 flags |= 2 /* FunctionFlags.Async */;
             break;
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             if (hasSyntacticModifier(node, 1024 /* ModifierFlags.Async */))
                 flags |= 2 /* FunctionFlags.Async */;
             break;
@@ -117,7 +117,7 @@ export function getFunctionFlags(node) {
 }
 export function isBindingPattern(node) {
     return (node !== undefined &&
-        (node.kind === 207 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 208 /* SyntaxKind.ArrayBindingPattern */));
+        (node.kind === 208 /* SyntaxKind.ObjectBindingPattern */ || node.kind === 209 /* SyntaxKind.ArrayBindingPattern */));
 }
 /** The index of the node with `node`'s range among `nodes`, which are in source order; -1 if none. */
 export function indexOfNode(nodes, node) {