refactor(migrate): replace Babel with native Oxc analysis

Author: fengmk2

Cargo.lock

@@ -13,6 +13,7 @@ ast-grep-core = { workspace = true }
 ast-grep-language = { workspace = true }
 brush-parser = { workspace = true }
 ignore = { workspace = true }
+oxc = { workspace = true }
 rayon = { workspace = true }
 regex = { workspace = true }
 serde_json = { workspace = true, features = ["preserve_order"] }

crates/vp_migration/Cargo.toml

@@ -14,6 +14,7 @@ mod pack_config;
 mod package;
 mod prettier;
 mod script_rewrite;
+mod source_analysis;
 mod vite_config;
 
 pub use file_walker::{WalkResult, find_ts_files};
@@ -22,6 +23,7 @@ pub use import_rewriter::{
     rewrite_imports_in_directory_with_options,
 };
 pub use package::{rewrite_eslint, rewrite_prettier, rewrite_scripts};
+pub use source_analysis::analyze_migration_source;
 pub use vite_config::{
     MergeResult, has_config_key, merge_json_config, merge_tsdown_config, upsert_json_config,
     wrap_lazy_plugins,

crates/vp_migration/src/lib.rs

@@ -0,0 +1,149 @@
+use std::collections::HashMap;
+
+use oxc::{
+    allocator::Allocator,
+    ast::AstKind,
+    ast_visit::utf8_to_utf16::Utf8ToUtf16,
+    parser::{ParseOptions, Parser},
+    semantic::SemanticBuilder,
+    span::{GetSpan, SourceType},
+};
+use serde_json::{Value, json};
+
+/// Parse migration input and resolve bindings with the Oxc already shipped by Rolldown.
+/// Keep transformation rules in TypeScript; export only the semantic facts they need,
+/// rather than duplicating JavaScript scope analysis or bundling another parser.
+pub fn analyze_migration_source(filename: &str, source: &str) -> Result<String, String> {
+    let allocator = Allocator::default();
+    let source_type =
+        SourceType::from_path(filename).map_err(|error| error.to_string())?.with_unambiguous(true);
+    // JavaScript migration input can contain JSX. For TypeScript, retain the
+    // extension's TS/TSX mode so `<T>(value: T) => value` is not parsed as JSX.
+    let source_type = source_type.with_jsx(source_type.is_javascript() || source_type.is_jsx());
+    let parsed = Parser::new(&allocator, source, source_type)
+        .with_options(ParseOptions { preserve_parens: false, ..ParseOptions::default() })
+        .parse();
+    if let Some(error) = parsed.diagnostics.first() {
+        return Err(error.to_string());
+    }
+    let mut program = parsed.program;
+    let analyzed = SemanticBuilder::new_compiler().with_build_nodes(true).build(&program);
+    if let Some(error) = analyzed.diagnostics.first() {
+        return Err(error.to_string());
+    }
+
+    // JavaScript slices and diagnostic columns use UTF-16, whereas Rust spans use
+    // UTF-8 bytes. Convert both semantic offsets and AST/comment spans together.
+    let spans = Utf8ToUtf16::new(source);
+    let mut converter = spans.converter();
+    let mut offset = |mut value| {
+        if let Some(converter) = converter.as_mut() {
+            converter.convert_offset(&mut value);
+        }
+        value
+    };
+    let semantic = analyzed.semantic;
+    let scoping = semantic.scoping();
+    // Oxc keeps type and value references separate. An invalid runtime use of
+    // a type-only import is unresolved, but must not be mistaken for a Vitest
+    // global by migration rules. Preserve its lexical import binding too.
+    let mut type_import_uses = HashMap::<_, Vec<u32>>::new();
+    for node in semantic.nodes().iter() {
+        if let AstKind::IdentifierReference(identifier) = node.kind()
+            && !scoping.has_binding(identifier.reference_id.get().unwrap())
+            && let Some(symbol) = scoping.find_binding(node.scope_id(), identifier.name)
+            && scoping.symbol_flags(symbol).is_type_import()
+        {
+            type_import_uses.entry(symbol).or_default().push(offset(identifier.span.start));
+        }
+    }
+    let bindings: Vec<Value> = scoping
+        .symbol_ids()
+        .map(|symbol| {
+            let mut references: Vec<u32> = scoping
+                .get_resolved_references(symbol)
+                .map(|reference| offset(semantic.nodes().kind(reference.node_id()).span().start))
+                .collect();
+            references.extend(type_import_uses.remove(&symbol).unwrap_or_default());
+            // Do not follow reassigned or redeclared aliases, including invalid
+            // writes to const bindings. `symbol_is_mutated` alone ignores those.
+            let constant = scoping.symbol_redeclarations(symbol).is_empty()
+                && !scoping.get_resolved_references(symbol).any(|reference| reference.is_write());
+            json!({
+                "start": offset(scoping.symbol_span(symbol).start),
+                "references": references,
+                "constant": constant,
+            })
+        })
+        .collect();
+    drop(semantic);
+    spans.convert_program_and_comments(&mut program);
+    let comments: Vec<Value> = program
+        .comments
+        .iter()
+        .map(|comment| json!({ "start": comment.span.start, "end": comment.span.end }))
+        .collect();
+
+    // Reuse the serializer already instantiated by oxc_parser_napi. Migration
+    // reads literal spelling from source, so it does not need the JS-only fixes
+    // that reconstruct RegExp/BigInt values from this ESTree JSON representation.
+    let mut result: Value = serde_json::from_str(&program.to_estree_json_with_fixes(true, false))
+        .map_err(|error| error.to_string())?;
+    serde_json::to_string(&json!({
+        "program": result["node"].take(),
+        "bindings": bindings,
+        "comments": comments,
+    }))
+    .map_err(|error| error.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::Value;
+
+    use super::analyze_migration_source;
+
+    #[test]
+    fn rejects_flow_and_invalid_syntax() {
+        for source in ["// @flow\nconst x: string = 'x';", "const = ;"] {
+            assert!(analyze_migration_source("test.js", source).is_err());
+        }
+    }
+
+    #[test]
+    fn preserves_type_imports_for_unresolved_value_uses() {
+        for source in [
+            "import type { expect } from 'vitest'; expect();",
+            "import { type expect } from 'vitest'; expect();",
+            "import type * as expect from 'vitest'; expect();",
+        ] {
+            let result: Value =
+                serde_json::from_str(&analyze_migration_source("test.ts", source).unwrap())
+                    .unwrap();
+            assert_eq!(
+                result["bindings"][0]["references"],
+                serde_json::json!([source.rfind("expect").unwrap()])
+            );
+        }
+    }
+
+    #[test]
+    fn resolves_shadowing_and_mutated_aliases_with_utf16_offsets() {
+        let source = "// 😀\nimport { vi } from 'vitest'; vi.fn(); function f(vi) { vi.fn(); } let alias = vi; alias = other; alias.fn();";
+        let result: Value =
+            serde_json::from_str(&analyze_migration_source("test.ts", source).unwrap()).unwrap();
+        let bindings = result["bindings"].as_array().unwrap();
+        let utf16 = |text: &str| source[..source.find(text).unwrap()].encode_utf16().count();
+        let imported = bindings.iter().find(|binding| binding["start"] == utf16("vi }")).unwrap();
+        assert_eq!(
+            imported["references"],
+            serde_json::json!([utf16("vi.fn()"), utf16("vi; alias")])
+        );
+        assert_eq!(imported["constant"], true);
+        let alias =
+            bindings.iter().find(|binding| binding["start"] == utf16("alias = vi")).unwrap();
+        assert_eq!(alias["constant"], false);
+        assert_eq!(result["program"]["body"][0]["start"], utf16("import"));
+        assert_eq!(result["comments"][0]["end"], "// 😀".encode_utf16().count());
+    }
+}

crates/vp_migration/src/source_analysis.rs

@@ -962,6 +962,7 @@ module.exports.resetNativeMemoryStats = nativeBinding.resetNativeMemoryStats;
 module.exports.resolveTsconfig = nativeBinding.resolveTsconfig;
 module.exports.shutdownAsyncRuntime = nativeBinding.shutdownAsyncRuntime;
 module.exports.startAsyncRuntime = nativeBinding.startAsyncRuntime;
+module.exports.analyzeMigrationSource = nativeBinding.analyzeMigrationSource;
 module.exports.detectWorkspace = nativeBinding.detectWorkspace;
 module.exports.downloadPackageManager = nativeBinding.downloadPackageManager;
 module.exports.ensureBlockingStdio = nativeBinding.ensureBlockingStdio;

packages/cli/binding/index.cjs

@@ -3434,6 +3434,9 @@ export declare function startAsyncRuntime(): void;
 export interface ViteImportGlobMeta {
   isSubImportsPattern?: boolean;
 }
+/** Parse source and resolve lexical bindings for the TypeScript migration rules. */
+export declare function analyzeMigrationSource(filename: string, source: string): string;
+
 /** Error from batch import rewriting */
 export interface BatchRewriteError {
   /** The file path that had an error */

packages/cli/binding/index.d.cts

@@ -3,6 +3,12 @@ use std::path::Path;
 use napi::{anyhow, bindgen_prelude::*};
 use napi_derive::napi;
 
+/// Parse source and resolve lexical bindings for the TypeScript migration rules.
+#[napi]
+pub fn analyze_migration_source(filename: String, source: String) -> Result<String> {
+    vp_migration::analyze_migration_source(&filename, &source).map_err(Error::from_reason)
+}
+
 /// Rewrite scripts json content using rules from rules_yaml
 ///
 /// # Arguments

packages/cli/binding/src/migration.rs

@@ -399,14 +399,10 @@
     "vitest": "catalog:"
   },
   "devDependencies": {
-    "@babel/parser": "catalog:",
-    "@babel/traverse": "catalog:",
-    "@babel/types": "catalog:",
     "@emnapi/core": "catalog:",
     "@emnapi/runtime": "catalog:",
     "@napi-rs/cli": "catalog:",
     "@nkzw/safe-word-list": "catalog:",
-    "@types/babel__traverse": "catalog:",
     "@types/cross-spawn": "catalog:",
     "@types/semver": "catalog:",
     "@types/validate-npm-package-name": "catalog:",

packages/cli/package.json

@@ -0,0 +1,150 @@
+import { describe, expect, it } from 'vitest';
+
+import { SourceEditor, parseSource } from '../vitest-v5/ast.ts';
+import { migrateVitestV5Config } from '../vitest-v5/config.ts';
+import { migrateVitestV5Source } from '../vitest-v5/source.ts';
+
+const options = { preserveV4: true, browser: true, globals: true };
+
+describe('Oxc migration analysis', () => {
+  it.each([
+    ['test.js', 'const element = <div />;'],
+    ['test.jsx', 'export const element = <div />;'],
+    ['test.ts', 'const identity = <T>(value: T): T => value;'],
+    ['test.tsx', 'const element = <div />; interface Props { value: string }'],
+    ['test.mts', 'export const value: number = 1;'],
+    ['test.cts', 'const value: number = 1; module.exports = value;'],
+    ['test.js', '@decorate class Example { method() {} }'],
+    ['test.ts', 'const value = 123n; const expression = /partial/v;'],
+  ])('parses %s syntax without another parser dependency', (file, content) => {
+    expect(parseSource(file, content).program.type).toBe('Program');
+  });
+
+  it('rejects Flow and malformed syntax instead of returning a partial AST', () => {
+    expect(() => parseSource('test.js', '// @flow\nconst value: string = "x";')).toThrow(
+      'Flow is not supported',
+    );
+    expect(() => parseSource('test.ts', 'const = ;')).toThrow();
+  });
+
+  it('preserves shadowed globals in destructuring, catch clauses, and hoisted declarations', () => {
+    const shadowed = `function parameter({ expect }) { expect(() => {}).toThrow(''); }
+try {} catch (expect) { expect(() => {}).toThrow(''); }
+function hoisted() { expect(() => {}).toThrow(''); var expect; }
+{ expect(() => {}).toThrow(''); let expect; }`;
+    const input = `${shadowed}\nexpect(() => {}).toThrow('');`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.content).toBe(`${shadowed}\nexpect(() => {}).toThrow(/^$/);`);
+    expect(result.findings).toEqual([]);
+  });
+
+  it('does not follow reassigned runner aliases', () => {
+    const input = `import { createVitest } from 'vitest/node';
+let runner = await createVitest('test', {});
+runner = other;
+runner.collect();`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.content).toBe(input);
+    expect(result.findings).toEqual([expect.objectContaining({ code: 'static-collect' })]);
+  });
+
+  it('resolves constructor references before and after their declaration', () => {
+    const input = `import { vi } from 'vitest';
+new mock(); const mock = vi.fn(); new mock();`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.findings).toEqual([expect.objectContaining({ code: 'class-mock' })]);
+  });
+
+  it('reserves generated names across bindings, unresolved references, and earlier edits', () => {
+    const input = `import { getFn } from '@vitest/runner';
+import { getHooks } from 'vitest/suite';
+const _VitestTestRunner = 1; use(_VitestTestRunner2);`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.content).toContain('TestRunner as _VitestTestRunner3');
+    expect(result.content).toContain('TestRunner as _VitestTestRunner4');
+    expect(result.findings).toEqual([]);
+    expect(parseSource('test.ts', result.content).program.type).toBe('Program');
+  });
+
+  it.each([
+    `import type * as v from 'vitest'; v.expect(() => {}).toThrow('');`,
+    `import type * as expect from 'vitest'; expect(() => {}).toThrow('');`,
+    `import type { expect } from 'vitest'; expect(() => {}).toThrow('');`,
+    `import { type expect } from 'vitest'; expect(() => {}).toThrow('');`,
+  ])('does not mistake a type-only import for a runtime API or global: %s', (input) => {
+    expect(migrateVitestV5Source('test.ts', input, options).content).toBe(input);
+  });
+
+  it.each([
+    `import { expect } from 'vitest'; expect?.(() => {}).toThrow('');`,
+    `import { expect } from 'vitest'; expect(() => {})?.toThrow('');`,
+    `import * as v from 'vitest'; v?.expect(() => {}).toThrow('');`,
+  ])('preserves optional API calls: %s', (input) => {
+    expect(migrateVitestV5Source('test.ts', input, options).content).toBe(input);
+  });
+
+  it('retains dynamic imports, CommonJS imports, and TS import-type diagnostics', () => {
+    const input = `const runner = await import('@vitest/runner');
+const other = require('vitest/runners');
+type Runner = import('vitest/internal/module-runner').ModuleRunner;
+function local(require) { return require('vitest/runners'); }`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.content).toBe(input);
+    expect(result.findings.map(({ code, severity }) => [code, severity])).toEqual([
+      ['removed-api', 'block'],
+      ['removed-api', 'block'],
+      ['removed-api', 'review'],
+    ]);
+  });
+
+  it('preserves non-ASCII text and reports UTF-16 columns with CRLF line endings', () => {
+    const input = `// 中文 😀\r\nimport { expect } from 'vitest';\r\nconst label = '😀'; expect.poll(() => label).toBe('x');`;
+    const result = migrateVitestV5Source('test.ts', input, options);
+    expect(result.content).toBe(input);
+    expect(result.findings).toContainEqual(
+      expect.objectContaining({
+        code: 'poll-timeout',
+        line: 3,
+        column: "const label = '😀'; ".length + 1,
+      }),
+    );
+    const edited = migrateVitestV5Source(
+      'test.ts',
+      `${input}\r\nexpect(() => {}).toThrow('');`,
+      options,
+    );
+    expect(edited.content).toBe(`${input}\r\nexpect(() => {}).toThrow(/^$/);`);
+  });
+
+  it.each([
+    'api: { port: 1 } /* keep , 😀 */, enabled: true',
+    'enabled: true, /* keep , 😀 */ api: { port: 1 }',
+    "enabled: true, api: { port: 1 }, /* keep , 😀 */ name: 'browser'",
+    'api: { port: 1 } /* keep , 😀 */,',
+    'api: { port: 1 } // keep , 😀\n, enabled: true',
+  ])('removes property punctuation without consuming comments: %s', (properties) => {
+    const input = `// 😀\nexport default { test: { browser: { ${properties} } } };`;
+    const result = migrateVitestV5Config('vite.config.ts', input, { preserveV4: false });
+    expect(result.findings).toEqual([]);
+    expect(result.content).toContain('keep , 😀');
+    expect(result.content.match(/api:/g)).toHaveLength(1);
+    expect(parseSource('vite.config.ts', result.content).program.type).toBe('Program');
+    expect(
+      migrateVitestV5Config('vite.config.ts', result.content, { preserveV4: false }).content,
+    ).toBe(result.content);
+  });
+
+  it('does not treat methods or getters as static config properties', () => {
+    const input = 'export default { test: { get browser() { return settings; } } };';
+    expect(migrateVitestV5Config('vite.config.ts', input, options).content).toBe(input);
+  });
+
+  it('returns the original source when an edit would produce invalid syntax', () => {
+    const editor = new SourceEditor('test.ts', 'const value = 1;');
+    editor.edit(0, 5, 'const =');
+    expect(editor.finish()).toEqual({
+      content: 'const value = 1;',
+      findings: [expect.objectContaining({ code: 'unsafe-syntax' })],
+    });
+  });
+});