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

package/dist/check-modifiers.js

@@ -257,6 +257,14 @@ function checkModifiers(node) {
             if (!(func?.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) {
                 throwError(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.');
+            }
+            if (param.name.kind === SyntaxKind.ArrayBindingPattern ||
+                param.name.kind === SyntaxKind.ObjectBindingPattern) {
+                throwError(modifier, 'A parameter property may not be declared using a binding pattern.');
+            }
         }
         // There are more cases in `checkGrammarObjectLiteralExpression` in TypeScript.
         // We may add more validations for them here in the future.

package/dist/convert.js

@@ -107,6 +107,9 @@ class Converter {
         (0, check_modifiers_1.checkModifiers)(node);
     }
     #throwError(node, message) {
+        if (this.options.allowInvalidAST) {
+            return;
+        }
         let start;
         let end;
         if (Array.isArray(node)) {
@@ -121,11 +124,6 @@ class Converter {
         }
         throw (0, node_utils_1.createError)(message, this.ast, start, end);
     }
-    #throwUnlessAllowInvalidAST(node, message) {
-        if (!this.options.allowInvalidAST) {
-            this.#throwError(node, message);
-        }
-    }
     /**
      * Creates a getter for a property under aliasKey that returns the value under
      * valueKey. If suppressDeprecatedPropertyWarnings is not enabled, the
@@ -187,11 +185,11 @@ class Converter {
     }
     assertModuleSpecifier(node, allowNull) {
         if (!allowNull && node.moduleSpecifier == null) {
-            this.#throwUnlessAllowInvalidAST(node, 'Module specifier must be a string literal.');
+            this.#throwError(node, 'Module specifier must be a string literal.');
         }
         if (node.moduleSpecifier &&
             node.moduleSpecifier?.kind !== SyntaxKind.StringLiteral) {
-            this.#throwUnlessAllowInvalidAST(node.moduleSpecifier, 'Module specifier must be a string literal.');
+            this.#throwError(node.moduleSpecifier, 'Module specifier must be a string literal.');
         }
     }
     convertBindingNameWithTypeAnnotation(name, tsType, parent) {
@@ -617,7 +615,7 @@ class Converter {
             // Exceptions
             case SyntaxKind.ThrowStatement:
                 if (node.expression.end === node.expression.pos) {
-                    this.#throwUnlessAllowInvalidAST(node, 'A throw statement must throw an expression.');
+                    this.#throwError(node, 'A throw statement must throw an expression.');
                 }
                 return this.createNode(node, {
                     type: ts_estree_1.AST_NODE_TYPES.ThrowStatement,
@@ -750,7 +748,7 @@ class Converter {
                     kind: (0, node_utils_1.getDeclarationKind)(node.declarationList),
                 });
                 if (!result.declarations.length) {
-                    this.#throwUnlessAllowInvalidAST(node, 'A variable declaration list must have at least one variable declarator.');
+                    this.#throwError(node, 'A variable declaration list must have at least one variable declarator.');
                 }
                 if (result.kind === 'using' || result.kind === 'await using') {
                     node.declarationList.declarations.forEach((declaration, i) => {
@@ -860,7 +858,7 @@ class Converter {
                         property.kind === SyntaxKind.SetAccessor ||
                         property.kind === SyntaxKind.MethodDeclaration) &&
                         !property.body) {
-                        this.#throwUnlessAllowInvalidAST(property.end - 1, "'{' expected.");
+                        this.#throwError(property.end - 1, "'{' expected.");
                     }
                     properties.push(this.convertChild(property));
                 }
@@ -1381,7 +1379,7 @@ class Converter {
                 if (!node.name &&
                     (!(0, node_utils_1.hasModifier)(ts.SyntaxKind.ExportKeyword, node) ||
                         !(0, node_utils_1.hasModifier)(ts.SyntaxKind.DefaultKeyword, node))) {
-                    this.#throwUnlessAllowInvalidAST(node, "A class declaration without the 'default' modifier must have a name.");
+                    this.#throwError(node, "A class declaration without the 'default' modifier must have a name.");
                 }
             /* intentional fallthrough */
             case SyntaxKind.ClassExpression: {
@@ -1394,23 +1392,23 @@ class Converter {
                 for (const heritageClause of heritageClauses) {
                     const { token, types } = heritageClause;
                     if (types.length === 0) {
-                        this.#throwUnlessAllowInvalidAST(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
+                        this.#throwError(heritageClause, `'${ts.tokenToString(token)}' list cannot be empty.`);
                     }
                     if (token === SyntaxKind.ExtendsKeyword) {
                         if (extendsClause) {
-                            this.#throwUnlessAllowInvalidAST(heritageClause, "'extends' clause already seen.");
+                            this.#throwError(heritageClause, "'extends' clause already seen.");
                         }
                         if (implementsClause) {
-                            this.#throwUnlessAllowInvalidAST(heritageClause, "'extends' clause must precede 'implements' clause.");
+                            this.#throwError(heritageClause, "'extends' clause must precede 'implements' clause.");
                         }
                         if (types.length > 1) {
-                            this.#throwUnlessAllowInvalidAST(types[1], 'Classes can only extend a single class.');
+                            this.#throwError(types[1], 'Classes can only extend a single class.');
                         }
                         extendsClause ??= heritageClause;
                     }
                     else if (token === SyntaxKind.ImplementsKeyword) {
                         if (implementsClause) {
-                            this.#throwUnlessAllowInvalidAST(heritageClause, "'implements' clause already seen.");
+                            this.#throwError(heritageClause, "'implements' clause already seen.");
                         }
                         implementsClause ??= heritageClause;
                     }
@@ -1556,7 +1554,7 @@ class Converter {
                  */
                 if (operator === '++' || operator === '--') {
                     if (!(0, node_utils_1.isValidAssignmentTarget)(node.operand)) {
-                        this.#throwUnlessAllowInvalidAST(node.operand, 'Invalid left-hand side expression in unary operation');
+                        this.#throwError(node.operand, 'Invalid left-hand side expression in unary operation');
                     }
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.UpdateExpression,
@@ -1672,7 +1670,7 @@ class Converter {
             case SyntaxKind.CallExpression: {
                 if (node.expression.kind === SyntaxKind.ImportKeyword) {
                     if (node.arguments.length !== 1 && node.arguments.length !== 2) {
-                        this.#throwUnlessAllowInvalidAST(node.arguments[2] ?? node, 'Dynamic import requires exactly one or two arguments.');
+                        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,
@@ -2006,7 +2004,7 @@ class Converter {
                 });
             case SyntaxKind.MappedType: {
                 if (node.members && node.members.length > 0) {
-                    this.#throwUnlessAllowInvalidAST(node.members[0], 'A mapped type may not declare properties or methods.');
+                    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,
@@ -2227,16 +2225,18 @@ class Converter {
                         ],
                     });
                 }
-                const result = this.createNode(node, {
+                const argument = this.convertChild(node.argument);
+                const source = argument.literal;
+                const result = this.createNode(node, this.#withDeprecatedGetter({
                     type: ts_estree_1.AST_NODE_TYPES.TSImportType,
                     range,
-                    argument: this.convertChild(node.argument),
                     options,
                     qualifier: this.convertChild(node.qualifier),
+                    source,
                     typeArguments: node.typeArguments
                         ? this.convertTypeArgumentsToTypeParameterInstantiation(node.typeArguments, node)
                         : null,
-                });
+                }, 'argument', 'source', argument));
                 if (node.isTypeOf) {
                     return this.createNode(node, {
                         type: ts_estree_1.AST_NODE_TYPES.TSTypeQuery,
@@ -2264,11 +2264,11 @@ class Converter {
             case SyntaxKind.EnumMember: {
                 const computed = node.name.kind === ts.SyntaxKind.ComputedPropertyName;
                 if (computed) {
-                    this.#throwUnlessAllowInvalidAST(node.name, 'Computed property names are not allowed in enums.');
+                    this.#throwError(node.name, 'Computed property names are not allowed in enums.');
                 }
                 if (node.name.kind === SyntaxKind.NumericLiteral ||
                     node.name.kind === SyntaxKind.BigIntLiteral) {
-                    this.#throwUnlessAllowInvalidAST(node.name, 'An enum member cannot have a numeric name.');
+                    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,
@@ -2288,10 +2288,10 @@ class Converter {
                             const body = this.convertChild(node.body);
                             if (body == null ||
                                 body.type === ts_estree_1.AST_NODE_TYPES.TSModuleDeclaration) {
-                                this.#throwUnlessAllowInvalidAST(node.body ?? node, 'Expected a valid module body');
+                                this.#throwError(node.body ?? node, 'Expected a valid module body');
                             }
                             if (id.type !== ts_estree_1.AST_NODE_TYPES.Identifier) {
-                                this.#throwUnlessAllowInvalidAST(node.name, 'global module augmentation must have an Identifier id');
+                                this.#throwError(node.name, 'global module augmentation must have an Identifier id');
                             }
                             return {
                                 body: body,
@@ -2315,10 +2315,10 @@ class Converter {
                         // 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.#throwUnlessAllowInvalidAST(node, 'Expected a module body');
+                            this.#throwError(node, 'Expected a module body');
                         }
                         if (node.name.kind !== ts.SyntaxKind.Identifier) {
-                            this.#throwUnlessAllowInvalidAST(node.name, '`namespace`s must have an Identifier id');
+                            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,

package/dist/parseSettings/inferSingleRun.js

@@ -21,12 +21,12 @@ function inferSingleRun(options) {
     // https://github.com/typescript-eslint/typescript-eslint/issues/9504
     // There's no support (yet?) for extraFileExtensions in single-run hosts.
     // Only watch program hosts and project service can support that.
-    if (options?.extraFileExtensions?.length) {
+    if (options?.extraFileExtensions?.length && options.project) {
         return false;
     }
     if (
     // single-run implies type-aware linting - no projects means we can't be in single-run mode
-    options?.project == null ||
+    (options?.project == null && !options?.projectService) ||
         // programs passed via options means the user should be managing the programs, so we shouldn't
         // be creating our own single-run programs accidentally
         options.programs != null) {

package/dist/parseSettings/resolveProjectList.js

@@ -7,8 +7,7 @@ exports.clearGlobCache = clearGlobCache;
 exports.resolveProjectList = resolveProjectList;
 exports.clearGlobResolutionCache = clearGlobResolutionCache;
 const debug_1 = __importDefault(require("debug"));
-const fast_glob_1 = require("fast-glob");
-const is_glob_1 = __importDefault(require("is-glob"));
+const tinyglobby_1 = require("tinyglobby");
 const shared_1 = require("../create-program/shared");
 const ExpiringCache_1 = require("./ExpiringCache");
 const log = (0, debug_1.default)('typescript-eslint:typescript-estree:parseSettings:resolveProjectList');
@@ -32,10 +31,7 @@ function resolveProjectList(options) {
     if (sanitizedProjects.length === 0) {
         return new Map();
     }
-    const projectFolderIgnoreList = (options.projectFolderIgnoreList ?? ['**/node_modules/**'])
-        .filter(folder => typeof folder === 'string')
-        // prefix with a ! for not match glob
-        .map(folder => (folder.startsWith('!') ? folder : `!${folder}`));
+    const projectFolderIgnoreList = (options.projectFolderIgnoreList ?? ['**/node_modules/**']).filter(folder => typeof folder === 'string');
     const cacheKey = getHash({
         project: sanitizedProjects,
         projectFolderIgnoreList,
@@ -58,15 +54,15 @@ function resolveProjectList(options) {
         }
     }
     // Transform glob patterns into paths
-    const nonGlobProjects = sanitizedProjects.filter(project => !(0, is_glob_1.default)(project));
-    const globProjects = sanitizedProjects.filter(project => (0, is_glob_1.default)(project));
+    const nonGlobProjects = sanitizedProjects.filter(project => !(0, tinyglobby_1.isDynamicPattern)(project));
+    const globProjects = sanitizedProjects.filter(project => (0, tinyglobby_1.isDynamicPattern)(project));
     let globProjectPaths = [];
     if (globProjects.length > 0) {
-        // Although fast-glob supports multiple patterns, fast-glob returns arbitrary order of results
-        // to improve performance. To ensure the order is correct, we need to call fast-glob for each pattern
+        // To ensure the order is correct, we need to glob for each pattern
         // separately and then concatenate the results in patterns' order.
-        globProjectPaths = globProjects.flatMap(pattern => (0, fast_glob_1.sync)(pattern, {
+        globProjectPaths = globProjects.flatMap(pattern => (0, tinyglobby_1.globSync)(pattern, {
             cwd: options.tsconfigRootDir,
+            expandDirectories: false,
             ignore: projectFolderIgnoreList,
         }));
     }

package/dist/parser-options.d.ts

@@ -1,6 +1,6 @@
 import type { CacheDurationSeconds, DebugLevel, JSDocParsingMode, ProjectServiceOptions, SourceType } from '@typescript-eslint/types';
 import type * as ts from 'typescript';
-import type { TSESTree, TSESTreeToTSNode, TSNode, TSToken } from './ts-estree';
+import type { TSESTree, TSESTreeToTSNode, TSToken } from './ts-estree';
 interface ParseOptions {
     /**
      * Specify the `sourceType`.
@@ -192,7 +192,7 @@ export interface ParserServicesBase {
 }
 export interface ParserServicesNodeMaps {
     esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, TSESTree.Node>;
+    tsNodeToESTreeNodeMap: ParserWeakMap<TSToken, TSESTree.Node>;
 }
 export interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps, ParserServicesBase {
     getSymbolAtLocation: (node: TSESTree.Node) => ts.Symbol | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/typescript-estree",
-  "version": "8.47.1-alpha.1",
+  "version": "8.47.1-alpha.11",
   "description": "A parser that converts TypeScript source code into an ESTree compatible form",
   "files": [
     "dist",
@@ -52,19 +52,17 @@
     "typecheck": "yarn run -BT nx typecheck"
   },
   "dependencies": {
-    "@typescript-eslint/project-service": "8.47.1-alpha.1",
-    "@typescript-eslint/tsconfig-utils": "8.47.1-alpha.1",
-    "@typescript-eslint/types": "8.47.1-alpha.1",
-    "@typescript-eslint/visitor-keys": "8.47.1-alpha.1",
+    "@typescript-eslint/project-service": "8.47.1-alpha.11",
+    "@typescript-eslint/tsconfig-utils": "8.47.1-alpha.11",
+    "@typescript-eslint/types": "8.47.1-alpha.11",
+    "@typescript-eslint/visitor-keys": "8.47.1-alpha.11",
     "debug": "^4.3.4",
-    "fast-glob": "^3.3.2",
-    "is-glob": "^4.0.3",
     "minimatch": "^9.0.4",
     "semver": "^7.6.0",
+    "tinyglobby": "^0.2.15",
     "ts-api-utils": "^2.1.0"
   },
   "devDependencies": {
-    "@types/is-glob": "^4.0.4",
     "@vitest/coverage-v8": "^3.1.3",
     "eslint": "*",
     "glob": "*",