Fill optional AST properties when both estree and typescript parser plugin are enabled (Part 1) (#17224)

* test: reduce jest-diff noises from different location prototype

* add more ts-eslint integration tests

* fix: provide optional properties for some ts-eslint AST

* update Babel parser AST fixtures

* Update packages/babel-parser/src/plugins/estree.ts

Co-authored-by: Nicolò Ribaudo <[email protected]>

* simplify castNodeTo usage

* use castNodeTo for TSEmptyBodyFunctionExpression

* add a few test cases

* handle TSAbstractMethodDefinition

* update Babel 8 AST fixtures

* fix AST checks

* parser type cleanup

---------

Co-authored-by: Nicolò Ribaudo <[email protected]>

Author: JLHwung

eslint/babel-eslint-parser/src/convert/convertAST.cts

@@ -50,8 +50,25 @@ const convertNodesVisitor = {
       delete node.extra;
     }
 
-    if (node.loc.identifierName) {
-      delete node.loc.identifierName;
+    if (process.env.IS_PUBLISH) {
+      if (node.loc.identifierName) {
+        delete node.loc.identifierName;
+      }
+    } else {
+      // To minimize the jest-diff noise comparing Babel AST and third-party AST,
+      // here we generate a deep copy of loc without identifierName and index
+      if (node.loc) {
+        node.loc = {
+          end: {
+            column: node.loc.end.column,
+            line: node.loc.end.line,
+          },
+          start: {
+            column: node.loc.start.column,
+            line: node.loc.start.line,
+          },
+        } as any;
+      }
     }
 
     if (node.type === "TypeParameter") {

eslint/babel-eslint-parser/src/convert/convertTokens.cts

@@ -1,4 +1,5 @@
 import type { BabelToken } from "../types.cts";
+import type * as t from "@babel/types";
 import ESLINT_VERSION = require("../utils/eslint-version.cjs");
 
 function convertTemplateType(tokens: BabelToken[], tl: Record<string, any>) {
@@ -101,6 +102,7 @@ function convertToken(
       pattern: string;
       flags: string;
     };
+    loc?: t.SourceLocation | null;
   } = token as any;
   newToken.range = [token.start, token.end];
 
@@ -203,6 +205,20 @@ function convertToken(
   ) {
     newToken.type = "Template";
   }
+  if (!process.env.IS_PUBLISH) {
+    // To minimize the jest-diff noise comparing Babel AST and third-party AST,
+    // here we generate a deep copy of loc without identifierName and index
+    newToken.loc = {
+      end: {
+        column: newToken.loc.end.column,
+        line: newToken.loc.end.line,
+      },
+      start: {
+        column: newToken.loc.start.column,
+        line: newToken.loc.start.line,
+      },
+    } as any;
+  }
   return newToken;
 }
 

eslint/babel-eslint-parser/test/typescript-estree.test.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { parseForESLint } from "../lib/index.cjs";
 import { ESLint } from "eslint";
-import { itDummy, commonJS } from "$repo-utils";
+import { itDummy, commonJS, IS_BABEL_8 } from "$repo-utils";
 
 const ESLINT_VERSION = ESLint.version;
 const isESLint9 = ESLINT_VERSION.startsWith("9.");
@@ -12,8 +12,6 @@ const PROPS_TO_REMOVE = [
   { key: "start", type: "Node" },
   { key: "end", type: "Node" },
 
-  { key: "importKind", type: "Node" },
-  { key: "exportKind", type: "Node" },
   { key: "variance", type: "Node" },
   { key: "typeArguments", type: "Node" },
   { key: "filename", type: null },
@@ -107,22 +105,80 @@ function deeplyRemoveProperties(obj, props) {
 
     it.each([
       ["empty", ""],
-
       ["boolean", "true"],
       ["boolean", "false"],
-
       ["numeric", "0"],
       // ["bigint", "0n"],
-
+      ["string", `"string"`],
       ["regexp without flag", `/foo/;`],
       ["regexp u flag", `/foo/dgimsuy;`],
       ["regexp v flag", `/foo/dgimsvy;`],
+      ["identifier", "i"],
 
       ["logical NOT", `!0`],
       ["bitwise NOT", `~0`],
+
+      ["function declaration", "function f(p) {}"],
+      ["function expression", "0, function f(p) {}"],
+      ["arrow function expression", "() => {}"],
+      ["async arrow function expression", "async () => {}"],
+
+      ["object method", "({ m() {} })"],
+      ["object property", "({ p: 0 })"],
+
+      ["class declaration", "class C {}"],
+      ["class expression", "0, class C {}"],
+      ["class method", "class C { m() {} }"],
+      ["class property", "class C { p; }"],
+      ["class static block", "class C { static {}; }"],
+
+      ["variable declaration", "var a = 0"],
+      [
+        "variable declaration destructuring",
+        "var [{ a: x = 0 }, ...b] = [{ a: 0 }]",
+      ],
+      // pending cloneIdentifier support
+      // ["variable declaration destructuring shorthand", "let { a = 0 } = { a: 0 }"]
+
+      ["assignment expression", "x = 1"],
+      // pending toAssignable support
+      // ["assignment expression destructuring", "[{ a: x = 0 }, ...b] = [{ a: 0 }]"],
+
+      ["async call expression", "async ([ x ])"],
+
+      ["import declaration", `import "foo"`],
+      ["import declaration default", `import foo from "foo"`],
+      // pending cloneIdentifier support
+      // ["import declaration named", `import { foo } from "foo"`]
+      ["import declaration named as", `import { foo as bar } from "foo"`],
+      [
+        "import declaration with attributes",
+        `import foo from "./foo.json" with { type: "json" }`,
+      ],
+
+      // pending cloneIdentifier support
+      // ["export declaration", `const foo = 0;export { foo }`],
+      ["export declaration as", `const foo = 0;export { foo as bar }`],
+      ["export function declaration", `export function foo() {}`],
+      ["export class declaration", `export class foo {}`],
+
+      ["member expression", `foo.bar`],
+      ["call expression", `foo(bar)`],
+      ["new expression", `new foo`],
     ])("%s: %s", (_, input) => {
       parseAndAssertSame(input);
     });
+
+    if (IS_BABEL_8()) {
+      it.each([
+        // ["class private method", "class C { #m() {} }"],
+        ["class abstract property", "abstract class C { abstract p; }"],
+        // ["class abstract private property", "abstract class C { abstract #p; }"]
+        ["class abstract method", "abstract class C { abstract m(): void }"],
+      ])("%s: %s", (_, input) => {
+        parseAndAssertSame(input);
+      });
+    }
   },
 );