chore: revert some compat code introduced by #81

Author: sapphi-red

packages/vite/src/node/plugins/importAnalysis.ts

@@ -1005,8 +1005,7 @@ export function transformCjsImport(
     node.type === 'ImportDeclaration' ||
     node.type === 'ExportNamedDeclaration'
   ) {
-    // NOTE: node.specifiers can be null in OXC: https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-    if (!node.specifiers?.length) {
+    if (!node.specifiers.length) {
       return `import "${url}"`
     }
 

packages/vite/src/node/ssr/ssrTransform.ts

@@ -211,21 +211,19 @@ async function ssrTransformScript(
 
   // 1. check all import statements and record id -> importName map
   for (const node of imports) {
-    // NOTE: node.specifiers can be null in OXC: https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-    const specifiers = node.specifiers ?? []
     // import foo from 'foo' --> foo -> __import_foo__.default
     // import { baz } from 'foo' --> baz -> __import_foo__.baz
     // import * as ok from 'foo' --> ok -> __import_foo__
     const importId = defineImport(hoistIndex, node, {
-      importedNames: specifiers
+      importedNames: node.specifiers
         .map((s) => {
           if (s.type === 'ImportSpecifier')
             return getIdentifierNameOrLiteralValue(s.imported) as string
           else if (s.type === 'ImportDefaultSpecifier') return 'default'
         })
         .filter(isDefined),
     })
-    for (const spec of specifiers) {
+    for (const spec of node.specifiers) {
       if (spec.type === 'ImportSpecifier') {
         if (spec.imported.type === 'Identifier') {
           idToImportMap.set(
@@ -368,9 +366,6 @@ async function ssrTransformScript(
           stmt.type !== 'FunctionDeclaration' &&
           stmt.type !== 'ClassDeclaration' &&
           stmt.type !== 'BlockStatement' &&
-          // NOTE: OXC uses `FunctionBody` instead of `BlockStatement`
-          // https://github.com/oxc-project/oxc/issues/2854
-          (stmt.type as any) !== 'FunctionBody' &&
           stmt.type !== 'ImportDeclaration'
         ) {
           s.appendLeft(stmt.end, ';')
@@ -537,7 +532,7 @@ function walk(
   }
 
   ;(eswalk as any)(root, {
-    enter(node: Node, parent: Node | null, prop: string) {
+    enter(node: Node, parent: Node | null) {
       if (node.type === 'ImportDeclaration') {
         return this.skip()
       }
@@ -549,10 +544,6 @@ function walk(
         node.type === 'StaticBlock'
       ) {
         onStatements(node.body as Node[])
-        // NOTE: OXC uses `FunctionBody` instead of `BlockStatement`
-        // https://github.com/oxc-project/oxc/issues/2854
-      } else if ((node.type as any) === 'FunctionBody') {
-        onStatements((node as any).statements)
       } else if (node.type === 'SwitchCase') {
         onStatements(node.consequent as Node[])
       }
@@ -580,7 +571,7 @@ function walk(
       if (node.type === 'Identifier') {
         if (
           !isInScope(node.name, parentStack) &&
-          isRefIdentifier(node, parent!, parentStack, prop)
+          isRefIdentifier(node, parent!, parentStack)
         ) {
           // record the identifier, for DFS -> BFS
           identifiers.push([node, parentStack.slice(0)])
@@ -601,14 +592,13 @@ function walk(
         }
         // walk function expressions and add its arguments to known identifiers
         // so that we don't prefix them
-        // NOTE: `node.params.items` is used for OXC instead of `node.params`: https://github.com/oxc-project/oxc/issues/2854
-        ;(node.params as any).items.forEach((p: Node) => {
+        node.params.forEach((p) => {
           if (p.type === 'ObjectPattern' || p.type === 'ArrayPattern') {
             handlePattern(p, node)
             return
           }
           ;(eswalk as any)(p.type === 'AssignmentPattern' ? p.left : p, {
-            enter(child: Node, parent: Node | undefined, prop: string) {
+            enter(child: Node, parent: Node | undefined) {
               // skip params default value of destructure
               if (
                 parent?.type === 'AssignmentPattern' &&
@@ -618,7 +608,7 @@ function walk(
               }
               if (child.type !== 'Identifier') return
               // do not record as scope variable if is a destructuring keyword
-              if (isStaticPropertyKey(child, parent, prop)) return
+              if (isStaticPropertyKey(child, parent)) return
               // do not record if this is a default value
               // assignment of a destructuring variable
               if (
@@ -641,14 +631,9 @@ function walk(
       } else if (node.type === 'ClassExpression' && node.id) {
         // A class expression name could shadow an import, so add its name to the scope
         setScope(node, node.id.name)
-      } else if (
-        // NOTE: OXC uses `BindingProperty` instead of `Property`
-        // https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-        (node.type as any) === 'BindingProperty' &&
-        parent!.type === 'ObjectPattern'
-      ) {
+      } else if (node.type === 'Property' && parent!.type === 'ObjectPattern') {
         // mark property in destructuring pattern
-        setIsNodeInPattern(node as Property)
+        setIsNodeInPattern(node)
       } else if (node.type === 'VariableDeclarator') {
         const parentFunction = findParentScope(
           parentStack,
@@ -658,9 +643,7 @@ function walk(
           handlePattern(node.id, parentFunction)
         }
       } else if (node.type === 'CatchClause' && node.param) {
-        // NOTE: OXC has CatchParameter inside CatchClause
-        // https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-        handlePattern((node.param as any).pattern, node)
+        handlePattern(node.param, node)
       }
     },
 
@@ -686,17 +669,10 @@ function walk(
   })
 }
 
-function isRefIdentifier(
-  id: Identifier,
-  parent: _Node,
-  parentStack: _Node[],
-  prop: string,
-) {
+function isRefIdentifier(id: Identifier, parent: _Node, parentStack: _Node[]) {
   // declaration id
   if (
-    // NOTE: OXC has CatchParameter inside CatchClause
-    // https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-    (parent.type as any) === 'CatchParameter' ||
+    parent.type === 'CatchClause' ||
     ((parent.type === 'VariableDeclarator' ||
       parent.type === 'ClassDeclaration') &&
       parent.id === id)
@@ -721,7 +697,7 @@ function isRefIdentifier(
   }
 
   // property key
-  if (isStaticPropertyKey(id, parent, prop)) {
+  if (isStaticPropertyKey(id, parent)) {
     return false
   }
 
@@ -740,10 +716,9 @@ function isRefIdentifier(
 
   // member expression property
   if (
-    // NOTE: OXC uses StaticMemberExpression instead of MemberExpression + `computed: false`
-    // https://github.com/oxc-project/oxc/issues/2854
-    (parent.type as any) === 'StaticMemberExpression' &&
-    (parent as any).property === id
+    parent.type === 'MemberExpression' &&
+    parent.property === id &&
+    !parent.computed
   ) {
     return false
   }
@@ -766,30 +741,17 @@ function isRefIdentifier(
 }
 
 const isStaticProperty = (node: _Node): node is Property =>
-  // NOTE: OXC uses `ObjectProperty` instead of `Property`
-  // https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-  ((node.type as any) === 'ObjectProperty' ||
-    (node.type as any) === 'BindingProperty') &&
-  !(node as Property).computed
-
-const isStaticPropertyKey = (
-  node: _Node,
-  parent: _Node | undefined,
-  prop: string,
-) =>
-  // NOTE: probably OXC has a similar problem with handling references here
-  // https://github.com/vitejs/vite/pull/14508#discussion_r1341972441
-  parent && isStaticProperty(parent) && prop === 'key' && parent.key === node
+  node.type === 'Property' && !node.computed
+
+const isStaticPropertyKey = (node: _Node, parent: _Node | undefined) =>
+  parent && isStaticProperty(parent) && parent.key === node
 
 const functionNodeTypeRE = /Function(?:Expression|Declaration)$|Method$/
 function isFunction(node: _Node): node is FunctionNode {
   return functionNodeTypeRE.test(node.type)
 }
 
-// NOTE: OXC uses `FunctionBody` instead of `BlockStatement`
-// https://github.com/oxc-project/oxc/issues/2854
-const blockNodeTypeRE =
-  /^BlockStatement$|^For(?:In|Of)?Statement$|^FunctionBody$/
+const blockNodeTypeRE = /^BlockStatement$|^For(?:In|Of)?Statement$/
 function isBlock(node: _Node) {
   return blockNodeTypeRE.test(node.type)
 }
@@ -805,13 +767,7 @@ function isInDestructuringAssignment(
   parent: _Node,
   parentStack: _Node[],
 ): boolean {
-  // NOTE: OXC uses `ObjectProperty` instead of `Property`
-  // https://github.com/oxc-project/oxc/issues/2854#issuecomment-2595115817
-  if (
-    (parent.type as any) === 'ObjectProperty' ||
-    (parent.type as any) === 'BindingProperty' ||
-    parent.type === 'ArrayPattern'
-  ) {
+  if (parent.type === 'Property' || parent.type === 'ArrayPattern') {
     return parentStack.some((i) => i.type === 'AssignmentExpression')
   }
   return false