@typescript-eslint/typescript-estree 8.50.2-alpha.7 → 8.50.2-alpha.9

package/dist/convert.js

@@ -709,8 +709,8 @@ class Converter {
                 return this.fixExports(node, result);
             }
             case SyntaxKind.VariableDeclaration: {
-                const definite = !!node.exclamationToken;
-                if (definite) {
+                const hasExclamationToken = !!node.exclamationToken;
+                if (hasExclamationToken) {
                     if (node.initializer) {
                         this.#throwError(node, 'Declarations with initializers cannot also have definite assignment assertions.');
                     }
@@ -718,60 +718,72 @@ class Converter {
                         this.#throwError(node, 'Declarations with definite assignment assertions must also have type annotations.');
                     }
                 }
+                if (node.parent.kind === SyntaxKind.VariableDeclarationList) {
+                    const variableDeclarationList = node.parent;
+                    const kind = (0, node_utils_1.getDeclarationKind)(variableDeclarationList);
+                    if ((variableDeclarationList.parent.kind ===
+                        SyntaxKind.ForInStatement ||
+                        variableDeclarationList.parent.kind ===
+                            SyntaxKind.ForStatement) &&
+                        (kind === 'using' || kind === 'await using')) {
+                        if (!node.initializer) {
+                            this.#throwError(node, `'${kind}' declarations may not be initialized in for statement.`);
+                        }
+                        if (node.name.kind !== SyntaxKind.Identifier) {
+                            this.#throwError(node.name, `'${kind}' declarations may not have binding patterns.`);
+                        }
+                    }
+                    if (variableDeclarationList.parent.kind === SyntaxKind.VariableStatement) {
+                        const variableStatement = variableDeclarationList.parent;
+                        if (kind === 'using' || kind === 'await using') {
+                            if (!node.initializer) {
+                                this.#throwError(node, `'${kind}' declarations must be initialized.`);
+                            }
+                            if (node.name.kind !== SyntaxKind.Identifier) {
+                                this.#throwError(node.name, `'${kind}' declarations may not have binding patterns.`);
+                            }
+                        }
+                        const hasDeclareKeyword = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, variableStatement);
+                        // Definite assignment only allowed for non-declare let and var
+                        if ((hasDeclareKeyword ||
+                            ['await using', 'const', 'using'].includes(kind)) &&
+                            hasExclamationToken) {
+                            this.#throwError(node, `A definite assignment assertion '!' is not permitted in this context.`);
+                        }
+                        if (hasDeclareKeyword &&
+                            node.initializer &&
+                            (['let', 'var'].includes(kind) || node.type)) {
+                            this.#throwError(node, `Initializers are not permitted in ambient contexts.`);
+                        }
+                        // Theoretically, only certain initializers are allowed for declare const,
+                        // (TS1254: A 'const' initializer in an ambient context must be a string
+                        // or numeric literal or literal enum reference.) but we just allow
+                        // all expressions
+                        // Note! No-declare does not mean the variable is not ambient, because
+                        // it can be further nested in other declare contexts. Therefore we cannot
+                        // check for const initializers.
+                    }
+                }
                 const init = this.convertChild(node.initializer);
                 const id = this.convertBindingNameWithTypeAnnotation(node.name, node.type, node);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.VariableDeclarator,
-                    definite,
+                    definite: hasExclamationToken,
                     id,
                     init,
                 });
             }
             case SyntaxKind.VariableStatement: {
+                const declarations = node.declarationList.declarations;
+                if (!declarations.length) {
+                    this.#throwError(node, 'A variable declaration list must have at least one variable declarator.');
+                }
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.VariableDeclaration,
-                    declarations: this.convertChildren(node.declarationList.declarations),
+                    declarations: this.convertChildren(declarations),
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
                     kind: (0, node_utils_1.getDeclarationKind)(node.declarationList),
                 });
-                if (!result.declarations.length) {
-                    this.#throwError(node, 'A variable declaration list must have at least one variable declarator.');
-                }
-                if (result.kind === 'using' || result.kind === 'await using') {
-                    node.declarationList.declarations.forEach((declaration, i) => {
-                        if (result.declarations[i].init == null) {
-                            this.#throwError(declaration, `'${result.kind}' declarations must be initialized.`);
-                        }
-                        if (result.declarations[i].id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                            this.#throwError(declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
-                        }
-                    });
-                }
-                // Definite assignment only allowed for non-declare let and var
-                if (result.declare ||
-                    ['await using', 'const', 'using'].includes(result.kind)) {
-                    node.declarationList.declarations.forEach((declaration, i) => {
-                        if (result.declarations[i].definite) {
-                            this.#throwError(declaration, `A definite assignment assertion '!' is not permitted in this context.`);
-                        }
-                    });
-                }
-                if (result.declare) {
-                    node.declarationList.declarations.forEach((declaration, i) => {
-                        if (result.declarations[i].init &&
-                            (['let', 'var'].includes(result.kind) ||
-                                result.declarations[i].id.typeAnnotation)) {
-                            this.#throwError(declaration, `Initializers are not permitted in ambient contexts.`);
-                        }
-                    });
-                    // Theoretically, only certain initializers are allowed for declare const,
-                    // (TS1254: A 'const' initializer in an ambient context must be a string
-                    // or numeric literal or literal enum reference.) but we just allow
-                    // all expressions
-                }
-                // Note! No-declare does not mean the variable is not ambient, because
-                // it can be further nested in other declare contexts. Therefore we cannot
-                // check for const initializers.
                 /**
                  * Semantically, decorators are not allowed on variable declarations,
                  * Pre 4.8 TS would include them in the AST, so we did as well.
@@ -783,23 +795,12 @@ class Converter {
             }
             // mostly for for-of, for-in
             case SyntaxKind.VariableDeclarationList: {
-                const result = this.createNode(node, {
+                return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.VariableDeclaration,
                     declarations: this.convertChildren(node.declarations),
                     declare: false,
                     kind: (0, node_utils_1.getDeclarationKind)(node),
                 });
-                if (result.kind === 'using' || result.kind === 'await using') {
-                    node.declarations.forEach((declaration, i) => {
-                        if (result.declarations[i].init != null) {
-                            this.#throwError(declaration, `'${result.kind}' declarations may not be initialized in for statement.`);
-                        }
-                        if (result.declarations[i].id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                            this.#throwError(declaration.name, `'${result.kind}' declarations may not have binding patterns.`);
-                        }
-                    });
-                }
-                return result;
             }
             // Expressions
             case SyntaxKind.ExpressionStatement:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.50.2-alpha.7",
+  "version": "8.50.2-alpha.9",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -52,10 +52,10 @@
     "typecheck": "yarn run -BT nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/project-service": "8.50.2-alpha.7",
-    "@typescript-eslint/tsconfig-utils": "8.50.2-alpha.7",
-    "@typescript-eslint/types": "8.50.2-alpha.7",
-    "@typescript-eslint/visitor-keys": "8.50.2-alpha.7",
+    "@typescript-eslint/project-service": "8.50.2-alpha.9",
+    "@typescript-eslint/tsconfig-utils": "8.50.2-alpha.9",
+    "@typescript-eslint/types": "8.50.2-alpha.9",
+    "@typescript-eslint/visitor-keys": "8.50.2-alpha.9",
     "debug": "^4.3.4",
     "minimatch": "^9.0.4",
     "semver": "^7.6.0",