feat: add support for typescript AST to getStaticValue, and ReferenceTracker (#255)

Author: ota-meshi

.github/workflows/ci.yml

@@ -96,18 +96,19 @@ jobs:
               with:
                   node-version: ${{ matrix.node }}
 
-            - name: 📥 Install dependencies
-              run: npm install
-
+            # If we run this after `npm install`, it may hang with npm warnings.
             - name: 📥 Install ESLint v${{ matrix.eslint }}
               run: npm install --save-dev eslint@${{ matrix.eslint }}
 
+            - name: 📥 Install dependencies
+              run: npm install
+
             - name: 🏗 Build
               run: npm run build
 
             - name: ▶️ Run test script
               run: |
-                  npm run test
+                  npm run test-coverage
 
                   # Load src/index.mjs to check for syntax errors.
                   # This is because for some reason the exit code does not become 1 in Node.js 12.

README.md

@@ -30,8 +30,8 @@ Please use GitHub's Issues/PRs.
 
 ### Development Tools
 
--   `npm test` runs tests and measures coverage.
--   `npm run clean` removes the coverage result of `npm test` command.
--   `npm run coverage` shows the coverage result of the last `npm test` command.
+-   `npm run test-coverage` runs tests and measures coverage.
+-   `npm run clean` removes the coverage result of `npm run test-coverage` command.
+-   `npm run coverage` shows the coverage result of the last `npm run test-coverage` command.
 -   `npm run lint` runs ESLint.
 -   `npm run watch` runs tests on each file change.

package.json

@@ -45,8 +45,9 @@
         "lint:installed-check": "installed-check -v -i installed-check -i npm-run-all2 -i knip -i rollup-plugin-dts",
         "lint:knip": "knip",
         "lint": "run-p lint:*",
-        "test": "c8 mocha --reporter dot \"test/*.mjs\"",
-        "preversion": "npm test && npm run -s build",
+        "test-coverage": "c8 mocha --reporter dot \"test/*.mjs\"",
+        "test": "mocha --reporter dot \"test/*.mjs\"",
+        "preversion": "npm test-coverage && npm run -s build",
         "postversion": "git push && git push --tags",
         "prewatch": "npm run -s clean",
         "watch": "warun \"{src,test}/**/*.mjs\" -- npm run -s test:mocha"
@@ -58,6 +59,8 @@
         "@eslint-community/eslint-plugin-mysticatea": "^15.6.1",
         "@types/eslint": "^9.6.1",
         "@types/estree": "^1.0.7",
+        "@typescript-eslint/parser": "^5.62.0",
+        "@typescript-eslint/types": "^5.62.0",
         "c8": "^8.0.1",
         "dot-prop": "^7.2.0",
         "eslint": "^8.57.1",

src/get-static-value.mjs

@@ -4,13 +4,13 @@ import { findVariable } from "./find-variable.mjs"
 /** @typedef {import("./types.mjs").StaticValue} StaticValue */
 /** @typedef {import("eslint").Scope.Scope} Scope */
 /** @typedef {import("estree").Node} Node */
-/** @typedef {import("eslint").Rule.Node} RuleNode */
-/** @typedef {import("eslint").Rule.NodeTypes} NodeTypes */
-/** @typedef {import("estree").MemberExpression} MemberExpression */
-/** @typedef {import("estree").Property} Property */
-/** @typedef {import("estree").RegExpLiteral} RegExpLiteral */
-/** @typedef {import("estree").BigIntLiteral} BigIntLiteral */
-/** @typedef {import("estree").SimpleLiteral} SimpleLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
+/** @typedef {import("@typescript-eslint/types").TSESTree.AST_NODE_TYPES} TSESTreeNodeTypes */
+/** @typedef {import("@typescript-eslint/types").TSESTree.MemberExpression} MemberExpression */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Property} Property */
+/** @typedef {import("@typescript-eslint/types").TSESTree.RegExpLiteral} RegExpLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.BigIntLiteral} BigIntLiteral */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Literal} Literal */
 
 const globalObject =
     typeof globalThis !== "undefined"
