@typescript-eslint/typescript-estree 8.52.1-alpha.0 → 8.52.1-alpha.10

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

@@ -1,2 +1,3 @@
 import * as ts from 'typescript';
-export declare function checkSyntaxError(tsNode: ts.Node): void;
+import type { TSNode } from './ts-estree';
+export declare function checkSyntaxError(tsNode: ts.Node, parent: TSNode, allowPattern: boolean): void;

package/dist/check-syntax-errors.js

@@ -38,7 +38,7 @@ 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) {
+function checkSyntaxError(tsNode, parent, allowPattern) {
     (0, check_modifiers_1.checkModifiers)(tsNode);
     const node = tsNode;
     switch (node.kind) {
@@ -90,19 +90,12 @@ function checkSyntaxError(tsNode) {
             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 (kind === 'using' || kind === 'await using') {
+                    if (variableDeclarationList.parent.kind === SyntaxKind.ForInStatement) {
+                        throw (0, node_utils_1.createError)(variableDeclarationList, `The left-hand side of a 'for...in' statement cannot be a '${kind}' declaration.`);
                     }
-                    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 (variableDeclarationList.parent.kind === SyntaxKind.ForStatement ||
+                        variableDeclarationList.parent.kind === SyntaxKind.VariableStatement) {
                         if (!node.initializer) {
                             throw (0, node_utils_1.createError)(node, `'${kind}' declarations must be initialized.`);
                         }
@@ -110,6 +103,9 @@ function checkSyntaxError(tsNode) {
                             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;
                     const hasDeclareKeyword = (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, variableStatement);
                     // Definite assignment only allowed for non-declare let and var
                     if ((hasDeclareKeyword ||
@@ -181,13 +177,6 @@ function checkSyntaxError(tsNode) {
                 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) {
@@ -246,12 +235,32 @@ function checkSyntaxError(tsNode) {
             }
             break;
         }
-        case SyntaxKind.ImportDeclaration:
+        case SyntaxKind.ImportDeclaration: {
+            const { importClause } = node;
+            if (
+            // TODO swap to `phaseModifier` once we add support for `import defer`
+            // https://github.com/estree/estree/issues/328
+            // eslint-disable-next-line @typescript-eslint/no-deprecated
+            importClause?.isTypeOnly &&
+                importClause.name &&
+                importClause.namedBindings) {
+                throw (0, node_utils_1.createError)(importClause, 'A type-only import can specify a default import or named bindings, but not both.');
+            }
             assertModuleSpecifier(node, false);
             break;
+        }
         case SyntaxKind.ExportDeclaration:
             assertModuleSpecifier(node, node.exportClause?.kind === SyntaxKind.NamedExports);
             break;
+        case SyntaxKind.ExportSpecifier: {
+            const local = node.propertyName ?? node.name;
+            if (local.kind === SyntaxKind.StringLiteral &&
+                parent.kind === SyntaxKind.ExportDeclaration &&
+                parent.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
+                throw (0, node_utils_1.createError)(local, 'A string literal cannot be used as a local exported binding without `from`.');
+            }
+            break;
+        }
         case SyntaxKind.CallExpression:
             if (node.expression.kind === SyntaxKind.ImportKeyword &&
                 node.arguments.length !== 1 &&
@@ -259,6 +268,138 @@ function checkSyntaxError(tsNode) {
                 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.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.");
+            }
+        // intentional fallthrough
+        case SyntaxKind.ClassExpression: {
+            const heritageClauses = node.heritageClauses ?? [];
+            let seenExtendsClause = false;
+            let seenImplementsClause = false;
+            for (const heritageClause of heritageClauses) {
+                const { token, types } = heritageClause;
+                if (types.length === 0) {
+                    throw (0, node_utils_1.createError)(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+                }
+                if (token === SyntaxKind.ExtendsKeyword) {
+                    if (seenExtendsClause) {
+                        throw (0, node_utils_1.createError)(heritageClause, "'extends' clause already seen.");
+                    }
+                    if (seenImplementsClause) {
+                        throw (0, node_utils_1.createError)(heritageClause, "'extends' clause must precede 'implements' clause.");
+                    }
+                    if (types.length > 1) {
+                        throw (0, node_utils_1.createError)(types[1], 'Classes can only extend a single class.');
+                    }
+                    seenExtendsClause = true;
+                }
+                else {
+                    // `implements`
+                    if (seenImplementsClause) {
+                        throw (0, node_utils_1.createError)(heritageClause, "'implements' clause already seen.");
+                    }
+                    for (const heritageType of heritageClause.types) {
+                        if (!(0, node_utils_1.isEntityNameExpression)(heritageType.expression) ||
+                            ts.isOptionalChain(heritageType.expression)) {
+                            throw (0, node_utils_1.createError)(heritageType, 'A class can only implement an identifier/qualified-name with optional type arguments.');
+                        }
+                    }
+                    seenImplementsClause = true;
+                }
+            }
+            break;
+        }
+        case SyntaxKind.InterfaceDeclaration: {
+            const interfaceHeritageClauses = node.heritageClauses ?? [];
+            let seenExtendsClause = false;
+            for (const heritageClause of interfaceHeritageClauses) {
+                const { token, types } = heritageClause;
+                if (token === SyntaxKind.ImplementsKeyword) {
+                    throw (0, node_utils_1.createError)(heritageClause, "Interface declaration cannot have 'implements' clause.");
+                }
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (token !== SyntaxKind.ExtendsKeyword) {
+                    throw (0, node_utils_1.createError)(heritageClause, 'Unexpected token.');
+                }
+                if (types.length === 0) {
+                    throw (0, node_utils_1.createError)(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+                }
+                if (seenExtendsClause) {
+                    throw (0, node_utils_1.createError)(heritageClause, "'extends' clause already seen.");
+                }
+                seenExtendsClause = true;
+                for (const heritageType of heritageClause.types) {
+                    if (!(0, node_utils_1.isEntityNameExpression)(heritageType.expression) ||
+                        ts.isOptionalChain(heritageType.expression)) {
+                        throw (0, node_utils_1.createError)(heritageType, 'Interface declaration can only extend an identifier/qualified name with optional type arguments.');
+                    }
+                }
+            }
+            break;
+        }
+        case SyntaxKind.GetAccessor:
+        case SyntaxKind.SetAccessor:
+            if (node.parent.kind === SyntaxKind.InterfaceDeclaration ||
+                node.parent.kind === SyntaxKind.TypeLiteral) {
+                return;
+            }
+        // otherwise, it is a non-type accessor - intentional fallthrough
+        case SyntaxKind.MethodDeclaration: {
+            const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
+            if (isAbstract && node.body) {
+                throw (0, node_utils_1.createError)(node.name, node.kind === SyntaxKind.GetAccessor ||
+                    node.kind === SyntaxKind.SetAccessor
+                    ? 'An abstract accessor cannot have an implementation.'
+                    : `Method '${(0, node_utils_1.declarationNameToString)(node.name)}' cannot have an implementation because it is marked abstract.`);
+            }
+            break;
+        }
+        case SyntaxKind.ObjectLiteralExpression: {
+            if (!allowPattern) {
+                for (const property of node.properties) {
+                    if ((property.kind === SyntaxKind.GetAccessor ||
+                        property.kind === SyntaxKind.SetAccessor ||
+                        property.kind === SyntaxKind.MethodDeclaration) &&
+                        !property.body) {
+                        throw (0, node_utils_1.createError)(property.end - 1, "'{' expected.", node.getSourceFile());
+                    }
+                }
+            }
+            break;
+        }
+        case SyntaxKind.ImportEqualsDeclaration:
+            if (node.isTypeOnly &&
+                node.moduleReference.kind !== SyntaxKind.ExternalModuleReference) {
+                throw (0, node_utils_1.createError)(node, "An import alias cannot use 'import type'");
+            }
+            break;
+        case SyntaxKind.ModuleDeclaration: {
+            if (node.flags & ts.NodeFlags.GlobalAugmentation) {
+                const { body } = node;
+                if (body == null || body.kind === SyntaxKind.ModuleDeclaration) {
+                    throw (0, node_utils_1.createError)(node.body ?? node, 'Expected a valid module body');
+                }
+                const { name } = node;
+                if (name.kind !== ts.SyntaxKind.Identifier) {
+                    throw (0, node_utils_1.createError)(name, 'global module augmentation must have an Identifier id');
+                }
+                return;
+            }
+            if (ts.isStringLiteral(node.name)) {
+                return;
+            }
+            if (node.body == null) {
+                throw (0, node_utils_1.createError)(node, 'Expected a module body');
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Fixme: confirm if it's possible
+            if (node.name.kind !== ts.SyntaxKind.Identifier) {
+                throw (0, node_utils_1.createError)(node.name, '`namespace`s must have an Identifier id');
+            }
+            break;
+        }
         case SyntaxKind.ForInStatement:
         case SyntaxKind.ForOfStatement: {
             checkForStatementDeclaration(node);
@@ -281,10 +422,6 @@ function checkForStatementDeclaration(node) {
         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 &&

package/dist/convert.d.ts

@@ -83,7 +83,7 @@ export declare class Converter {
      * @param typeParameters ts.Node typeParameters
      * @returns TypeParameterDeclaration node
      */
-    private convertTSTypeParametersToTypeParametersDeclaration;
+    private convertTypeParameters;
     /**
      * Converts an array of ts.Node parameters into an array of ESTreeNode params
      * @param parameters An array of ts.Node params to be converted

package/dist/convert.js

@@ -51,15 +51,6 @@ const SyntaxKind = ts.SyntaxKind;
 function convertError(error) {
     return (0, node_utils_1.createError)(error.start, ('message' in error && error.message) || error.messageText, error.file);
 }
-function isPropertyAccessEntityNameExpression(node) {
-    return (ts.isPropertyAccessExpression(node) &&
-        ts.isIdentifier(node.name) &&
-        isEntityNameExpression(node.expression));
-}
-function isEntityNameExpression(node) {
-    return (node.kind === SyntaxKind.Identifier ||
-        isPropertyAccessEntityNameExpression(node));
-}
 class Converter {
     allowPattern = false;
     ast;
@@ -76,11 +67,11 @@ class Converter {
         this.ast = ast;
         this.options = { ...options };
     }
-    #checkSyntaxError(node) {
+    #checkSyntaxError(node, parent) {
         if (this.options.allowInvalidAST) {
             return;
         }
-        (0, check_syntax_errors_1.checkSyntaxError)(node);
+        (0, check_syntax_errors_1.checkSyntaxError)(node, parent, this.allowPattern);
     }
     #throwError(node, message) {
         if (this.options.allowInvalidAST) {
@@ -289,7 +280,11 @@ class Converter {
      * @param typeParameters ts.Node typeParameters
      * @returns TypeParameterDeclaration node
      */
-    convertTSTypeParametersToTypeParametersDeclaration(typeParameters) {
+    convertTypeParameters(node) {
+        const { typeParameters } = node;
+        if (!typeParameters) {
+            return undefined;
+        }
         const greaterThanToken = (0, node_utils_1.findNextToken)(typeParameters, this.ast, this.ast);
         const range = [
             typeParameters.pos - 1,
@@ -334,12 +329,13 @@ class Converter {
         if (!node) {
             return null;
         }
-        this.#checkSyntaxError(node);
         const pattern = this.allowPattern;
         if (allowPattern != null) {
             this.allowPattern = allowPattern;
         }
-        const result = this.convertNode(node, (parent ?? node.parent));
+        const parentNode = (parent ?? node.parent);
+        this.#checkSyntaxError(node, parentNode);
+        const result = this.convertNode(node, parentNode);
         this.registerTSNodeInNodeMap(node, result);
         this.allowPattern = pattern;
         return result;
@@ -449,8 +445,7 @@ class Converter {
             readonly: (0, node_utils_1.hasModifier)(SyntaxKind.ReadonlyKeyword, node),
             returnType: node.type && this.convertTypeAnnotation(node.type, node),
             static: (0, node_utils_1.hasModifier)(SyntaxKind.StaticKeyword, node),
-            typeParameters: node.typeParameters &&
-                this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+            typeParameters: this.convertTypeParameters(node),
         });
     }
     /**
@@ -647,8 +642,7 @@ class Converter {
                     id: this.convertChild(node.name),
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 return this.fixExports(node, result);
             }
@@ -727,19 +721,9 @@ class Converter {
                         typeAnnotation: undefined,
                     });
                 }
-                const properties = [];
-                for (const property of node.properties) {
-                    if ((property.kind === SyntaxKind.GetAccessor ||
-                        property.kind === SyntaxKind.SetAccessor ||
-                        property.kind === SyntaxKind.MethodDeclaration) &&
-                        !property.body) {
-                        this.#throwError(property.end - 1, "'{' expected.");
-                    }
-                    properties.push(this.convertChild(property));
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ObjectExpression,
-                    properties,
+                    properties: this.convertChildren(node.properties),
                 });
             }
             case SyntaxKind.PropertyAssignment: {
@@ -832,13 +816,6 @@ class Converter {
             }
             // otherwise, it is a non-type accessor - intentional fallthrough
             case SyntaxKind.MethodDeclaration: {
-                const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
-                if (isAbstract && node.body) {
-                    this.#throwError(node.name, node.kind === SyntaxKind.GetAccessor ||
-                        node.kind === SyntaxKind.SetAccessor
-                        ? 'An abstract accessor cannot have an implementation.'
-                        : `Method '${(0, node_utils_1.declarationNameToString)(node.name, this.ast)}' cannot have an implementation because it is marked abstract.`);
-                }
                 const method = this.createNode(node, {
                     type: !node.body
                         ? ts_estree_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression
@@ -852,8 +829,7 @@ class Converter {
                     id: null,
                     params: [],
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 if (method.typeParameters) {
                     this.fixParentLocation(method, method.typeParameters.range);
@@ -874,6 +850,7 @@ class Converter {
                 }
                 else {
                     // class
+                    const isAbstract = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
                     /**
                      * Unlike in object literal methods, class method params can have decorators
                      */
@@ -929,8 +906,7 @@ class Converter {
                     id: null,
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 if (constructor.typeParameters) {
                     this.fixParentLocation(constructor, constructor.typeParameters.range);
@@ -979,8 +955,7 @@ class Converter {
                     id: this.convertChild(node.name),
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
             }
             case SyntaxKind.SuperKeyword:
@@ -1077,8 +1052,7 @@ class Converter {
                     id: null,
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
             }
             case SyntaxKind.YieldExpression:
@@ -1221,36 +1195,11 @@ class Converter {
             // Classes
             case SyntaxKind.ClassDeclaration:
             case SyntaxKind.ClassExpression: {
-                const heritageClauses = node.heritageClauses ?? [];
                 const classNodeType = node.kind === SyntaxKind.ClassDeclaration
                     ? ts_estree_1.AST_NODE_TYPES.ClassDeclaration
                     : ts_estree_1.AST_NODE_TYPES.ClassExpression;
-                let extendsClause;
-                let implementsClause;
-                for (const heritageClause of heritageClauses) {
-                    const { token, types } = heritageClause;
-                    if (types.length === 0) {
-                        this.#throwError(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
-                    }
-                    if (token === SyntaxKind.ExtendsKeyword) {
-                        if (extendsClause) {
-                            this.#throwError(heritageClause, "'extends' clause already seen.");
-                        }
-                        if (implementsClause) {
-                            this.#throwError(heritageClause, "'extends' clause must precede 'implements' clause.");
-                        }
-                        if (types.length > 1) {
-                            this.#throwError(types[1], 'Classes can only extend a single class.');
-                        }
-                        extendsClause ??= heritageClause;
-                    }
-                    else if (token === SyntaxKind.ImplementsKeyword) {
-                        if (implementsClause) {
-                            this.#throwError(heritageClause, "'implements' clause already seen.");
-                        }
-                        implementsClause ??= heritageClause;
-                    }
-                }
+                const extendsClause = node.heritageClauses?.find(heritageClause => heritageClause.token === SyntaxKind.ExtendsKeyword);
+                const implementsClause = node.heritageClauses?.find(heritageClause => heritageClause.token === SyntaxKind.ImplementsKeyword);
                 const result = this.createNode(node, {
                     type: classNodeType,
                     abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
@@ -1267,8 +1216,7 @@ class Converter {
                         ? this.convertChild(extendsClause.types[0].expression)
                         : null,
                     superTypeArguments: undefined,
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 if (extendsClause?.types[0]?.typeArguments) {
                     result.superTypeArguments = this.convertTypeArguments(extendsClause.types[0]);
@@ -1355,11 +1303,6 @@ class Converter {
             }
             case SyntaxKind.ExportSpecifier: {
                 const local = node.propertyName ?? node.name;
-                if (local.kind === SyntaxKind.StringLiteral &&
-                    parent.kind === SyntaxKind.ExportDeclaration &&
-                    parent.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-                    this.#throwError(local, 'A string literal cannot be used as a local exported binding without `from`.');
-                }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ExportSpecifier,
                     exported: this.convertChild(node.name),
@@ -1841,8 +1784,7 @@ class Converter {
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
                     id: this.convertChild(node.name),
                     typeAnnotation: this.convertChild(node.type),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 return this.fixExports(node, result);
             }
@@ -1877,8 +1819,7 @@ class Converter {
                     abstract: (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node),
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
             }
             case SyntaxKind.FunctionType:
@@ -1893,8 +1834,7 @@ class Converter {
                     type,
                     params: this.convertParameters(node.parameters),
                     returnType: node.type && this.convertTypeAnnotation(node.type, node),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
             }
             case SyntaxKind.ExpressionWithTypeArguments: {
@@ -1911,27 +1851,14 @@ class Converter {
                 });
             }
             case SyntaxKind.InterfaceDeclaration: {
-                const interfaceHeritageClauses = node.heritageClauses ?? [];
-                const interfaceExtends = [];
-                let seenExtendsClause = false;
-                for (const heritageClause of interfaceHeritageClauses) {
-                    if (heritageClause.token !== SyntaxKind.ExtendsKeyword) {
-                        this.#throwError(heritageClause, heritageClause.token === SyntaxKind.ImplementsKeyword
-                            ? "Interface declaration cannot have 'implements' clause."
-                            : 'Unexpected token.');
-                    }
-                    if (seenExtendsClause) {
-                        this.#throwError(heritageClause, "'extends' clause already seen.");
-                    }
-                    seenExtendsClause = true;
-                    for (const heritageType of heritageClause.types) {
-                        if (!isEntityNameExpression(heritageType.expression) ||
-                            ts.isOptionalChain(heritageType.expression)) {
-                            this.#throwError(heritageType, 'Interface declaration can only extend an identifier/qualified name with optional type arguments.');
-                        }
-                        interfaceExtends.push(this.convertChild(heritageType, node));
-                    }
-                }
+                const interfaceExtends = node.heritageClauses?.flatMap(heritageClause => 
+                // `InterfaceDeclaration` can only have `extends`,
+                // already checked in `check-syntax-errors.ts`,
+                // However, `allowInvalidAST` allow to bypass the syntax check,
+                // We'll just ignore clauses after other keywords
+                heritageClause.token === SyntaxKind.ExtendsKeyword
+                    ? heritageClause.types.map(heritageType => this.convertChild(heritageType, node))
+                    : []) ?? [];
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSInterfaceDeclaration,
                     body: this.createNode(node, {
@@ -1942,8 +1869,7 @@ class Converter {
                     declare: (0, node_utils_1.hasModifier)(SyntaxKind.DeclareKeyword, node),
                     extends: interfaceExtends,
                     id: this.convertChild(node.name),
-                    typeParameters: node.typeParameters &&
-                        this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters),
+                    typeParameters: this.convertTypeParameters(node),
                 });
                 return this.fixExports(node, result);
             }
@@ -2070,23 +1996,12 @@ class Converter {
                 const result = this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration,
                     ...(() => {
-                        // the constraints checked by this function are syntactically enforced by TS
-                        // the checks mostly exist for type's sake
                         if (node.flags & ts.NodeFlags.GlobalAugmentation) {
-                            const id = this.convertChild(node.name);
-                            const body = this.convertChild(node.body);
-                            if (body == null ||
-                                body.type === ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration) {
-                                this.#throwError(node.body ?? node, 'Expected a valid module body');
-                            }
-                            if (id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                                this.#throwError(node.name, 'global module augmentation must have an Identifier id');
-                            }
                             return {
-                                body: body,
+                                body: this.convertChild(node.body),
                                 declare: false,
                                 global: false,
-                                id,
+                                id: this.convertChild(node.name),
                                 kind: 'global',
                             };
                         }
@@ -2103,12 +2018,6 @@ class Converter {
                         // Nested module declarations are stored in TypeScript as nested tree nodes.
                         // We "unravel" them here by making our own nested TSQualifiedName,
                         // with the innermost node's body as the actual node body.
-                        if (node.body == null) {
-                            this.#throwError(node, 'Expected a module body');
-                        }
-                        if (node.name.kind !== ts.SyntaxKind.Identifier) {
-                            this.#throwError(node.name, '`namespace`s must have an Identifier id');
-                        }
                         let name = this.createNode(node.name, {
                             type: ts_estree_1.AST_NODE_TYPES.Identifier,
                             range: [node.name.getStart(this.ast), node.name.getEnd()],
@@ -2352,7 +2261,8 @@ class Converter {
         if ('typeParameters' in node) {
             result.typeParameters =
                 node.typeParameters && 'pos' in node.typeParameters
-                    ? this.convertTSTypeParametersToTypeParametersDeclaration(node.typeParameters)
+                    ? // @ts-expect-error -- Fix me
+                        this.convertTypeParameters(node)
                     : null;
         }
         const decorators = (0, getModifiers_1.getDecorators)(node);

package/dist/node-utils.d.ts

@@ -184,5 +184,6 @@ export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.
 export declare function isThisInTypeQuery(node: ts.Node): boolean;
 export declare function isValidAssignmentTarget(node: ts.Node): boolean;
 export declare function getNamespaceModifiers(node: ts.ModuleDeclaration): ts.Modifier[] | undefined;
-export declare function declarationNameToString(name: ts.Node, ast: ts.SourceFile): string;
+export declare function declarationNameToString(node: ts.Node): string;
+export declare function isEntityNameExpression(node: ts.Node): node is ts.EntityNameExpression;
 export {};

package/dist/node-utils.js

@@ -70,6 +70,7 @@ exports.isThisInTypeQuery = isThisInTypeQuery;
 exports.isValidAssignmentTarget = isValidAssignmentTarget;
 exports.getNamespaceModifiers = getNamespaceModifiers;
 exports.declarationNameToString = declarationNameToString;
+exports.isEntityNameExpression = isEntityNameExpression;
 const ts = __importStar(require("typescript"));
 const getModifiers_1 = require("./getModifiers");
 const xhtml_entities_1 = require("./jsx/xhtml-entities");
@@ -657,7 +658,16 @@ function getNamespaceModifiers(node) {
     return modifiers;
 }
 // `ts.declarationNameToString`
-function declarationNameToString(name, ast) {
-    const text = ast.text.slice(name.pos, name.end).trimStart();
+function declarationNameToString(node) {
+    const text = node.getSourceFile().text.slice(node.pos, node.end).trimStart();
     return text || '(Missing)';
 }
+function isPropertyAccessEntityNameExpression(node) {
+    return (ts.isPropertyAccessExpression(node) &&
+        ts.isIdentifier(node.name) &&
+        isEntityNameExpression(node.expression));
+}
+function isEntityNameExpression(node) {
+    return (node.kind === SyntaxKind.Identifier ||
+        isPropertyAccessEntityNameExpression(node));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.52.1-alpha.0",
+  "version": "8.52.1-alpha.10",
   "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.52.1-alpha.0",
-    "@typescript-eslint/tsconfig-utils": "8.52.1-alpha.0",
-    "@typescript-eslint/types": "8.52.1-alpha.0",
-    "@typescript-eslint/visitor-keys": "8.52.1-alpha.0",
+    "@typescript-eslint/project-service": "8.52.1-alpha.10",
+    "@typescript-eslint/tsconfig-utils": "8.52.1-alpha.10",
+    "@typescript-eslint/types": "8.52.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.52.1-alpha.10",
     "debug": "^4.4.3",
     "minimatch": "^9.0.5",
     "semver": "^7.7.3",