feat(formatter): add snapshot-based test infrastructure

Implement a flexible snapshot-based testing framework for oxc_formatter using `insta` and build-time test generation.

## Features

- **Auto-discovery**: Tests are automatically discovered from `tests/fixtures/` directory
- **Individual test functions**: Each fixture file gets its own test function for easy identification
- **Hierarchical options**: Support for `options.json` files at any directory level
- **Multiple option sets**: Test the same input with multiple formatting configurations
- **Co-located snapshots**: Snapshot files are stored next to test files (e.g., `foo.js.snap`)
- **Comprehensive README**: Detailed documentation for adding and running tests

## Implementation

- **build.rs**: Scans `tests/fixtures/` and generates test functions at build time
- **tests/fixtures/mod.rs**: Core test infrastructure with option resolution and snapshot generation
- **tests/README.md**: Complete guide for using the test framework
- **Sample tests**: Example tests demonstrating JS, JSX, TS, and nested configurations

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Dunqing

Cargo.lock

@@ -31,5 +31,10 @@ rustc-hash = { workspace = true }
 unicode-width = "0.2"
 
 [dev-dependencies]
+insta = { workspace = true }
 oxc_parser = { workspace = true }
 pico-args = { workspace = true }
+serde_json = { workspace = true }
+
+[build-dependencies]
+oxc_span = { workspace = true }

crates/oxc_formatter/Cargo.toml

