@typescript-eslint/typescript-estree 8.47.1-alpha.2 → 8.47.1-alpha.4

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,
@@ -2264,11 +2262,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 +2286,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 +2313,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/package.json

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