@typescript-eslint/typescript-estree 8.51.1-alpha.1 → 8.51.1-alpha.11

package/dist/ast-converter.js

@@ -53,7 +53,7 @@ function astConverter(ast, parseSettings, shouldPreserveNodeMaps) {
      * Optionally convert and include all comments in the AST
      */
     if (parseSettings.comment) {
-        estree.comments = (0, convert_comments_1.convertComments)(ast, parseSettings.codeFullText);
+        estree.comments = (0, convert_comments_1.convertComments)(ast);
     }
     const astMaps = instance.getASTMaps();
     return { astMaps, estree };

package/dist/check-syntax-errors.d.ts

@@ -0,0 +1,2 @@
+import * as ts from 'typescript';
+export declare function checkSyntaxError(tsNode: ts.Node): void;

package/dist/check-syntax-errors.js

@@ -0,0 +1,303 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSyntaxError = checkSyntaxError;
+const ts = __importStar(require("typescript"));
+const check_modifiers_1 = require("./check-modifiers");
+const node_utils_1 = require("./node-utils");
+const SyntaxKind = ts.SyntaxKind;
+function checkSyntaxError(tsNode) {
+    (0, check_modifiers_1.checkModifiers)(tsNode);
+    const node = tsNode;
+    switch (node.kind) {
+        case SyntaxKind.SwitchStatement:
+            if (node.caseBlock.clauses.filter(switchCase => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
+                throw (0, node_utils_1.createError)(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
+            }
+            break;
+        case SyntaxKind.ThrowStatement:
+            if (node.expression.end === node.expression.pos) {
+                throw (0, node_utils_1.createError)(node, 'A throw statement must throw an expression.');
+            }
+            break;
+        case SyntaxKind.CatchClause:
+            if (node.variableDeclaration?.initializer) {
+                throw (0, node_utils_1.createError)(node.variableDeclaration.initializer, 'Catch clause variable cannot have an initializer.');
+            }
+            break;
+        case SyntaxKind.FunctionDeclaration: {
+            const isDeclare = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
+            const isAsync = (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node);
+            const isGenerator = !!node.asteriskToken;
+            if (isDeclare) {
+                if (node.body) {
+                    throw (0, node_utils_1.createError)(node, 'An implementation cannot be declared in ambient contexts.');
+                }
+                else if (isAsync) {
+                    throw (0, node_utils_1.createError)(node, "'async' modifier cannot be used in an ambient context.");
+                }
+                else if (isGenerator) {
+                    throw (0, node_utils_1.createError)(node, 'Generators are not allowed in an ambient context.');
+                }
+            }
+            else if (!node.body && isGenerator) {
+                throw (0, node_utils_1.createError)(node, 'A function signature cannot be declared as a generator.');
+            }
+            break;
+        }
+        case SyntaxKind.VariableDeclaration: {
+            const hasExclamationToken = !!node.exclamationToken;
+            if (hasExclamationToken) {
+                if (node.initializer) {
+                    throw (0, node_utils_1.createError)(node, 'Declarations with initializers cannot also have definite assignment assertions.');
+                }
+                else if (node.name.kind !== SyntaxKind.Identifier || !node.type) {
+                    throw (0, node_utils_1.createError)(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) {
+                        throw (0, node_utils_1.createError)(node, `'${kind}' declarations may not be initialized in for statement.`);
+                    }
+                    if (node.name.kind !== SyntaxKind.Identifier) {
+                        throw (0, node_utils_1.createError)(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) {
+                            throw (0, node_utils_1.createError)(node, `'${kind}' declarations must be initialized.`);
+                        }
+                        if (node.name.kind !== SyntaxKind.Identifier) {
+                            throw (0, node_utils_1.createError)(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) {
+                        throw (0, node_utils_1.createError)(node, `A definite assignment assertion '!' is not permitted in this context.`);
+                    }
+                    if (hasDeclareKeyword &&
+                        node.initializer &&
+                        (['let', 'var'].includes(kind) || node.type)) {
+                        throw (0, node_utils_1.createError)(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.
+                }
+            }
+            break;
+        }
+        case SyntaxKind.VariableStatement: {
+            const declarations = node.declarationList.declarations;
+            if (!declarations.length) {
+                throw (0, node_utils_1.createError)(node, 'A variable declaration list must have at least one variable declarator.');
+            }
+            break;
+        }
+        case SyntaxKind.PropertyAssignment: {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const { exclamationToken, questionToken } = node;
+            if (questionToken) {
+                throw (0, node_utils_1.createError)(questionToken, 'A property assignment cannot have a question token.');
+            }
+            if (exclamationToken) {
+                throw (0, node_utils_1.createError)(exclamationToken, 'A property assignment cannot have an exclamation token.');
+            }
+            break;
+        }
+        case SyntaxKind.ShorthandPropertyAssignment: {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const { exclamationToken, modifiers, questionToken } = node;
+            if (modifiers) {
+                throw (0, node_utils_1.createError)(modifiers[0], 'A shorthand property assignment cannot have modifiers.');
+            }
+            if (questionToken) {
+                throw (0, node_utils_1.createError)(questionToken, 'A shorthand property assignment cannot have a question token.');
+            }
+            if (exclamationToken) {
+                throw (0, node_utils_1.createError)(exclamationToken, 'A shorthand property assignment cannot have an exclamation token.');
+            }
+            break;
+        }
+        case SyntaxKind.PropertyDeclaration: {
+            const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
+            if (isAbstract && node.initializer) {
+                throw (0, node_utils_1.createError)(node.initializer, `Abstract property cannot have an initializer.`);
+            }
+            if (node.name.kind === SyntaxKind.StringLiteral &&
+                node.name.text === 'constructor') {
+                throw (0, node_utils_1.createError)(node.name, "Classes may not have a field named 'constructor'.");
+            }
+            break;
+        }
+        case SyntaxKind.TaggedTemplateExpression:
+            if (node.tag.flags & ts.NodeFlags.OptionalChain) {
+                throw (0, node_utils_1.createError)(node, 'Tagged template expressions are not permitted in an optional chain.');
+            }
+            break;
+        case SyntaxKind.ClassDeclaration:
+            if (!node.name &&
+                (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) ||
+                    !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
+                throw (0, node_utils_1.createError)(node, "A class declaration without the 'default' modifier must have a name.");
+            }
+            break;
+        case SyntaxKind.BinaryExpression:
+            if (node.operatorToken.kind !== SyntaxKind.InKeyword &&
+                node.left.kind === SyntaxKind.PrivateIdentifier) {
+                throw (0, node_utils_1.createError)(node.left, "Private identifiers cannot appear on the right-hand-side of an 'in' expression.");
+            }
+            else if (node.right.kind === SyntaxKind.PrivateIdentifier) {
+                throw (0, node_utils_1.createError)(node.right, "Private identifiers are only allowed on the left-hand-side of an 'in' expression.");
+            }
+            break;
+        case SyntaxKind.MappedType:
+            if (node.members && node.members.length > 0) {
+                throw (0, node_utils_1.createError)(node.members[0], 'A mapped type may not declare properties or methods.');
+            }
+            break;
+        case SyntaxKind.PropertySignature: {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const { initializer } = node;
+            if (initializer) {
+                throw (0, node_utils_1.createError)(initializer, 'A property signature cannot have an initializer.');
+            }
+            break;
+        }
+        case SyntaxKind.FunctionType: {
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            const { modifiers } = node;
+            if (modifiers) {
+                throw (0, node_utils_1.createError)(modifiers[0], 'A function type cannot have modifiers.');
+            }
+            break;
+        }
+        case SyntaxKind.EnumMember: {
+            const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
+            if (computed) {
+                throw (0, node_utils_1.createError)(node.name, 'Computed property names are not allowed in enums.');
+            }
+            if (node.name.kind === SyntaxKind.NumericLiteral ||
+                node.name.kind === SyntaxKind.BigIntLiteral) {
+                throw (0, node_utils_1.createError)(node.name, 'An enum member cannot have a numeric name.');
+            }
+            break;
+        }
+        case SyntaxKind.ExternalModuleReference:
+            if (node.expression.kind !== SyntaxKind.StringLiteral) {
+                throw (0, node_utils_1.createError)(node.expression, 'String literal expected.');
+            }
+            break;
+        case SyntaxKind.PrefixUnaryExpression:
+        case SyntaxKind.PostfixUnaryExpression: {
+            const operator = (0, node_utils_1.getTextForTokenKind)(node.operator);
+            /**
+             * ESTree uses UpdateExpression for ++/--
+             */
+            if ((operator === '++' || operator === '--') &&
+                !(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
+                throw (0, node_utils_1.createError)(node.operand, 'Invalid left-hand side expression in unary operation');
+            }
+            break;
+        }
+        case SyntaxKind.ImportDeclaration:
+            assertModuleSpecifier(node, false);
+            break;
+        case SyntaxKind.ExportDeclaration:
+            assertModuleSpecifier(node, node.exportClause?.kind === SyntaxKind.NamedExports);
+            break;
+        case SyntaxKind.CallExpression:
+            if (node.expression.kind === SyntaxKind.ImportKeyword &&
+                node.arguments.length !== 1 &&
+                node.arguments.length !== 2) {
+                throw (0, node_utils_1.createError)(node.arguments.length > 1 ? node.arguments[2] : node, 'Dynamic import requires exactly one or two arguments.');
+            }
+            break;
+        case SyntaxKind.ForInStatement:
+        case SyntaxKind.ForOfStatement: {
+            checkForStatementDeclaration(node);
+            break;
+        }
+        // No default
+    }
+}
+function checkForStatementDeclaration(node) {
+    const { initializer, kind } = node;
+    const loop = kind === SyntaxKind.ForInStatement ? 'for...in' : 'for...of';
+    if (ts.isVariableDeclarationList(initializer)) {
+        if (initializer.declarations.length !== 1) {
+            throw (0, node_utils_1.createError)(initializer, `Only a single variable declaration is allowed in a '${loop}' statement.`);
+        }
+        const declaration = initializer.declarations[0];
+        if (declaration.initializer) {
+            throw (0, node_utils_1.createError)(declaration, `The variable declaration of a '${loop}' statement cannot have an initializer.`);
+        }
+        else if (declaration.type) {
+            throw (0, node_utils_1.createError)(declaration, `The variable declaration of a '${loop}' statement cannot have a type annotation.`);
+        }
+        if (kind === SyntaxKind.ForInStatement &&
+            initializer.flags & ts.NodeFlags.Using) {
+            throw (0, node_utils_1.createError)(initializer, "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.");
+        }
+    }
+    else if (!(0, node_utils_1.isValidAssignmentTarget)(initializer) &&
+        initializer.kind !== SyntaxKind.ObjectLiteralExpression &&
+        initializer.kind !== SyntaxKind.ArrayLiteralExpression) {
+        throw (0, node_utils_1.createError)(initializer, `The left-hand side of a '${loop}' statement must be a variable or a property access.`);
+    }
+}
+function assertModuleSpecifier(node, allowNull) {
+    if (!allowNull && node.moduleSpecifier == null) {
+        throw (0, node_utils_1.createError)(node, 'Module specifier must be a string literal.');
+    }
+    if (node.moduleSpecifier &&
+        node.moduleSpecifier.kind !== SyntaxKind.StringLiteral) {
+        throw (0, node_utils_1.createError)(node.moduleSpecifier, 'Module specifier must be a string literal.');
+    }
+}

package/dist/convert-comments.d.ts

@@ -3,8 +3,7 @@ import type { TSESTree } from './ts-estree';
 /**
  * Convert all comments for the given AST.
  * @param ast the AST object
- * @param code the TypeScript code
  * @returns the converted ESTreeComment
  * @private
  */
-export declare function convertComments(ast: ts.SourceFile, code: string): TSESTree.Comment[];
+export declare function convertComments(ast: ts.SourceFile): TSESTree.Comment[];

package/dist/convert-comments.js

@@ -41,31 +41,21 @@ const ts_estree_1 = require("./ts-estree");
 /**
  * Convert all comments for the given AST.
  * @param ast the AST object
- * @param code the TypeScript code
  * @returns the converted ESTreeComment
  * @private
  */
-function convertComments(ast, code) {
-    const comments = [];
-    tsutils.forEachComment(ast, (_, comment) => {
-        const type = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
+function convertComments(ast) {
+    return Array.from(tsutils.iterateComments(ast), ({ end, kind, pos, value }) => {
+        const type = kind === ts.SyntaxKind.SingleLineCommentTrivia
             ? ts_estree_1.AST_TOKEN_TYPES.Line
             : ts_estree_1.AST_TOKEN_TYPES.Block;
-        const range = [comment.pos, comment.end];
+        const range = [pos, end];
         const loc = (0, node_utils_1.getLocFor)(range, ast);
-        // both comments start with 2 characters - /* or //
-        const textStart = range[0] + 2;
-        const textEnd = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
-            ? // single line comments end at the end
-                range[1]
-            : // multiline comments end 2 characters early
-                range[1] - 2;
-        comments.push({
+        return {
             type,
             loc,
             range,
-            value: code.slice(textStart, textEnd),
-        });
-    }, ast);
-    return comments;
+            value,
+        };
+    });
 }

package/dist/convert.d.ts

@@ -33,7 +33,6 @@ export declare class Converter {
      * @returns the converted ESTreeNode
      */
     constructor(ast: ts.SourceFile, options?: ConverterOptions);
-    private assertModuleSpecifier;
     private convertBindingNameWithTypeAnnotation;
     /**
      * Coverts body Nodes and add a directive field to StringLiterals
@@ -78,7 +77,7 @@ export declare class Converter {
      * @param node parent used to create this node
      * @returns TypeParameterInstantiation node
      */
-    private convertTypeArgumentsToTypeParameterInstantiation;
+    private convertTypeArguments;
     /**
      * Converts a ts.Node's typeParameters to TSTypeParameterDeclaration node
      * @param typeParameters ts.Node typeParameters

package/dist/convert.js

@@ -38,7 +38,7 @@ exports.convertError = convertError;
 // There's lots of funny stuff due to the typing of ts.Node
 /* eslint-disable @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-unnecessary-condition, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access */
 const ts = __importStar(require("typescript"));
-const check_modifiers_1 = require("./check-modifiers");
+const check_syntax_errors_1 = require("./check-syntax-errors");
 const getModifiers_1 = require("./getModifiers");
 const node_utils_1 = require("./node-utils");
 const ts_estree_1 = require("./ts-estree");
@@ -76,35 +76,11 @@ class Converter {
         this.ast = ast;
         this.options = { ...options };
     }
-    #checkForStatementDeclaration(initializer, kind) {
-        const loop = kind === ts.SyntaxKind.ForInStatement ? 'for...in' : 'for...of';
-        if (ts.isVariableDeclarationList(initializer)) {
-            if (initializer.declarations.length !== 1) {
-                this.#throwError(initializer, `Only a single variable declaration is allowed in a '${loop}' statement.`);
-            }
-            const declaration = initializer.declarations[0];
-            if (declaration.initializer) {
-                this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have an initializer.`);
-            }
-            else if (declaration.type) {
-                this.#throwError(declaration, `The variable declaration of a '${loop}' statement cannot have a type annotation.`);
-            }
-            if (kind === ts.SyntaxKind.ForInStatement &&
-                initializer.flags & ts.NodeFlags.Using) {
-                this.#throwError(initializer, "The left-hand side of a 'for...in' statement cannot be a 'using' declaration.");
-            }
-        }
-        else if (!(0, node_utils_1.isValidAssignmentTarget)(initializer) &&
-            initializer.kind !== ts.SyntaxKind.ObjectLiteralExpression &&
-            initializer.kind !== ts.SyntaxKind.ArrayLiteralExpression) {
-            this.#throwError(initializer, `The left-hand side of a '${loop}' statement must be a variable or a property access.`);
-        }
-    }
-    #checkModifiers(node) {
+    #checkSyntaxError(node) {
         if (this.options.allowInvalidAST) {
             return;
         }
-        (0, check_modifiers_1.checkModifiers)(node);
+        (0, check_syntax_errors_1.checkSyntaxError)(node);
     }
     #throwError(node, message) {
         if (this.options.allowInvalidAST) {
@@ -127,7 +103,7 @@ class Converter {
                 ? () => node[valueKey]
                 : () => {
                     if (!warned) {
-                        process.emitWarning(`The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.`, 'DeprecationWarning');
+                        process.emitWarning(`The '${aliasKey}' property is deprecated on ${node.type} nodes. Use '${valueKey}' instead. See https://tseslint.com/key-property-deprecated.`, 'DeprecationWarning');
                         warned = true;
                     }
                     return node[valueKey];
@@ -154,8 +130,7 @@ class Converter {
                         if (preferredKey) {
                             message += ` Use ${preferredKey} instead.`;
                         }
-                        message +=
-                            ' See https://typescript-eslint.io/troubleshooting/faqs/general#the-key-property-is-deprecated-on-type-nodes-use-key-instead-warnings.';
+                        message += ' See https://tseslint.com/key-property-deprecated.';
                         process.emitWarning(message, 'DeprecationWarning');
                         warned = true;
                     }
@@ -171,15 +146,6 @@ class Converter {
         });
         return node;
     }
-    assertModuleSpecifier(node, allowNull) {
-        if (!allowNull && node.moduleSpecifier == null) {
-            this.#throwError(node, 'Module specifier must be a string literal.');
-        }
-        if (node.moduleSpecifier &&
-            node.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-            this.#throwError(node.moduleSpecifier, 'Module specifier must be a string literal.');
-        }
-    }
     convertBindingNameWithTypeAnnotation(name, tsType, parent) {
         const id = this.convertPattern(name);
         if (tsType) {
@@ -302,7 +268,11 @@ class Converter {
      * @param node parent used to create this node
      * @returns TypeParameterInstantiation node
      */
-    convertTypeArgumentsToTypeParameterInstantiation(typeArguments, node) {
+    convertTypeArguments(node) {
+        const { typeArguments } = node;
+        if (!typeArguments) {
+            return undefined;
+        }
         const greaterThanToken = (0, node_utils_1.findNextToken)(typeArguments, this.ast, this.ast);
         const range = [typeArguments.pos - 1, greaterThanToken.end];
         if (typeArguments.length === 0) {
@@ -364,7 +334,7 @@ class Converter {
         if (!node) {
             return null;
         }
-        this.#checkModifiers(node);
+        this.#checkSyntaxError(node);
         const pattern = this.allowPattern;
         if (allowPattern != null) {
             this.allowPattern = allowPattern;
@@ -582,9 +552,6 @@ class Converter {
                     test: this.convertChild(node.expression),
                 });
             case SyntaxKind.SwitchStatement:
-                if (node.caseBlock.clauses.filter(switchCase => switchCase.kind === SyntaxKind.DefaultClause).length > 1) {
-                    this.#throwError(node, "A 'default' clause cannot appear more than once in a 'switch' statement.");
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.SwitchStatement,
                     cases: this.convertChildren(node.caseBlock.clauses),
@@ -602,9 +569,6 @@ class Converter {
                 });
             // Exceptions
             case SyntaxKind.ThrowStatement:
-                if (node.expression.end === node.expression.pos) {
-                    this.#throwError(node, 'A throw statement must throw an expression.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ThrowStatement,
                     argument: this.convertChild(node.expression),
@@ -617,9 +581,6 @@ class Converter {
                     handler: this.convertChild(node.catchClause),
                 });
             case SyntaxKind.CatchClause:
-                if (node.variableDeclaration?.initializer) {
-                    this.#throwError(node.variableDeclaration.initializer, 'Catch clause variable cannot have an initializer.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CatchClause,
                     body: this.convertChild(node.block),
@@ -653,7 +614,6 @@ class Converter {
                     update: this.convertChild(node.incrementor),
                 });
             case SyntaxKind.ForInStatement:
-                this.#checkForStatementDeclaration(node.initializer, node.kind);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForInStatement,
                     body: this.convertChild(node.statement),
@@ -661,7 +621,6 @@ class Converter {
                     right: this.convertChild(node.expression),
                 });
             case SyntaxKind.ForOfStatement: {
-                this.#checkForStatementDeclaration(node.initializer, node.kind);
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ForOfStatement,
                     await: node.awaitModifier?.kind === SyntaxKind.AwaitKeyword,
@@ -675,20 +634,6 @@ class Converter {
                 const isDeclare = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node);
                 const isAsync = (0, node_utils_1.hasModifier)(SyntaxKind.AsyncKeyword, node);
                 const isGenerator = !!node.asteriskToken;
-                if (isDeclare) {
-                    if (node.body) {
-                        this.#throwError(node, 'An implementation cannot be declared in ambient contexts.');
-                    }
-                    else if (isAsync) {
-                        this.#throwError(node, "'async' modifier cannot be used in an ambient context.");
-                    }
-                    else if (isGenerator) {
-                        this.#throwError(node, 'Generators are not allowed in an ambient context.');
-                    }
-                }
-                else if (!node.body && isGenerator) {
-                    this.#throwError(node, 'A function signature cannot be declared as a generator.');
-                }
                 const result = this.createNode(node, {
                     // declare implies no body due to the invariant above
                     type: !node.body
@@ -709,60 +654,6 @@ class Converter {
             }
             case SyntaxKind.VariableDeclaration: {
                 const hasExclamationToken = !!node.exclamationToken;
-                if (hasExclamationToken) {
-                    if (node.initializer) {
-                        this.#throwError(node, 'Declarations with initializers cannot also have definite assignment assertions.');
-                    }
-                    else if (node.name.kind !== SyntaxKind.Identifier || !node.type) {
-                        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, {
@@ -774,9 +665,6 @@ class Converter {
             }
             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(declarations),
@@ -855,14 +743,6 @@ class Converter {
                 });
             }
             case SyntaxKind.PropertyAssignment: {
-                // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { exclamationToken, questionToken } = node;
-                if (questionToken) {
-                    this.#throwError(questionToken, 'A property assignment cannot have a question token.');
-                }
-                if (exclamationToken) {
-                    this.#throwError(exclamationToken, 'A property assignment cannot have an exclamation token.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.Property,
                     computed: (0, node_utils_1.isComputedProperty)(node.name),
@@ -875,17 +755,6 @@ class Converter {
                 });
             }
             case SyntaxKind.ShorthandPropertyAssignment: {
-                // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { exclamationToken, modifiers, questionToken } = node;
-                if (modifiers) {
-                    this.#throwError(modifiers[0], 'A shorthand property assignment cannot have modifiers.');
-                }
-                if (questionToken) {
-                    this.#throwError(questionToken, 'A shorthand property assignment cannot have a question token.');
-                }
-                if (exclamationToken) {
-                    this.#throwError(exclamationToken, 'A shorthand property assignment cannot have an exclamation token.');
-                }
                 if (node.objectAssignmentInitializer) {
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.Property,
@@ -920,13 +789,6 @@ class Converter {
                 return this.convertChild(node.expression);
             case SyntaxKind.PropertyDeclaration: {
                 const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
-                if (isAbstract && node.initializer) {
-                    this.#throwError(node.initializer, `Abstract property cannot have an initializer.`);
-                }
-                if (node.name.kind === SyntaxKind.StringLiteral &&
-                    node.name.text === 'constructor') {
-                    this.#throwError(node.name, "Classes may not have a field named 'constructor'.");
-                }
                 const isAccessor = (0, node_utils_1.hasModifier)(SyntaxKind.AccessorKeyword, node);
                 const type = (() => {
                     if (isAccessor) {
@@ -1259,15 +1121,11 @@ class Converter {
                 return result;
             }
             case SyntaxKind.TaggedTemplateExpression: {
-                if (node.tag.flags & ts.NodeFlags.OptionalChain) {
-                    this.#throwError(node, 'Tagged template expressions are not permitted in an optional chain.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TaggedTemplateExpression,
                     quasi: this.convertChild(node.template),
                     tag: this.convertChild(node.tag),
-                    typeArguments: node.typeArguments &&
-                        this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+                    typeArguments: this.convertTypeArguments(node),
                 });
             }
             case SyntaxKind.TemplateHead:
@@ -1362,12 +1220,6 @@ class Converter {
             }
             // Classes
             case SyntaxKind.ClassDeclaration:
-                if (!node.name &&
-                    (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) ||
-                        !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
-                    this.#throwError(node, "A class declaration without the 'default' modifier must have a name.");
-                }
-            /* intentional fallthrough */
             case SyntaxKind.ClassExpression: {
                 const heritageClauses = node.heritageClauses ?? [];
                 const classNodeType = node.kind === SyntaxKind.ClassDeclaration
@@ -1419,8 +1271,7 @@ class Converter {
                         this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
                 });
                 if (extendsClause?.types[0]?.typeArguments) {
-                    result.superTypeArguments =
-                        this.convertTypeArgumentsToTypeParameterInstantiation(extendsClause.types[0].typeArguments, extendsClause.types[0]);
+                    result.superTypeArguments = this.convertTypeArguments(extendsClause.types[0]);
                 }
                 return this.fixExports(node, result);
             }
@@ -1431,7 +1282,6 @@ class Converter {
                     body: this.convertBodyExpressions(node.statements, node),
                 });
             case SyntaxKind.ImportDeclaration: {
-                this.assertModuleSpecifier(node, false);
                 const result = this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ImportDeclaration,
                     attributes: this.convertImportAttributes(node),
@@ -1484,7 +1334,6 @@ class Converter {
             }
             case SyntaxKind.ExportDeclaration: {
                 if (node.exportClause?.kind === SyntaxKind.NamedExports) {
-                    this.assertModuleSpecifier(node, true);
                     return this.createNode(node, this.#withDeprecatedAliasGetter({
                         type: ts_estree_1.AST_NODE_TYPES.ExportNamedDeclaration,
                         attributes: this.convertImportAttributes(node),
@@ -1494,7 +1343,6 @@ class Converter {
                         specifiers: this.convertChildren(node.exportClause.elements, node),
                     }, 'assertions', 'attributes', true));
                 }
-                this.assertModuleSpecifier(node, false);
                 return this.createNode(node, this.#withDeprecatedAliasGetter({
                     type: ts_estree_1.AST_NODE_TYPES.ExportAllDeclaration,
                     attributes: this.convertImportAttributes(node),
@@ -1539,9 +1387,6 @@ class Converter {
                  * ESTree uses UpdateExpression for ++/--
                  */
                 if (operator === '++' || operator === '--') {
-                    if (!(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
-                        this.#throwError(node.operand, 'Invalid left-hand side expression in unary operation');
-                    }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.UpdateExpression,
                         argument: this.convertChild(node.operand),
@@ -1585,13 +1430,6 @@ class Converter {
                 });
             // Binary Operations
             case SyntaxKind.BinaryExpression: {
-                if (node.operatorToken.kind !== SyntaxKind.InKeyword &&
-                    node.left.kind === SyntaxKind.PrivateIdentifier) {
-                    this.#throwError(node.left, "Private identifiers cannot appear on the right-hand-side of an 'in' expression.");
-                }
-                else if (node.right.kind === SyntaxKind.PrivateIdentifier) {
-                    this.#throwError(node.right, "Private identifiers are only allowed on the left-hand-side of an 'in' expression.");
-                }
                 // TypeScript uses BinaryExpression for sequences as well
                 if ((0, node_utils_1.isComma)(node.operatorToken)) {
                     const result = this.createNode(node, {
@@ -1655,9 +1493,6 @@ class Converter {
             }
             case SyntaxKind.CallExpression: {
                 if (node.expression.kind === SyntaxKind.ImportKeyword) {
-                    if (node.arguments.length !== 1 && node.arguments.length !== 2) {
-                        this.#throwError(node.arguments[2] ?? node, 'Dynamic import requires exactly one or two arguments.');
-                    }
                     return this.createNode(node, this.#withDeprecatedAliasGetter({
                         type: ts_estree_1.AST_NODE_TYPES.ImportExpression,
                         options: node.arguments[1]
@@ -1668,8 +1503,7 @@ class Converter {
                 }
                 const callee = this.convertChild(node.expression);
                 const args = this.convertChildren(node.arguments);
-                const typeArguments = node.typeArguments &&
-                    this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+                const typeArguments = this.convertTypeArguments(node);
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.CallExpression,
                     arguments: args,
@@ -1680,8 +1514,7 @@ class Converter {
                 return this.convertChainExpression(result, node);
             }
             case SyntaxKind.NewExpression: {
-                const typeArguments = node.typeArguments &&
-                    this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node);
+                const typeArguments = this.convertTypeArguments(node);
                 // NOTE - NewExpression cannot have an optional chain in it
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.NewExpression,
@@ -1830,9 +1663,7 @@ class Converter {
                         attributes: this.convertChildren(node.attributes.properties),
                         name: this.convertJSXTagName(node.tagName, node),
                         selfClosing: true,
-                        typeArguments: node.typeArguments
-                            ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
-                            : undefined,
+                        typeArguments: this.convertTypeArguments(node),
                     }),
                 });
             }
@@ -1842,8 +1673,7 @@ class Converter {
                     attributes: this.convertChildren(node.attributes.properties),
                     name: this.convertJSXTagName(node.tagName, node),
                     selfClosing: false,
-                    typeArguments: node.typeArguments &&
-                        this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+                    typeArguments: this.convertTypeArguments(node),
                 });
             }
             case SyntaxKind.JsxClosingElement:
@@ -1911,8 +1741,7 @@ class Converter {
             case SyntaxKind.TypeReference:
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeReference,
-                    typeArguments: node.typeArguments &&
-                        this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+                    typeArguments: this.convertTypeArguments(node),
                     typeName: this.convertChild(node.typeName),
                 });
             case SyntaxKind.TypeParameter: {
@@ -1985,13 +1814,9 @@ class Converter {
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery,
                     exprName: this.convertChild(node.exprName),
-                    typeArguments: node.typeArguments &&
-                        this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+                    typeArguments: this.convertTypeArguments(node),
                 });
             case SyntaxKind.MappedType: {
-                if (node.members && node.members.length > 0) {
-                    this.#throwError(node.members[0], 'A mapped type may not declare properties or methods.');
-                }
                 return this.createNode(node, this.#withDeprecatedGetter({
                     type: ts_estree_1.AST_NODE_TYPES.TSMappedType,
                     constraint: this.convertChild(node.typeParameter.constraint),
@@ -2025,11 +1850,6 @@ class Converter {
                 return this.convertMethodSignature(node);
             }
             case SyntaxKind.PropertySignature: {
-                // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { initializer } = node;
-                if (initializer) {
-                    this.#throwError(initializer, 'A property signature cannot have an initializer.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSPropertySignature,
                     accessibility: (0, node_utils_1.getTSNodeAccessibility)(node),
@@ -2061,14 +1881,7 @@ class Converter {
                         this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
                 });
             }
-            case SyntaxKind.FunctionType: {
-                // eslint-disable-next-line @typescript-eslint/no-deprecated
-                const { modifiers } = node;
-                if (modifiers) {
-                    this.#throwError(modifiers[0], 'A function type cannot have modifiers.');
-                }
-            }
-            // intentional fallthrough
+            case SyntaxKind.FunctionType:
             case SyntaxKind.ConstructSignature:
             case SyntaxKind.CallSignature: {
                 const type = node.kind === SyntaxKind.ConstructSignature
@@ -2094,8 +1907,7 @@ class Converter {
                 return this.createNode(node, {
                     type,
                     expression: this.convertChild(node.expression),
-                    typeArguments: node.typeArguments &&
-                        this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node),
+                    typeArguments: this.convertTypeArguments(node),
                 });
             }
             case SyntaxKind.InterfaceDeclaration: {
@@ -2219,9 +2031,7 @@ class Converter {
                     options,
                     qualifier: this.convertChild(node.qualifier),
                     source,
-                    typeArguments: node.typeArguments
-                        ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
-                        : null,
+                    typeArguments: this.convertTypeArguments(node) ?? null,
                 }, 'argument', 'source', argument));
                 if (node.isTypeOf) {
                     return this.createNode(node, {
@@ -2249,13 +2059,6 @@ class Converter {
             }
             case SyntaxKind.EnumMember: {
                 const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
-                if (computed) {
-                    this.#throwError(node.name, 'Computed property names are not allowed in enums.');
-                }
-                if (node.name.kind === SyntaxKind.NumericLiteral ||
-                    node.name.kind === SyntaxKind.BigIntLiteral) {
-                    this.#throwError(node.name, 'An enum member cannot have a numeric name.');
-                }
                 return this.createNode(node, this.#withDeprecatedGetter({
                     type: ts_estree_1.AST_NODE_TYPES.TSEnumMember,
                     id: this.convertChild(node.name),
@@ -2409,9 +2212,6 @@ class Converter {
                 }));
             }
             case SyntaxKind.ExternalModuleReference: {
-                if (node.expression.kind !== SyntaxKind.StringLiteral) {
-                    this.#throwError(node.expression, 'String literal expected.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSExternalModuleReference,
                     expression: this.convertChild(node.expression),
@@ -2546,7 +2346,7 @@ class Converter {
         if ('typeArguments' in node) {
             result.typeArguments =
                 node.typeArguments && 'pos' in node.typeArguments
-                    ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
+                    ? this.convertTypeArguments(node)
                     : null;
         }
         if ('typeParameters' in node) {

package/dist/create-program/createProjectProgramError.js

@@ -29,7 +29,7 @@ function getErrorDetails(describedFilePath, parseSettings, programsForProjects)
             `Either:`,
             `- Switch to \`parserOptions.projectService\``,
             `- Use an ESLint-specific TSConfig`,
-            `See the typescript-eslint docs for more info: https://typescript-eslint.io/troubleshooting/typed-linting#are-typescript-project-references-supported`,
+            `See the typescript-eslint docs for more info: https://tseslint.com/are-project-references-supported`,
         ];
     }
     const { extraFileExtensions } = parseSettings;
@@ -69,6 +69,6 @@ function getErrorDetails(describedFilePath, parseSettings, programsForProjects)
         `- Change ESLint's list of included files to not include this file`,
         `- Change ${describedSpecifiers} to include this file`,
         `- Create a new TSConfig that includes this file and include it in your parserOptions.project`,
-        `See the typescript-eslint docs for more info: https://typescript-eslint.io/troubleshooting/typed-linting#i-get-errors-telling-me-eslint-was-configured-to-run--however-that-tsconfig-does-not--none-of-those-tsconfigs-include-this-file`,
+        `See the typescript-eslint docs for more info: https://tseslint.com/none-of-those-tsconfigs-include-this-file`,
     ];
 }

package/dist/create-program/validateDefaultProjectForFilesGlob.d.ts

@@ -1,2 +1,2 @@
-export declare const DEFAULT_PROJECT_FILES_ERROR_EXPLANATION = "\n\nHaving many files run with the default project is known to cause performance issues and slow down linting.\n\nSee https://typescript-eslint.io/troubleshooting/typed-linting#allowdefaultproject-glob-too-wide\n";
+export declare const DEFAULT_PROJECT_FILES_ERROR_EXPLANATION = "\n\nHaving many files run with the default project is known to cause performance issues and slow down linting.\n\nSee https://tseslint.com/allowdefaultproject-glob-too-wide\n";
 export declare function validateDefaultProjectForFilesGlob(allowDefaultProject: string[] | undefined): void;

package/dist/create-program/validateDefaultProjectForFilesGlob.js

@@ -6,7 +6,7 @@ exports.DEFAULT_PROJECT_FILES_ERROR_EXPLANATION = `
 
 Having many files run with the default project is known to cause performance issues and slow down linting.
 
-See https://typescript-eslint.io/troubleshooting/typed-linting#allowdefaultproject-glob-too-wide
+See https://tseslint.com/allowdefaultproject-glob-too-wide
 `;
 function validateDefaultProjectForFilesGlob(allowDefaultProject) {
     if (!allowDefaultProject?.length) {

package/dist/parseSettings/candidateTSConfigRootDirs.js

@@ -22,7 +22,7 @@ function getInferredTSConfigRootDir() {
                 'No tsconfigRootDir was set, and multiple candidate TSConfigRootDirs are present:',
                 ...entries.map(candidate => ` - ${candidate}`),
                 "You'll need to explicitly set tsconfigRootDir in your parser options.",
-                'See: https://typescript-eslint.io/packages/parser/#tsconfigrootdir',
+                'See: https://tseslint.com/parser-tsconfigrootdir',
             ].join('\n'));
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.51.1-alpha.1",
+  "version": "8.51.1-alpha.11",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -52,23 +52,23 @@
     "typecheck": "yarn run -BT nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/project-service": "8.51.1-alpha.1",
-    "@typescript-eslint/tsconfig-utils": "8.51.1-alpha.1",
-    "@typescript-eslint/types": "8.51.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.51.1-alpha.1",
-    "debug": "^4.3.4",
-    "minimatch": "^9.0.4",
-    "semver": "^7.6.0",
+    "@typescript-eslint/project-service": "8.51.1-alpha.11",
+    "@typescript-eslint/tsconfig-utils": "8.51.1-alpha.11",
+    "@typescript-eslint/types": "8.51.1-alpha.11",
+    "@typescript-eslint/visitor-keys": "8.51.1-alpha.11",
+    "debug": "^4.4.3",
+    "minimatch": "^9.0.5",
+    "semver": "^7.7.3",
     "tinyglobby": "^0.2.15",
-    "ts-api-utils": "^2.2.0"
+    "ts-api-utils": "^2.4.0"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^3.1.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "eslint": "*",
     "glob": "*",
     "rimraf": "*",
     "typescript": "*",
-    "vitest": "^3.1.3"
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "typescript": ">=4.8.4 <6.0.0"