@@ -236,7 +236,7 @@ function isGetter(object, name) {
 
 /**
  * Get the element values of a given node list.
- * @param {(Node|null)[]} nodeList The node list to get values.
+ * @param {(Node|TSESTreeNode|null)[]} nodeList The node list to get values.
  * @param {Scope|undefined|null} initialScope The initial scope to find variables.
  * @returns {any[]|null} The value list if all nodes are constant. Otherwise, null.
  */
@@ -284,14 +284,14 @@ function isEffectivelyConst(variable) {
 }
 
 /**
- * @template {NodeTypes} T
+ * @template {TSESTreeNodeTypes} T
  * @callback VisitorCallback
- * @param {RuleNode & { type: T }} node
+ * @param {TSESTreeNode & { type: T }} node
  * @param {Scope|undefined|null} initialScope
  * @returns {StaticValue | null}
  */
 /**
- * @typedef { { [K in NodeTypes]?: VisitorCallback<K> } } Operations
+ * @typedef { { [K in TSESTreeNodeTypes]?: VisitorCallback<K> } } Operations
  */
 /**
  * @type {Operations}
@@ -542,7 +542,7 @@ const operations = Object.freeze({
 
     Literal(node) {
         const literal =
-            /** @type {Partial<SimpleLiteral> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
+            /** @type {Partial<Literal> & Partial<RegExpLiteral> & Partial<BigIntLiteral>} */ (
                 node
             )
         //istanbul ignore if : this is implementation-specific behavior.
@@ -749,18 +749,33 @@ const operations = Object.freeze({
 
         return null
     },
+    TSAsExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSSatisfiesExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSTypeAssertion(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSNonNullExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
+    TSInstantiationExpression(node, initialScope) {
+        return getStaticValueR(node.expression, initialScope)
+    },
 })
 
 /**
  * Get the value of a given node if it's a static value.
- * @param {Node|null|undefined} node The node to get.
+ * @param {Node|TSESTreeNode|null|undefined} node The node to get.
  * @param {Scope|undefined|null} initialScope The scope to start finding variable.
  * @returns {StaticValue|null} The static value of the node, or `null`.
  */
 function getStaticValueR(node, initialScope) {
     if (node != null && Object.hasOwnProperty.call(operations, node.type)) {
         return /** @type {VisitorCallback<any>} */ (operations[node.type])(
-            /** @type {RuleNode} */ (node),
+            /** @type {TSESTreeNode} */ (node),
             initialScope,
         )
     }

src/reference-tracker.mjs

@@ -21,6 +21,7 @@ import { getStringIfConstant } from "./get-string-if-constant.mjs"
 /** @typedef {import("estree").Property} Property */
 /** @typedef {import("estree").AssignmentProperty} AssignmentProperty */
 /** @typedef {import("estree").Literal} Literal */
+/** @typedef {import("@typescript-eslint/types").TSESTree.Node} TSESTreeNode */
 /** @typedef {import("./types.mjs").ReferenceTrackerOptions} ReferenceTrackerOptions */
 /**
  * @template T
@@ -82,7 +83,7 @@ function isModifiedGlobal(variable) {
  * @returns {node is RuleNode & {parent: Expression}} `true` if the node is passed through.
  */
 function isPassThrough(node) {
-    const parent = /** @type {RuleNode} */ (node).parent
+    const parent = /** @type {TSESTreeNode} */ (node).parent
 
     if (parent) {
         switch (parent.type) {
@@ -96,6 +97,12 @@ function isPassThrough(node) {
                 )
             case "ChainExpression":
                 return true
+            case "TSAsExpression":
+            case "TSSatisfiesExpression":
+            case "TSTypeAssertion":
+            case "TSNonNullExpression":
+            case "TSInstantiationExpression":
+                return true
 
             default:
                 return false

test/get-static-value.mjs

@@ -1,11 +1,12 @@
+import tsParser from "@typescript-eslint/parser"
 import assert from "assert"
 import eslint from "eslint"
 import semver from "semver"
 import { getStaticValue } from "../src/index.mjs"
 import { getScope, newCompatLinter } from "./test-lib/eslint-compat.mjs"
 
 describe("The 'getStaticValue' function", () => {
-    for (const { code, expected, noScope = false } of [
+    for (const { code, expected, noScope = false, parser } of [
         { code: "[]", expected: { value: [] } },
         { code: "[1, 2, 3]", expected: { value: [1, 2, 3] } },
         { code: "[,, 3]", expected: { value: [, , 3] } }, //eslint-disable-line no-sparse-arrays
@@ -397,6 +398,32 @@ const aMap = Object.freeze({
                   },
               ]
             : []),
+        // TypeScript support
+        {
+            code: `const a = 42; a as number;`,
+            expected: { value: 42 },
+            parser: tsParser,
+        },
+        {
+            code: `const a = 42; a satisfies number;`,
+            expected: { value: 42 },
+            parser: tsParser,
+        },
+        {
+            code: `const a = 42; <number>a;`,
+            expected: { value: 42 },
+            parser: tsParser,
+        },
+        {
+            code: `const a = 42; a!;`,
+            expected: { value: 42 },
+            parser: tsParser,
+        },
+        {
+            code: `const a = 42; a<number>;`,
+            expected: { value: 42 },
+            parser: tsParser,
+        },
     ]) {
         it(`should return ${JSON.stringify(expected)} from ${code}`, () => {
             const linter = newCompatLinter()
@@ -407,6 +434,7 @@ const aMap = Object.freeze({
                     ecmaVersion: semver.gte(eslint.Linter.version, "8.0.0")
                         ? 2022
                         : 2020,
+                    parser,
                 },
                 rules: { "test/test": "error" },
                 plugins: {

test/has-side-effect.mjs

@@ -1,3 +1,4 @@
+import tsParser from "@typescript-eslint/parser"
 import assert from "assert"
 import { getProperty } from "dot-prop"
 import eslint from "eslint"
@@ -6,7 +7,13 @@ import { hasSideEffect } from "../src/index.mjs"
 import { newCompatLinter } from "./test-lib/eslint-compat.mjs"
 
 describe("The 'hasSideEffect' function", () => {
-    for (const { code, key = "body[0].expression", options, expected } of [
+    for (const {
+        code,
+        key = "body[0].expression",
+        options,
+        expected,
+        parser,
+    } of [
         {
             code: "777",
             options: undefined,
@@ -300,6 +307,32 @@ describe("The 'hasSideEffect' function", () => {
             options: undefined,
             expected: false,
         },
+        // TypeScript support
+        {
+            code: `a as number`,
+            expected: false,
+            parser: tsParser,
+        },
+        {
+            code: `a satisfies number`,
+            expected: false,
+            parser: tsParser,
+        },
+        {
+            code: `<number>a`,
+            expected: false,
+            parser: tsParser,
+        },
+        {
+            code: `a!`,
+            expected: false,
+            parser: tsParser,
+        },
+        {
+            code: `a<number>`,
+            expected: false,
+            parser: tsParser,
+        },
     ]) {
         it(`should return ${expected} on the code \`${code}\` and the options \`${JSON.stringify(
             options,
@@ -312,6 +345,7 @@ describe("The 'hasSideEffect' function", () => {
                     ecmaVersion: semver.gte(eslint.Linter.version, "8.0.0")
                         ? 2022
                         : 2020,
+                    parser,
                 },
                 rules: { "test/test": "error" },
                 plugins: {