@typescript-eslint/typescript-estree 8.48.1-alpha.1 → 8.48.1-alpha.10

package/dist/check-modifiers.js

@@ -125,26 +125,20 @@ function nodeHasIllegalDecorators(node) {
     return !!('illegalDecorators' in node &&
         node.illegalDecorators?.length);
 }
-function throwError(node, message) {
-    const ast = node.getSourceFile();
-    const start = node.getStart(ast);
-    const end = node.getEnd();
-    throw (0, node_utils_1.createError)(message, ast, start, end);
-}
 function checkModifiers(node) {
     // typescript<5.0.0
     if (nodeHasIllegalDecorators(node)) {
-        throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
+        throw (0, node_utils_1.createError)(node.illegalDecorators[0], 'Decorators are not valid here.');
     }
     for (const decorator of (0, getModifiers_1.getDecorators)(node, 
     /* includeIllegalDecorators */ true) ?? []) {
         // `checkGrammarModifiers` function in typescript
         if (!nodeCanBeDecorated(node)) {
             if (ts.isMethodDeclaration(node) && !nodeIsPresent(node.body)) {
-                throwError(decorator, 'A decorator can only decorate a method implementation, not an overload.');
+                throw (0, node_utils_1.createError)(decorator, 'A decorator can only decorate a method implementation, not an overload.');
             }
             else {
-                throwError(decorator, 'Decorators are not valid here.');
+                throw (0, node_utils_1.createError)(decorator, 'Decorators are not valid here.');
             }
         }
     }
@@ -153,19 +147,19 @@ function checkModifiers(node) {
         if (modifier.kind !== SyntaxKind.ReadonlyKeyword) {
             if (node.kind === SyntaxKind.PropertySignature ||
                 node.kind === SyntaxKind.MethodSignature) {
-                throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type member`);
+                throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type member`);
             }
             if (node.kind === SyntaxKind.IndexSignature &&
                 (modifier.kind !== SyntaxKind.StaticKeyword ||
                     !ts.isClassLike(node.parent))) {
-                throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on an index signature`);
+                throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on an index signature`);
             }
         }
         if (modifier.kind !== SyntaxKind.InKeyword &&
             modifier.kind !== SyntaxKind.OutKeyword &&
             modifier.kind !== SyntaxKind.ConstKeyword &&
             node.kind === SyntaxKind.TypeParameter) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
         }
         if ((modifier.kind === SyntaxKind.InKeyword ||
             modifier.kind === SyntaxKind.OutKeyword) &&
@@ -173,25 +167,25 @@ function checkModifiers(node) {
                 !(ts.isInterfaceDeclaration(node.parent) ||
                     ts.isClassLike(node.parent) ||
                     ts.isTypeAliasDeclaration(node.parent)))) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a type parameter of a class, interface or type alias`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a type parameter of a class, interface or type alias`);
         }
         if (modifier.kind === SyntaxKind.ReadonlyKeyword &&
             node.kind !== SyntaxKind.PropertyDeclaration &&
             node.kind !== SyntaxKind.PropertySignature &&
             node.kind !== SyntaxKind.IndexSignature &&
             node.kind !== SyntaxKind.Parameter) {
-            throwError(modifier, "'readonly' modifier can only appear on a property declaration or index signature.");
+            throw (0, node_utils_1.createError)(modifier, "'readonly' modifier can only appear on a property declaration or index signature.");
         }
         if (modifier.kind === SyntaxKind.DeclareKeyword &&
             ts.isClassLike(node.parent) &&
             !ts.isPropertyDeclaration(node)) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on class elements of this kind.`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on class elements of this kind.`);
         }
         if (modifier.kind === SyntaxKind.DeclareKeyword &&
             ts.isVariableStatement(node)) {
             const declarationKind = (0, node_utils_1.getDeclarationKind)(node.declarationList);
             if (declarationKind === 'using' || declarationKind === 'await using') {
-                throwError(modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
+                throw (0, node_utils_1.createError)(modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
             }
         }
         if (modifier.kind === SyntaxKind.AbstractKeyword &&
@@ -201,7 +195,7 @@ function checkModifiers(node) {
             node.kind !== SyntaxKind.PropertyDeclaration &&
             node.kind !== SyntaxKind.GetAccessor &&
             node.kind !== SyntaxKind.SetAccessor) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a class, method, or property declaration.`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier can only appear on a class, method, or property declaration.`);
         }
         if ((modifier.kind === SyntaxKind.StaticKeyword ||
             modifier.kind === SyntaxKind.PublicKeyword ||
@@ -209,11 +203,11 @@ function checkModifiers(node) {
             modifier.kind === SyntaxKind.PrivateKeyword) &&
             (node.parent.kind === SyntaxKind.ModuleBlock ||
                 node.parent.kind === SyntaxKind.SourceFile)) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`);
         }
         if (modifier.kind === SyntaxKind.AccessorKeyword &&
             node.kind !== SyntaxKind.PropertyDeclaration) {
-            throwError(modifier, "'accessor' modifier can only appear on a property declaration.");
+            throw (0, node_utils_1.createError)(modifier, "'accessor' modifier can only appear on a property declaration.");
         }
         // `checkGrammarAsyncModifier` function in `typescript`
         if (modifier.kind === SyntaxKind.AsyncKeyword &&
@@ -221,7 +215,7 @@ function checkModifiers(node) {
             node.kind !== SyntaxKind.FunctionDeclaration &&
             node.kind !== SyntaxKind.FunctionExpression &&
             node.kind !== SyntaxKind.ArrowFunction) {
-            throwError(modifier, "'async' modifier cannot be used here.");
+            throw (0, node_utils_1.createError)(modifier, "'async' modifier cannot be used here.");
         }
         // `checkGrammarModifiers` function in `typescript`
         if (node.kind === SyntaxKind.Parameter &&
@@ -229,7 +223,7 @@ function checkModifiers(node) {
                 modifier.kind === SyntaxKind.ExportKeyword ||
                 modifier.kind === SyntaxKind.DeclareKeyword ||
                 modifier.kind === SyntaxKind.AsyncKeyword)) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
         }
         // `checkGrammarModifiers` function in `typescript`
         if (modifier.kind === SyntaxKind.PublicKeyword ||
@@ -240,7 +234,7 @@ function checkModifiers(node) {
                     (anotherModifier.kind === SyntaxKind.PublicKeyword ||
                         anotherModifier.kind === SyntaxKind.ProtectedKeyword ||
                         anotherModifier.kind === SyntaxKind.PrivateKeyword)) {
-                    throwError(anotherModifier, `Accessibility modifier already seen.`);
+                    throw (0, node_utils_1.createError)(anotherModifier, `Accessibility modifier already seen.`);
                 }
             }
         }
@@ -255,15 +249,15 @@ function checkModifiers(node) {
                 modifier.kind === SyntaxKind.OverrideKeyword)) {
             const func = getContainingFunction(node);
             if (!(func?.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) {
-                throwError(modifier, 'A parameter property is only allowed in a constructor implementation.');
+                throw (0, node_utils_1.createError)(modifier, 'A parameter property is only allowed in a constructor implementation.');
             }
             const param = node;
             if (param.dotDotDotToken) {
-                throwError(modifier, 'A parameter property cannot be a rest parameter.');
+                throw (0, node_utils_1.createError)(modifier, 'A parameter property cannot be a rest parameter.');
             }
             if (param.name.kind === SyntaxKind.ArrayBindingPattern ||
                 param.name.kind === SyntaxKind.ObjectBindingPattern) {
-                throwError(modifier, 'A parameter property may not be declared using a binding pattern.');
+                throw (0, node_utils_1.createError)(modifier, 'A parameter property may not be declared using a binding pattern.');
             }
         }
         // There are more cases in `checkGrammarObjectLiteralExpression` in TypeScript.
@@ -271,7 +265,7 @@ function checkModifiers(node) {
         if (modifier.kind !== SyntaxKind.AsyncKeyword &&
             node.kind === SyntaxKind.MethodDeclaration &&
             node.parent.kind === SyntaxKind.ObjectLiteralExpression) {
-            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot be used here.`);
+            throw (0, node_utils_1.createError)(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot be used here.`);
         }
     }
 }

package/dist/convert.js

@@ -49,7 +49,7 @@ const SyntaxKind = ts.SyntaxKind;
  * @returns converted error object
  */
 function convertError(error) {
-    return (0, node_utils_1.createError)(('message' in error && error.message) || error.messageText, error.file, error.start);
+    return (0, node_utils_1.createError)(error.start, ('message' in error && error.message) || error.messageText, error.file);
 }
 function isPropertyAccessEntityNameExpression(node) {
     return (ts.isPropertyAccessExpression(node) &&
@@ -110,19 +110,7 @@ class Converter {
         if (this.options.allowInvalidAST) {
             return;
         }
-        let start;
-        let end;
-        if (Array.isArray(node)) {
-            [start, end] = node;
-        }
-        else if (typeof node === 'number') {
-            start = end = node;
-        }
-        else {
-            start = node.getStart(this.ast);
-            end = node.getEnd();
-        }
-        throw (0, node_utils_1.createError)(message, this.ast, start, end);
+        throw (0, node_utils_1.createError)(node, message, this.ast);
     }
     /**
      * Creates a getter for a property under aliasKey that returns the value under
@@ -722,17 +710,16 @@ class Converter {
             }
             case SyntaxKind.VariableDeclaration: {
                 const definite = !!node.exclamationToken;
-                const init = this.convertChild(node.initializer);
-                const id = this.convertBindingNameWithTypeAnnotation(node.name, node.type, node);
                 if (definite) {
-                    if (init) {
+                    if (node.initializer) {
                         this.#throwError(node, 'Declarations with initializers cannot also have definite assignment assertions.');
                     }
-                    else if (id.type !== ts_estree_1.AST_NODE_TYPES.Identifier ||
-                        !id.typeAnnotation) {
+                    else if (node.name.kind !== SyntaxKind.Identifier || !node.type) {
                         this.#throwError(node, 'Declarations with definite assignment assertions must also have type annotations.');
                     }
                 }
+                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,

package/dist/node-utils.d.ts

@@ -155,6 +155,7 @@ export declare class TSError extends Error {
             offset: number;
         };
     };
+    name: string;
     constructor(message: string, fileName: string, location: {
         end: {
             column: number;
@@ -171,7 +172,8 @@ export declare class TSError extends Error {
     get lineNumber(): number;
     get column(): number;
 }
-export declare function createError(message: string, ast: ts.SourceFile, startIndex: number, endIndex?: number): TSError;
+export declare function createError(node: ts.Node, message: string): TSError;
+export declare function createError(node: number | ts.Node | TSESTree.Range, message: string, sourceFile: ts.SourceFile): TSError;
 export declare function nodeHasTokens(n: ts.Node, ast: ts.SourceFile): boolean;
 /**
  * Like `forEach`, but suitable for use with numbers and strings (which may be falsy).

package/dist/node-utils.js

@@ -533,15 +533,11 @@ function convertTokens(ast) {
 class TSError extends Error {
     fileName;
     location;
+    name = 'TSError';
     constructor(message, fileName, location) {
         super(message);
         this.fileName = fileName;
         this.location = location;
-        Object.defineProperty(this, 'name', {
-            configurable: true,
-            enumerable: false,
-            value: new.target.name,
-        });
     }
     // For old version of ESLint https://github.com/typescript-eslint/typescript-eslint/pull/6556#discussion_r1123237311
     get index() {
@@ -557,12 +553,28 @@ class TSError extends Error {
     }
 }
 exports.TSError = TSError;
-function createError(message, ast, startIndex, endIndex = startIndex) {
+function createError(node, message, sourceFile) {
+    let startIndex;
+    let endIndex;
+    if (Array.isArray(node)) {
+        [startIndex, endIndex] = node;
+    }
+    else if (typeof node === 'number') {
+        startIndex = endIndex = node;
+    }
+    else {
+        sourceFile ??= node.getSourceFile();
+        startIndex = node.getStart(sourceFile);
+        endIndex = node.getEnd();
+    }
+    if (!sourceFile) {
+        throw new Error('`sourceFile` is required.');
+    }
     const [start, end] = [startIndex, endIndex].map(offset => {
-        const { character: column, line } = ast.getLineAndCharacterOfPosition(offset);
+        const { character: column, line } = sourceFile.getLineAndCharacterOfPosition(offset);
         return { column, line: line + 1, offset };
     });
-    return new TSError(message, ast.fileName, { end, start });
+    return new TSError(message, sourceFile.fileName, { end, start });
 }
 function nodeHasTokens(n, ast) {
     // If we have a token or node that has a non-zero width, it must have tokens.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.48.1-alpha.1",
+  "version": "8.48.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.48.1-alpha.1",
-    "@typescript-eslint/tsconfig-utils": "8.48.1-alpha.1",
-    "@typescript-eslint/types": "8.48.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.48.1-alpha.1",
+    "@typescript-eslint/project-service": "8.48.1-alpha.10",
+    "@typescript-eslint/tsconfig-utils": "8.48.1-alpha.10",
+    "@typescript-eslint/types": "8.48.1-alpha.10",
+    "@typescript-eslint/visitor-keys": "8.48.1-alpha.10",
     "debug": "^4.3.4",
     "minimatch": "^9.0.4",
     "semver": "^7.6.0",