@typescript-eslint/typescript-estree 8.45.1-alpha.8 → 8.46.0

package/dist/check-modifiers.d.ts

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

package/dist/check-modifiers.js

@@ -0,0 +1,269 @@
+"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.checkModifiers = checkModifiers;
+const ts = __importStar(require("typescript"));
+const getModifiers_1 = require("./getModifiers");
+const node_utils_1 = require("./node-utils");
+const SyntaxKind = ts.SyntaxKind;
+// `ts.nodeIsMissing`
+function nodeIsMissing(node) {
+    if (node == null) {
+        return true;
+    }
+    return (node.pos === node.end &&
+        node.pos >= 0 &&
+        node.kind !== SyntaxKind.EndOfFileToken);
+}
+// `ts.nodeIsPresent`
+function nodeIsPresent(node) {
+    return !nodeIsMissing(node);
+}
+// `ts.hasAbstractModifier`
+function hasAbstractModifier(node) {
+    return (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node);
+}
+// `ts.getThisParameter`
+function getThisParameter(signature) {
+    if (signature.parameters.length && !ts.isJSDocSignature(signature)) {
+        const thisParameter = signature.parameters[0];
+        if (parameterIsThisKeyword(thisParameter)) {
+            return thisParameter;
+        }
+    }
+    return null;
+}
+// `ts.parameterIsThisKeyword`
+function parameterIsThisKeyword(parameter) {
+    return (0, node_utils_1.isThisIdentifier)(parameter.name);
+}
+// `ts.getContainingFunction`
+function getContainingFunction(node) {
+    return ts.findAncestor(node.parent, ts.isFunctionLike);
+}
+// Rewrite version of `ts.nodeCanBeDecorated`
+// Returns `true` for both `useLegacyDecorators: true` and `useLegacyDecorators: false`
+function nodeCanBeDecorated(node) {
+    switch (node.kind) {
+        case SyntaxKind.ClassDeclaration:
+            return true;
+        case SyntaxKind.ClassExpression:
+            // `ts.nodeCanBeDecorated` returns `false` if `useLegacyDecorators: true`
+            return true;
+        case SyntaxKind.PropertyDeclaration: {
+            const { parent } = node;
+            // `ts.nodeCanBeDecorated` uses this if `useLegacyDecorators: true`
+            if (ts.isClassDeclaration(parent)) {
+                return true;
+            }
+            // `ts.nodeCanBeDecorated` uses this if `useLegacyDecorators: false`
+            if (ts.isClassLike(parent) && !hasAbstractModifier(node)) {
+                return true;
+            }
+            return false;
+        }
+        case SyntaxKind.GetAccessor:
+        case SyntaxKind.SetAccessor:
+        case SyntaxKind.MethodDeclaration: {
+            const { parent } = node;
+            // In `ts.nodeCanBeDecorated`
+            // when `useLegacyDecorators: true` uses `ts.isClassDeclaration`
+            // when `useLegacyDecorators: true` uses `ts.isClassLike`
+            return (Boolean(node.body) &&
+                (ts.isClassDeclaration(parent) || ts.isClassLike(parent)));
+        }
+        case SyntaxKind.Parameter: {
+            // `ts.nodeCanBeDecorated` returns `false` if `useLegacyDecorators: false`
+            const { parent } = node;
+            const grandparent = parent.parent;
+            return (Boolean(parent) &&
+                'body' in parent &&
+                Boolean(parent.body) &&
+                (parent.kind === SyntaxKind.Constructor ||
+                    parent.kind === SyntaxKind.MethodDeclaration ||
+                    parent.kind === SyntaxKind.SetAccessor) &&
+                getThisParameter(parent) !== node &&
+                Boolean(grandparent) &&
+                grandparent.kind === SyntaxKind.ClassDeclaration);
+        }
+    }
+    return false;
+}
+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.');
+    }
+    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.');
+            }
+            else {
+                throwError(decorator, 'Decorators are not valid here.');
+            }
+        }
+    }
+    for (const modifier of (0, getModifiers_1.getModifiers)(node, 
+    /* includeIllegalModifiers */ true) ?? []) {
+        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`);
+            }
+            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`);
+            }
+        }
+        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`);
+        }
+        if ((modifier.kind === SyntaxKind.InKeyword ||
+            modifier.kind === SyntaxKind.OutKeyword) &&
+            (node.kind !== SyntaxKind.TypeParameter ||
+                !(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`);
+        }
+        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.");
+        }
+        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.`);
+        }
+        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.`);
+            }
+        }
+        if (modifier.kind === SyntaxKind.AbstractKeyword &&
+            node.kind !== SyntaxKind.ClassDeclaration &&
+            node.kind !== SyntaxKind.ConstructorType &&
+            node.kind !== SyntaxKind.MethodDeclaration &&
+            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.`);
+        }
+        if ((modifier.kind === SyntaxKind.StaticKeyword ||
+            modifier.kind === SyntaxKind.PublicKeyword ||
+            modifier.kind === SyntaxKind.ProtectedKeyword ||
+            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.`);
+        }
+        if (modifier.kind === SyntaxKind.AccessorKeyword &&
+            node.kind !== SyntaxKind.PropertyDeclaration) {
+            throwError(modifier, "'accessor' modifier can only appear on a property declaration.");
+        }
+        // `checkGrammarAsyncModifier` function in `typescript`
+        if (modifier.kind === SyntaxKind.AsyncKeyword &&
+            node.kind !== SyntaxKind.MethodDeclaration &&
+            node.kind !== SyntaxKind.FunctionDeclaration &&
+            node.kind !== SyntaxKind.FunctionExpression &&
+            node.kind !== SyntaxKind.ArrowFunction) {
+            throwError(modifier, "'async' modifier cannot be used here.");
+        }
+        // `checkGrammarModifiers` function in `typescript`
+        if (node.kind === SyntaxKind.Parameter &&
+            (modifier.kind === SyntaxKind.StaticKeyword ||
+                modifier.kind === SyntaxKind.ExportKeyword ||
+                modifier.kind === SyntaxKind.DeclareKeyword ||
+                modifier.kind === SyntaxKind.AsyncKeyword)) {
+            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
+        }
+        // `checkGrammarModifiers` function in `typescript`
+        if (modifier.kind === SyntaxKind.PublicKeyword ||
+            modifier.kind === SyntaxKind.ProtectedKeyword ||
+            modifier.kind === SyntaxKind.PrivateKeyword) {
+            for (const anotherModifier of (0, getModifiers_1.getModifiers)(node) ?? []) {
+                if (anotherModifier !== modifier &&
+                    (anotherModifier.kind === SyntaxKind.PublicKeyword ||
+                        anotherModifier.kind === SyntaxKind.ProtectedKeyword ||
+                        anotherModifier.kind === SyntaxKind.PrivateKeyword)) {
+                    throwError(anotherModifier, `Accessibility modifier already seen.`);
+                }
+            }
+        }
+        // `checkParameter` function in `typescript`
+        if (node.kind === SyntaxKind.Parameter &&
+            // In `typescript` package, it's `ts.hasSyntacticModifier(node, ts.ModifierFlags.ParameterPropertyModifier)`
+            // https://github.com/typescript-eslint/typescript-eslint/pull/6615#discussion_r1136489935
+            (modifier.kind === SyntaxKind.PublicKeyword ||
+                modifier.kind === SyntaxKind.PrivateKeyword ||
+                modifier.kind === SyntaxKind.ProtectedKeyword ||
+                modifier.kind === SyntaxKind.ReadonlyKeyword ||
+                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.');
+            }
+        }
+        // There are more cases in `checkGrammarObjectLiteralExpression` in TypeScript.
+        // We may add more validations for them here in the future.
+        if (modifier.kind === SyntaxKind.AbstractKeyword &&
+            node.kind === SyntaxKind.MethodDeclaration &&
+            node.parent.kind === SyntaxKind.ObjectLiteralExpression) {
+            throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot be used here.`);
+        }
+    }
+}

package/dist/convert.js

@@ -38,6 +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 getModifiers_1 = require("./getModifiers");
 const node_utils_1 = require("./node-utils");
 const ts_estree_1 = require("./ts-estree");
@@ -103,133 +104,7 @@ class Converter {
         if (this.options.allowInvalidAST) {
             return;
         }
-        // typescript<5.0.0
-        if ((0, node_utils_1.nodeHasIllegalDecorators)(node)) {
-            this.#throwError(node.illegalDecorators[0], 'Decorators are not valid here.');
-        }
-        for (const decorator of (0, getModifiers_1.getDecorators)(node, 
-        /* includeIllegalDecorators */ true) ?? []) {
-            // `checkGrammarModifiers` function in typescript
-            if (!(0, node_utils_1.nodeCanBeDecorated)(node)) {
-                if (ts.isMethodDeclaration(node) && !(0, node_utils_1.nodeIsPresent)(node.body)) {
-                    this.#throwError(decorator, 'A decorator can only decorate a method implementation, not an overload.');
-                }
-                else {
-                    this.#throwError(decorator, 'Decorators are not valid here.');
-                }
-            }
-        }
-        for (const modifier of (0, getModifiers_1.getModifiers)(node, 
-        /* includeIllegalModifiers */ true) ?? []) {
-            if (modifier.kind !== SyntaxKind.ReadonlyKeyword) {
-                if (node.kind === SyntaxKind.PropertySignature ||
-                    node.kind === SyntaxKind.MethodSignature) {
-                    this.#throwError(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))) {
-                    this.#throwError(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) {
-                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a type parameter`);
-            }
-            if ((modifier.kind === SyntaxKind.InKeyword ||
-                modifier.kind === SyntaxKind.OutKeyword) &&
-                (node.kind !== SyntaxKind.TypeParameter ||
-                    !(ts.isInterfaceDeclaration(node.parent) ||
-                        ts.isClassLike(node.parent) ||
-                        ts.isTypeAliasDeclaration(node.parent)))) {
-                this.#throwError(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) {
-                this.#throwError(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)) {
-                this.#throwError(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') {
-                    this.#throwError(modifier, `'declare' modifier cannot appear on a '${declarationKind}' declaration.`);
-                }
-            }
-            if (modifier.kind === SyntaxKind.AbstractKeyword &&
-                node.kind !== SyntaxKind.ClassDeclaration &&
-                node.kind !== SyntaxKind.ConstructorType &&
-                node.kind !== SyntaxKind.MethodDeclaration &&
-                node.kind !== SyntaxKind.PropertyDeclaration &&
-                node.kind !== SyntaxKind.GetAccessor &&
-                node.kind !== SyntaxKind.SetAccessor) {
-                this.#throwError(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 ||
-                modifier.kind === SyntaxKind.ProtectedKeyword ||
-                modifier.kind === SyntaxKind.PrivateKeyword) &&
-                (node.parent.kind === SyntaxKind.ModuleBlock ||
-                    node.parent.kind === SyntaxKind.SourceFile)) {
-                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a module or namespace element.`);
-            }
-            if (modifier.kind === SyntaxKind.AccessorKeyword &&
-                node.kind !== SyntaxKind.PropertyDeclaration) {
-                this.#throwError(modifier, "'accessor' modifier can only appear on a property declaration.");
-            }
-            // `checkGrammarAsyncModifier` function in `typescript`
-            if (modifier.kind === SyntaxKind.AsyncKeyword &&
-                node.kind !== SyntaxKind.MethodDeclaration &&
-                node.kind !== SyntaxKind.FunctionDeclaration &&
-                node.kind !== SyntaxKind.FunctionExpression &&
-                node.kind !== SyntaxKind.ArrowFunction) {
-                this.#throwError(modifier, "'async' modifier cannot be used here.");
-            }
-            // `checkGrammarModifiers` function in `typescript`
-            if (node.kind === SyntaxKind.Parameter &&
-                (modifier.kind === SyntaxKind.StaticKeyword ||
-                    modifier.kind === SyntaxKind.ExportKeyword ||
-                    modifier.kind === SyntaxKind.DeclareKeyword ||
-                    modifier.kind === SyntaxKind.AsyncKeyword)) {
-                this.#throwError(modifier, `'${ts.tokenToString(modifier.kind)}' modifier cannot appear on a parameter.`);
-            }
-            // `checkGrammarModifiers` function in `typescript`
-            if (modifier.kind === SyntaxKind.PublicKeyword ||
-                modifier.kind === SyntaxKind.ProtectedKeyword ||
-                modifier.kind === SyntaxKind.PrivateKeyword) {
-                for (const anotherModifier of (0, getModifiers_1.getModifiers)(node) ?? []) {
-                    if (anotherModifier !== modifier &&
-                        (anotherModifier.kind === SyntaxKind.PublicKeyword ||
-                            anotherModifier.kind === SyntaxKind.ProtectedKeyword ||
-                            anotherModifier.kind === SyntaxKind.PrivateKeyword)) {
-                        this.#throwError(anotherModifier, `Accessibility modifier already seen.`);
-                    }
-                }
-            }
-            // `checkParameter` function in `typescript`
-            if (node.kind === SyntaxKind.Parameter &&
-                // In `typescript` package, it's `ts.hasSyntacticModifier(node, ts.ModifierFlags.ParameterPropertyModifier)`
-                // https://github.com/typescript-eslint/typescript-eslint/pull/6615#discussion_r1136489935
-                (modifier.kind === SyntaxKind.PublicKeyword ||
-                    modifier.kind === SyntaxKind.PrivateKeyword ||
-                    modifier.kind === SyntaxKind.ProtectedKeyword ||
-                    modifier.kind === SyntaxKind.ReadonlyKeyword ||
-                    modifier.kind === SyntaxKind.OverrideKeyword)) {
-                const func = (0, node_utils_1.getContainingFunction)(node);
-                if (!(func.kind === SyntaxKind.Constructor && (0, node_utils_1.nodeIsPresent)(func.body))) {
-                    this.#throwError(modifier, 'A parameter property is only allowed in a constructor implementation.');
-                }
-            }
-        }
+        (0, check_modifiers_1.checkModifiers)(node);
     }
     #throwError(node, message) {
         let start;
@@ -1110,6 +985,13 @@ 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
@@ -1152,7 +1034,7 @@ class Converter {
                     /**
                      * TypeScript class methods can be defined as "abstract"
                      */
-                    const methodDefinitionType = (0, node_utils_1.hasModifier)(SyntaxKind.AbstractKeyword, node)
+                    const methodDefinitionType = isAbstract
                         ? ts_estree_1.AST_NODE_TYPES.TSAbstractMethodDefinition
                         : ts_estree_1.AST_NODE_TYPES.MethodDefinition;
                     result = this.createNode(node, {
@@ -1719,6 +1601,13 @@ 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, {

package/dist/node-utils.d.ts

@@ -1,5 +1,5 @@
 import * as ts from 'typescript';
-import type { TSESTree, TSNode } from './ts-estree';
+import type { TSESTree } from './ts-estree';
 import { AST_NODE_TYPES, AST_TOKEN_TYPES } from './ts-estree';
 declare const SyntaxKind: typeof ts.SyntaxKind;
 type LogicalOperatorKind = ts.SyntaxKind.AmpersandAmpersandToken | ts.SyntaxKind.BarBarToken | ts.SyntaxKind.QuestionQuestionToken;
@@ -172,9 +172,6 @@ export declare class TSError extends Error {
     get column(): number;
 }
 export declare function createError(message: string, ast: ts.SourceFile, startIndex: number, endIndex?: number): TSError;
-export declare function nodeHasIllegalDecorators(node: ts.Node): node is {
-    illegalDecorators: ts.Node[];
-} & ts.Node;
 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).
@@ -183,9 +180,7 @@ export declare function firstDefined<T, U>(array: readonly T[] | undefined, call
 export declare function identifierIsThisKeyword(id: ts.Identifier): boolean;
 export declare function isThisIdentifier(node: ts.Node | undefined): node is ts.Identifier;
 export declare function isThisInTypeQuery(node: ts.Node): boolean;
-export declare function nodeIsPresent(node: ts.Node | undefined): node is ts.Node;
-export declare function getContainingFunction(node: ts.Node): ts.SignatureDeclaration | undefined;
-export declare function nodeCanBeDecorated(node: TSNode): 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 {};

package/dist/node-utils.js

@@ -62,17 +62,14 @@ exports.getTokenType = getTokenType;
 exports.convertToken = convertToken;
 exports.convertTokens = convertTokens;
 exports.createError = createError;
-exports.nodeHasIllegalDecorators = nodeHasIllegalDecorators;
 exports.nodeHasTokens = nodeHasTokens;
 exports.firstDefined = firstDefined;
 exports.identifierIsThisKeyword = identifierIsThisKeyword;
 exports.isThisIdentifier = isThisIdentifier;
 exports.isThisInTypeQuery = isThisInTypeQuery;
-exports.nodeIsPresent = nodeIsPresent;
-exports.getContainingFunction = getContainingFunction;
-exports.nodeCanBeDecorated = nodeCanBeDecorated;
 exports.isValidAssignmentTarget = isValidAssignmentTarget;
 exports.getNamespaceModifiers = getNamespaceModifiers;
+exports.declarationNameToString = declarationNameToString;
 const ts = __importStar(require("typescript"));
 const getModifiers_1 = require("./getModifiers");
 const xhtml_entities_1 = require("./jsx/xhtml-entities");
@@ -567,10 +564,6 @@ function createError(message, ast, startIndex, endIndex = startIndex) {
     });
     return new TSError(message, ast.fileName, { end, start });
 }
-function nodeHasIllegalDecorators(node) {
-    return !!('illegalDecorators' in node &&
-        node.illegalDecorators?.length);
-}
 function nodeHasTokens(n, ast) {
     // If we have a token or node that has a non-zero width, it must have tokens.
     // Note: getWidth() does not take trivia into account.
@@ -615,89 +608,6 @@ function isThisInTypeQuery(node) {
     }
     return node.parent.kind === SyntaxKind.TypeQuery;
 }
-// `ts.nodeIsMissing`
-function nodeIsMissing(node) {
-    if (node == null) {
-        return true;
-    }
-    return (node.pos === node.end &&
-        node.pos >= 0 &&
-        node.kind !== SyntaxKind.EndOfFileToken);
-}
-// `ts.nodeIsPresent`
-function nodeIsPresent(node) {
-    return !nodeIsMissing(node);
-}
-// `ts.getContainingFunction`
-function getContainingFunction(node) {
-    return ts.findAncestor(node.parent, ts.isFunctionLike);
-}
-// `ts.hasAbstractModifier`
-function hasAbstractModifier(node) {
-    return hasModifier(SyntaxKind.AbstractKeyword, node);
-}
-// `ts.getThisParameter`
-function getThisParameter(signature) {
-    if (signature.parameters.length && !ts.isJSDocSignature(signature)) {
-        const thisParameter = signature.parameters[0];
-        if (parameterIsThisKeyword(thisParameter)) {
-            return thisParameter;
-        }
-    }
-    return null;
-}
-// `ts.parameterIsThisKeyword`
-function parameterIsThisKeyword(parameter) {
-    return isThisIdentifier(parameter.name);
-}
-// Rewrite version of `ts.nodeCanBeDecorated`
-// Returns `true` for both `useLegacyDecorators: true` and `useLegacyDecorators: false`
-function nodeCanBeDecorated(node) {
-    switch (node.kind) {
-        case SyntaxKind.ClassDeclaration:
-            return true;
-        case SyntaxKind.ClassExpression:
-            // `ts.nodeCanBeDecorated` returns `false` if `useLegacyDecorators: true`
-            return true;
-        case SyntaxKind.PropertyDeclaration: {
-            const { parent } = node;
-            // `ts.nodeCanBeDecorated` uses this if `useLegacyDecorators: true`
-            if (ts.isClassDeclaration(parent)) {
-                return true;
-            }
-            // `ts.nodeCanBeDecorated` uses this if `useLegacyDecorators: false`
-            if (ts.isClassLike(parent) && !hasAbstractModifier(node)) {
-                return true;
-            }
-            return false;
-        }
-        case SyntaxKind.GetAccessor:
-        case SyntaxKind.SetAccessor:
-        case SyntaxKind.MethodDeclaration: {
-            const { parent } = node;
-            // In `ts.nodeCanBeDecorated`
-            // when `useLegacyDecorators: true` uses `ts.isClassDeclaration`
-            // when `useLegacyDecorators: true` uses `ts.isClassLike`
-            return (Boolean(node.body) &&
-                (ts.isClassDeclaration(parent) || ts.isClassLike(parent)));
-        }
-        case SyntaxKind.Parameter: {
-            // `ts.nodeCanBeDecorated` returns `false` if `useLegacyDecorators: false`
-            const { parent } = node;
-            const grandparent = parent.parent;
-            return (Boolean(parent) &&
-                'body' in parent &&
-                Boolean(parent.body) &&
-                (parent.kind === SyntaxKind.Constructor ||
-                    parent.kind === SyntaxKind.MethodDeclaration ||
-                    parent.kind === SyntaxKind.SetAccessor) &&
-                getThisParameter(parent) !== node &&
-                Boolean(grandparent) &&
-                grandparent.kind === SyntaxKind.ClassDeclaration);
-        }
-    }
-    return false;
-}
 function isValidAssignmentTarget(node) {
     switch (node.kind) {
         case SyntaxKind.Identifier:
@@ -734,3 +644,8 @@ function getNamespaceModifiers(node) {
     }
     return modifiers;
 }
+// `ts.declarationNameToString`
+function declarationNameToString(name, ast) {
+    const text = ast.text.slice(name.pos, name.end).trimStart();
+    return text || '(Missing)';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.45.1-alpha.8",
+  "version": "8.46.0",
   "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.45.1-alpha.8",
-    "@typescript-eslint/tsconfig-utils": "8.45.1-alpha.8",
-    "@typescript-eslint/types": "8.45.1-alpha.8",
-    "@typescript-eslint/visitor-keys": "8.45.1-alpha.8",
+    "@typescript-eslint/project-service": "8.46.0",
+    "@typescript-eslint/tsconfig-utils": "8.46.0",
+    "@typescript-eslint/types": "8.46.0",
+    "@typescript-eslint/visitor-keys": "8.46.0",
     "debug": "^4.3.4",
     "fast-glob": "^3.3.2",
     "is-glob": "^4.0.3",