@@ -0,0 +1,108 @@
+use std::{
+    env,
+    fs::{self, File},
+    io::Write,
+    path::Path,
+};
+
+use oxc_span::SourceType;
+
+fn main() {
+    let out_dir = env::var("OUT_DIR").unwrap();
+    let dest_path = Path::new(&out_dir).join("generated_tests.rs");
+    let mut f = File::create(&dest_path).unwrap();
+
+    let fixtures_dir = Path::new("tests/fixtures");
+
+    if !fixtures_dir.exists() {
+        // If no fixtures directory exists, create an empty file
+        writeln!(f, "// No test fixtures found").unwrap();
+        return;
+    }
+
+    writeln!(f, "// Auto-generated test functions").unwrap();
+    writeln!(f).unwrap();
+
+    generate_tests_for_dir(&mut f, fixtures_dir, fixtures_dir).unwrap();
+
+    println!("cargo:rerun-if-changed=tests/fixtures");
+}
+
+fn generate_tests_for_dir(f: &mut File, dir: &Path, base_dir: &Path) -> std::io::Result<()> {
+    let entries = fs::read_dir(dir)?;
+
+    for entry in entries {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.is_dir() {
+            generate_tests_for_dir(f, &path, base_dir)?;
+        } else if is_test_file(&path) {
+            generate_test_function(f, &path, base_dir)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn is_test_file(path: &Path) -> bool {
+    if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
+        SourceType::from_extension(ext).is_ok()
+    } else {
+        false
+    }
+}
+
+fn generate_test_function(f: &mut File, file_path: &Path, base_dir: &Path) -> std::io::Result<()> {
+    let relative_path = file_path.strip_prefix(base_dir).unwrap();
+    let test_name = path_to_test_name(relative_path);
+
+    writeln!(f, "#[test]")?;
+    writeln!(f, "fn {test_name}() {{")?;
+    writeln!(
+        f,
+        "    let path = std::path::Path::new(\"tests/fixtures/{}\");",
+        relative_path.display()
+    )?;
+    writeln!(f, "    test_file(path);")?;
+    writeln!(f, "}}")?;
+    writeln!(f)?;
+
+    Ok(())
+}
+
+fn path_to_test_name(path: &Path) -> String {
+    let mut name = String::new();
+
+    for component in path.components() {
+        if let std::path::Component::Normal(os_str) = component {
+            let part = os_str.to_string_lossy();
+            if !name.is_empty() {
+                name.push('_');
+            }
+            // Replace non-alphanumeric characters with underscores
+            for c in part.chars() {
+                if c.is_alphanumeric() {
+                    name.push(c.to_ascii_lowercase());
+                } else {
+                    name.push('_');
+                }
+            }
+        }
+    }
+
+    // Remove file extension
+    if let Some(pos) = name.rfind('_') {
+        let after_underscore = &name[pos + 1..];
+        if SourceType::from_extension(after_underscore).is_ok() {
+            name.truncate(pos);
+        }
+    }
+
+    // Ensure it starts with a letter or underscore
+    if name.is_empty() || name.chars().next().unwrap().is_numeric() {
+        name = format!("test_{name}");
+    }
+
+    name
+}

crates/oxc_formatter/build.rs

@@ -0,0 +1,145 @@
+# Oxc Formatter Tests
+
+This directory contains snapshot-based tests for the oxc_formatter crate.
+
+## Overview
+
+The test infrastructure is designed to be simple and flexible:
+
+- **File-based testing**: Just create `.js`, `.jsx`, `.ts`, or `.tsx` files in the `fixtures/` directory
+- **Hierarchical options**: Configure format options via `options.json` files at any directory level
+- **Automatic discovery**: Tests are automatically discovered via build script - no manual registration needed
+- **Individual test functions**: Each file gets its own test function, visible in `cargo test` output
+- **Snapshot testing**: Uses `insta` for snapshot testing with easy review workflow
+- **Co-located snapshots**: Snapshots are stored next to test files for easy navigation
+
+## Directory Structure
+
+```
+tests/
+├── mod.rs                    # Main test runner
+└── fixtures/                 # Test input files
+    ├── js/                  # JavaScript/JSX tests
+    │   ├── options.json     # Shared options for all js tests
+    │   ├── arrow-functions.js
+    │   ├── arrow-functions.js.snap   # Snapshot file (includes extension)
+    │   ├── simple.jsx
+    │   ├── simple.jsx.snap
+    │   └── nested/
+    │       ├── options.json # Overrides parent options
+    │       ├── example.js
+    │       └── example.js.snap
+    └── ts/                  # TypeScript/TSX tests
+        ├── generics.ts
+        └── generics.ts.snap
+```
+
+## Adding New Tests
+
+### Simple Test (using default options)
+
+Just create a new file in `fixtures/js/` or `fixtures/ts/`:
+
+```bash
+# Create a new test file
+echo "const foo = bar;" > tests/fixtures/js/my-test.js
+
+# The test is automatically discovered - just run tests
+cargo test -p oxc_formatter --test mod
+```
+
+The test function is automatically generated by the build script and will be named `js_my_test`. The snapshot will be created as `tests/fixtures/js/my-test.js.snap` next to your test file.
+
+### Test with Custom Options
+
+Create an `options.json` file in the same directory (or parent directory):
+
+```json
+[
+  {
+    "semi": true,
+    "singleQuote": false,
+    "arrowParens": "always"
+  },
+  {
+    "semi": false,
+    "singleQuote": true,
+    "arrowParens": "avoid",
+    "printWidth": 120
+  }
+]
+```
+
+**Note**: Each object in the array is a separate option set. The options are displayed in the snapshot output.
+
+### Nested/Organized Tests
+
+Create subdirectories to organize related tests:
+
+```bash
+mkdir -p tests/fixtures/js/classes
+echo "class Foo {}" > tests/fixtures/js/classes/simple.js
+```
+
+The test will inherit options from the nearest `options.json` file in the directory tree.
+
+## Supported Options
+
+The following format options are supported in `options.json`:
+
+- `semi`: `true` | `false` - Semicolons (maps to `Semicolons::Always` / `Semicolons::AsNeeded`)
+- `singleQuote`: `true` | `false` - Quote style
+- `jsxSingleQuote`: `true` | `false` - JSX quote style
+- `arrowParens`: `"always"` | `"avoid"` - Arrow function parentheses
+- `trailingComma`: `"none"` | `"es5"` | `"all"` - Trailing commas
+- `printWidth`: number - Line width
+- `tabWidth`: number - Indentation width
+- `useTabs`: `true` | `false` - Use tabs for indentation
+- `bracketSpacing`: `true` | `false` - Object literal spacing
+- `bracketSameLine`: `true` | `false` - JSX bracket on same line
+- `jsxBracketSameLine`: `true` | `false` - (alias for bracketSameLine)
+
+## Running Tests
+
+### Run all tests
+```bash
+cargo test -p oxc_formatter --test mod
+```
+
+### Accept new/changed snapshots
+```bash
+cargo insta test --accept -p oxc_formatter --test mod
+```
+
+### Accept snapshots for specific tests
+```bash
+FILTER="arrow" cargo insta test --accept -p oxc_formatter --test mod
+```
+
+### Review snapshots interactively
+```bash
+cargo insta review -p oxc_formatter
+```
+
+## How It Works
+
+1. **Build-time Discovery**: The build script (`build.rs`) scans `tests/fixtures/` for all `.{js,jsx,ts,tsx}` files
+2. **Code Generation**: For each file, a test function is generated (e.g., `js_arrow_functions_js()`)
+3. **Test Execution**: Each generated test function calls the shared `test_file()` helper
+4. **Filtering**: If `FILTER` env var is set, only matching paths are tested
+5. **Option Resolution**: For each file, walk up the directory tree to find `options.json`
+6. **Formatting**: Format the file with each option set
+7. **Snapshot**: Generate a snapshot showing input + all outputs (stored next to test file)
+8. **Comparison**: Compare with existing snapshot (if any)
+
+## Tips
+
+- **Auto-discovery**: Just add a `.js/.jsx/.ts/.tsx` file to `fixtures/` - no need to register it anywhere
+- **Test names**: Test function names are generated from file paths (e.g., `js/nested/example.js` → `js_nested_example_js`)
+- **Organization**: Use subdirectories to group related tests (e.g., `fixtures/js/arrows/`, `fixtures/js/classes/`)
+- **Shared Options**: Put `options.json` at the directory level to apply to all files in that directory
+- **Override Options**: Create `options.json` in a subdirectory to override parent options
+- **Default Options**: If no `options.json` is found, `FormatOptions::default()` is used
+- **File Extensions**: The source type is detected automatically from the file extension
+- **Co-located Snapshots**: Snapshots are stored next to test files for easy navigation and review
+- **Rebuilds**: The build script automatically rebuilds when files in `tests/fixtures/` change