feat: add support for typescript AST to isParenthesized (#258)

Co-authored-by: Yosuke Ota <[email protected]>

Author: 9romise

src/is-parenthesized.mjs

@@ -1,5 +1,7 @@
 import { isClosingParenToken, isOpeningParenToken } from "./token-predicate.mjs"
 /** @typedef {import("estree").Node} Node */
+/** @typedef {import("@typescript-eslint/types").TSESTree.NewExpression} TSNewExpression */
+/** @typedef {import("@typescript-eslint/types").TSESTree.CallExpression} TSCallExpression */
 /** @typedef {import("eslint").SourceCode} SourceCode */
 /** @typedef {import("eslint").AST.Token} Token */
 /** @typedef {import("eslint").Rule.Node} RuleNode */
@@ -11,6 +13,7 @@ import { isClosingParenToken, isOpeningParenToken } from "./token-predicate.mjs"
  * @param {SourceCode} sourceCode The source code object to get tokens.
  * @returns {Token|null} The left parenthesis of the parent node syntax
  */
+// eslint-disable-next-line complexity
 function getParentSyntaxParen(node, sourceCode) {
     const parent = /** @type {RuleNode} */ (node).parent
 
@@ -19,7 +22,13 @@ function getParentSyntaxParen(node, sourceCode) {
         case "NewExpression":
             if (parent.arguments.length === 1 && parent.arguments[0] === node) {
                 return sourceCode.getTokenAfter(
-                    parent.callee,
+                    /** @type {RuleNode} */ (
+                        /** @type {unknown} */ (
+                            /** @type {TSNewExpression | TSCallExpression} */ (
+                                parent
+                            ).typeParameters
+                        )
+                    ) || parent.callee,
                     isOpeningParenToken,
                 )
             }

test/is-parenthesized.mjs

@@ -1,10 +1,11 @@
+import tsParser from "@typescript-eslint/parser"
 import assert from "assert"
 import { getProperty } from "dot-prop"
 import { isParenthesized } from "../src/index.mjs"
 import { newCompatLinter } from "./test-lib/eslint-compat.mjs"
 
 describe("The 'isParenthesized' function", () => {
-    for (const { code, expected } of [
+    for (const { code, expected, parser } of [
         {
             code: "777",
             expected: {
@@ -215,6 +216,73 @@ describe("The 'isParenthesized' function", () => {
                 "body[0].parent": false,
             },
         },
+        // TypeScript support
+        {
+            code: "f<import('foo')>(a)",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": false,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "f<import('foo')>((a))",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": true,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "f<import('foo')>(a,b)",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": false,
+                "body[0].expression.arguments[1]": false,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "f<import('foo')>((a),b)",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": true,
+                "body[0].expression.arguments[1]": false,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "f<import('foo')>(a,(b))",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": false,
+                "body[0].expression.arguments[1]": true,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "new f<import('foo')>(a)",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": false,
+            },
+            parser: tsParser,
+        },
+        {
+            code: "new f<import('foo')>((a))",
+            expected: {
+                "body[0]": false,
+                "body[0].expression": false,
+                "body[0].expression.arguments[0]": true,
+            },
+            parser: tsParser,
+        },
     ]) {
         describe(`on the code \`${code}\``, () => {
             for (const key of Object.keys(expected)) {
@@ -226,6 +294,7 @@ describe("The 'isParenthesized' function", () => {
                         languageOptions: {
                             ecmaVersion: 2020,
                             sourceType: "script",
+                            parser,
                         },
                         rules: { "test/test": "error" },
                         plugins: {