c
\n", + "src/d.svelte": "d
\n", +}; + +describe.concurrent("bun fmt --doctor", () => { + test("with a .prettierrc", async () => { + const { stdout, stderr, exitCode, isUntouched } = await doctor(prettier); + expect(stderr).toBe(""); + expect(stdout).toBe(`Using .prettierrc (Prettier config) +Also .editorconfig + + 4 files are formatted natively + 2 files go to your installed Prettier: 2 *.svelte + +Built-in plugins: @ianvs/prettier-plugin-sort-imports +Plugins that use your installed Prettier: prettier-plugin-svelte + +You can remove: prettier-plugin-astro +Still needed: @ianvs/prettier-plugin-sort-imports, prettier, prettier-plugin-svelte (some files go to them) +Not checked: other tools' configs, CI files, Git hooks +`); + expect(isUntouched).toBe(true); + expect(exitCode).toBe(0); + }); + + test("-f json prints the same report as JSON", async () => { + const { stdout, exitCode } = await doctor(prettier, ["-f", "json"]); + expect(JSON.parse(stdout)).toEqual({ + config: { path: ".prettierrc", kind: "prettier", nested: [], editorconfig: true }, + files: { formatted: 4, by_prettier: { "*.svelte": 2 }, not_formatted: {}, left_for_plugins: 0 }, + plugins: { + built_in: ["@ianvs/prettier-plugin-sort-imports"], + by_prettier: ["prettier-plugin-svelte"], + not_supported: [], + not_installed: [], + }, + options_not_supported: [], + packages: { + removable: ["prettier-plugin-astro"], + needed: [ + { name: "@ianvs/prettier-plugin-sort-imports", reason: "files", by: null }, + { name: "prettier", reason: "files", by: null }, + { name: "prettier-plugin-svelte", reason: "files", by: null }, + ], + not_checked: ["other tools' configs", "CI files", "Git hooks"], + }, + notes: [], + }); + expect(exitCode).toBe(0); + }); + + test("Prettier and a built-in plugin are removable when no file needs them", async () => { + const { stdout, exitCode } = await doctor({ + "package.json": dependencies("prettier", "@trivago/prettier-plugin-sort-imports"), + ".prettierrc.json": JSON.stringify({ plugins: ["@trivago/prettier-plugin-sort-imports"] }), + "a.js": ugly, + }); + expect(stdout).toBe(`Using .prettierrc.json (Prettier config) + + 3 files are formatted natively + +Built-in plugins: @trivago/prettier-plugin-sort-imports + +You can remove: @trivago/prettier-plugin-sort-imports, prettier +Not checked: other tools' configs, CI files, Git hooks +`); + expect(exitCode).toBe(0); + }); + + test("the plugin that sorts classes is built in", async () => { + const { stdout, exitCode } = await doctor({ + "package.json": dependencies("prettier", "prettier-plugin-tailwindcss", "tailwindcss"), + ".prettierrc.json": JSON.stringify({ plugins: ["prettier-plugin-tailwindcss"], tailwindFunctions: ["cn"] }), + "a.js": ugly, + }); + expect(stdout).toBe(`Using .prettierrc.json (Prettier config) + + 3 files are formatted natively + +Built-in plugins: prettier-plugin-tailwindcss + +You can remove: prettier, prettier-plugin-tailwindcss +Not checked: other tools' configs, CI files, Git hooks +`); + expect(exitCode).toBe(0); + }); + + test("lists unsupported plugins and plugins that aren't installed", async () => { + const project = { + ...installed("prettier"), + "package.json": dependencies("prettier", "prettier-plugin-css-order", "prettier-plugin-astro"), + ".prettierrc.json": JSON.stringify({ plugins: ["prettier-plugin-astro"] }), + "styled/.prettierrc.json": JSON.stringify({ plugins: ["prettier-plugin-css-order"] }), + "styled/a.js": ugly, + "b.astro": "b
\n", + }; + const [text, { stdout, exitCode }] = await Promise.all([doctor(project), doctor(project, ["-f", "json"])]); + expect(text.stdout).toStartWith(`Using .prettierrc.json (Prettier config) +Also styled/.prettierrc.json + + 2 files are formatted natively + 1 file cannot be formatted: 1 *.astro + 2 files are skipped because a plugin is not supported + Use --allow-unsupported to format them without it + +Plugins that use your installed Prettier: prettier-plugin-astro +Plugins that are not supported: prettier-plugin-css-order +Not installed: prettier-plugin-astro + +Still needed: prettier, prettier-plugin-astro (some files go to them) + prettier-plugin-css-order (the skipped files need it) +`); + const { config, files, plugins, packages } = JSON.parse(stdout); + expect(config.nested).toEqual(["styled/.prettierrc.json"]); + expect(files).toEqual({ formatted: 2, by_prettier: {}, not_formatted: { "*.astro": 1 }, left_for_plugins: 2 }); + expect(plugins).toEqual({ + built_in: [], + by_prettier: ["prettier-plugin-astro"], + not_supported: ["prettier-plugin-css-order"], + not_installed: ["prettier-plugin-astro"], + }); + expect(packages).toEqual({ + removable: [], + needed: [ + { name: "prettier", reason: "files", by: null }, + { name: "prettier-plugin-astro", reason: "files", by: null }, + { name: "prettier-plugin-css-order", reason: "skipped_files", by: null }, + ], + not_checked: ["other tools' configs", "CI files", "Git hooks"], + }); + expect(exitCode).toBe(0); + }); + + test("Prettier is not removable while files are skipped because of a plugin", async () => { + const { stdout, exitCode } = await doctor({ + "package.json": dependencies("prettier", "prettier-plugin-css-order", "prettier-plugin-other"), + ".prettierrc": JSON.stringify({ plugins: ["prettier-plugin-css-order"] }), + "a.js": ugly, + }); + expect(stdout).toStartWith(`Using .prettierrc (Prettier config) + + 0 files are formatted natively + 3 files are skipped because a plugin is not supported + Use --allow-unsupported to format them without it + +Plugins that are not supported: prettier-plugin-css-order + +You can remove: prettier-plugin-other +Still needed: prettier, prettier-plugin-css-order (the skipped files need them) +Not checked: other tools' configs, CI files, Git hooks +`); + expect(exitCode).toBe(0); + }); + + test("packages that a JavaScript config file imports are still needed", async () => { + const { stdout, exitCode } = await doctor({ + "node_modules/prettier-config-shared/package.json": JSON.stringify({ + name: "prettier-config-shared", + main: "index.js", + }), + "node_modules/prettier-config-shared/index.js": "module.exports = { semi: false };", + "package.json": dependencies("prettier", "prettier-config-shared"), + "prettier.config.cjs": `module.exports = { ...require("prettier-config-shared"), singleQuote: true };`, + "a.js": ugly, + }); + expect(stdout).toBe(`Using prettier.config.cjs (Prettier config) + + 3 files are formatted natively + +You can remove: prettier +Still needed: prettier-config-shared (prettier.config.cjs loads it) +Not checked: other tools' configs, CI files, Git hooks +`); + expect(exitCode).toBe(0); + }); + + test("only packages named like formatter tooling are removable", async () => { + const names = [ + "prettier", + "oxfmt", + "prettier-plugin-a", + "@scope/prettier-plugin-a", + "@prettier/plugin-php", + "prettier-config-a", + "@scope/prettier-config", + "@scope/prettier-config-a", + ]; + const others = [ + "eslint-plugin-prettier", + "eslint-config-prettier", + "prettier-eslint", + "pretty-quick", + "prettierx", + "vite-plugin-prettier", + "@scope/prettier", + ]; + const { stdout, exitCode } = await doctor( + { "package.json": dependencies(...names, ...others), ".prettierrc": "{}" }, + ["-f", "json"], + ); + expect(JSON.parse(stdout).packages).toEqual({ + removable: names.toSorted(), + needed: [], + not_checked: ["other tools' configs", "CI files", "Git hooks"], + }); + expect(exitCode).toBe(0); + }); + + test("a package used by a script, lint-staged or another dependency is still needed", async () => { + const project = (fields: object) => ({ + "package.json": + JSON.stringify({ devDependencies: { prettier: "*", "eslint-plugin-prettier": "*" }, ...fields }, null, 2) + + "\n", + ".prettierrc": "{}\n", + }); + const peer = { + "node_modules/eslint-plugin-prettier/package.json": JSON.stringify({ + name: "eslint-plugin-prettier", + peerDependencies: { prettier: ">=3" }, + }), + }; + const [script, staged, dependent, free] = await Promise.all([ + doctor(project({ scripts: { check: "prettier --check ." } })), + doctor(project({ "lint-staged": { "*": "prettier --write" } })), + doctor({ ...project({}), ...peer }), + doctor(project({ scripts: { check: "bun fmt --check", pretty: "prettierx ." } })), + ]); + expect(script.stdout).toEndWith(`\nStill needed: prettier (the "check" script runs it)\n`); + expect(staged.stdout).toEndWith(`\nStill needed: prettier (lint-staged runs it)\n`); + expect(dependent.stdout).toEndWith(`\nStill needed: prettier (eslint-plugin-prettier needs it)\n`); + expect(free.stdout).toEndWith( + `\nYou can remove: prettier\nNot checked: other tools' configs, CI files, Git hooks\n`, + ); + }); + + test("with an .oxfmtrc.json", async () => { + const { stdout, exitCode, isUntouched } = await doctor({ + "package.json": dependencies("oxfmt"), + ".oxfmtrc.json": JSON.stringify({ semi: false }), + "a.js": ugly, + }); + expect(stdout).toBe(`Using .oxfmtrc.json (oxfmt config) + + 3 files are formatted natively + +You can remove: oxfmt +Not checked: other tools' configs, CI files, Git hooks +`); + expect(isUntouched).toBe(true); + expect(exitCode).toBe(0); + }); + + test("without a config file", async () => { + const { stdout, stderr, exitCode, isUntouched } = await doctor({ "a.js": ugly }); + expect(stderr).toBe(""); + expect(stdout).toBe(`No Prettier or oxfmt config found. Bun formats like Prettier by default. + + 1 file is formatted natively + +Run bun fmt --init to add a [fmt] section to bunfig.toml +`); + expect(isUntouched).toBe(true); + expect(exitCode).toBe(0); + }); + + test("an invalid config file is an error", async () => { + const { stdout, stderr, exitCode } = await doctor({ ".prettierrc.json": "{", "a.js": ugly }); + expect(stdout).toBe(""); + expect(stderr).toContain(".prettierrc.json"); + expect(exitCode).toBe(2); + }); + + test("-f only accepts json", async () => { + const { stderr, exitCode } = await doctor({ "a.js": ugly }, ["-f", "yaml"]); + expect(stderr).toContain(`--format takes json, not "yaml"`); + expect(exitCode).not.toBe(0); + }); + + test("runs even if package.json has a `fmt` script", async () => { + const { stdout, exitCode } = await doctor({ + "package.json": JSON.stringify({ scripts: { fmt: "echo the script" } }), + "a.js": ugly, + }); + expect(stdout).toStartWith("No Prettier or oxfmt config found."); + expect(exitCode).toBe(0); + }); +}); diff --git a/test/cli/format/format.test.ts b/test/cli/format/format.test.ts index ac7f7f7e6d4d..4a52201b6582 100644 --- a/test/cli/format/format.test.ts +++ b/test/cli/format/format.test.ts @@ -34,7 +34,9 @@ import { inputs as lineEndingInputs } from "./line-endings.cases.ts"; afterAll(endChildren); -const command = [bunExe(), "format"]; +const command = [bunExe(), "fmt"]; +/** Matches the start of an error line: Prettier's `[error]` or Bun's `error:`. */ +const anError = /^(?:\[error\]|error:) /m; const env = { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: undefined }; @@ -77,6 +79,13 @@ async function format(files: Record\n {{#if a}}\n
\n", "This block is not closed (2:3)"],
+ ["block.hbs", "\n {{#if a}}\n
\n", "Unclosed block (2:3)"],
["mustache.hbs", "\n {{a\n
\n", "Unexpected character (3:1)"],
["end.hbs", "{{a", "Unexpected end of file (1:4)"],
- ["end-tag.hbs", "\n
\n", "This end tag does not close the element that is open (3:1)"],
- ["name.hbs", "{{#if a}}b{{/each}}\n", "This is not the name of the block that is open (1:11)"],
+ ["end-tag.hbs", "\n
\n
\n", "This end tag does not match the open element (3:1)"],
+ ["name.hbs", "{{#if a}}b{{/each}}\n", "This name does not match the open block (1:11)"],
["no-start.hbs", "\n", "This end tag has no start tag (1:1)"],
["hash.hbs", "{{a b=}}\n", "Unexpected token (1:6)"],
- ["in-tag.hbs", "\n", "A block can only be in an element or in another block (1:6)"],
+ ["in-tag.hbs", "\n", "A block can only be inside an element or another block (1:6)"],
["partial.hbs", "{{> a}}\n", "Partials, decorators and raw blocks are not supported (1:1)"],
- ["void.hbs", "\n", "This element has no end tag (1:8)"],
- ["element.hbs", "{{#if a}}\n
{{/if}}\n", "This element is not closed (1:10)"],
- ["comment.hbs", "{{!-- a\n", "This comment is not closed (1:1)"],
- ["short-comment.hbs", "{{! a\n", "This comment is not closed (1:1)"],
- ["string.hbs", '{{a "b}}\n', "This string is not closed (1:5)"],
- ["segment.hbs", "{{a [b}}\n", "This bracket is not closed (1:5)"],
+ ["void.hbs", "\n", "This element cannot have an end tag (1:8)"],
+ ["element.hbs", "{{#if a}}b;\n"],
+ ["babel-ts", "a = x\n", "a = x;\n"],
+ ["babel-ts", "a = x\nlet b: = 1\n", "(2:8)"],
+ ])("typescript reports the error of the syntax the code looks like: %j", async (stdin, position) => {
+ const result = await format(prettier, ["--parser", "typescript"], { stdin });
+ expect(result.stderr.split("\n")[0]).toBe(`[error] stdin: SyntaxError: Type expected. ${position}`);
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("prints nothing for empty input", async () => {
+ // `stdin: "ignore"`, like `< /dev/null`.
+ const results = await Promise.all([
+ format(files, ["--parser", "babel"], { reads }),
+ pipe(files, [], { stdin: "" }),
+ ]);
+ for (const result of results) expect(result).toMatchObject({ raw: "", stderr: "", exitCode: 0 });
+ expect(results[0].files).toEqual(files);
+ });
+
+ test("uses the config of the working directory", async () => {
+ const nested = { ...noSemi, "sub/.prettierrc": `{ "tabWidth": 8 }\n`, "sub/dir/a.txt": "", "other/a.txt": "" };
+ const [here, below, nearer, off, named] = await Promise.all([
+ pipe(noSemi),
+ pipe(nested, [], { cwd: "other" }),
+ pipe(nested, [], { cwd: "sub/dir" }),
+ pipe(noSemi, ["--no-config"]),
+ pipe({ ...prettier, "x.json": `{ "semi": false }` }, ["--config", "x.json"]),
+ ]);
+ expect(here.raw).toBe(withoutSemi);
+ expect(below.raw).toBe(withoutSemi);
+ expect(nearer.raw).toBe(printed.replace(" return", " return"));
+ expect(off.raw).toBe(printed);
+ expect(named.raw).toBe(withoutSemi);
+ });
+
+ test.each([
+ [
+ "overrides in .prettierrc",
+ { ".prettierrc": `{ "overrides": [{ "files": $, "options": { "singleQuote": true } }] }` },
+ ],
+ ["overrides in --config", { "x.json": `{ "overrides": [{ "files": $, "options": { "singleQuote": true } }] }` }],
+ [
+ "overrides in .oxfmtrc.json",
+ { ".oxfmtrc.json": `{ "overrides": [{ "files": $, "options": { "singleQuote": true } }] }` },
+ ],
+ ["[[fmt.overrides]]", { "bunfig.toml": `[[fmt.overrides]]\nfiles = $\noptions = { singleQuote = true }\n` }],
+ ])("there's no file name for %s to match", async (_, project) => {
+ const [[name, text]] = Object.entries(project);
+ const globs = `["*", "**", "**/*", "*.js", "stdin", "(stdin)"]`;
+ const flags = name === "x.json" ? ["--config", name] : [];
+ const result = await pipe({ [name]: text.replace("$", globs) }, flags);
+ expect(result).toMatchObject({ raw: printed, stderr: "", exitCode: 0 });
+ // The same override does match a name.
+ const control = await format({ [name]: text.replace("$", globs) }, [...flags, "--stdin-filepath", "a.js"], {
+ stdin: js,
+ });
+ expect(control.raw).toBe(printed.replaceAll('"', "'"));
+ });
+
+ test.each([
+ ["no config", {}],
+ ["a Prettier config", prettier],
+ ])(".editorconfig doesn't apply: %s", async (_, config) => {
+ const project = { ...config, ".editorconfig": "root = true\n[*]\nindent_style = tab\n" };
+ expect((await pipe(project)).raw).toBe(printed);
+ const control = await format(project, ["--stdin-filepath", "a.js"], { stdin: js });
+ expect(control.raw).toBe(printed.replace(" return", "\treturn"));
+ });
+
+ test("ignore files don't apply", async () => {
+ const everything = "*\n**\nstdin\n";
+ const results = await Promise.all([
+ pipe({ ...prettier, ".prettierignore": everything }),
+ pipe({ ...prettier, ".gitignore": everything }),
+ pipe({ ...prettier, ig: everything }, ["--ignore-path", "ig"]),
+ pipe(prettier, ["--ignore-path", "missing"]),
+ pipe({ ...prettier, "node_modules/x/a.txt": "" }, [], { cwd: "node_modules/x" }),
+ pipe({}, ["--ignore-pattern", "*"]),
+ ]);
+ for (const result of results) expect(result).toMatchObject({ raw: printed, stderr: "", exitCode: 0 });
+ });
+
+ test.each([
+ [["--check"], js, "(stdin)\n", 1],
+ [["--list-different"], js, "(stdin)\n", 1],
+ [["--check"], printed, "", 0],
+ [["--list-different"], printed, "", 0],
+ [["--write"], js, printed, 0],
+ [["--check", "--write"], js, "", 0],
+ [["--list-different", "--write"], js, "", 0],
+ [["--log-level", "silent"], js, printed, 0],
+ [["--log-level", "warn", "--check"], js, "", 1],
+ ])("%j", async (flags, stdin, raw, exitCode) => {
+ for (const config of [{}, prettier]) {
+ const result = await pipe({ ...files, ...config }, flags, { stdin, reads });
+ expect(result).toMatchObject({ raw, stderr: "", exitCode, files });
+ }
+ });
+
+ test.each<[Record, string[], string, number]>([
+ [prettier, [], "[error] stdin: SyntaxError: ", 2],
+ [prettier, ["--write"], "[error] stdin: SyntaxError: ", 2],
+ [prettier, ["--check"], "[error] ", 0],
+ [prettier, ["--list-different"], "[error] ", 0],
+ [{}, [], "error: stdin: SyntaxError: ", 2],
+ [{ ".oxfmtrc.json": "{}" }, [], "[error] stdin: SyntaxError: ", 2],
+ ])("a syntax error: %j %j", async (config, flags, before, exitCode) => {
+ const result = await format(config, ["--parser", "typescript", ...flags], { stdin: "let a: = 1;\n" });
+ const margin = before.startsWith("[") ? "[error] " : "";
+ const why = ".oxfmtrc.json" in config ? "Unexpected token" : "Type expected.";
+ expect(result.raw).toBe("");
+ expect(result.stderr.split("\n")).toEqual([
+ `${before}${why} (1:8)`,
+ `${margin}> 1 | let a: = 1;`,
+ `${margin} | ^`,
+ `${margin} 2 |`,
+ ]);
+ expect(result.exitCode).toBe(exitCode);
+ });
+
+ test.each<[Record, string[], string, number]>([
+ [prettier, [], "[error] ", 1],
+ [prettier, ["--check"], "[error] ", 0],
+ [prettier, ["--list-different"], "[error] ", 0],
+ [prettier, ["--ignore-unknown"], "[error] ", 1],
+ [{}, [], "error: ", 2],
+ [{}, ["--check"], "error: ", 2],
+ ])("a parser nobody has: %j %j", async (config, flags, before, exitCode) => {
+ const result = await format({ ...files, ...config }, ["--parser", "nonsense", ...flags], { stdin: js, reads });
+ expect(result).toMatchObject({
+ raw: "",
+ stderr: `${before}Couldn't resolve parser "nonsense".`,
+ exitCode,
+ files,
+ });
+ });
+
+ test("--config-precedence", async () => {
+ const none = "[error] No parser and no file path given, couldn't infer a parser.";
+ const prefer = ["--config-precedence", "prefer-file"];
+ const override = ["--config-precedence", "file-override"];
+ const json = { ".prettierrc": `{ "parser": "json" }` };
+ expect(await pipe(noSemi, ["--semi", ...override])).toMatchObject({ raw: withoutSemi, exitCode: 0 });
+ expect(await pipe(noSemi, ["--semi"])).toMatchObject({ raw: printed, exitCode: 0 });
+ expect(await pipe(json, override, { stdin: `{"a":1}` })).toMatchObject({ raw: `{ "a": 1 }\n`, exitCode: 0 });
+ expect(await pipe(json, prefer, { stdin: `{"a":1}` })).toMatchObject({ raw: `{ "a": 1 }\n`, exitCode: 0 });
+ // The config file wins, and it has no parser.
+ expect(await pipe(noSemi, prefer)).toMatchObject({ raw: "", stderr: none, exitCode: 2 });
+ expect(await pipe(noSemi, [...prefer, "--check"])).toMatchObject({ raw: "", stderr: none, exitCode: 0 });
+ expect(await pipe(noSemi, [...prefer, "--ignore-unknown"])).toMatchObject({ raw: "", stderr: "", exitCode: 0 });
+ });
+
+ test.each([
+ [["--cursor-offset", "13"], js, printed, "14"],
+ [["--cursor-offset", "0"], js, printed, "0"],
+ [
+ ["--range-start", "10", "--range-end", "20"],
+ "a = 1;\nb = 2;\nc = 3;\n",
+ "a = 1;\nb = 2;\nc = 3;\n",
+ "",
+ ],
+ [["--range-start", "10", "--cursor-offset", "3"], "a = 1;\nb = 2;\n", "a = 1;\nb = 2;\n", "3"],
+ [["--insert-pragma"], "a\n", "/** @format */\n\na;\n", ""],
+ [["--require-pragma"], js, js, ""],
+ [["--require-pragma"], "/** @format */\n" + js, "/** @format */\n" + printed, ""],
+ [["--check-ignore-pragma"], "/** @noformat */\n" + js, "/** @noformat */\n" + js, ""],
+ [["--single-quote", "--use-tabs"], js, "function f() {\n\treturn 'a';\n}\n", ""],
+ [["--end-of-line", "auto"], "a = 1;\r\nb;\r\n", "a = 1;\r\nb;\r\n", ""],
+ ])("%j", async (flags, stdin, raw, stderr) => {
+ expect(await pipe(prettier, flags, { stdin })).toMatchObject({ raw, stderr, exitCode: 0 });
+ });
+
+ test("an empty --stdin-filepath is no file name either", async () => {
+ expect(await pipe(noSemi, ["--stdin-filepath", ""])).toMatchObject({ raw: withoutSemi, stderr: "", exitCode: 0 });
+ });
+
+ test.each([[["--parser", "babel"]], [["--stdin-filepath", "a.js"]]])(
+ "warns about an unknown option in the config: %j",
+ async args => {
+ const result = await format({ ".prettierrc": `{ "nope": 1 }` }, args, { stdin: js });
+ expect(result).toMatchObject({
+ raw: printed,
+ stderr: "[warn] Ignored unknown option { nope: 1 }.",
+ exitCode: 0,
+ });
+ },
+ );
+
+ test("with an oxfmt config, uses its options", async () => {
+ const project = {
+ ".oxfmtrc.json": `{ "semi": false }`,
+ ".editorconfig": "[*]\nindent_style = tab\n[*.js]\nindent_size = 8\n",
+ };
+ // oxfmt reads `[*]` as settings for the whole project, not as a pattern.
+ expect(await pipe(project)).toMatchObject({
+ raw: withoutSemi.replace(" return", "\treturn"),
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(await pipe(project, ["--check"])).toMatchObject({ raw: "(stdin)\n", exitCode: 1 });
+ });
+
+ test.each(["--staged", "--changed"])("%s has no file list to filter", async flag => {
+ const result = await pipe(files, [flag], { reads });
+ expect(result).toMatchObject({
+ raw: "",
+ stderr: `error: ${flag} and --parser without files cannot be used together`,
+ exitCode: 2,
+ files,
+ });
+ });
+
+ test("without --parser, piped input still means the working directory", async () => {
+ const result = await format({ "a.js": ugly }, [], { stdin: js, reads: ["a.js"] });
+ expect(result.files).toEqual({ "a.js": formatted });
+ expect(result.stdout).toBe("a.js");
+ expect(result.exitCode).toBe(0);
+ });
+
+ // Some sandboxes have no pseudo-terminals.
+ const hasTerminal = (() => {
+ if (isWindows) return false;
+ try {
+ new Bun.Terminal({}).close();
+ return true;
+ } catch {
+ return false;
+ }
+ })();
+
+ test.skipIf(!hasTerminal)(
+ "in a terminal with nothing piped in, it's an error instead of waiting for input",
+ async () => {
+ using dir = tempDir("bun-format", files);
+ let output = "";
+ await using proc = spawn({
+ cmd: [...command, "--parser", "babel"],
+ env: { ...env, NO_COLOR: "1", TERM: "xterm-256color" },
+ cwd: String(dir),
+ terminal: {
+ cols: 200,
+ rows: 40,
+ data(_terminal, chunk) {
+ output += Buffer.from(chunk).toString();
+ },
+ },
+ });
+ expect(await proc.exited).toBe(2);
+ expect(output.replaceAll("\r\n", "\n")).toBe(
+ "error: --parser without files formats standard input, and nothing is piped in\n Pipe the code in, or name the files to format.\n",
+ );
+ },
+ );
+ });
+
+ describe("--parser with a directory", () => {
+ const files = {
+ "a.md": "# a\n",
+ "LICENSE": "a b\n",
+ "src/b.md": "# b\n",
+ "src/c.js": "c ;\n",
+ ".env": "A = 1\n",
+ };
+ const reads = Object.keys(files);
+
+ test.each([
+ [["--parser", "markdown", "."], ".", "markdown", "**/*.md"],
+ [["--parser", "markdown", "./"], "./", "markdown", "**/*.md"],
+ [["--parser", "flow", "src"], "src", "flow", "src/**/*.js"],
+ [["--parser", "babel", "a.md", "src/"], "src/", "babel", "src/**/*.js"],
+ [["--parser", "typescript", "--check", "src"], "src", "typescript", "src/**/*.ts"],
+ [["--parser", "json5", "-l", "src"], "src", "json5", "src/**/*.json5"],
+ [["--parser", "glimmer", "--no-config", "src"], "src", "glimmer", "src/**/*.hbs"],
+ [["--parser", "markdown", ""], "", "markdown", "**/*.md"],
+ ])("is an error without a config: %j", async (args, directory, parser, glob) => {
+ const result = await format(files, args, { reads });
+ expect(result.files).toEqual(files);
+ expect(result.raw).toBe("");
+ expect(result.stderr.split("\n")).toEqual([
+ `error: --parser ${parser} would read every file in "${directory}" as ${parser}`,
+ ` Name the files, or use a glob: bun fmt --parser ${parser} "${glob}"`,
+ ]);
+ expect(result.exitCode).toBe(2);
+ });
+
+ // oxfmt 0.72.0 has no --parser, so there's nothing to be compatible with.
+ test.each<[Record, string[]]>([
+ [{ ".oxfmtrc.json": "{}\n" }, []],
+ [{}, ["--flavor=oxfmt"]],
+ ])("is an error when formatting like oxfmt: %j %j", async (config, flags) => {
+ const result = await format({ ...files, ...config }, [...flags, "--parser", "markdown", "."], { reads });
+ expect(result.files).toEqual(files);
+ expect(result.raw).toBe("");
+ expect(result.stderr.split("\n")).toEqual([
+ `[error] --parser markdown would read every file in "." as markdown`,
+ `[error] Name the files, or use a glob: bun fmt --parser markdown "**/*.md"`,
+ ]);
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("files and globs are explicit, so they're formatted", async () => {
+ const result = await format(files, ["--parser", "markdown", "LICENSE", "**/*.md"], { reads });
+ expect(result.files).toEqual({ ...files, "LICENSE": "a b\n", "a.md": "# a\n", "src/b.md": "# b\n" });
+ expect(result.exitCode).toBe(0);
+ });
+
+ // Prettier 3.9.9 rewrites the same files.
+ test("with a Prettier config, every file in it is read with that parser, like Prettier does", async () => {
+ const result = await format({ ...files, ".prettierrc": "{}\n" }, ["--parser", "markdown", "."], { reads });
+ expect(result.files).toEqual({
+ "a.md": "# a\n",
+ "LICENSE": "a b\n",
+ "src/b.md": "# b\n",
+ "src/c.js": "c ;\n",
+ ".env": "A = 1\n",
+ });
+ expect(result.exitCode).toBe(0);
+ });
+ });
+
describe("the command line", () => {
test("formatting options", async () => {
const result = await format(
@@ -3857,8 +4997,8 @@ try {
test("--help", async () => {
const result = await format({}, ["--help"]);
- expect(result.stdout).toContain("bun format");
- expect(result.stdout).toContain("--list-different");
+ expect(result.stdout).toContain("bun fmt");
+ expect(result.stdout).toContain("--check");
expect(result.exitCode).toBe(0);
});
});
@@ -3891,7 +5031,7 @@ describe.concurrent("what an ignore file has is not written, however it is come
const kept = ["generated/a.js", "generated/deep/b.js", "vendor/c.js"];
const result = await format(files, ["generated", "generated/*.js", "vendor", "src"], { reads: kept });
expect(result.stdout).toBe("src/d.js");
- expect(result.stderr).not.toContain("[error]");
+ expect(result.stderr).not.toMatch(anError);
expect(result.files).toEqual(Object.fromEntries(kept.map(name => [name, ugly])));
expect(result.exitCode).toBe(0);
});
@@ -3901,7 +5041,7 @@ describe.concurrent("what an ignore file has is not written, however it is come
async (...args) => {
const files = { ".prettierignore": "src/a.js\nsrc/b.js\n", "src/a.js": ugly, "src/b.js": ugly };
const result = await format(files, ["--check", ...args], { reads: ["src/a.js"] });
- expect(result.stderr).not.toContain("[error]");
+ expect(result.stderr).not.toMatch(anError);
expect(result.files).toEqual({ "src/a.js": ugly });
expect(result.exitCode).toBe(0);
},
@@ -3910,7 +5050,7 @@ describe.concurrent("what an ignore file has is not written, however it is come
test("a pattern that matches nothing is an error beside a directory of which every file is ignored", async () => {
const files = { ".prettierignore": "src/a.js\n", "src/a.js": ugly };
const result = await format(files, ["--check", "src", "none/*.js"]);
- expect(result.stderr).toContain(`[error] No files matching the pattern were found: "none/*.js".`);
+ expect(result.stderr).toContain(`error: No files matching the pattern were found: "none/*.js".`);
expect(result.stderr).not.toContain(`"src"`);
expect(result.exitCode).toBe(2);
});
@@ -4018,7 +5158,8 @@ describe.concurrent("how a path is written", () => {
commandLine: [],
};
await using proc = spawn({
- cmd: [bunExe(), "-e", `const given = ${JSON.stringify(given)};\n${source}`],
+ // As there: nothing is fetched.
+ cmd: [bunExe(), "--no-install", "-e", `const given = ${JSON.stringify(given)};\n${source}`],
env,
cwd: String(dir),
stdin: "ignore",
@@ -4047,14 +5188,14 @@ describe.concurrent("how a path is written", () => {
});
return (await proc.stderr.text()).split(/\r?\n/)[0];
};
- const noParser = `[error] No parser could be inferred for file "${join(String(dir), "notes.foo")}".`;
+ const noParser = `error: No parser could be inferred for file "${join(String(dir), "notes.foo")}".`;
expect(
await Promise.all([
firstLine(["-l", join("src", "*.foo")]),
firstLine(["-l", join(String(dir), "notes.foo")]),
firstLine(["--stdin-filepath", join("src", "..", "notes.foo")], "a\n"),
]),
- ).toEqual([`[error] No files matching the pattern were found: "${join("src", "*.foo")}".`, noParser, noParser]);
+ ).toEqual([`error: No files matching the pattern were found: "${join("src", "*.foo")}".`, noParser, noParser]);
});
// src/config/prettier-config/config-searcher.js and the package `editorconfig` ask the system for a file of that name.
@@ -4087,8 +5228,7 @@ describe.concurrent("a file that is not UTF-8, or has a NUL", () => {
});
const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
return {
- // Not the lines of a code frame: `[error] > 2 | ..`, `[error] | ^`.
- errors: stderr.split(/\r?\n/).filter(line => /^\[error\] [^ >|]/.test(line)),
+ errors: stderr.split(/\r?\n/).filter(line => line.startsWith("error: ")),
exitCode,
files: Object.fromEntries(
Object.keys(files).map(name => [name, readFileSync(join(String(dir), name)).toString("latin1")]),
@@ -4122,9 +5262,9 @@ describe.concurrent("a file that is not UTF-8, or has a NUL", () => {
expect(result.files).toEqual(
Object.fromEntries(Object.entries(files).map(([name, bytes]) => [name, bytes.toString("latin1")])),
);
- expect(result.errors.map(line => line.split(":")[0]).sort()).toEqual(
+ expect(result.errors.map(line => line.split(":").slice(0, 2).join(":")).sort()).toEqual(
Object.keys(files)
- .map(name => `[error] ${name}`)
+ .map(name => `error: ${name}`)
.sort(),
);
expect(result.exitCode).toBe(2);
@@ -4140,8 +5280,8 @@ describe.concurrent("a file that is not UTF-8, or has a NUL", () => {
const result = await bytesAfter(files);
expect(result.files).toEqual(files);
expect(result.errors.sort()).toEqual([
- "[error] a.html: SyntaxError: What follows this NUL would be lost (2:5)",
- "[error] a.vue: SyntaxError: What follows this NUL would be lost (2:5)",
+ "error: a.html: SyntaxError: Unexpected NUL character (2:5)",
+ "error: a.vue: SyntaxError: Unexpected NUL character (2:5)",
]);
expect(result.exitCode).toBe(2);
});
@@ -4153,7 +5293,7 @@ describe.concurrent("a file that is not UTF-8, or has a NUL", () => {
["the value of an attribute without quotes", ", args: string[], variables: Record = {}) {
using dir = tempDir("bun-format-process", files);
@@ -4627,10 +5776,11 @@ describe.concurrent("what bun format takes from Bun", () => {
test("colors are Bun's to decide: FORCE_COLOR, NO_COLOR, and none in a pipe", async () => {
const files = { "a.js": ugly };
+ const ofPrettier = { ...files, ".prettierrc": "{}\n" };
const [forced, refused, piped, asOxfmt] = await Promise.all([
- format(files, ["--check"], { env: { FORCE_COLOR: "1" } }),
- format(files, ["--check"], { env: { NO_COLOR: "1" } }),
- format(files, ["--check"]),
+ format(ofPrettier, ["--check"], { env: { FORCE_COLOR: "1" } }),
+ format(ofPrettier, ["--check"], { env: { NO_COLOR: "1" } }),
+ format(ofPrettier, ["--check"]),
format({ ...files, ".oxfmtrc.json": "{}\n" }, ["--check", "a.js"], { env: { FORCE_COLOR: "1" } }),
]);
expect(forced.stderr.split("\n")[0]).toBe("[\x1b[33mwarn\x1b[0m] a.js");
@@ -4642,12 +5792,12 @@ describe.concurrent("what bun format takes from Bun", () => {
test("--cwd behind format, before it, and in BUN_OPTIONS, whose other flags are not the formatter's", async () => {
const files = { "a.js": ugly, "sub/b.js": ugly };
const results = await Promise.all([
- bun(files, ["format", "--cwd", "sub", "-l"]),
- bun(files, ["format", "--cwd=sub", "-l"]),
- bun(files, ["--cwd=sub", "format", "-l"]),
- bun(files, ["format", "-l"], { BUN_OPTIONS: "--cwd=sub" }),
- bun(files, ["--silent", "format", "-l", "sub"]),
- bun(files, ["format", "-l", "sub"], { BUN_OPTIONS: "--silent --no-install" }),
+ bun(files, ["fmt", "--cwd", "sub", "-l"]),
+ bun(files, ["fmt", "--cwd=sub", "-l"]),
+ bun(files, ["--cwd=sub", "fmt", "-l"]),
+ bun(files, ["fmt", "-l"], { BUN_OPTIONS: "--cwd=sub" }),
+ bun(files, ["--silent", "fmt", "-l", "sub"]),
+ bun(files, ["fmt", "-l", "sub"], { BUN_OPTIONS: "--silent --no-install" }),
]);
expect(results.map(it => [it.stdout.replaceAll("\\", "/"), it.stderr, it.exitCode])).toEqual([
...Array(4).fill(["b.js\n", "", 1]),
@@ -4658,7 +5808,7 @@ describe.concurrent("what bun format takes from Bun", () => {
// The process that runs the configuration file starts in that directory. With BUN_OPTIONS it would look for `sub` in `sub`.
test("--cwd in BUN_OPTIONS, with a configuration file that is a program", async () => {
const files = { "sub/.prettierrc.mjs": "export default { semi: false };\n", "sub/b.js": "b;\n" };
- const result = await bun(files, ["format", "-l", "b.js"], { BUN_OPTIONS: "--cwd=sub" });
+ const result = await bun(files, ["fmt", "-l", "b.js"], { BUN_OPTIONS: "--cwd=sub" });
expect(result).toEqual({ stdout: "b.js\n", stderr: "", exitCode: 1 });
});
@@ -4668,25 +5818,25 @@ describe.concurrent("what bun format takes from Bun", () => {
"prettier.config.mjs": "setInterval(() => {}, 1000);\nexport default { semi: false };\n",
"b.js": "b;\n",
};
- expect(await bun(files, ["format", "-l", "b.js"])).toEqual({ stdout: "b.js\n", stderr: "", exitCode: 1 });
+ expect(await bun(files, ["fmt", "-l", "b.js"])).toEqual({ stdout: "b.js\n", stderr: "", exitCode: 1 });
});
test("what the bunfig.toml of the project has for other commands is not read", async () => {
- const result = await bun({ "bunfig.toml": "[install]\nglobalDir = 1\n", "a.js": ugly }, ["format", "-l"]);
+ const result = await bun({ "bunfig.toml": "[install]\nglobalDir = 1\n", "a.js": ugly }, ["fmt", "-l"]);
expect(result).toEqual({ stdout: "a.js\n", stderr: "", exitCode: 1 });
});
test("--config= before format names another file than bunfig.toml", async () => {
const files = {
- "bunfig.toml": "[format]\nsemi = false\n",
- "other.toml": "[format]\nsingleQuote = true\n",
+ "bunfig.toml": "[fmt]\nsemi = false\n",
+ "other.toml": "[fmt]\nsingleQuote = true\n",
"a.js": "a('b');\n",
};
const results = await Promise.all([
- bun(files, ["format", "-l"]),
- bun(files, ["--config=other.toml", "format", "-l"]),
- bun(files, ["-c=other.toml", "format", "-l"]),
- bun(files, ["--config=none.toml", "format", "-l"]),
+ bun(files, ["fmt", "-l"]),
+ bun(files, ["--config=other.toml", "fmt", "-l"]),
+ bun(files, ["-c=other.toml", "fmt", "-l"]),
+ bun(files, ["--config=none.toml", "fmt", "-l"]),
]);
expect(results.map(it => [it.stdout, it.exitCode])).toEqual([
["a.js\n", 1],
@@ -4697,9 +5847,9 @@ describe.concurrent("what bun format takes from Bun", () => {
expect(results[3].stderr).toContain(`while reading config "`);
});
- test("what is wrong with [format] is shown where it is, as for every other section", async () => {
- const files = { "bunfig.toml": `[format]\nsemi = false\nprintWidth = "wide"\n`, "a.js": ugly };
- const result = await bun(files, ["format", "-l"]);
+ test("what is wrong with [fmt] is shown where it is, as for every other section", async () => {
+ const files = { "bunfig.toml": `[fmt]\nsemi = false\nprintWidth = "wide"\n`, "a.js": ugly };
+ const result = await bun(files, ["fmt", "-l"]);
expect(result.stderr).toContain(`3 | printWidth = "wide"\n`);
expect(result.stderr).toMatch(/error: expected number but received string\n\s+at .*bunfig\.toml:3:14\n/);
expect(result.stdout).toBe("");
@@ -4741,7 +5891,7 @@ describe.concurrent("what bun format takes from Bun", () => {
writeFileSync(name, ugly);
const run = async (argument: string) => {
await using proc = spawn({
- cmd: ["sh", "-c", `exec "$0" format ${argument}`, bunExe()],
+ cmd: ["sh", "-c", `exec "$0" fmt ${argument}`, bunExe()],
env,
cwd: String(dir),
stdout: "pipe",
@@ -4780,18 +5930,18 @@ describe.concurrent("what bun format takes from Bun", () => {
async open => {
const result = await format({}, ["--stdin-filepath", "deep.jsx"], { stdin: open.repeat(100_000) + "\n" });
expect(result.raw).toBe("");
- expect(result.stderr).toStartWith("[error] deep.jsx:");
+ expect(result.stderr).toStartWith("error: deep.jsx:");
expect(result.exitCode).toBe(2);
},
);
});
-// What differs between Windows, macOS and Linux, for `bun format`: how a path is written, which names are the same file, how a line
+// What differs between Windows, macOS and Linux, for `bun fmt`: how a path is written, which names are the same file, how a line
// ends, what a link is, what can be written. Nothing here is passed through `normalizeBunSnapshot`, which makes `/` of every `\`
// and `\n` of every `\r\n`: what is printed is compared as it is printed.
//
// A test that can only tell something on one system runs on all of them where it can: there it is a test that nothing else breaks.
-describe("bun format on Windows, macOS and Linux", () => {
+describe("bun fmt on Windows, macOS and Linux", () => {
const env = { ...bunEnv, AGENT: "0", CLAUDECODE: undefined, NO_COLOR: "1", FORCE_COLOR: undefined };
// A drive letter that a test has taken would stay, for every process of the session, if the test ran out of time.
@@ -4821,10 +5971,10 @@ describe("bun format on Windows, macOS and Linux", () => {
type Directory = string | { toString(): string };
- /** Runs `bun format ` in `cwd`. What it prints is returned as it is. */
+ /** Runs `bun fmt ` in `cwd`. What it prints is returned as it is. */
async function format(cwd: Directory, args: string[], stdin?: string, before: string[] = []) {
const proc = spawn({
- cmd: [...before, bunExe(), "format", ...args],
+ cmd: [...before, bunExe(), "fmt", ...args],
env,
cwd: String(cwd),
stdin: stdin === undefined ? "ignore" : Buffer.from(stdin),
@@ -4900,15 +6050,11 @@ describe("bun format on Windows, macOS and Linux", () => {
const results = await Promise.all([format(listed, ["-l"]), format(checked, ["--check"]), format(written, [])]);
expect(results.map(it => it.stdout)).toEqual([
"a.js\nsrc/deep/b.ts\n",
- "Checking formatting...\nError occurred when checking code style in the above file.\n",
"a.js\nsrc/deep/b.ts\n",
- ]);
- expect(results[1].stderr.split("\n").filter(line => line.startsWith("[warn] "))).toEqual([
- "[warn] a.js",
- "[warn] src/deep/b.ts",
+ "a.js\nsrc/deep/b.ts\n",
]);
for (const { stderr } of results) {
- expect(stderr).toContain("[error] src/broken.js: SyntaxError: ");
+ expect(stderr).toContain("error: src/broken.js: SyntaxError: ");
expect(stderr).not.toContain("\r");
}
});
@@ -4988,14 +6134,14 @@ describe("bun format on Windows, macOS and Linux", () => {
test(
"a project in a directory with blanks, `#`, `%41` and letters that are not ASCII",
async () => {
- using dir = tempDir("bun format #1 %41 é 日本", {
+ using dir = tempDir("bun fmt #1 %41 é 日本", {
".prettierrc.mjs": `import shared from "./my configs/shared#1.mjs";\nexport default { ...shared };\n`,
"my configs/shared#1.mjs": "export default { semi: false };\n",
"sources é/ü 100%.js": formatted,
"sources é/中文.js": formatted,
});
const { stdout, stderr, exitCode } = await format(dir, ["sources é"]);
- expect(stderr).not.toContain("[error]");
+ expect(stderr).not.toMatch(anError);
expect(stdout).toBe("sources é/ü 100%.js\nsources é/中文.js\n");
expect(read(dir, "sources é", "ü 100%.js")).toBe("a\n");
expect(exitCode).toBe(0);
@@ -5011,7 +6157,7 @@ describe("bun format on Windows, macOS and Linux", () => {
writeFileSync(join(String(dir), ...names, "a.js"), formatted);
writeFileSync(join(String(dir), ...names, "b.js"), formatted);
const walked = await format(dir, []);
- expect(walked.stderr).not.toContain("[error]");
+ expect(walked.stderr).not.toMatch(anError);
expect(walked.stdout).toBe(`${names.join("/")}/a.js\n${names.join("/")}/b.js\n`);
expect(read(dir, ...names, "a.js")).toBe("a\n");
writeFileSync(join(String(dir), ...names, "b.js"), formatted);
@@ -5072,7 +6218,7 @@ describe("bun format on Windows, macOS and Linux", () => {
]),
).toEqual([["src/a.js"], ["src/a.js"], [`${share}/src/a.js`.replaceAll("\\", "/")]]);
const written = await format(share, []);
- expect(written.stderr).not.toContain("[error]");
+ expect(written.stderr).not.toMatch(anError);
expect(read(dir, "src", "a.js")).toBe("a\n");
expect(read(dir, "src", "ignored.js")).toBe(formatted);
expect(everythingIn(dir)).toEqual([".prettierignore", ".prettierrc", "src", "src/a.js", "src/ignored.js"]);
@@ -5089,7 +6235,7 @@ describe("bun format on Windows, macOS and Linux", () => {
});
const real = realpathSync(String(dir));
const { stderr, exitCode } = await format(`\\\\127.0.0.1\\${real[0]}$\\${real.slice(3)}`, ["a.js"]);
- expect(stderr).not.toContain("[error]");
+ expect(stderr).not.toMatch(anError);
expect(read(dir, "a.js")).toBe("a\n");
expect(exitCode).toBe(0);
},
@@ -5144,11 +6290,12 @@ describe("bun format on Windows, macOS and Linux", () => {
test("a file that is named in the other case is formatted if the system finds it", async () => {
using dir = tempDir("bun-format-platform", { "src/Button.js": ugly });
const foldsCase = existsSync(join(String(dir), "SRC", "bUTTON.JS"));
- const { stdout, exitCode } = await format(dir, [join("src", "Button.js"), join("SRC", "bUTTON.JS")]);
+ const { stdout, stderr, exitCode } = await format(dir, [join("src", "Button.js"), join("SRC", "bUTTON.JS")]);
expect(stdout.split("\n")[0]).toBe("src/Button.js");
expect(read(dir, "src", "Button.js")).toBe(formatted);
expect(everythingIn(dir)).toEqual(["src", "src/Button.js"]);
- expect(exitCode).toBe(foldsCase ? 0 : 2);
+ // With stderr, so that a failure says why.
+ expect({ stderr, exitCode }).toEqual({ stderr: expect.any(String), exitCode: foldsCase ? 0 : 2 });
});
// macOS finds `é` whether it is written as one character or as `e` and an accent.
@@ -5238,7 +6385,7 @@ describe("bun format on Windows, macOS and Linux", () => {
name === ".editorconfig" ? ["if (a) {\n b;\n}\n", "if (a) {\n\tb;\n}\n"] : [formatted, "a\n"];
using dir = tempDir("bun-format-platform", { [name]: crlf(text), "a.js": before });
const { stderr } = await format(dir, ["a.js"]);
- expect(stderr).not.toContain("[error]");
+ expect(stderr).not.toMatch(anError);
expect(read(dir, "a.js")).toBe(after);
});
});
@@ -5263,7 +6410,7 @@ describe("bun format on Windows, macOS and Linux", () => {
using dir = tempDir("bun-format-platform", { "real/a.js": ugly });
link(join(String(dir), "real"), join(String(dir), "linked"));
const { stderr, exitCode } = await format(dir, ["-l", "linked"]);
- expect(stderr).toContain('[error] Explicitly specified pattern "linked" is a symbolic link.');
+ expect(stderr).toContain('error: Explicitly specified pattern "linked" is a symbolic link.');
expect(exitCode).toBe(2);
});
@@ -5330,7 +6477,7 @@ describe("bun format on Windows, macOS and Linux", () => {
expect(handle).not.toBe(0xffffffffffffffffn);
try {
const { stderr, exitCode } = await format(dir, []);
- expect(stderr).not.toContain("[error]");
+ expect(stderr).not.toMatch(anError);
expect(read(dir, "a.js")).toBe(formatted);
expect(everythingIn(dir)).toEqual(["a.js"]);
expect(exitCode).toBe(0);
@@ -5396,8 +6543,8 @@ describe("bun format on Windows, macOS and Linux", () => {
});
});
-// A key of `[format]` is the default of the flag of the same name.
-describe.concurrent("[format] in bunfig.toml", () => {
+// A key of `[fmt]` is the default of the flag of the same name.
+describe.concurrent("[fmt] in bunfig.toml", () => {
/** What a run leaves behind: what it prints but for the times, how it ends, and the files. */
async function run(files: Record, args: string[]) {
const reads = Object.keys(files).filter(name => name !== "bunfig.toml");
@@ -5447,7 +6594,7 @@ describe.concurrent("[format] in bunfig.toml", () => {
test.each(options)("%s", async (key, value, other, name, source) => {
const files = { [name]: source };
- const bunfig = { "bunfig.toml": `[format]\n${key} = ${toml(value)}\n` };
+ const bunfig = { "bunfig.toml": `[fmt]\n${key} = ${toml(value)}\n` };
const rc = { ".prettierrc": JSON.stringify({ [key]: other }) };
const [plain, byKey, byFlag, underFlag, byOtherFlag, overFile, flagOverFile] = await Promise.all([
run(files, [name]),
@@ -5538,13 +6685,15 @@ describe.concurrent("[format] in bunfig.toml", () => {
];
test.each(others)("%s", async (line, flags, opposite, files, args) => {
- const bunfig = { "bunfig.toml": `[format]\n${line}\n` };
+ const bunfig = { "bunfig.toml": `[fmt]\n${line}\n` };
+ // bunfig.toml gets formatted too, so every run has one to keep the outputs comparable.
+ const empty = { "bunfig.toml": "# Nothing.\n" };
const [plain, byKey, byFlag, underFlag, byOtherFlag] = await Promise.all([
- run(files, args),
+ run({ ...files, ...empty }, args),
run({ ...files, ...bunfig }, args),
- run(files, [...flags, ...args]),
+ run({ ...files, ...empty }, [...flags, ...args]),
run({ ...files, ...bunfig }, [...opposite, ...args]),
- run(files, [...(opposite.length ? opposite : flags), ...args]),
+ run({ ...files, ...empty }, [...(opposite.length ? opposite : flags), ...args]),
]);
expect(byKey).toEqual(byFlag);
expect(byKey).not.toEqual(plain);
@@ -5554,19 +6703,19 @@ describe.concurrent("[format] in bunfig.toml", () => {
test("threads", async () => {
const files = { "a.js": ugly, "b.js": ugly };
const [byKey, byFlag, zero] = await Promise.all([
- run({ ...files, "bunfig.toml": "[format]\nthreads = 1\n" }, ["a.js", "b.js"]),
+ run({ ...files, "bunfig.toml": "[fmt]\nthreads = 1\n" }, ["a.js", "b.js"]),
run(files, ["--threads=1", "a.js", "b.js"]),
- run({ ...files, "bunfig.toml": "[format]\nthreads = 0\n" }, ["a.js", "b.js"]),
+ run({ ...files, "bunfig.toml": "[fmt]\nthreads = 0\n" }, ["a.js", "b.js"]),
]);
expect(byKey).toEqual(byFlag);
- expect(zero.stderr).toContain(`--threads takes a number above zero, not "0".`);
+ expect(zero.stderr).toContain(`--threads takes a number above zero, not "0"`);
expect(zero.exitCode).toBe(2);
});
test.each(["67108864", "9007199254740991"])("%s threads are as many as there can be", async count => {
const files = { "a.js": ugly, "b.js": ugly };
const [byKey, byFlag, few] = await Promise.all([
- run({ ...files, "bunfig.toml": `[format]\nthreads = ${count}\n` }, ["a.js", "b.js"]),
+ run({ ...files, "bunfig.toml": `[fmt]\nthreads = ${count}\n` }, ["a.js", "b.js"]),
run(files, [`--threads=${count}`, "a.js", "b.js"]),
run(files, ["--threads=1", "a.js", "b.js"]),
]);
@@ -5575,12 +6724,12 @@ describe.concurrent("[format] in bunfig.toml", () => {
});
test("a list on the command line is added to the list of the file", async () => {
- const files = { "a.js": ugly, "b.js": ugly, "c.js": ugly, "bunfig.toml": `[format]\nignorePatterns = ["b.js"]\n` };
+ const files = { "a.js": ugly, "b.js": ugly, "c.js": ugly, "bunfig.toml": `[fmt]\nignorePatterns = ["b.js"]\n` };
expect(await different(files, ["--ignore-pattern=c.js", "."])).toEqual(["a.js"]);
});
test("with configPrecedence = prefer-file the section counts only where there is no configuration file", async () => {
- const bunfig = `[format]\nconfigPrecedence = "prefer-file"\nsemi = false\n`;
+ const bunfig = `[fmt]\nconfigPrecedence = "prefer-file"\nsemi = false\n`;
const [alone, beside] = await Promise.all([
run({ "bunfig.toml": bunfig, "a.js": "a;\n" }, ["a.js"]),
run({ "bunfig.toml": bunfig, ".prettierrc": "{}", "a.js": "a;\n" }, ["a.js"]),
@@ -5589,7 +6738,7 @@ describe.concurrent("[format] in bunfig.toml", () => {
});
test("the file is that of the working directory, after --cwd", async () => {
- const files = { "bunfig.toml": "[format]\nsemi = false\n", "sub/bunfig.toml": "[format]\nsingleQuote = true\n" };
+ const files = { "bunfig.toml": "[fmt]\nsemi = false\n", "sub/bunfig.toml": "[fmt]\nsingleQuote = true\n" };
const source = { "a.js": `a("b");\n`, "sub/a.js": `a("b");\n` };
const [above, below, inside] = await Promise.all([
run({ ...files, ...source }, ["sub/a.js"]),
@@ -5617,9 +6766,9 @@ describe.concurrent("[format] in bunfig.toml", () => {
[`cwd = "sub"`, "--cwd"],
])("%s is refused, and nothing is written", async (line, flag) => {
const key = line.split(" ")[0];
- const result = await run({ "bunfig.toml": `[format]\n${line}\n`, "a.js": ugly }, ["a.js"]);
+ const result = await run({ "bunfig.toml": `[fmt]\n${line}\n`, "a.js": ugly }, ["a.js"]);
expect(result.stderr).toContain(
- `"${key}" cannot be set in bunfig.toml, it says what one run does. Pass ${flag} on the command line`,
+ `error: "${key}" cannot be set in bunfig.toml\n Use ${flag} on the command line\n`,
);
expect(result.files["a.js"]).toBe(ugly);
expect(result.exitCode).toBe(2);
@@ -5640,44 +6789,53 @@ describe.concurrent("[format] in bunfig.toml", () => {
[`flavor = "biome"`, `Invalid --flavor value. Expected "oxfmt" or "prettier", but received "biome".`],
[`logLevel = "loud"`, `Invalid --log-level value.`],
[`configPrecedence = "mine"`, `Invalid --config-precedence value.`],
- ["semicolons = false", `unknown key "semicolons" in [format]. Did you mean "semi"?`],
- ["printwidth = 80", `unknown key "printwidth" in [format]. Did you mean "printWidth"?`],
- [`plugins = ["a"]`, `unknown key "plugins" in [format].`],
- [`parser = "babel"`, `unknown key "parser" in [format].`],
- ["overrides = []", `unknown key "overrides" in [format].`],
+ ["semicolons = false", `Unknown key "semicolons" in [fmt]\n`],
+ ["printwidth = 80", `Unknown key "printwidth" in [fmt]\n Did you mean "printWidth"?`],
+ [`plugins = ["a"]`, `Unknown key "plugins" in [fmt]\n`],
+ [`parser = "babel"`, `Unknown key "parser" in [fmt]\n`],
])("%s is refused: %s", async (line, message) => {
- const result = await run({ "bunfig.toml": `[format]\n${line}\n`, "a.js": ugly }, ["a.js"]);
+ const result = await run({ "bunfig.toml": `[fmt]\n${line}\n`, "a.js": ugly }, ["a.js"]);
expect(result.stderr).toContain(message);
expect(result.files["a.js"]).toBe(ugly);
expect(result.exitCode).toBe(2);
});
test("a file that is not TOML", async () => {
- const result = await run({ "bunfig.toml": "[format\nsemi = false\n", "a.js": ugly }, ["a.js"]);
+ const result = await run({ "bunfig.toml": "[fmt\nsemi = false\n", "a.js": ugly }, ["a.js"]);
expect(result.files["a.js"]).toBe(ugly);
expect(result.exitCode).toBe(2);
});
- test("format that is no table", async () => {
- const result = await run({ "bunfig.toml": `format = "prettier"\n`, "a.js": ugly }, ["a.js"]);
+ test("fmt that is no table", async () => {
+ const result = await run({ "bunfig.toml": `fmt = "prettier"\n`, "a.js": ugly }, ["a.js"]);
expect(result.stderr).toContain("expected object but received string");
expect(result.exitCode).toBe(2);
});
test("every flag in the help is a key, or is refused as a key with its name", async () => {
- const help = await format({}, ["--help"]);
+ const help = await format({}, ["--help", "--all"]);
const flags = [...help.stdout.matchAll(/^\s+(?:-\w, )?--([a-z-]+)/gm)].map(it => it[1]);
- expect(flags.length).toBeGreaterThan(40);
+ expect(flags.length).toBeGreaterThan(60);
const answers = await Promise.all(
flags.map(async flag => {
const positive = flag.replace(/^no-/, "");
const key =
positive === "ignore-pattern" ? "ignorePatterns" : positive.replace(/-(\w)/g, (_, it) => it.toUpperCase());
// Of a type that no key takes: one that exists says what it expects.
- const { stderr } = await run({ "bunfig.toml": `[format]\n${key} = {}\n` }, ["--list-files"]);
- return [flag, /expected \w+ but received object|cannot be set in bunfig\.toml/.test(stderr)];
+ const { stderr } = await run({ "bunfig.toml": `[fmt]\n${key} = [[]]\n` }, ["--list-files"]);
+ return [flag, /expected [\w ]+ but received array|cannot be set in bunfig\.toml/.test(stderr)];
}),
);
- expect(answers.filter(it => !it[1])).toEqual([]);
+ // Prettier and oxfmt flags that aren't project settings, or that do nothing.
+ expect(answers.filter(it => !it[1]).map(it => it[0])).toEqual([
+ "parser",
+ "plugin",
+ "jsx-bracket-same-line",
+ "cache",
+ "cache-location",
+ "cache-strategy",
+ "experimental-cli",
+ "lsp",
+ ]);
});
});
diff --git a/test/cli/format/glob.test.ts b/test/cli/format/glob.test.ts
new file mode 100644
index 000000000000..2123534ad327
--- /dev/null
+++ b/test/cli/format/glob.test.ts
@@ -0,0 +1,216 @@
+import { afterAll, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+const env = { ...bunEnv, AGENT: "0", CLAUDECODE: undefined, GITHUB_ACTIONS: undefined };
+const ugly = "if (a) {\nb( 1 )\n}\n";
+
+async function format(files: Record, args: string[], stdin?: string) {
+ using dir = tempDir("bun-format-glob", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "fmt", ...args],
+ env,
+ cwd: String(dir),
+ stdin: stdin === undefined ? "ignore" : Buffer.from(stdin),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const names = [
+ "a.js",
+ "a.cjs",
+ "a.mjs",
+ "a.ts",
+ "src/a.js",
+ "src/b.ts",
+ "src/x/d.js",
+ "src/x/e.tsx",
+ "lib/f.js",
+ "lib/deep/g.js",
+ "lib/deep/h.min.js",
+ "sub/i.js",
+];
+const project = { ...Object.fromEntries(names.map(name => [name, ugly])), ".prettierrc.json": "{}" };
+
+// The expected files come from Prettier 3.9.
+test.concurrent.each([
+ ["src/**/*.@(js|ts)", "src/a.js src/b.ts src/x/d.js"],
+ ["{a,src/x/*}.?(c)js", "a.cjs a.js src/x/d.js"],
+ ["lib/!(deep)*.js", "lib/f.js"],
+ ["**/+(a|d).js", "a.js src/a.js src/x/d.js"],
+ // Prettier also treats parentheses without a prefix as a group.
+ ["(src|lib)/*.js", "lib/f.js src/a.js"],
+ // `a/**` also matches `a` itself.
+ ["lib/*/**", "lib/deep/g.js lib/deep/h.min.js lib/f.js"],
+])("the command line pattern %s lists the same files as Prettier", async (pattern, expected) => {
+ const { stdout, exitCode } = await format(project, ["-l", pattern]);
+ expect(stdout.trim().split("\n").sort().join(" ")).toBe(expected);
+ expect(exitCode).toBe(1);
+});
+
+test.concurrent("extglob patterns work in `files` and `excludeFiles` of Prettier overrides", async () => {
+ const overrides = [
+ { files: "*.?(c|m)js", options: { semi: false } },
+ { files: "src/**/*.@(ts|tsx)", options: { tabWidth: 8 } },
+ { files: "lib/!(deep)/**", options: { tabWidth: 1 } },
+ { files: ["lib/+(deep|x)/*.js"], excludeFiles: "**/*.min.js", options: { useTabs: true } },
+ ];
+ const files = { ".prettierrc.json": JSON.stringify({ overrides }) };
+ const second = async (name: string) => (await format(files, ["--stdin-filepath", name], ugly)).stdout.split("\n")[1];
+ expect(Object.fromEntries(await Promise.all(names.map(async name => [name, await second(name)])))).toEqual({
+ "a.js": " b(1)",
+ "a.cjs": " b(1)",
+ "a.mjs": " b(1)",
+ "a.ts": " b(1);",
+ "src/a.js": " b(1)",
+ "src/b.ts": " b(1);",
+ "src/x/d.js": " b(1)",
+ "src/x/e.tsx": " b(1);",
+ "lib/f.js": " b(1)",
+ "lib/deep/g.js": "\tb(1)",
+ "lib/deep/h.min.js": " b(1)",
+ "sub/i.js": " b(1)",
+ });
+});
+
+test.concurrent.each([
+ // Braces without a comma are literal.
+ ["{a.js}", "a.js", " "],
+ ["{a.js,b.js}", "a.js", " "],
+ ["*.{js}", "a.js", " "],
+ // `**` crosses `/` anywhere in the section name.
+ ["**.js", "lib/deep/a.js", " "],
+ ["lib/**.js", "lib/deep/a.js", " "],
+ ["lib/**.js", "a.js", " "],
+ ["li**a.js", "lib/deep/a.js", " "],
+ ["li**/a.js", "lib/deep/a.js", " "],
+ ["li**", "lib/deep/a.js", " "],
+ ["lib/*.js", "lib/deep/a.js", " "],
+ // A section without `/` matches in any directory.
+ ["a.js", "lib/deep/a.js", " "],
+ ["/a.js", "lib/deep/a.js", " "],
+])(".editorconfig section [%s] with %s behaves like Prettier", async (section, name, indent) => {
+ const files = { ".prettierrc.json": "{}", ".editorconfig": `root = true\n[${section}]\nindent_size = 4\n` };
+ const { stdout, exitCode } = await format(files, ["--stdin-filepath", name], ugly);
+ expect(stdout).toBe(`if (a) {\n${indent}b(1);\n}\n`);
+ expect(exitCode).toBe(0);
+});
+
+const numbered = [
+ "0",
+ "1",
+ "2",
+ "3",
+ "4",
+ "9",
+ "10",
+ "11",
+ "15",
+ "20",
+ "01",
+ "02",
+ "03",
+ "001",
+ "-1",
+ "a",
+ "b",
+ "c",
+ "d",
+];
+
+// The expected results come from Prettier 3.9. fast-glob expands `{1..3}` to 1, 2 and 3. micromatch turns it into the class `[1-3]`.
+test.concurrent.each([
+ ["x{1..3}.js", "1 2 3", "1 2 3"],
+ ["x{3..1}.js", "1 2 3", "1 2 3"],
+ ["x{01..03}.js", "01 02 03", ""],
+ ["x{1..10}.js", "1 10 2 3 4 9", "0 1"],
+ ["x{10..20}.js", "10 11 15 20", "0 1 2"],
+ ["x{1..9..2}.js", "1 3 9", "1 2 9"],
+ ["x{a..c}.js", "a b c", "a b c"],
+ ["x{c..a}.js", "a b c", "a b c"],
+ ["x{-1..1}.js", "-1 0 1", "1"],
+ ["x{a}.js", "", ""],
+])("%s behaves like Prettier on the command line and in an override", async (pattern, listed, overridden) => {
+ const files = Object.fromEntries(numbered.map(it => [`x${it}.js`, "a( 1 )\n"]));
+ const names = (text: string) =>
+ text
+ .split(" ")
+ .filter(Boolean)
+ .map(it => `x${it}.js`)
+ .sort();
+ const { stdout } = await format({ ...files, ".prettierrc.json": "{}" }, ["-l", pattern]);
+ expect(stdout.trim().split("\n").filter(Boolean).sort()).toEqual(names(listed));
+
+ const config = { ".prettierrc.json": JSON.stringify({ overrides: [{ files: pattern, options: { semi: false } }] }) };
+ const printed = await Promise.all(
+ numbered.map(async it => [
+ `x${it}.js`,
+ (await format(config, ["--stdin-filepath", `x${it}.js`], "a( 1 )\n")).stdout,
+ ]),
+ );
+ expect(
+ printed
+ .filter(it => it[1] === "a(1)\n")
+ .map(it => it[0])
+ .sort(),
+ ).toEqual(names(overridden));
+});
+
+test.concurrent.each([
+ ["{1..3}.js", "2.js", " "],
+ ["{1..3}.js", "4.js", " "],
+ ["{1..3}.js", "02.js", " "],
+ ["{01..03}.js", "02.js", " "],
+ ["{-1..1}.js", "-1.js", " "],
+ ["{3..1}.js", "2.js", " "],
+ ["v{1..2}/*.js", "v2/a.js", " "],
+])(".editorconfig number range [%s] with %s behaves like Prettier", async (section, name, indent) => {
+ const files = { ".prettierrc.json": "{}", ".editorconfig": `root = true\n[${section}]\nindent_size = 4\n` };
+ const { stdout, exitCode } = await format(files, ["--stdin-filepath", name], ugly);
+ expect(stdout).toBe(`if (a) {\n${indent}b(1);\n}\n`);
+ expect(exitCode).toBe(0);
+});
+
+// The expected files come from Prettier 3.9. Its `ignore` package looks for a `/` before it trims the line, so `a/ ` is anchored.
+test.concurrent.each([
+ ["a/", "z.js"],
+ ["a/ ", "sub/a/y.js z.js"],
+ ["a ", "z.js"],
+])("the .prettierignore line %j ignores the same files as Prettier", async (line, expected) => {
+ const files = {
+ "a/x.js": ugly,
+ "sub/a/y.js": ugly,
+ "z.js": ugly,
+ ".prettierrc.json": "{}\n",
+ ".prettierignore": `${line}\n`,
+ };
+ const { stdout, exitCode } = await format(files, ["-l", "."]);
+ expect(stdout.trim().split("\n").sort().join(" ")).toBe(expected);
+ expect(exitCode).toBe(1);
+});
+
+// The expected files come from Prettier 3.9. To its `ignore` package the `**` in `build/**/` can stand for nothing, so the line is
+// about `build` itself. git reads it differently: there `build/a.js` isn't ignored.
+test.concurrent.each([
+ ["build/**/", "a.js a/f.js ab.js src/build/d.js src/e.js"],
+ ["**/build/**/", "a.js a/f.js ab.js src/e.js"],
+ ["build/", "a.js a/f.js ab.js src/e.js"],
+ ["build/**", "a.js a/f.js ab.js src/build/d.js src/e.js"],
+ ["build/**/x/", "a.js a/f.js ab.js build/a.js build/sub/b.js src/build/d.js src/e.js"],
+ ["a**/**", "a.js ab.js build/a.js build/sub/b.js build/sub/x/c.js src/build/d.js src/e.js"],
+])("the .prettierignore line %j with ** ignores the same files as Prettier", async (line, expected) => {
+ const names = "build/a.js build/sub/b.js build/sub/x/c.js src/build/d.js src/e.js a.js a/f.js ab.js".split(" ");
+ const files = {
+ ...Object.fromEntries(names.map(name => [name, ugly])),
+ ".prettierrc.json": "{}\n",
+ ".prettierignore": `${line}\n`,
+ };
+ const { stdout, exitCode } = await format(files, ["-l", "."]);
+ expect(stdout.trim().split("\n").sort().join(" ")).toBe(expected);
+ expect(exitCode).toBe(1);
+});
diff --git a/test/cli/format/line-endings.cases.ts b/test/cli/format/line-endings.cases.ts
index 342c61d9c31f..b1e9d8a819c6 100644
--- a/test/cli/format/line-endings.cases.ts
+++ b/test/cli/format/line-endings.cases.ts
@@ -1,4 +1,4 @@
-// Small inputs in every language that `bun format` reads, with line breaks wherever they mean something: in comments, in
+// Small inputs in every language that `bun fmt` reads, with line breaks wherever they mean something: in comments, in
// `prettier-ignore`d code, in strings, templates and block scalars, in embedded code, between things that keep an empty line.
// They are written with \n. `format.test.ts` gives them other line breaks and a byte order mark.
export const inputs: Record = {
diff --git a/test/cli/format/oracle/fuzz/README.md b/test/cli/format/oracle/fuzz/README.md
index f17738b2a3c5..e9ce0b801ac6 100644
--- a/test/cli/format/oracle/fuzz/README.md
+++ b/test/cli/format/oracle/fuzz/README.md
@@ -1,8 +1,8 @@
# Fuzzers
-They run `bun format` on texts that they make, and ask the npm package of Prettier about each. Neither runs in CI: they need Prettier.
+They run `bun fmt` on texts that they make, and ask the npm package of Prettier about each. Neither runs in CI: they need Prettier.
| file | what it makes |
| --- | --- |
-| `handlebars/damage.ts` | Handlebars: the templates whose syntax tree, as Prettier compares trees in its own tests, is another one after formatting, and of which `bun format` does not say that it would damage them |
-| `near.ts` | every language: Prettier's fixtures, or real files (`--files`), each a little changed: a token deleted, doubled, swapped with the next, or the text cut off: a file while it is typed. It runs `bun format --write` itself, with its checks, and asks Prettier, or oxfmt (`--oxfmt`), with the defaults or a set of options (`--options`). Two tables: how many have the same bytes, and which check refused what the other tool prints, rightly or not. `bun near.ts --command="bun format" --prettier= --language=js` (`css`, `yaml`, `graphql`, `json`, `handlebars`, `markdown`, `html`) |
+| `handlebars/damage.ts` | Handlebars: the templates whose syntax tree, as Prettier compares trees in its own tests, is another one after formatting, and of which `bun fmt` does not say that it would damage them |
+| `near.ts` | every language: Prettier's fixtures, or real files (`--files`), each a little changed: a token deleted, doubled, swapped with the next, or the text cut off: a file while it is typed. It runs `bun fmt --write` itself, with its checks, and asks Prettier, or oxfmt (`--oxfmt`), with the defaults or a set of options (`--options`). Two tables: how many have the same bytes, and which check refused what the other tool prints, rightly or not. `bun near.ts --command="bun fmt" --prettier= --language=js` (`css`, `yaml`, `graphql`, `json`, `handlebars`, `markdown`, `html`) |
diff --git a/test/cli/format/oracle/fuzz/handlebars/damage.ts b/test/cli/format/oracle/fuzz/handlebars/damage.ts
index 43a0eb335cd6..5f98130eb2cb 100644
--- a/test/cli/format/oracle/fuzz/handlebars/damage.ts
+++ b/test/cli/format/oracle/fuzz/handlebars/damage.ts
@@ -1,8 +1,8 @@
-// Prettier changes what some templates mean. `bun format` prints the same, but says so and leaves the file alone. This looks for templates
+// Prettier changes what some templates mean. `bun fmt` prints the same, but says so and leaves the file alone. This looks for templates
// that it does not say it of: those whose syntax tree, as Prettier compares trees in its own tests, is another one after formatting, or that
// cannot be parsed any more.
//
-// bun damage.ts "bun format" [-show=10] [-told]
+// bun damage.ts "bun fmt" [-show=10] [-told]
//
// `-told`: also prints the templates that it says it of although the trees are the same: what the parsers drop is in neither tree.
import { readFileSync, readdirSync } from "node:fs";
diff --git a/test/cli/format/oracle/fuzz/near.ts b/test/cli/format/oracle/fuzz/near.ts
index d02023c81424..276f01a89a09 100644
--- a/test/cli/format/oracle/fuzz/near.ts
+++ b/test/cli/format/oracle/fuzz/near.ts
@@ -1,8 +1,8 @@
// Texts that are nearly normal: Prettier's fixtures, or real files, each a little changed: a token deleted, two neighbours deleted, a token
-// doubled, swapped with the next, or the text cut off after it. That is what a file looks like while it is typed. `bun format --write` runs on
+// doubled, swapped with the next, or the text cut off after it. That is what a file looks like while it is typed. `bun fmt --write` runs on
// them, with the checks that it makes before it writes, and the npm package of Prettier, or oxfmt, is asked about each.
//
-// bun near.ts --command="bun format" --prettier= --language=css
+// bun near.ts --command="bun fmt" --prettier= --language=css
// [--oxfmt=] the flavor of oxfmt, against oxfmt
// [--options] each text with one of SETS in the place of the defaults
// [--files=] real files in the place of the fixtures, one change each. More than once: more directories
@@ -14,7 +14,7 @@
// Languages: js (with jsx, ts, tsx), css (with less, scss), yaml, graphql, json, handlebars, markdown (with mdx), html (with vue, angular, mjml).
// Nothing is stored: what is expected is asked when it is run. The same seed makes the same texts.
//
-// It prints two tables. The second is about refusals: `bun format` leaves a file alone if what it has printed does not say what the file says.
+// It prints two tables. The second is about refusals: `bun fmt` leaves a file alone if what it has printed does not say what the file says.
// Where the other tool prints something, that is a true alarm if the other tool has lost or added a letter or a digit (in HTML and Handlebars also
// a `<` or a `{`), and a false one if not.
import { spawnSync } from "node:child_process";
@@ -82,7 +82,7 @@ if (process.argv[2] == "--child") {
const endings = ENDINGS[language];
if (!endings || !flags.has("command") || !(flags.has("prettier") || isOxfmt)) {
throw new Error(
- `usage: bun near.ts --command="bun format" --prettier= --language=<${Object.keys(ENDINGS).join("|")}> ..`,
+ `usage: bun near.ts --command="bun fmt" --prettier= --language=<${Object.keys(ENDINGS).join("|")}> ..`,
);
}
@@ -310,7 +310,7 @@ if (process.argv[2] == "--child") {
if (flags.has("texts") && ours !== undefined && expected !== undefined)
writeFileSync(join(flag("texts"), name), text);
if (verdict == "only we refuse: a check") {
- const key = `${ending} | ${refusal!.replace(/\. It is left as it is.*$/, "")}`;
+ const key = `${ending} | ${refusal!.replace(/\. It was not formatted.*$/, "")}`;
const alarm = alarms.get(key) ?? { texts: 0, isTrue: 0 };
alarms.set(key, alarm);
alarm.texts++;
diff --git a/test/cli/format/oracle/sort-imports/make-fixtures.mjs b/test/cli/format/oracle/sort-imports/make-fixtures.mjs
index 2d1251315ca1..ecbd193ab792 100644
--- a/test/cli/format/oracle/sort-imports/make-fixtures.mjs
+++ b/test/cli/format/oracle/sort-imports/make-fixtures.mjs
@@ -1,10 +1,10 @@
// Makes test/cli/format/sort-imports/*.json of the cases that fixtures.mjs, fuzz.mjs and oxfmt.mjs make.
//
-// node make-fixtures.mjs --out= --sample=150 [--bin="bun format"]
+// node make-fixtures.mjs --out= --sample=150 [--bin="bun fmt"]
//
// All cases of the tools' own tests are taken, and of the others (`fuzz/..`) every n-th, so that `--sample` are left of
-// each file. Left out: what the tool itself fails on, syntax that bun format does not read, and, of the cases for oxfmt,
-// those that bun format and oxfmt format differently without sorting imports (`plain`): they are not about imports.
+// each file. Left out: what the tool itself fails on, syntax that bun fmt does not read, and, of the cases for oxfmt,
+// those that bun fmt and oxfmt format differently without sorting imports (`plain`): they are not about imports.
import { spawnSync } from "node:child_process";
import fs from "node:fs";
import os from "node:os";
@@ -28,7 +28,7 @@ for (const file of positional) {
{ ...it, options, output: it.plain },
{ ...it, options, input: it.output },
]);
- const [bin, ...args] = (named.bin ?? "bun format").split(" ");
+ const [bin, ...args] = (named.bin ?? "bun fmt").split(" ");
const differs = new Set();
// One run for all the cases with the same options.
for (const [options, group] of Map.groupBy(plain, it => JSON.stringify(it.options))) {
@@ -48,7 +48,7 @@ for (const file of positional) {
for (const [index, it] of cases.entries()) {
if (index % step !== 0 || UNSUPPORTED.some(pattern => pattern.test(it.name)) || /\bassert\s*\{/.test(it.input) || REFUSED.test(it.input)) continue;
const { parser, flavor, ...options } = it.options;
- // `bun format` refuses the syntax of TypeScript in a JavaScript file, as Prettier does, unless such a parser is asked for.
+ // `bun fmt` refuses the syntax of TypeScript in a JavaScript file, as Prettier does, unless such a parser is asked for.
if (/\.[cm]?jsx?$/.test(it.filename) && ["typescript", "babel-ts", "flow", "babel-flow"].includes(parser) && /^tests\/(Angular|Typescript)/.test(it.name)) {
options.overrides = [{ files: "*.js", options: { parser } }];
}
diff --git a/test/cli/format/oracle/sort-imports/oxfmt.mjs b/test/cli/format/oracle/sort-imports/oxfmt.mjs
index daa8ca27254d..da4811f9600d 100644
--- a/test/cli/format/oracle/sort-imports/oxfmt.mjs
+++ b/test/cli/format/oracle/sort-imports/oxfmt.mjs
@@ -5,7 +5,7 @@
//
// - `tests`: every `assert_format(input, config, expected)` of crates/oxc_formatter/tests/ir_transform/sort_imports/*.rs.
// - `tokens`, `lines`: as in fuzz.mjs.
-// A case also has `plain`: what oxfmt prints without `sortImports`. Where bun format and oxfmt differ on that, the
+// A case also has `plain`: what oxfmt prints without `sortImports`. Where bun fmt and oxfmt differ on that, the
// difference is not about imports.
import fs from "node:fs";
import { createRequire } from "node:module";
diff --git a/test/cli/format/own/README.md b/test/cli/format/own/README.md
index b9cedef67092..f46e2dfbb73e 100644
--- a/test/cli/format/own/README.md
+++ b/test/cli/format/own/README.md
@@ -1,9 +1,9 @@
# Inputs of our own
-Small programs on which `bun format` once differed from Prettier, and which no test of Prettier or of oxfmt has: most were found in real code. They are in the form of oxfmt's tests (`../oxfmt/README.md`), as plain files:
+Small programs on which `bun fmt` once differed from Prettier, and which no test of Prettier or of oxfmt has: most were found in real code. They are in the form of oxfmt's tests (`../oxfmt/README.md`), as plain files:
- `cases/**/.input`: the input. `` says what language it is. `.input` keeps everything else from taking it for code.
-- `.prettier.snap`: what Prettier prints, which is what `bun format` has to print.
+- `.prettier.snap`: what Prettier prints, which is what `bun fmt` has to print.
- `.snap`: what oxfmt prints, which is what it has to print for whoever has an `.oxfmtrc.json`. Where it does not yet, the file is called `.snap.todo` and is not compared.
- `options.json`: the sets of options for the inputs of a directory. Each is run at `printWidth` 80 and 100 too.
@@ -13,4 +13,6 @@ To add one, write the input and run `sync.ts`, which asks both:
bun test/cli/format/own/sync.ts
```
-**Nothing here fails**, so there is no list of what is expected to: `../conformance.test.ts` wants no line that starts with `FAIL`. An input comes in the commit that makes `bun format` print what Prettier prints for it. If the runner says `FAIL oxfmt` for it, rename its `.snap` to `.snap.todo`.
+**Nothing here fails**, so there is no list of what is expected to: `../conformance.test.ts` wants no line that starts with `FAIL`. An input comes in the commit that makes `bun fmt` print what Prettier prints for it. If the runner says `FAIL oxfmt` for it, rename its `.snap` to `.snap.todo`.
+
+**What `bun fmt` prints differently on purpose is not here.** Where what Prettier or oxfmt prints means something else than the input, `bun fmt` prints the right thing. Such an input is a row in `../format.test.ts`, with what `bun fmt` prints and what the tool prints.
diff --git a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.input b/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.input
deleted file mode 100644
index 589cb3104b36..000000000000
--- a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.input
+++ /dev/null
@@ -1 +0,0 @@
-{{[].a}} {{[]/a}} {{@[].a}} {{a.[]}} {{a [].b c=[].d}}
diff --git a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.prettier.snap b/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.prettier.snap
deleted file mode 100644
index e1d7b2bac77a..000000000000
--- a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.prettier.snap
+++ /dev/null
@@ -1,9 +0,0 @@
-------------------
-{ printWidth: 80 }
-------------------
-{{a}} {{a}} {{@a}} {{a.}} {{a b c=d}}
--------------------
-{ printWidth: 100 }
--------------------
-{{a}} {{a}} {{@a}} {{a.}} {{a b c=d}}
-===================== End =====================
diff --git a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.snap b/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.snap
deleted file mode 100644
index e1d7b2bac77a..000000000000
--- a/test/cli/format/own/cases/handlebars/an-empty-first-segment.hbs.snap
+++ /dev/null
@@ -1,9 +0,0 @@
-------------------
-{ printWidth: 80 }
-------------------
-{{a}} {{a}} {{@a}} {{a.}} {{a b c=d}}
--------------------
-{ printWidth: 100 }
--------------------
-{{a}} {{a}} {{@a}} {{a.}} {{a b c=d}}
-===================== End =====================
diff --git a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.input b/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.input
deleted file mode 100644
index 0a56949794ff..000000000000
--- a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.input
+++ /dev/null
@@ -1,5 +0,0 @@
-a
-
{{~! b ~}}
-
{{! prettier-ignore }} {{ i }} {{!-- j --~}}
-{{k
-
l}} {{~! m }}
diff --git a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.prettier.snap b/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.prettier.snap
deleted file mode 100644
index 794f461f0a26..000000000000
--- a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.prettier.snap
+++ /dev/null
@@ -1,23 +0,0 @@
-------------------
-{ printWidth: 80 }
-------------------
-a
{{! b }}
-
-
-
{{! prettier-ignore }
- {{ i }
-{{! j }}
-{{k l}}
-{{! m }}
--------------------
-{ printWidth: 100 }
--------------------
-a
{{! b }}
-
-
-
{{! prettier-ignore }
- {{ i }
-{{! j }}
-{{k l}}
-{{! m }}
-===================== End =====================
diff --git a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.snap b/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.snap
deleted file mode 100644
index 794f461f0a26..000000000000
--- a/test/cli/format/own/cases/handlebars/columns-behind-a-line-separator.hbs.snap
+++ /dev/null
@@ -1,23 +0,0 @@
-------------------
-{ printWidth: 80 }
-------------------
-a
{{! b }}
-
-
-
{{! prettier-ignore }
- {{ i }
-{{! j }}
-{{k l}}
-{{! m }}
--------------------
-{ printWidth: 100 }
--------------------
-a
{{! b }}
-
-
-
{{! prettier-ignore }
- {{ i }
-{{! j }}
-{{k l}}
-{{! m }}
-===================== End =====================
diff --git a/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.input b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.input
new file mode 100644
index 000000000000..4ea2e146ce5b
--- /dev/null
+++ b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.input
@@ -0,0 +1,11 @@
+{{@a/b}} {{a.[b].[c d]}}
+{{&a}}
+{{1.50}} {{-0}} {{007}}
+{{^a}}b{{else}}c{{/a}} {{#a}}b{{^}}c{{/a}}
+ {{> b}} {{/if}} -->
+![]()
+a\{{b}} c\\{{d}} e\\\{{f}}
+{{#a}}{{else}}{{#if b}}{{/if}}{{/a}} {{#a}}{{else b}}{{else a}}{{/a}} {{#a}}{{~else b~}}c{{~/a~}}
+{{a "b\"c" 'd\'e' g="h'i\"j"}}
+<b>
+{{a "f\"}}
diff --git a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.prettier.snap b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.prettier.snap
similarity index 69%
rename from test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.prettier.snap
rename to test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.prettier.snap
index 77425422ed59..004909a840fc 100644
--- a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.prettier.snap
+++ b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.prettier.snap
@@ -1,38 +1,20 @@
------------------
{ printWidth: 80 }
------------------
-
-{{a}}
-{{this.this}}
-{{this}}
-{{a b}}
-{{a/b}}
-{{a.[#b]}}
{{@a/b}}
{{a.b.[c d]}}
{{{a}}}
-{{"a"}}
-{{ c}}
-{{a ( d)}}
{{1.5}}
{{0}}
{{7}}
-{{1.2345678901234568e+29}}
-{{1e-7}}
{{#a}}c{{else}}b{{/a}}
{{#a}}b{{else}}c{{/a}}
-{{#raw a}} \{{c}} {{/raw}}
-
-{{a}}
-{{b}}
{{> b}} {{/if}} -->
-b
![]()
a\{{b}} c\\{{d}}
e\\\{{f}}
-
{{#a}}{{else if b}}{{/a}}
{{#a}}{{else}}{{#b}}{{else}}{{#a}}{{/a}}{{/b}}{{/a}}
{{#a}}{{~else~}}{{~#b~}}c{{~/b~}}{{~/a~}}
@@ -48,38 +30,20 @@ e\\\{{f}}
-------------------
{ printWidth: 100 }
-------------------
-
-{{a}}
-{{this.this}}
-{{this}}
-{{a b}}
-{{a/b}}
-{{a.[#b]}}
{{@a/b}}
{{a.b.[c d]}}
{{{a}}}
-{{"a"}}
-{{ c}}
-{{a ( d)}}
{{1.5}}
{{0}}
{{7}}
-{{1.2345678901234568e+29}}
-{{1e-7}}
{{#a}}c{{else}}b{{/a}}
{{#a}}b{{else}}c{{/a}}
-{{#raw a}} \{{c}} {{/raw}}
-
-{{a}}
-{{b}}
{{> b}} {{/if}} -->
-b
![]()
a\{{b}} c\\{{d}}
e\\\{{f}}
-
{{#a}}{{else if b}}{{/a}}
{{#a}}{{else}}{{#b}}{{else}}{{#a}}{{/a}}{{/b}}{{/a}}
{{#a}}{{~else~}}{{~#b~}}c{{~/b~}}{{~/a~}}
diff --git a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.snap b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.snap
similarity index 69%
rename from test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.snap
rename to test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.snap
index 77425422ed59..004909a840fc 100644
--- a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.snap
+++ b/test/cli/format/own/cases/handlebars/what-the-parsers-change.hbs.snap
@@ -1,38 +1,20 @@
------------------
{ printWidth: 80 }
------------------
-
-{{a}}
-{{this.this}}
-{{this}}
-{{a b}}
-{{a/b}}
-{{a.[#b]}}
{{@a/b}}
{{a.b.[c d]}}
{{{a}}}
-{{"a"}}
-{{ c}}
-{{a ( d)}}
{{1.5}}
{{0}}
{{7}}
-{{1.2345678901234568e+29}}
-{{1e-7}}
{{#a}}c{{else}}b{{/a}}
{{#a}}b{{else}}c{{/a}}
-{{#raw a}} \{{c}} {{/raw}}
-
-{{a}}
-{{b}}
{{> b}} {{/if}} -->
-b
![]()
a\{{b}} c\\{{d}}
e\\\{{f}}
-
{{#a}}{{else if b}}{{/a}}
{{#a}}{{else}}{{#b}}{{else}}{{#a}}{{/a}}{{/b}}{{/a}}
{{#a}}{{~else~}}{{~#b~}}c{{~/b~}}{{~/a~}}
@@ -48,38 +30,20 @@ e\\\{{f}}
-------------------
{ printWidth: 100 }
-------------------
-
-{{a}}
-{{this.this}}
-{{this}}
-{{a b}}
-{{a/b}}
-{{a.[#b]}}
{{@a/b}}
{{a.b.[c d]}}
{{{a}}}
-{{"a"}}
-{{ c}}
-{{a ( d)}}
{{1.5}}
{{0}}
{{7}}
-{{1.2345678901234568e+29}}
-{{1e-7}}
{{#a}}c{{else}}b{{/a}}
{{#a}}b{{else}}c{{/a}}
-{{#raw a}} \{{c}} {{/raw}}
-
-{{a}}
-{{b}}
{{> b}} {{/if}} -->
-b
![]()
a\{{b}} c\\{{d}}
e\\\{{f}}
-
{{#a}}{{else if b}}{{/a}}
{{#a}}{{else}}{{#b}}{{else}}{{#a}}{{/a}}{{/b}}{{/a}}
{{#a}}{{~else~}}{{~#b~}}c{{~/b~}}{{~/a~}}
diff --git a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.input b/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.input
deleted file mode 100644
index 8e82ba90e251..000000000000
--- a/test/cli/format/own/cases/handlebars/what-the-parsers-drop-and-change.hbs.input
+++ /dev/null
@@ -1,14 +0,0 @@
-
-
-{{this/a}} {{[this]}} {{this.this}} {{a ...b}} {{[a/b]}} {{a.#b}} {{@a/b}} {{a.[b].[c d]}}
-{{&a}} {{"a" b c=d}} {{(a=b) c}} {{a ((b=c) d)}}
-{{1.50}} {{-0}} {{007}} {{123456789012345678901234567890}} {{0.0000001}}
-{{^a}}b{{else}}c{{/a}} {{#a}}b{{^}}c{{/a}}
-{{{{raw a}}}} {{c}} {{{{/raw}}}}
- {{> b}} {{/if}} -->
-< a>b ![]()
-a\{{b}} c\\{{d}} e\\\{{f}}
-{{#a}}{{else}}{{#if b}}{{/if}}{{/a}} {{#a}}{{else b}}{{else a}}{{/a}} {{#a}}{{~else b~}}c{{~/a~}}
-{{a "b\"c" 'd\'e' g="h'i\"j"}}
-<b>
-{{a "f\"}}
diff --git a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.input b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.input
deleted file mode 100644
index 9948bc97cb33..000000000000
--- a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.input
+++ /dev/null
@@ -1,7 +0,0 @@
-a = html`<${t} >`;
-b = html`<${t} ${a}>x`;
-c = html``;
-d = html`<${t} ${a}>x`;
-e = open ? html`<${t} ${a}>` : html`<${t} ${a}>${k}`;
-f = html`<${t} ${a} />`;
-g = html`
{{/if}}\n", "Unclosed element (1:10)"],
+ ["comment.hbs", "{{!-- a\n", "Unclosed comment (1:1)"],
+ ["short-comment.hbs", "{{! a\n", "Unclosed comment (1:1)"],
+ ["string.hbs", '{{a "b}}\n', "Unclosed string (1:5)"],
+ ["segment.hbs", "{{a [b}}\n", "Unclosed bracket (1:5)"],
["path.hbs", "{{a/../b}}\n", '"..", "." and "this" can only be at the start of a path (1:8)'],
["params.hbs", "{{#each a as ||}}{{/each}}\n", "Expected a name (1:15)"],
- ["tag-params.hbs", "\n\n", "These block parameters cannot be read (1:9)"],
+ ["tag-params.hbs", "\n\n", "Invalid block parameters (1:9)"],
["attribute.hbs", '\n', "An end tag cannot have attributes (1:12)"],
- ["self-closing.hbs", "\n", "An end tag cannot close itself (1:6)"],
- ["unquoted.hbs", "\n", "A value with a mustache and text in it needs quotes (1:8)"],
- ["tag-name.hbs", "<{{a}}>\n", "A mustache cannot be here (1:2)"],
+ ["self-closing.hbs", "\n", "An end tag cannot be self-closing (1:6)"],
+ [
+ "unquoted.hbs",
+ "\n",
+ "An attribute value that mixes text and a mustache needs quotes (1:8)",
+ ],
+ ["tag-name.hbs", "<{{a}}>\n", "A mustache is not allowed here (1:2)"],
["equals.hbs", "\n", "Unexpected character (1:6)"],
["sexpr.hbs", "{{a (b}}\n", 'Expected ")" (1:7)'],
- ["doctype.hbs", "\n", "This doctype cannot be read (1:20)"],
+ ["doctype.hbs", "\n", "Invalid doctype (1:20)"],
["close.hbs", "{{a b=c d}}\n", 'Expected "}}" (1:9)'],
- ["mustache-comment.hbs", "\n", "A comment cannot be here (1:8)"],
- ["raw.hbs", "{{{{a}}}} b\n", "This block is not closed (1:10)"],
- ["colon.hbs", "<:>\n", "This is not the name of an element (1:1)"],
+ ["mustache-comment.hbs", "\n", "A comment is not allowed here (1:8)"],
+ ["raw.hbs", "{{{{a}}}} b\n", "Unclosed block (1:10)"],
+ ["colon.hbs", "<:>\n", "Invalid element name (1:1)"],
["mapping.yaml", "a: b: c\n", "Unexpected token (1:5)"],
["flow.yaml", "a: [1, 2\nb: 3\n", "Unexpected token (2:1)"],
["string.yaml", 'a: "x\n', "Unexpected character (2:1)"],
["single.yaml", "a: 'x\n", "Unexpected character (2:1)"],
- ["tab.yaml", "\ta: 1\n", "A tab cannot be indentation (1:3)"],
- ["anchors.yaml", "a: &x &y 1\n", "A node has one anchor and one tag at most (1:7)"],
+ ["tab.yaml", "\ta: 1\n", "Tabs cannot be used for indentation (1:3)"],
+ ["anchors.yaml", "a: &x &y 1\n", "A node can have at most one anchor and one tag (1:7)"],
["token.yaml", "- a\nb: 1\n", "Unexpected token (2:1)"],
["directive.yaml", "%YAML 1.2\na: 1\n", "Unexpected token (2:1)"],
["directive-end.yaml", "%YAML 1.2\n", "Unexpected token (2:1)"],
@@ -648,7 +661,7 @@ describe.concurrent("bun format", () => {
["comma.yaml", "a: [b c: d e]\n[a b]\n", "Unexpected token (3:1)"],
["missing-comma.yaml", "[a: b c: d]\n", "Unexpected token (1:8)"],
["comment.yaml", 'a: "b"#c\n', "Unexpected character (1:7)"],
- ["key.yaml", "[a\nb: c]\n", 'A key without "?" has to be on one line (2:2)'],
+ ["key.yaml", "[a\nb: c]\n", 'A key without "?" must be on one line (2:2)'],
["colon.yaml", "a: 1\nb\n", "Unexpected token (3:1)"],
["indent.yaml", "a:\n - b\n - c\n", "Unexpected token (3:2)"],
["block-in-flow.yaml", "[a: |\n b\n]\n", "Unexpected token (1:5)"],
@@ -661,17 +674,17 @@ describe.concurrent("bun format", () => {
["set.yaml", "{!!set}\n", "This cannot be formatted (1:2)"],
["token.json", '{"a": }\n', "Unexpected token (1:7)"],
["end.json", '{"a": 1\n', "Unexpected end of file (2:1)"],
- ["string.json", '{"a": "x\n}\n', "This string is not closed (1:7)"],
+ ["string.json", '{"a": "x\n}\n', "Unclosed string (1:7)"],
["escape.json", '{"a": "\\x"}\n', "Invalid escape sequence (1:7)"],
- ["comment.json", '{"a": 1} /* b\n', "This comment is not closed (1:10)"],
- ["more.json", '{"a": 1} 2\n', "Expected the end of the file (1:10)"],
+ ["comment.json", '{"a": 1} /* b\n', "Unclosed comment (1:10)"],
+ ["more.json", '{"a": 1} 2\n', "Expected end of file (1:10)"],
["only-comments.json", "// a\n", "Unexpected end of file (2:1)"],
["word.json", "nul\n", "Unexpected token (1:1)"],
["sign-before-a-string.json", "+''\n", "Unexpected token (1:2)"],
["sign-before-a-word.json5", "-null\n", "Unexpected token (1:2)"],
];
const result = await format(Object.fromEntries(cases.map(([name, text]) => [name, text])), []);
- const said = [...result.stderr.matchAll(/^\[error\] ([^:\n]+): SyntaxError: (.+)$/gm)].map(it => [it[1], it[2]]);
+ const said = [...result.stderr.matchAll(/^error: ([^:\n]+): SyntaxError: (.+)$/gm)].map(it => [it[1], it[2]]);
expect(Object.fromEntries(said)).toEqual(Object.fromEntries(cases.map(([name, , message]) => [name, message])));
expect(result.exitCode).toBe(2);
});
@@ -686,38 +699,38 @@ describe.concurrent("bun format", () => {
};
const result = await format(files, []);
expect(result.stderr).toMatchInlineSnapshot(`
- "[error] a.css: SyntaxError: This string is not closed (2:16)
- [error] 1 | a {
- [error] > 2 | /* é😀 */ b: "x
- [error] | ^
- [error] 3 | }
- [error] 4 |
- [error] b.css: SyntaxError: This string is not closed (7:6)
- [error] 5 |
- [error] 6 | d {
- [error] > 7 | e: "f
- [error] | ^
- [error] 8 | }
- [error] 9 |
- [error] 10 | g {
- [error] c.js: SyntaxError: Expression expected. (1:11)
- [error] > 1 | const a = ;
- [error] | ^
- [error] 2 |
- [error] d.yaml: SyntaxError: A tab cannot be indentation (2:2)
- [error] 1 | a:
- [error] > 2 | - b
- [error] | ^
- [error] 3 |
+ "error: a.css: SyntaxError: Unclosed string (2:16)
+ 1 | a {
+ > 2 | /* é😀 */ b: "x
+ | ^
+ 3 | }
+ 4 |
+ error: b.css: SyntaxError: Unclosed string (7:6)
+ 5 |
+ 6 | d {
+ > 7 | e: "f
+ | ^
+ 8 | }
+ 9 |
+ 10 | g {
+ error: c.js: SyntaxError: Expression expected. (1:11)
+ > 1 | const a = ;
+ | ^
+ 2 |
+ error: d.yaml: SyntaxError: Tabs cannot be used for indentation (2:2)
+ 1 | a:
+ > 2 | - b
+ | ^
+ 3 |
Formatted 0 files, 0 unchanged"
`);
expect(result.exitCode).toBe(2);
const stdin = await format({}, ["--stdin-filepath", "a.css"], { stdin: "a {\n" });
expect(stdin.stderr).toMatchInlineSnapshot(`
- "[error] a.css: SyntaxError: This block is not closed (1:1)
- [error] > 1 | a {
- [error] | ^
- [error] 2 |"
+ "error: a.css: SyntaxError: Unclosed block (1:1)
+ > 1 | a {
+ | ^
+ 2 |"
`);
expect(stdin.exitCode).toBe(2);
});
@@ -739,15 +752,47 @@ describe.concurrent("bun format", () => {
}
});
- test("a file is left as it is if what would be written is another program", async () => {
- // Like Prettier 3.9.9, the formatter writes no `;` before the `(` here, which makes `c(..)` of the two statements.
- const text = "a ? b : c;\n(d ? e : f) ? g : h;\n";
- const result = await format({ "a.js": text, "b.js": ugly }, ["--no-semi", "--experimental-ternaries"], {
- reads: ["a.js"],
+ describe("without semicolons, a statement that would go on with the line before it starts with one", () => {
+ // Prettier 3.9.9 writes none before these, which makes `c(..)` of two statements, and `let c` of two others.
+ test.each([
+ [
+ "the parentheses of --experimental-ternaries around a condition",
+ ["--experimental-ternaries"],
+ "a ? b : c;\n(d ? e : f) ? g : h;\n",
+ "a ? b : c\n;(\n d ? e : f\n) ?\n g\n: h\n",
+ "a ? b : c\n(\n d ? e : f\n) ?\n g\n: h\n",
+ ],
+ [
+ "the same around a condition that does not fit on the line",
+ ["--experimental-ternaries", "--print-width=20"],
+ "a;\nbbbbbbbbbb && cccccccccc ? d : e;\nf && g ? h : i;\n",
+ "a\n;(\n bbbbbbbbbb &&\n cccccccccc\n) ?\n d\n: e\nf && g ? h : i\n",
+ "a\n(\n bbbbbbbbbb &&\n cccccccccc\n) ?\n d\n: e\nf && g ? h : i\n",
+ ],
+ ["a variable that is called let", [], "a;\nlet;\nc;\n", "a\n;(let)\nc\n", "a\nlet\nc\n"],
+ ])("%s", async (_, flags, text, right, ofPrettier) => {
+ expect(right).not.toBe(ofPrettier);
+ const result = await format({ "a.js": text }, ["--no-semi", ...flags], { reads: ["a.js"] });
+ expect(result.files).toEqual({ "a.js": right });
+ expect(result.exitCode).toBe(0);
+ const checked = await format({ "a.js": text, "b.js": right }, ["--no-semi", ...flags, "--debug-check"]);
+ expect(checked.stderr).toBe("");
+ expect(checked.stdout.split("\n")).toEqual(["a.js", "b.js"]);
+ expect(checked.exitCode).toBe(0);
+ expect((await format({ "a.js": right }, ["--no-semi", ...flags, "--check"])).exitCode).toBe(0);
});
- expect(result.files).toEqual({ "a.js": text });
- expect(result.stderr).toContain("[error] a.js: formatting would change what the code means.");
- expect(result.exitCode).toBe(2);
+ });
+
+ test("in TypeScript no line ends with what looks like type arguments", async () => {
+ // Prettier 3.9.9 prints `a <\n b >\n c;`, which is `a; c;`.
+ const files = { "a.ts": "a < b > c;\n", "b.js": "a < b > c;\n" };
+ const flags = ["--print-width=5"];
+ const result = await format(files, flags, { reads: ["a.ts", "b.js"] });
+ expect(result.files).toEqual({ "a.ts": "a <\n b > c;\n", "b.js": "a <\n b >\n c;\n" });
+ expect(result.exitCode).toBe(0);
+ const checked = await format(files, [...flags, "--debug-check"]);
+ expect(checked.stderr).toBe("");
+ expect(checked.exitCode).toBe(0);
});
test("Handlebars", async () => {
@@ -759,99 +804,357 @@ describe.concurrent("bun format", () => {
expect(result.exitCode).toBe(0);
});
- describe("a template that Prettier damages is left as it is", () => {
- // What Prettier 3.9.9 prints for each of these says something else, or cannot be parsed any more.
- const damaged = {
- "doctype": "\n\n",
- "character-behind-less-than": "a <3 b >\n",
- "start-of-a-comment": "\n",
- "mustache-where-a-comment-starts": "\n",
- "open-tag-at-the-end": "\n",
- "escaped-mustache-in-a-name": "\n",
- "escaped-mustache-in-pre": "![]()
a\n",
- "this-and-a-slash": "{{this/a }}\n",
- "this-behind-an-at": "{{@this.a }}\n",
- "this-in-brackets": "{{[this] }}\n",
- "empty-brackets": "{{[].a }}\n",
- "arguments-of-a-literal": '{{"a" b}}\n',
- "hash-that-is-called": "{{(a=b) c}}\n",
- "raw-block": "{{{{a}}}} {{b}} {{{{/a}}}}\n",
- "inverted-block": "{{^a }}b{{else}}c{{/a}}\n",
- "key-in-brackets": "{{a [b c]=d}}\n",
- "literal-in-brackets": "{{a [true]}}\n",
- "number-in-brackets": "{{a [-1]}}\n",
- "else-in-brackets": "{{[else] }}\n",
- "argument-in-brackets": "{{a [@b]}}\n",
- "bracket-in-brackets": "{{a [b\\]]}}\n",
- "line-break-in-brackets": "{{a [b\nc]}}\n",
- "block-parameter-in-brackets": "{{#a as |[b] c|}}{{/a}}\n",
- "private-name": "{{a.#b }}\n",
- "number-with-an-exponent": "{{a 1000000000000000000000}}\n",
- "backslash-at-the-end-of-a-string": '{{a "b\\"}}\n',
- "tilde-in-three-braces": "{{{a }~}}\n",
- "three-braces-around-a-modifier": "\n",
- "tilde-at-the-end-of-a-comment": "{{!-- a ~--}}\n",
- "dashes-at-the-start-of-a-comment": "{{!---- a --}}\n",
- "rest-of-the-name-behind-else": "{{#a }}{{else if.b c}}{{/a}}\n",
- "tilde-of-an-if-that-is-all-that-follows-else": "{{#a }}{{else}}{{~#if b}}c{{/if}}{{/a}}\n",
- "line-separator-behind-a-line-break": "a\n\u2028{{b }}\n",
- "indented-mark-of-a-document-in-front-matter": "---\n ---\na: b\n---\n\n",
+ describe("a template of which Prettier changes the meaning", () => {
+ // The template, what Bun makes of it, and what Prettier 3.9.9 makes of it, which says something else or cannot be parsed
+ // any more. Where nothing else is clearly right, the smallest part around the place stays as it is written.
+ const templates: Record = {
+ "doctype": ["\n\n", "\n", ""],
+ "character-behind-less-than": ["a <3 b >\n", "a <3 b >\n", "a "],
+ "start-of-a-comment": ["\n", "", ""],
+ "mustache-where-a-comment-starts": ["\n", "", "{{a}}"],
+ "open-tag-at-the-end": [""],
+ "escaped-mustache-in-a-comment": [
+ "\n",
+ "",
+ "",
+ ],
+ "escaped-mustache-in-a-name": ["\n", "", ""],
+ "escaped-mustache-in-pre": ["![]()
a\n", "![]()
a", "![]()
"],
+ "this-and-a-slash": ["{{this/a }}\n", "{{this/a}}", "{{a}}"],
+ "this-behind-an-at": ["{{@this.a }}\n", "{{@this.a}}", "{{@a}}"],
+ "this-in-brackets": ["{{[this] }}\n", "{{[this]}}", "{{this.this}}"],
+ "empty-brackets": ["{{[].a }}\n", "{{[].a}}", "{{a}}"],
+ "arguments-of-a-literal": ['{{"a" b}}\n', '{{"a" b}}', '{{"a"}}'],
+ "hash-that-is-called": ["{{(a=b) c}}\n", "{{(a=b) c}}", "{{ c}}"],
+ "raw-block": ["{{{{a}}}} {{b}} {{{{/a}}}}\n", "{{{{a}}}} {{b}} {{{{/a}}}}", "{{#a}} \\{{b}} {{/a}}"],
+ "key-in-brackets": ["{{a [b c]=d}}\n", "{{a [b c]=d}}", "{{a b c=d}}"],
+ "literal-in-brackets": ["{{a [true]}}\n", "{{a [true]}}", "{{a true}}"],
+ "number-in-brackets": ["{{a [-1]}}\n", "{{a [-1]}}", "{{a -1}}"],
+ "else-in-brackets": ["{{[else] }}\n", "{{[else]}}", "{{else}}"],
+ "argument-in-brackets": ["{{a [@b]}}\n", "{{a [@b]}}", "{{a @b}}"],
+ "bracket-in-brackets": ["{{a [b\\]]}}\n", "{{a [b\\]]}}", "{{a [b]]}}"],
+ "line-break-in-brackets": ["{{a [b\nc]}}\n", "{{a [b\nc]}}", "{{a [[b\nc]]}}"],
+ "private-name": ["{{a.#b }}\n", "{{a.#b}}", "{{a.[#b]}}"],
+ "number-with-an-exponent": ["{{a 1000000000000000000000}}\n", "{{a 1000000000000000000000}}", "{{a 1e+21}}"],
+ "tilde-in-three-braces": ["{{{a }~}}\n", "{{{a}~}}", "{{{a~}}}"],
+ "three-braces-around-a-modifier": ["\n", "", ""],
+ "tilde-at-the-end-of-a-comment": ["{{!-- a ~--}}\n", "{{!-- a ~--}}", "{{! a ~}}"],
+ "dashes-at-the-start-of-a-comment": ["{{!---- a --}}\n", "{{!---- a --}}", "{{!-- a }}"],
+ "rest-of-the-name-behind-else": [
+ "{{#a }}{{else if.b c}}{{/a}}\n",
+ "{{#a}}{{else if.b c}}{{/a}}",
+ "{{#a}}{{else if c}}{{/a}}",
+ ],
+ "tilde-of-an-if-that-is-all-that-follows-else": [
+ "{{#a }}{{else}}{{~#if b}}c{{/if}}{{/a}}\n",
+ "{{#a}}{{else}}{{~#if b}}c{{/if}}{{/a}}",
+ "{{#a}}{{else if b}}c{{/a}}",
+ ],
+ "indented-mark-of-a-document-in-front-matter": [
+ "---\n ---\na: b\n---\n\n",
+ "---\n ---\na: b\n---\n\n",
+ "---\n---\na: b\n---\n\n",
+ ],
+ "no-break-space-that-is-all-of-the-template": ["\u00a0\n", "\u00a0", ""],
+ "white-space-that-is-all-of-a-block-in-a-textarea": [
+ "\n",
+ "",
+ "",
+ ],
+ "white-space-that-is-all-of-a-block-in-pre": [
+ " = {
+ "inverted-block": ["{{^a }}b{{else}}c{{/a}}\n", "{{#a}}c{{else}}b{{/a}}"],
+ "block-parameter-in-brackets": ["{{#a as |[b] c|}}{{/a}}\n", "{{#a as |[b] c|}}{{/a}}"],
+ "backslash-at-the-end-of-a-string": ['{{a "b\\"}}\n', '{{a "b\\"}}'],
+ "line-separator-behind-a-line-break": ["a\n\u2028{{b }}\n", "a \u2028{{b}}"],
+ };
+ const all = Object.entries({ ...templates, ...harmless });
+ const files = Object.fromEntries(all.map(([name, it]) => [`${name}.hbs`, it[0]]));
+ const written = Object.fromEntries(all.map(([name, it]) => [`${name}.hbs`, it[1]]));
+
+ test("says the same afterwards", async () => {
+ for (const [, after, ofPrettier] of Object.values(templates)) expect(after).not.toBe(ofPrettier);
+ const result = await format(files, [], { reads: Object.keys(files) });
+ expect(result.files).toEqual(written);
+ expect(result.exitCode).toBe(0);
+ });
- test.each([[[] as string[]], [["--check"]], [["-l"]]])("%j", async args => {
- const result = await format({ ...files, "fine.hbs": "{{a }}" }, args, {
- reads: [...Object.keys(files), "fine.hbs"],
- });
- expect(result.files).toEqual({ ...files, "fine.hbs": args.length > 0 ? "{{a }}" : "{{a}}" });
- expect(errorsIn(result.stderr)).toEqual(errors);
- expect(result.exitCode).toBe(2);
+ test.each([
+ ["no config", {}],
+ [".prettierrc", { ".prettierrc": "{}\n" }],
+ [".oxfmtrc.json", { ".oxfmtrc.json": "{}\n" }],
+ ])("with %s", async (_, config: Record) => {
+ const result = await format({ ...config, ...files }, Object.keys(files), { reads: Object.keys(files) });
+ expect(result.files).toEqual(written);
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("--debug-check has nothing to say about it", async () => {
+ const result = await format(files, ["--debug-check"], { reads: Object.keys(files) });
+ expect(result.files).toEqual(files);
+ expect(result.stderr).toBe("");
+ expect(result.stdout.split("\n").sort()).toEqual(Object.keys(files).sort());
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("what is written is formatted", async () => {
+ expect(await different(written, [])).toEqual([]);
+ });
+
+ test("where white space does not count, a word and an escaped mustache stay two words", async () => {
+ // Prettier 3.9.9 prints `p\\{{a}} {{q}}`.
+ const flags = ["--html-whitespace-sensitivity=ignore"];
+ const result = await format({ "a.hbs": "p \\{{a}} {{q }}\n" }, flags, { reads: ["a.hbs"] });
+ expect(result.files).toEqual({ "a.hbs": "p \\{{a}} {{q}}" });
+ expect(result.exitCode).toBe(0);
});
test("standard input", async () => {
- const result = await format({}, ["--stdin-filepath", "a.hbs"], { stdin: damaged.doctype });
- expect(result.raw).toBe("");
- expect(errorsIn(result.stderr)).toEqual([
- "[error] a.hbs: formatting it the way Prettier does would change what it means. It is left as it is.",
- ]);
- expect(result.exitCode).toBe(2);
+ const [before, after] = templates.doctype;
+ const result = await format({}, ["--stdin-filepath", "a.hbs"], { stdin: before });
+ expect(result.raw).toBe(after);
+ expect(result.exitCode).toBe(0);
});
- test("in Markdown, only the block of code is", async () => {
+ test("in a block of code in Markdown", async () => {
const text = "# a\n\n```hbs\n\n\n```\n\n```hbs\n\n```\n";
const result = await format({ "a.md": text }, [], { reads: ["a.md"] });
expect(result.files).toEqual({
- "a.md": "# a\n\n```hbs\n\n\n```\n\n```hbs\n\n```\n",
+ "a.md": "# a\n\n```hbs\n\n\n```\n\n```hbs\n\n```\n",
});
expect(result.exitCode).toBe(0);
});
});
+ describe("Markdown of which Prettier changes the meaning", () => {
+ // The text, what Bun makes of it, and what Prettier 3.9.9 makes of it: it gives two emphases that touch the same marker,
+ // which makes one of them, or none.
+ test.each([
+ ["x *a*_b_\n", "x *a*_b_\n", "x _a__b_\n"],
+ ["x _a_*b*\n", "x _a_*b*\n", "x _a__b_\n"],
+ ["x **a**__b__\n", "x **a**__b__\n", "x **a****b**\n"],
+ ["x ***a******b***\n", "x ***a******b***\n", "x _**a**__**b**_\n"],
+ ["- *a*_b_*c*\n", "- *a*_b_*c*\n", "- _a__b__c_\n"],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ const result = await format({ "a.md": before, "b.md": after }, [], { reads: ["a.md", "b.md"] });
+ expect(result.files).toEqual({ "a.md": after, "b.md": after });
+ expect(result.exitCode).toBe(0);
+ });
+
+ // Known: Bun prints what Prettier 3.9.9 prints for these, and a CommonMark parser reads that as something else. All are
+ // emphasis three deep, or runs of `*` and `_` that are text in an emphasis. Telling them from `*foo_bar*`, of which
+ // `_foo_bar_` is right, takes the rules for delimiter runs.
+ test.each([
+ ["**a****a**\n", "**a\\****a**\n"],
+ ["*b **a*b*** c*\n", "*b \\**a*b*** c*\n"],
+ ["*b _a_*b* c*\n", "*b *a**b* c*\n"],
+ ["*b _*a*_ c*\n", "*b _*a*\\_ c*\n"],
+ ["*b *_a_* c*\n", "_b **a** c_\n"],
+ ["**b __**a**__ c**\n", "**b __**a**\\__ c**\n"],
+ ["**__a__****__a__**\n", "****a********a****\n"],
+ ["*b a__b__c c*\n", "_b a__b_\\_c c_\n"],
+ ["*b __a__b c*\n", "_b \\__a_\\_b c_\n"],
+ ["**b __a__b c**\n", "**b \\__a_\\_b c**\n"],
+ ["*b **(a)**b c*\n", "*b **(a)*_b c_\n"],
+ ["*b _\u4e2d_a c*\n", "_b _\u4e2d_a c_\n"],
+ ["*b a_\u4e2d_ c*\n", "_b a_\u4e2d_ c_\n"],
+ ])("known: %j", async (before, ofPrettier) => {
+ const result = await format({ "a.md": before }, [], { reads: ["a.md"] });
+ expect(result.files).toEqual({ "a.md": ofPrettier });
+ });
+ });
+
+ test("a folded scalar of YAML that keeps its line breaks has as many with --prose-wrap=never", async () => {
+ // Prettier 3.9.9 prints `k: >+\n a\n \n \n\nl: m\n`, which has one more.
+ const result = await format({ "a.yaml": "k: >+\n a\n\n\nl: m\n" }, ["--prose-wrap=never"], {
+ reads: ["a.yaml"],
+ });
+ expect(result.files).toEqual({ "a.yaml": "k: >+\n a\n\n\nl: m\n" });
+ expect(result.exitCode).toBe(0);
+ });
+
+ describe("an escaped blank at the end of the parameters of an at-rule", () => {
+ // Prettier 3.9.9 prints `@extend .a\\;`: the backslash escapes the `;`.
+ const names = ["extend", "include", "media", "supports", "container", "layer", "import", "custom"];
+ test.each(["a.css", "a.scss", "a.less"])("%s", async file => {
+ const before = names.map(name => `x{@${name} .a\\ ;}\n@${name} .a\\ ;\n`).join("") + "@last .a\\ ";
+ const after = names.map(name => `x {\n @${name} .a\\ ;\n}\n@${name} .a\\ ;\n`).join("") + "@last .a\\ ;\n";
+ const result = await format({ [file]: before }, [], { reads: [file] });
+ expect(result.files).toEqual({ [file]: after });
+ expect(result.exitCode).toBe(0);
+ expect(await different({ [file]: after }, [])).toEqual([]);
+ });
+
+ test("before a parenthesis, and not twice where Prettier has one", async () => {
+ // Prettier 3.9.9 prints `@media (a\\) {`. What it prints for the second is right.
+ const files = { "a.scss": "@media (a\\ ){b{c:d}}\n@each .a\\ ;\n" };
+ const result = await format(files, [], { reads: ["a.scss"] });
+ expect(result.files).toEqual({ "a.scss": "@media (a\\ ) {\n b {\n c: d;\n }\n}\n@each .a\\ ;\n" });
+ expect(result.exitCode).toBe(0);
+ });
+ });
+
+ describe("a selector without a namespace", () => {
+ // The selector, what Bun makes of it, and what Prettier 3.9.9 makes of it.
+ test.each([
+ ["x |b", "x |b", "x|b"],
+ ["x,|b,y", "x,\n|b,\ny", "x,\n,|b,\ny"],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ const written = `${after} {\n c: d;\n}\n`;
+ const result = await format({ "a.css": `${before}{c:d}\n`, "b.css": written }, [], { reads: ["a.css", "b.css"] });
+ expect(result.files).toEqual({ "a.css": written, "b.css": written });
+ expect(result.exitCode).toBe(0);
+ });
+ });
+
+ describe("a backslash in a value of a style sheet", () => {
+ // The value, what Bun makes of it, and what Prettier 3.9.9 makes of it: it writes nothing behind a word with a backslash.
+ test.each([
+ ["Font\\ Awesome\\ 5", "Font\\ Awesome\\ 5", "Font\\Awesome\\5"],
+ ["a\\b c", "a\\b c", "a\\bc"],
+ ["d\\ e", "d\\ e", "d\\e"],
+ ["d\\ -5", "d\\ -5", "d\\-5"],
+ ["d\\ ", "d\\ ", "d\\"],
+ ["(a\\ )", "(a\\ )", "(a\\)"],
+ ["f(b a\\ )", "f(b a\\ )", "f(b a\\)"],
+ ["f(a\\ , b)", "f(a\\ , b)", "f(a\\, b)"],
+ ["a\\ , b", "a\\ , b", "a\\, b"],
+ // What the backslash escapes here is no blank, and Prettier is right.
+ ["\\@a 1\\/3", "\\@a 1\\/3", null],
+ ["d\\\\ e", "d\\\\ e", "d\\\\e"],
+ ["x d\\e f g", "x d\\e f g", "x d\\ef g"],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ const files = Object.fromEntries(["a.css", "b.scss", "c.less"].map(name => [name, `a{b:${before}}\n`]));
+ const result = await format(files, [], { reads: Object.keys(files) });
+ const written = `a {\n b: ${after};\n}\n`;
+ expect(result.files).toEqual({ "a.css": written, "b.scss": written, "c.less": written });
+ expect(result.exitCode).toBe(0);
+ expect(await different({ "a.css": written }, [])).toEqual([]);
+ });
+ });
+
+ describe("YAML of which Prettier changes a value", () => {
+ // The text, what Bun makes of it, and what Prettier 3.9.9 makes of it: a key with one line break more, a scalar that has
+ // become a marker, a byte order mark that was the start of a key, and a key that cannot be read.
+ test.each([
+ ["? |+\n a\n\n: m\n", "? |+\n a\n\n: m\n", "? |+\n a\n\n\n: m\n"],
+ ["k: l\n? >+\n a\n\n", "k: l\n? >+\n a\n\n", "k: l\n? >+\n a\n\n\n"],
+ ["--- ---\n", "--- ---\n", "---\n---\n"],
+ ["--- ... x\n", "--- ... x\n", "---\n... x\n"],
+ ["? \ufeffa\n: m\n", "? \ufeffa\n: m\n", "\ufeffa: m\n"],
+ ["? {a\n b: c}\n: m\n", "? { ? a\n b\n : c }\n: m\n", "{ ? a\n b\n : c }: m\n"],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ expect(Bun.YAML.parse(after)).toEqual(Bun.YAML.parse(before));
+ const result = await format({ "a.yaml": before, "b.yaml": after }, [], { reads: ["a.yaml", "b.yaml"] });
+ expect(result.files).toEqual({ "a.yaml": after, "b.yaml": after });
+ expect(result.exitCode).toBe(0);
+ });
+ });
+
+ describe("front matter that would end early", () => {
+ // Prettier 3.9.9 formats the YAML, which puts the second `---` at the start of its line: there the front matter ends.
+ const frontMatter = "---\n ---\na: b\n---\n";
+ test.each([
+ ["a.md", "\n# c\n", "\n# c\n"],
+ ["a.mdx", "\n# c\n", "\n# c\n"],
+ ["a.css", "a{b:c}\n", "\na {\n b: c;\n}\n"],
+ ["a.scss", "a{b:c}\n", "\na {\n b: c;\n}\n"],
+ ["a.html", "\n',
@@ -961,52 +1264,150 @@ describe.concurrent("bun format", () => {
reads: ["a.html", "b.html"],
});
expect(result.files).toEqual({ "a.html": "b;\n", "//
\nconst a = \\{{a}}\n",
- "escaped-mustache-in-style": '\n',
- "white-space-next-to-a-mustache-in-style": "\n",
- "no-break-space-that-is-all-of-a-block": "{{#a }}\u00a0{{/a}}\n",
- "no-break-space-that-is-all-of-a-component": "\u00a0\n",
- "no-break-space-in-a-class": '\n',
- "escaped-mustache-that-is-ignored": "{{! prettier-ignore }}a\\{{b}}\n",
- "backslash-before-a-mustache-in-a-value": '\n',
- "backslash-before-a-comment": "a\\\\{{! b }}\n",
- "backslash-before-the-end-of-a-block": "{{#a }}b\\\\{{/a}}\n",
- "both-quotes-in-a-value": `\n`,
- "lines-of-a-script": "\n",
- "lines-of-a-textarea": "\n",
- "white-space-further-down-in-pre": "a\n b\n", - "children-of-what-counts-as-void": "
\\{{a}}\n", "\\{{a}}", "{{a}}"],
+ "escaped-mustache-in-style": [
+ '\n',
+ '',
+ '',
+ ],
+ "white-space-next-to-a-mustache-in-style": [
+ "\n",
+ "",
+ "",
+ ],
+ "no-break-space-that-is-all-of-a-block": ["{{#a }}\u00a0{{/a}}\n", "{{#a}}\u00a0{{/a}}", "{{#a}}{{/a}}"],
+ "no-break-space-that-is-all-of-a-component": ["\u00a0\n", "\u00a0", ""],
+ "no-break-space-in-a-class": ['\n', '', ''],
+ "escaped-mustache-that-is-ignored": [
+ "{{! prettier-ignore }}a\\{{b}}\n",
+ "{{! prettier-ignore }}a\\{{b}}",
+ "{{! prettier-ignore }}a{{b}}",
+ ],
+ "backslash-before-a-mustache-in-a-value": [
+ '\n',
+ '',
+ '',
+ ],
+ "backslash-before-a-comment": ["a\\\\{{! b }}\n", "a\\\\{{! b }}", "a\\{{! b }}"],
+ "backslash-before-the-end-of-a-block": ["{{#a }}b\\\\{{/a}}\n", "{{#a}}b\\\\{{/a}}", "{{#a}}b\\{{/a}}"],
+ "both-quotes-in-a-value": ["\n", '', ''],
+ "lines-of-a-script": [
+ "\n",
+ "",
+ "",
+ ],
+ "lines-of-a-textarea": [
+ "\n",
+ "",
+ "",
+ ],
+ "white-space-further-down-in-pre": [
+ "a\n b\n", + "
a\n b", + "
a b", + ], + "children-of-what-counts-as-void": ["
{{#a}} {{/a}}\n",
+ "{{#a}} {{/a}}",
+ "{{#a}}{{/a}}",
+ ],
+ "tilde-of-an-else-if-in-an-if-that-is-all-that-follows-else": [
+ "{{#z }}y{{else}}{{#if a}}b{{~else if c}}d {{/if}}{{/z}}\n",
+ "{{#z}}y{{else}}{{#if a}}b{{~else if c}}d {{/if}}{{/z}}",
+ "{{#z}}y{{else if a}}b{{~else if c}}d {{/z}}",
+ ],
+ "name-in-brackets-behind-else": [
+ "{{#[a b] }}{{else [a b] c}}{{/[a b]}}\n",
+ "{{#[a b]}}{{else [a b] c}}{{/[a b]}}",
+ "{{#[a b]}}{{else a b c}}{{/[a b]}}",
+ ],
+ "empty-brackets-and-a-slash": ["{{[]/a }}\n", "{{[]/a}}", "{{a}}"],
+ "empty-brackets-behind-an-at": ["{{@[].a }}\n", "{{@[].a}}", "{{@a}}"],
+ "empty-brackets-at-the-end": ["{{a.[] }}\n", "{{a.[]}}", "{{a.}}"],
+ "empty-brackets-in-arguments": ["{{a [].b c=[].d}}\n", "{{a [].b c=[].d}}", "{{a b c=d}}"],
+ "doctype-with-identifiers": [
+ '\n\n',
+ '\n',
+ "",
+ ],
+ "this-twice": ["{{this.this }}\n", "{{this.this}}", "{{this}}"],
+ "dots-before-a-name": ["{{a ...b}}\n", "{{a ...b}}", "{{a b}}"],
+ "slash-in-brackets": ["{{[a/b] }}\n", "{{[a/b]}}", "{{a/b}}"],
+ "hash-that-is-called-in-parentheses": ["{{a ((b=c) d)}}\n", "{{a ((b=c) d)}}", "{{a ( d)}}"],
+ "number-with-a-negative-exponent": ["{{a 0.0000001}}\n", "{{a 0.0000001}}", "{{a 1e-7}}"],
+ "mustache-where-a-comment-may-end": [
+ "\n",
+ "",
+ "{{b}}",
+ ],
+ "blank-behind-less-than": ["< a>b\n", "< a>b\n", "b"],
+ "columns-behind-a-line-separator": [
+ 'a\n\u2028{{~! b ~}} \n\u2029{{! prettier-ignore }} {{ i }} {{!-- j --~}}\n{{k\n\u2028 l}} {{~! m }}\n',
+ 'a \u2028{{~! b ~}}\n\n\n\u2029{{! prettier-ignore }}\n{{ i }}\n{{! j ~}}\n{{k l}}\n{{~! m }}',
+ 'a \u2028{{! b }}\n\n\n\u2029\u2029{{! prettier-ignore }\n {{ i }\n{{! j }}\n{{k l}}\n{{! m }}',
+ ],
};
- const files = Object.fromEntries(Object.entries(damaged).map(([name, text]) => [`${name}.hbs`, text]));
- const errors = Object.keys(files)
- .map(
- name => `[error] ${name}: formatting it the way Prettier does would change what it means. It is left as it is.`,
- )
- .sort();
- const errorsIn = (stderr: string) =>
- stderr
- .split("\n")
- .filter(line => line.startsWith("[error] "))
- .sort();
+ // These look like it, but Handlebars reads what Prettier prints as it reads the template.
+ const harmless: Recordc
\n", "\nc
\n"], + ])("%s", async (name, before, after) => { + const result = await format({ [name]: frontMatter + before }, [], { reads: [name] }); + expect(result.files).toEqual({ [name]: frontMatter + after }); + expect(result.exitCode).toBe(0); + expect(await different({ [name]: frontMatter + after }, [])).toEqual([]); + }); + }); + test("HTML, Vue, Angular templates, MJML", async () => { const files = { "a.html": 'c
\n", "b.html": "
\nconst a = a
\n" }); - expect(result.stderr).toContain("[error] a.html: SyntaxError:"); + expect(result.stderr).toContain("error: a.html: SyntaxError:"); expect(result.exitCode).toBe(2); }); - describe("HTML of which something would be lost is left as it is", () => { - // Prettier 3.9.9 writes a media query in lower case, which makes a `k` of the Kelvin sign. - const lossy = "\n"; - const error = (name: string) => - `[error] ${name}: formatting it the way Prettier does would change what is in it. It is left as it is.`; + describe("a with an element in it and no end tag", () => {
+ // The text, what Bun makes of it, and what Prettier 3.9.9 makes of it: all that follows the start tag is lost.
+ test.each([
+ ["a\n", "a\n", ">\n"],
+ ["ac\n", "ac\n", ">\n"],
+ [
+ 'x
a\n b\n',
+ 'x
\na\n b\n',
+ 'x
\n>\n',
+ ],
+ ["a\n", "a\n", ">\n"],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ const result = await format({ "a.html": before, "b.html": after }, [], { reads: ["a.html", "b.html"] });
+ expect(result.files).toEqual({ "a.html": after, "b.html": after });
+ expect(result.exitCode).toBe(0);
+ const checked = await format({ "a.html": before }, ["--debug-check"]);
+ expect(checked.stderr).toBe("");
+ expect(checked.exitCode).toBe(0);
+ });
+ });
+
+ describe("a style sheet of which Prettier changes a letter", () => {
+ // Prettier 3.9.9 writes a media query in lower case, which makes a `k` of the Kelvin sign: `@media (ka)`. To CSS only
+ // the letters of ASCII are the same in both cases.
+ const lossy = "\n";
+ const written = "\n";
- test.each([[[] as string[]], [["--check"]], [["-l"]]])("%j", async args => {
- const result = await format({ "a.html": lossy, "b.html": "a
\n" }, args, {
- reads: ["a.html", "b.html"],
- });
- expect(result.files).toEqual({ "a.html": lossy, "b.html": args.length > 0 ? "a
\n" : "a
\n" });
- expect(result.stderr.split("\n").filter(line => line.startsWith("[error] "))).toEqual([error("a.html")]);
- expect(result.exitCode).toBe(2);
+ test("keeps it", async () => {
+ const files = { "a.html": lossy, "b.css": "@media (\u212AA){a{b:c}}\n" };
+ const result = await format(files, [], { reads: ["a.html", "b.css"] });
+ expect(result.files).toEqual({ "a.html": written, "b.css": "@media (\u212Aa) {\n a {\n b: c;\n }\n}\n" });
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("--debug-check has nothing to say about it", async () => {
+ const result = await format({ "a.html": lossy }, ["--debug-check"], { reads: ["a.html"] });
+ expect(result.files).toEqual({ "a.html": lossy });
+ expect(result.stderr).toBe("");
+ expect(result.stdout).toBe("a.html");
+ expect(result.exitCode).toBe(0);
+ });
+
+ test.each([["--check"], ["-l"]])("%s says that it needs formatting", async flag => {
+ const result = await format({ "a.html": lossy }, [flag], { reads: ["a.html"] });
+ expect(result.files).toEqual({ "a.html": lossy });
+ expect(result.stdout).toBe("a.html");
+ expect(result.exitCode).toBe(1);
});
test("standard input", async () => {
const result = await format({}, ["--stdin-filepath", "a.html"], { stdin: lossy });
- expect(result.raw).toBe("");
- expect(result.stderr.split("\n").filter(line => line.startsWith("[error] "))).toEqual([error("a.html")]);
- expect(result.exitCode).toBe(2);
+ expect(result.raw).toBe(written);
+ expect(result.exitCode).toBe(0);
});
- test("in a template and in a block of code, only that is", async () => {
+ test("in a template and in a block of code", async () => {
const files = {
"a.js": "const a = html`" + lossy.trim() + "`;\nconst b = html`c
`;\n",
"b.md": "# a\n\n```html\n" + lossy + "```\n\n```html\nc
\n```\n",
};
const result = await format(files, [], { reads: ["a.js", "b.md"] });
expect(result.files).toEqual({
- "a.js": "const a = html`" + lossy.trim() + "`;\nconst b = html`c
`;\n",
- "b.md": "# a\n\n```html\n" + lossy + "```\n\n```html\nc
\n```\n",
+ "a.js": "const a = html`" + written.trim() + "`;\nconst b = html`c
`;\n",
+ "b.md": "# a\n\n```html\n" + written + "```\n\n```html\nc
\n```\n",
});
expect(result.exitCode).toBe(0);
});
+ });
- test("--no-verify", async () => {
- const result = await format({ "a.html": lossy }, ["--no-verify"], { reads: ["a.html"] });
- expect(result.files).toEqual({
- "a.html": "\n",
- });
+ // What Prettier 3.9.9 does with the flag. oxfmt 0.72 does not have it. The comparison is Bun's own.
+ describe.each([
+ ["no config", {}, "error: "],
+ [".prettierrc", { ".prettierrc": "{}\n" }, "[error] "],
+ [".oxfmtrc.json", { ".oxfmtrc.json": "{}\n" }, "[error] "],
+ ])("--debug-check with %s", (_, config: Record, prefix) => {
+ const files = { "a.js": formatted, "b.js": ugly };
+ const names = Object.keys(files);
+ // Without the parentheses, which neither Prettier nor Bun writes, it means the same, but the tree is another. Prettier's
+ // check reports it too.
+ const lossy = "(a)();\n";
+
+ test("every file that passes is named, formatted or not, and nothing is written", async () => {
+ const result = await format({ ...config, ...files }, ["--debug-check", ...names], { reads: names });
+ expect(result.files).toEqual(files);
+ expect(result.stderr).toBe("");
+ expect(result.stdout.split("\n")).toEqual(["a.js", "b.js"]);
expect(result.exitCode).toBe(0);
});
+
+ test("a file that would say something else is an error", async () => {
+ const all = { "a.ts": lossy, "b.js": ugly };
+ const result = await format({ ...config, ...all }, ["--debug-check", "a.ts", "b.js"], {
+ reads: ["a.ts", "b.js"],
+ });
+ expect(result.files).toEqual(all);
+ expect(result.stderr.trim()).toBe(`${prefix}a.ts: formatting would change what the code does.`);
+ expect(result.stdout).toBe("b.js");
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("-l names what needs formatting as well", async () => {
+ const result = await format({ ...config, ...files }, ["--debug-check", "-l", ...names], { reads: names });
+ expect(result.files).toEqual(files);
+ expect(result.stdout.split("\n")).toEqual(["a.js", "b.js", "b.js"]);
+ expect(result.exitCode).toBe(1);
+ });
+
+ test("--check exits with 1 if a file needs formatting", async () => {
+ const result = await format({ ...config, ...files }, ["--debug-check", "--check", ...names], { reads: names });
+ expect(result.files).toEqual(files);
+ expect(result.exitCode).toBe(1);
+ });
+
+ test("--write is refused", async () => {
+ const result = await format({ ...config, ...files }, ["--debug-check", "--write", ...names], { reads: names });
+ expect(result.files).toEqual(files);
+ expect(result.stderr.trim()).toBe(`${prefix}Cannot use --write and --debug-check together.`);
+ expect(result.exitCode).toBe(1);
+ });
+
+ test("standard input", async () => {
+ const [named, unnamed, looks, lost] = await Promise.all([
+ format(config, ["--debug-check", "--stdin-filepath", "x.js"], { stdin: ugly }),
+ format(config, ["--debug-check", "--parser", "babel"], { stdin: ugly }),
+ format(config, ["--debug-check", "--check", "--stdin-filepath", "x.js"], { stdin: ugly }),
+ format(config, ["--debug-check", "--stdin-filepath", "x.ts"], { stdin: lossy }),
+ ]);
+ // The path, and no line break.
+ expect(named.raw).toEndWith(`${sep}x.js`);
+ expect(named.exitCode).toBe(0);
+ expect(unnamed.raw).toBe("(stdin)\n");
+ expect(unnamed.exitCode).toBe(0);
+ // oxfmt refuses --check with --stdin-filepath.
+ expect(looks.raw).toBe(".oxfmtrc.json" in config ? "" : "(stdin)\n");
+ expect(looks.exitCode).toBe(1);
+ expect(lost.raw).toBe("");
+ expect(lost.stderr.trim()).toBe(`${prefix}x.ts: formatting would change what the code does.`);
+ expect(lost.exitCode).toBe(2);
+ });
});
test("HTML in templates", async () => {
@@ -1045,13 +1446,34 @@ describe.concurrent("bun format", () => {
expect(result.exitCode).toBe(0);
});
- test("a file is left as it is if a template would get an expression twice", async () => {
- // Like Prettier 3.9.9, the formatter closes the element: html`<${b}>c`.
- const text = "const a = html`<${b}>c`;\n";
- const result = await format({ "a.js": text }, [], { reads: ["a.js"] });
- expect(result.files).toEqual({ "a.js": text });
- expect(result.stderr).toContain("[error] a.js: formatting would change what the code means.");
- expect(result.exitCode).toBe(2);
+ describe("HTML in a template of which Prettier changes the substitutions", () => {
+ // The code, what Bun makes of it, and what Prettier 3.9.9 makes of it: it closes the element, so `b` is evaluated twice,
+ // and it does not find what stands for `${b}` again once that is in lower case. oxfmt 0.72 leaves both as they are.
+ test.each([
+ ["const a = html`<${b}>c`;\n", "const a = html`<${b}>c`;\n", "const a = html`<${b}>c`;\n"],
+ [
+ "const a = html`e
d`;\n",
+ "const a = html`e
d`;\n",
+ "const a = html`e
\n d `;\n",
+ ],
+ [
+ "const a = html``;\n",
+ "const a = html``;\n",
+ "const a = html``;\n",
+ ],
+ ])("%j", async (before, after, ofPrettier) => {
+ expect(after).not.toBe(ofPrettier);
+ const [written, again, checked] = await Promise.all([
+ format({ "a.js": before }, [], { reads: ["a.js"] }),
+ different({ "a.js": after }, []),
+ format({ "a.js": before }, ["--debug-check"], { reads: ["a.js"] }),
+ ]);
+ expect(written.files).toEqual({ "a.js": after });
+ expect(written.exitCode).toBe(0);
+ expect(again).toEqual([]);
+ expect(checked.stderr).toBe("");
+ expect(checked.exitCode).toBe(0);
+ });
});
test("HTML and Vue in blocks of code in Markdown", async () => {
@@ -1085,12 +1507,13 @@ describe.concurrent("bun format", () => {
const left = { "a.astro": "a
\n", "b.astro": "b
\n" };
const files = { ".prettierrc": '{ "plugins": ["prettier-plugin-astro"] }\n', ...left, "c.js": ugly };
const reads = [...Object.keys(left), "c.js"];
- const text = "2 files are in a language that bun format does not support yet, and left as they are: 2 .astro";
+ const text = "2 files were not formatted because bun fmt does not support their language yet: 2 .astro";
const result = await format(files, [], { reads });
expect(result.files).toEqual({ ...left, "c.js": formatted });
- expect(result.stderr.trimEnd().split("\n").at(-1)).toBe(
- `[error] ${text}. With --allow-unsupported this is a warning.`,
- );
+ expect(result.stderr.trimEnd().split("\n").slice(-2)).toEqual([
+ `[error] ${text}`,
+ "[error] Use --allow-unsupported to make this a warning.",
+ ]);
expect(result.exitCode).toBe(2);
const checked = await format({ ...files, "c.js": formatted }, ["--check"], { reads });
expect(checked.stderr).toContain(`[error] ${text}`);
@@ -1143,8 +1566,57 @@ exports.format = async (text, options) => {
const paths = [JSON.parse(calls[0]).filepath, ...result.files[reads[3]]!.trim().split("\n")];
expect(paths.map(it => basename(it))).toEqual(["a.svelte", "a.svelte", ".prettierrc"]);
expect(paths).toEqual(paths.map(it => resolve(it)));
- expect(result.stderr).toContain("1 file was handed to the Prettier of the project");
+ expect(result.stderr).toContain("Used your installed Prettier for 1 file in a language that needs a plugin");
+ expect(result.exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ // The order of prettier-plugin-packagejson is that of the package sort-package-json, not that of `sortPackageJson`.
+ test(
+ "so does a package.json with prettier-plugin-packagejson, and no other file",
+ async () => {
+ const plugin = "prettier-plugin-packagejson";
+ const project = {
+ ...packages,
+ [`node_modules/${plugin}/package.json`]: `{ "name": "${plugin}", "version": "3.0.0" }`,
+ ".prettierrc": `{ "plugins": ["${plugin}"], "packageSortOrder": ["version"] }\n`,
+ "package.json": '{ "a": 1 }\n',
+ "packages/b/package.json": '{ "b": 1 }\n',
+ "my-package.json": '{ "c": 1 }\n',
+ "d.js": "d ;\n",
+ };
+ const names = ["package.json", "packages/b/package.json", "my-package.json", "d.js"];
+ const result = await format(project, [], { reads: names });
+ expect(result.files).toEqual({
+ "package.json": '{ "a": 1 }\n',
+ "packages/b/package.json": '{ "b": 1 }\n',
+ "my-package.json": '{ "c": 1 }\n',
+ "d.js": "d;\n",
+ });
+ expect(result.stderr).toContain("Used your installed Prettier for 2 files");
+ expect(result.stderr).not.toContain("[warn]");
expect(result.exitCode).toBe(0);
+ // The flag is for what cannot be done, and this can.
+ const withFlag = await format(project, ["--allow-unsupported"], { reads: names });
+ expect(withFlag.files).toEqual(result.files);
+ expect(withFlag.stderr).toContain("Used your installed Prettier for 2 files");
+
+ // Without Prettier only those files are left, and with the flag they are formatted without the plugin.
+ const { ".prettierrc": config, "package.json": text } = project;
+ const alone = { ".prettierrc": config, "package.json": text, "d.js": "d ;\n" };
+ const left = await format(alone, [], { reads: ["package.json", "d.js"] });
+ expect(left.files).toEqual({ "package.json": text, "d.js": "d;\n" });
+ expect(left.stderr).toContain(`Not installed: prettier, ${plugin}`);
+ expect(left.stderr).toContain(
+ `[error] 1 file was not formatted because the Prettier config uses plugins that bun fmt does not include: ${plugin}\n[error] Use --allow-unsupported to format it without the plugins.\n`,
+ );
+ expect(left.stderr).not.toContain("language");
+ expect(left.exitCode).toBe(2);
+ const allowed = await format(alone, ["--allow-unsupported"], { reads: ["package.json"] });
+ expect(allowed.files).toEqual({ "package.json": '{\n "a": 1\n}\n' });
+ expect(allowed.stderr).toContain(`[warn] Not installed: prettier, ${plugin}`);
+ expect(allowed.exitCode).toBe(0);
},
timeout,
);
@@ -1155,7 +1627,7 @@ exports.format = async (text, options) => {
// What the file takes from the rest of the worker, with the paths of another system.
const run = (system: string, path: string, config: string | null) => `(() => {
const nodePath = require("node:path").${system};
- const [MESSAGE, DONE, FAILED, NOT_INSTALLED, cwd, seen] = [0, "0", "1", "5", "/", []];
+ const [DONE, FAILED, NOT_INSTALLED, cwd, seen] = ["0", "1", "5", "/", []];
let loadingTime = 0;
const prettier = {
resolveConfig: async (file, { config }) => void seen.push(file, config ?? null),
@@ -1164,8 +1636,8 @@ exports.format = async (text, options) => {
const createRequire = () => Object.assign(() => prettier, { resolve() {} });
const json = Buffer.from(${JSON.stringify(JSON.stringify({ ...head, path, config }))});
const message = new Uint8Array([...new Uint8Array(new Uint32Array([json.length]).buffer), ...json, 120]);
- const [buffers, ask] = [[message.buffer], () => message.length];
- const decode = (buffer, from, to) => Buffer.from(buffer, from, to - from).toString();
+ const messageWords = count => new Uint32Array(message.buffer, 0, count);
+ const messageText = (from, to = message.length) => Buffer.from(message.buffer, from, to - from).toString();
${readFileSync(join(worker, "paths.js"), "utf8")}
${readFileSync(join(worker, "prettier.js"), "utf8")}
return formatWithPrettier().then(result => [result, ...seen]);
@@ -1216,6 +1688,66 @@ exports.format = async (text, options) => {
timeout,
);
+ test(
+ "--parser with the plugin's parser: piped code goes to Prettier without a file name",
+ async () => {
+ const stdin = "c
\n";
+ const result = await format(files, ["--parser", "svelte", "--tab-width", "8"], { stdin, reads });
+ expect(result).toMatchObject({ raw: "c
\n", stderr: "", exitCode: 0 });
+ expect(result.files["a.svelte"]).toBe(files["a.svelte"]);
+ // `JSON.stringify` drops `filepath: undefined`.
+ expect(JSON.parse(result.files[reads[2]]!)).toEqual({ ...config, parser: "svelte", tabWidth: 8 });
+ expect(result.files[reads[3]]!.split("\n")[0]).toBe("undefined");
+ const checked = await format(files, ["--parser", "svelte", "--check"], { stdin });
+ expect(checked).toMatchObject({ raw: "(stdin)\n", exitCode: 1 });
+ },
+ timeout,
+ );
+
+ test.each<[string[], string, number]>([
+ [[], "[error] stdin: SyntaxError: Unexpected token (1:2)", 2],
+ [["--check"], "[error] Unexpected token (1:2)", 0],
+ ])(
+ "--parser with the plugin's parser, and the code doesn't parse: %j",
+ async (flags, stderr, exitCode) => {
+ const result = await format(files, ["--parser", "svelte", ...flags], { stdin: "broken
\n" });
+ expect(result).toMatchObject({ raw: "", stderr, exitCode });
+ },
+ timeout,
+ );
+
+ test(
+ "--parser with a parser that none of the plugins has",
+ async () => {
+ const prettier = `exports.resolveConfig = async () => null;
+class ConfigError extends Error {
+ name = "ConfigError";
+}
+exports.format = async (text, { parser }) => {
+ throw new ConfigError(\`Couldn't resolve parser "\${parser}".\`);
+};
+`;
+ const project = { ...files, "node_modules/prettier/index.cjs": prettier };
+ const result = await format(project, ["--parser", "nonsense"], { stdin: "a\n" });
+ expect(result).toMatchObject({ raw: "", stderr: `[error] Couldn't resolve parser "nonsense".`, exitCode: 1 });
+ },
+ timeout,
+ );
+
+ test("--parser with the plugin's parser, and nothing is installed", async () => {
+ const result = await format({ ".prettierrc": files[".prettierrc"] }, ["--parser", "svelte"], {
+ stdin: "c
\n",
+ });
+ expect(result.raw).toBe("");
+ expect(result.stderr.split("\n")).toEqual([
+ "[warn] Not installed: prettier, prettier-plugin-svelte",
+ "[warn] Install prettier and every plugin in your config, and bun fmt will use them for these files.",
+ "[error] 1 file was not formatted because bun fmt does not support its language yet: 1 svelte",
+ "[error] Use --allow-unsupported to make this a warning.",
+ ]);
+ expect(result.exitCode).toBe(2);
+ });
+
// As Prettier 3.9.9 with a plugin that throws this.
test.each<[string[], string, number]>([
[[], "[error] c.svelte: SyntaxError: Unexpected token (1:2)", 2],
@@ -1242,13 +1774,15 @@ exports.format = async (text, options) => {
...Object.fromEntries(installed.map(name => [name, "{}"])),
};
const stdin = "c
\n";
- const unsupported = "1 file is in a language that bun format does not support yet, and left as it is: 1 .svelte";
+ const unsupported = "1 file was not formatted because bun fmt does not support its language yet: 1 .svelte";
test.each([[[]], [["--check"]], [["--list-different"]]])("%j", async flags => {
const result = await format(project, [...flags, "--stdin-filepath", "c.svelte"], { stdin });
expect(result.raw).toBe("");
expect(result.stderr.split("\n")).toEqual([
- `[warn] Not installed: ${missing}. With all plugins of the configuration and prettier installed, bun format hands the files of their languages to them.`,
- `[error] ${unsupported}. With --allow-unsupported this is a warning.`,
+ `[warn] Not installed: ${missing}`,
+ "[warn] Install prettier and every plugin in your config, and bun fmt will use them for these files.",
+ `[error] ${unsupported}`,
+ "[error] Use --allow-unsupported to make this a warning.",
]);
expect(result.exitCode).toBe(2);
});
@@ -1354,7 +1888,7 @@ exports.format = async (text, options) => {
{ reads: ["a.svelte", "c.svelte"] },
);
expect(result.files).toEqual({ "a.svelte": "a
\n", "c.svelte": "waits
\n" });
- expect(result.stderr).toContain("[error] c.svelte: A promise is not settled, and nothing is left to wait for.");
+ expect(result.stderr).toContain("[error] c.svelte: A promise never settled, and nothing is left to wait for.");
expect(result.exitCode).toBe(2);
},
timeout,
@@ -1391,9 +1925,9 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format(others, [], { reads: ["a.svelte"] });
expect(result.files["a.svelte"]).toBe(files["a.svelte"]);
expect(result.stderr).toContain(
- "[warn] Not installed: prettier-plugin-svelte. With all plugins of the configuration and prettier installed, bun format hands the files of their languages to them.",
+ "[warn] Not installed: prettier-plugin-svelte\n[warn] Install prettier and every plugin in your config, and bun fmt will use them for these files.",
);
- expect(result.stderr).toContain("and left as it is: 1 .svelte.");
+ expect(result.stderr).toContain("does not support its language yet: 1 .svelte\n");
expect(result.exitCode).toBe(2);
},
timeout,
@@ -1412,23 +1946,24 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const reads = Object.keys(files);
const result = await format({ ...files, ".oxfmtrc.json": '{ "svelte": {} }\n' }, [], { reads });
expect(result.files).toEqual(after);
- expect(result.stderr).toContain("does not support yet, and left as it is: 1 .svelte.");
+ expect(result.stderr).toContain("does not support its language yet: 1 .svelte\n");
expect(result.exitCode).toBe(2);
const without = await format({ ...files, ".oxfmtrc.json": "{}\n" }, [], { reads });
expect(without.files).toEqual(after);
- expect(without.stderr).not.toContain("does not support yet");
+ expect(without.stderr).not.toContain("does not support");
expect(without.exitCode).toBe(0);
// oxfmt 0.72 formats the one, and gives the other back.
const piped = (config: string) =>
format({ ".oxfmtrc.json": config }, ["--stdin-filepath", "a.svelte"], { stdin: files["a.svelte"] });
expect(await piped('{ "svelte": {} }\n')).toMatchObject({
raw: "",
- stderr: expect.stringContaining("does not support yet, and left as it is: 1 .svelte."),
+ stderr: expect.stringContaining("does not support its language yet: 1 .svelte\n"),
exitCode: 2,
});
expect(await piped("{}\n")).toMatchObject({ raw: files["a.svelte"], stderr: "", exitCode: 0 });
- // Prettier has no TOML.
- expect(await different(files, [])).toEqual(["c.js"]);
+ // Prettier doesn't format TOML. Without a Prettier or oxfmt config, Bun formats it like any other language.
+ expect(await different({ ...files, ".prettierrc": "{}\n" }, [])).toEqual(["c.js"]);
+ expect(await different(files, [])).toEqual(["b.toml", "c.js", "Pipfile"]);
const broken = await format({ "b.toml": "a = = 1\n", ".oxfmtrc.json": "{}\n" }, [], { reads: ["b.toml"] });
expect(broken.files["b.toml"]).toBe("a = = 1\n");
expect(broken.stderr).toMatch(/b\.toml: SyntaxError: .+ \(1:\d+\)/);
@@ -1498,10 +2033,10 @@ ${packages["node_modules/prettier/index.cjs"]}`;
['{ "semi": null }', "Invalid semi value: null."],
['{ "semi": "true" }', 'Invalid semi value: "true".'],
['{ "endOfLine": null }', "Invalid endOfLine value: null."],
- ['{ "plugins": "x" }', '"plugins" is not an array.'],
- ['{ "overrides": 1 }', '"overrides" is not an array of objects with "files"'],
- ['{ "overrides": [{ "options": {} }] }', '"overrides" is not an array of objects with "files"'],
- ['{ "overrides": [{ "files": 1 }] }', '"overrides" is not an array of objects with "files"'],
+ ['{ "plugins": "x" }', '"plugins" must be an array'],
+ ['{ "overrides": 1 }', '"overrides" must be an array of objects, each with "files"'],
+ ['{ "overrides": [{ "options": {} }] }', '"overrides" must be an array of objects, each with "files"'],
+ ['{ "overrides": [{ "files": 1 }] }', '"overrides" must be an array of objects, each with "files"'],
])("a .prettierrc that Prettier cannot use is an error: %s", async (config, message) => {
const result = await format({ ".prettierrc": config, "a.js": ugly }, ["a.js"], { reads: ["a.js"] });
expect(result.files["a.js"]).toBe(ugly);
@@ -1514,8 +2049,8 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format({ "a.json": "", "b.js": ugly }, ["--check", "."], {
before: dir => truncateSync(join(dir, "a.json"), 2 ** 29),
});
- expect(result.stderr).toContain(`[error] Unable to read file "a.json":\n[error] EFBIG: `);
- expect(result.stderr).toContain("[warn] b.js");
+ expect(result.stderr).toContain(`error: Unable to read file "a.json":\nEFBIG: `);
+ expect(result.stdout).toBe("b.js");
expect(result.exitCode).toBe(2);
});
@@ -1539,7 +2074,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
[],
],
[{ ".prettierrc.mjs": `export default { printWidth: Infinity, rangeStart: 0, rangeEnd: Infinity };` }, []],
- [{ "bunfig.toml": `[format]\nprintWidth = 100000\n` }, []],
+ [{ "bunfig.toml": `[fmt]\nprintWidth = 100000\n` }, []],
[{}, ["--print-width", "65536"]],
[{}, ["--print-width=100000"]],
[{}, ["--print-width=9007199254740991"]],
@@ -1605,23 +2140,27 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format(files, [], { reads });
expect(result.files).toEqual({ "a.js": ugly, "b.astro": files["b.astro"], "other/c.js": formatted });
expect(result.stderr).toContain(
- "[error] 2 files are left as they are: the configuration names plugins that bun format does not have, and that may print them in another way: prettier-plugin-brace-style, ./own.js. With --allow-unsupported they are formatted without.",
+ "[error] 2 files were not formatted because the Prettier config uses plugins that bun fmt does not include: prettier-plugin-brace-style, ./own.js\n[error] Use --allow-unsupported to format them without the plugins.",
+ );
+ expect(result.stderr).toContain(
+ "[error] 1 file was not formatted because bun fmt does not support its language yet",
);
- expect(result.stderr).toContain("[error] 1 file is in a language that bun format does not support yet");
expect(result.exitCode).toBe(2);
const allowed = await format(files, ["--allow-unsupported"], { reads });
expect(allowed.files).toEqual({ "a.js": formatted, "b.astro": files["b.astro"], "other/c.js": formatted });
- expect(allowed.stderr).toContain("[warn] Plugins are not supported");
+ expect(allowed.stderr).toMatch(
+ /\[warn\] prettier-plugin-brace-style, \.\/own\.js in \S+\.prettierrc have no effect because bun fmt does not include those plugins\n/,
+ );
expect(allowed.exitCode).toBe(0);
const flag = await format({ "a.js": ugly }, ["--plugin", "prettier-plugin-brace-style"], { reads: ["a.js"] });
expect(flag.files["a.js"]).toBe(ugly);
- expect(flag.stderr).toContain("bun format does not have the plugin prettier-plugin-brace-style");
+ expect(flag.stderr).toContain("bun fmt does not include the plugin prettier-plugin-brace-style\n");
expect(flag.exitCode).toBe(2);
for (const flags of [[], ["--check"], ["--list-different"]]) {
const piped = await format(files, [...flags, "--stdin-filepath", "d.js"], { stdin: ugly });
expect(piped.raw).toBe("");
expect(piped.stderr).toBe(
- "[error] 1 file is left as it is: the configuration names plugins that bun format does not have, and that may print it in another way: prettier-plugin-brace-style, ./own.js. With --allow-unsupported it is formatted without.",
+ "[error] 1 file was not formatted because the Prettier config uses plugins that bun fmt does not include: prettier-plugin-brace-style, ./own.js\n[error] Use --allow-unsupported to format it without the plugins.",
);
expect(piped.exitCode).toBe(2);
}
@@ -1635,7 +2174,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format(files, [], { reads: ["a.js", "legacy/b.js"] });
expect(result.files).toEqual({ "a.js": formatted, "legacy/b.js": ugly });
expect(result.stderr).toContain(
- "[error] 1 file is left as it is: the configuration names plugins that bun format does not have, and that may print it in another way: prettier-plugin-brace-style.",
+ "[error] 1 file was not formatted because the Prettier config uses plugins that bun fmt does not include: prettier-plugin-brace-style\n",
);
expect(result.exitCode).toBe(2);
// An override that empties the list takes its files out.
@@ -1650,6 +2189,40 @@ ${packages["node_modules/prettier/index.cjs"]}`;
expect(other.exitCode).toBe(2);
});
+ // Prettier 3.9.9 prints 3,939 files of JavaScript and TypeScript the same with and without @prettier/plugin-oxc 0.2.3.
+ test.each<[string, Record, string[]?]>([
+ ["its name", { ".prettierrc": '{ "plugins": ["@prettier/plugin-oxc"] }' }],
+ [
+ "the module",
+ {
+ "prettier.config.mjs": 'import * as oxc from "@prettier/plugin-oxc";\nexport default { plugins: [oxc] };',
+ "node_modules/@prettier/plugin-oxc/package.json":
+ '{ "name": "@prettier/plugin-oxc", "exports": "./index.mjs" }',
+ "node_modules/@prettier/plugin-oxc/index.mjs":
+ 'export const parsers = { oxc: { astFormat: "estree" }, "oxc-ts": { astFormat: "estree" } };\n',
+ },
+ ],
+ [
+ "overrides with its parsers",
+ {
+ ".prettierrc": JSON.stringify({
+ overrides: [
+ { files: "*.js", options: { parser: "oxc", plugins: ["@prettier/plugin-oxc"] } },
+ { files: "*.ts", options: { parser: "oxc-ts", plugins: ["@prettier/plugin-oxc"] } },
+ ],
+ }),
+ },
+ ],
+ ["--plugin", {}, ["--plugin", "@prettier/plugin-oxc"]],
+ ])("the plugin that only reads with another parser, named by %s, changes nothing", async (_, files, flags = []) => {
+ const result = await format({ ...files, "a.js": ugly, "a.ts": "let a: 1\n" }, ["--log-level=warn", ...flags], {
+ reads: ["a.js", "a.ts"],
+ });
+ expect(result.stderr).toBe("");
+ expect(result.files).toEqual({ "a.js": formatted, "a.ts": "let a: 1;\n" });
+ expect(result.exitCode).toBe(0);
+ });
+
test("a plugin that only adds a language: the rest is formatted, and the files of that language are counted", async () => {
const files = {
".prettierrc": '{ "plugins": ["prettier-plugin-astro"] }\n',
@@ -1659,7 +2232,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
};
const result = await format(files, [], { reads: ["a.js", "b.astro", "c.svelte"] });
expect(result.files).toEqual({ "a.js": formatted, "b.astro": files["b.astro"], "c.svelte": files["c.svelte"] });
- expect(result.stderr).toContain("and left as it is: 1 .astro.");
+ expect(result.stderr).toContain("does not support its language yet: 1 .astro\n");
expect(result.exitCode).toBe(2);
});
@@ -1720,7 +2293,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const after = async (files: Record, args: string[] = []) =>
(await format({ "a.ts": asOxfmt, ...files }, args, { reads: ["a.ts"] })).files["a.ts"];
- test("a project that depends on oxfmt, or Vite+, and not on Prettier is formatted like oxfmt does", async () => {
+ test("a project that depends on oxfmt or Vite+ gets oxfmt's style", async () => {
expect(await after({})).toBe(asPrettier);
expect(await after({ "package.json": '{ "devDependencies": { "oxfmt": "0.72.0" } }\n' })).toBe(asOxfmt);
expect(await after({ "package.json": '{ "dependencies": { "vite-plus": "1.0.0" } }\n' })).toBe(asOxfmt);
@@ -1729,9 +2302,10 @@ ${packages["node_modules/prettier/index.cjs"]}`;
["a.ts"],
{ reads: ["a.ts"] },
);
- expect(both.files["a.ts"]).toBe(asPrettier);
+ // Depending on both suggests a migration to oxfmt, so oxfmt wins.
+ expect(both.files["a.ts"]).toBe(asOxfmt);
expect(both.stderr).toContain(
- "[warn] There is no configuration file, and the project depends on both oxfmt and prettier",
+ "note: No config file found, and package.json depends on both oxfmt and prettier\n Formatting like oxfmt. Add a config file to change that.",
);
// A configuration file says more than that.
expect(
@@ -1807,17 +2381,6 @@ ${packages["node_modules/prettier/index.cjs"]}`;
expect(result.files).toEqual({ "a.ts": asOxfmt, "pnpm-lock.yaml": "a: 1\n" });
expect(result.exitCode).toBe(0);
});
-
- test("--init writes an .oxfmtrc.json, as oxfmt does, and not over one that is there", async () => {
- const result = await format({ "a.ts": asOxfmt }, ["--init"], { reads: [".oxfmtrc.json", "a.ts"] });
- expect(result.files).toEqual({ ".oxfmtrc.json": '{\n "ignorePatterns": []\n}\n', "a.ts": asOxfmt });
- expect(result.stdout).toBe("Created `.oxfmtrc.json`.");
- expect(result.exitCode).toBe(0);
- const again = await format({ ".oxfmtrc.jsonc": "{}\n" }, ["--init"], { reads: [".oxfmtrc.jsonc"] });
- expect(again.files[".oxfmtrc.jsonc"]).toBe("{}\n");
- expect(again.stderr).toContain("A configuration file of oxfmt already exists.");
- expect(again.exitCode).toBe(1);
- });
});
// As Prettier 3.9.9 and oxfmt 0.72.
@@ -1873,7 +2436,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const files = {
[`sub/${name}`]: `
const seen = JSON.stringify([process.argv[0] === process.execPath, ...process.argv.slice(1)]);
- export default { semi: seen !== ${JSON.stringify(JSON.stringify([true, "format", ...args]))} };\n`,
+ export default { semi: seen !== ${JSON.stringify(JSON.stringify([true, "fmt", ...args]))} };\n`,
"sub/a.js": "a;\n",
};
const result = await format(files, args, { reads: ["sub/a.js"] });
@@ -1920,21 +2483,23 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format({ ...files, ".prettierrc": config }, [], { reads });
expect(result.files).toEqual({ ...files, "d.js": "d;\n" });
expect(result.stderr).toContain(
- "3 files are in a language that bun format does not support yet, and left as they are: 1 .astro, 1 .foo, 1 .js",
+ "3 files were not formatted because bun fmt does not support their language yet: 1 .astro, 1 .foo, 1 .js",
);
expect(result.exitCode).toBe(2);
const checked = await format({ ...files, ".prettierrc": config, "d.js": "d;\n" }, ["--check", ...reads], {
reads,
});
expect(checked.files).toEqual({ ...files, "d.js": "d;\n" });
- expect(checked.stderr).toContain("3 files are in a language that bun format does not support yet");
+ expect(checked.stderr).toContain(
+ "3 files were not formatted because bun fmt does not support their language yet",
+ );
expect(checked.exitCode).toBe(2);
});
test("at the top of a .prettierrc: every file is left as it is", async () => {
const result = await format({ ...files, ".prettierrc": '{ "parser": "nonsense" }\n' }, [], { reads });
expect(result.files).toEqual(files);
- expect(result.stderr).toContain("files are in a language that bun format does not support yet");
+ expect(result.stderr).toContain("files were not formatted because bun fmt does not support their language yet");
expect(result.exitCode).toBe(2);
});
@@ -1945,7 +2510,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
});
expect(result.raw).toBe("");
expect(result.stderr).toBe(
- "[error] 1 file is in a language that bun format does not support yet, and left as it is: 1 .astro. With --allow-unsupported this is a warning.",
+ "[error] 1 file was not formatted because bun fmt does not support its language yet: 1 .astro\n[error] Use --allow-unsupported to make this a warning.",
);
expect(result.exitCode).toBe(2);
});
@@ -1961,11 +2526,11 @@ ${packages["node_modules/prettier/index.cjs"]}`;
test("after --parser: an error, and nothing is written", async () => {
const result = await format(files, ["--parser", "nonsense"], { reads });
expect(result.files).toEqual(files);
- expect(result.stderr).toContain(`[error] Couldn't resolve parser "nonsense".`);
+ expect(result.stderr).toContain(`error: Couldn't resolve parser "nonsense".`);
expect(result.exitCode).toBe(2);
const piped = await format({}, ["--parser", "nonsense", "--stdin-filepath", "c.js"], { stdin: files["c.js"] });
expect(piped.raw).toBe("");
- expect(piped.stderr).toContain(`[error] Couldn't resolve parser "nonsense".`);
+ expect(piped.stderr).toContain(`error: Couldn't resolve parser "nonsense".`);
expect(piped.exitCode).toBe(2);
});
});
@@ -1979,8 +2544,8 @@ ${packages["node_modules/prettier/index.cjs"]}`;
])("JSON is not formatted into gigabytes: %s", async (_, make) => {
const files = { "ok.json": make(512), "huge.json": make(200_000) };
const [ok, huge] = await Promise.all(Object.keys(files).map(name => format(files, ["--check", name])));
- expect(ok.stderr).not.toContain("[error]");
- expect(huge.stderr).toContain("[error] huge.json:");
+ expect(ok.stderr).not.toContain("error:");
+ expect(huge.stderr).toContain("error: huge.json:");
expect(huge.exitCode).toBe(2);
});
@@ -2259,7 +2824,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
stderr: "pipe",
});
const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
- expect(stderr).toBeOneOf(["", "[error] a.js: RangeError: The code is nested too deeply.\n"]);
+ expect(stderr).toBeOneOf(["", "error: a.js: RangeError: The code is nested too deeply.\n"]);
expect({ exitCode, signalCode: proc.signalCode }).toEqual({
exitCode: stderr === "" ? 0 : 2,
signalCode: null,
@@ -2272,7 +2837,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const text = `![]()
\n`;
const result = await format({ "a.html": text }, ["a.html"], { reads: ["a.html"] });
expect(result.files["a.html"]).toBe(text);
- expect(result.stderr).toContain("[error] a.html: RangeError: Invalid string length");
+ expect(result.stderr).toContain("error: a.html: RangeError: Invalid string length");
expect(result.exitCode).toBe(2);
});
@@ -2280,9 +2845,9 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const result = await format({ "a.css": `a{${"b:c;".repeat(250)}}}` }, ["a.css"]);
// As Prettier shows them.
expect(result.stderr.split("\n").slice(0, 3)).toEqual([
- `[error] a.css: SyntaxError: Unexpected "}" (1:1004)`,
- `[error] > 1 | a{${"b:c;".repeat(250)}}}`,
- `[error] | ${" ".repeat(1_003)}^`,
+ `error: a.css: SyntaxError: Unexpected "}" (1:1004)`,
+ `> 1 | a{${"b:c;".repeat(250)}}}`,
+ ` | ${" ".repeat(1_003)}^`,
]);
expect(result.exitCode).toBe(2);
});
@@ -2308,8 +2873,8 @@ ${packages["node_modules/prettier/index.cjs"]}`;
async word => {
const text = word === "@" ? word.repeat(100_000) : `// @flow\ntype A = ${word.repeat(100_000)}x;`;
const result = await format({ "deep.js": text + "\n" }, ["--check", "deep.js"]);
- expect(result.stderr).toMatch(/^\[(?:error\] deep\.js:|warn\] deep\.js$)/m);
- expect(result.exitCode).toBe(result.stderr.includes("[error]") ? 2 : 1);
+ expect(result.stdout + "\n" + result.stderr).toMatch(/^(?:error: deep\.js:|deep\.js$)/m);
+ expect(result.exitCode).toBe(result.stderr.includes("error:") ? 2 : 1);
},
);
@@ -2333,7 +2898,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const files = { "a.js": code + "\n", "b.mjs": code + "\n", "c.jsx": code + "\n" };
const result = await format(files, [], { reads: Object.keys(files) });
expect(result.files).toEqual(files);
- for (const name of Object.keys(files)) expect(result.stderr).toContain(`[error] ${name}: SyntaxError: `);
+ for (const name of Object.keys(files)) expect(result.stderr).toContain(`error: ${name}: SyntaxError: `);
expect(result.exitCode).toBe(2);
});
@@ -2364,7 +2929,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
])("what only TypeScript's parser reads is a syntax error in JavaScript: %j", async code => {
const result = await format({ "a.js": code + "\n" }, ["a.js"], { reads: ["a.js"] });
expect(result.files).toEqual({ "a.js": code + "\n" });
- expect(result.stderr).toContain("[error] a.js: SyntaxError: ");
+ expect(result.stderr).toContain("error: a.js: SyntaxError: ");
expect(result.exitCode).toBe(2);
});
@@ -2378,7 +2943,7 @@ ${packages["node_modules/prettier/index.cjs"]}`;
const files = { "a.js": `// @flow\n${code}\n` };
const result = await format(files, ["a.js"], { reads: ["a.js"] });
expect(result.files).toEqual(files);
- expect(result.stderr).toContain("[error] a.js: SyntaxError: ");
+ expect(result.stderr).toContain("error: a.js: SyntaxError: ");
expect(result.exitCode).toBe(2);
});
@@ -2405,6 +2970,29 @@ declare export function h(): void;
["a.ts", "using a;"],
["a.js", "const a;"],
["a.js", "const { a };"],
+ ["a.ts", "class A { set x(a = await g()) {} }"],
+ ["a.ts", "yield g;"],
+ ["a.ts", "function* g() { function yield() {} }"],
+ ["a.js", "class A { static { var await; } }"],
+ ["a.ts", "label: enum E {}"],
+ ["a.cjs", "void import.meta;"],
+ ["a.ts", "module M { await g(); }"],
+ ["a.ts", "namespace N { for await (const x of y) ; }"],
+ ["a.ts", "let x: { a; b; c?; readonly d; [e: string] };"],
+ ["a.d.ts", "await g;"],
+ ["a.ts", "declare class A { x = await g; }"],
+ ["a.ts", "class A { set x(v?: number) {} }"],
+ ["a.ts", "declare module A { export = B }"],
+ ["a.d.ts", "function f() { yield; }"],
+ ["a.ts", "declare namespace N { export default class {} }"],
+ ["a.d.ts", "await using x = g();"],
+ ["a.ts", "class A { constructor(this: never) {} }"],
+ ["a.js", 'export * from "m" with { type: 1 };'],
+ ["a.ts", 'export * from "m" with { type: 1 };'],
+ ["a.js", 'import a from "m" with { type: 1 };'],
+ ["a.ts", "type T = A;"],
+ ["a.ts", "interface I {}"],
+ ["a.ts", "function f() {}"],
])("with an .oxfmtrc.json what OXC's parser refuses is a syntax error: %s: %j", async (name, code) => {
const files = { [name]: code + "\n" };
const result = await format({ ...files, ".oxfmtrc.json": "{}\n" }, [name], { reads: [name] });
@@ -2420,9 +3008,18 @@ declare export function h(): void;
["a.ts", "export {};\nlet = 1;"],
["a.js", "export {};\nstatic = 1;"],
["a.js", "for (const a of b);"],
+ // typescript-estree and Babel refuse these.
+ ["a.js", "function f(a = await g()) {}"],
+ ["a.js", "function* a(x = yield 1) {}"],
+ ["a.mts", "for (var i = 0 in {});"],
+ ["a.ts", "for (const x: any of y);"],
+ ["a.ts", "with (a) b;"],
+ ["a.js", "if (a) label: function f() {}"],
+ ["a.js", 'import("m", { with: { type: 1 } });'],
+ ["a.ts", "class C {}\nfunction g() {}\ninterface I {}"],
])("with an .oxfmtrc.json what OXC's parser takes is formatted: %s: %j", async (name, code) => {
const result = await format({ [name]: code + "\n", ".oxfmtrc.json": "{}\n" }, ["--check", name]);
- expect(result.stderr).not.toContain("[error]");
+ expect(result.stderr).not.toMatch(anError);
expect(result.exitCode).toBe(0);
});
@@ -2542,7 +3139,7 @@ try {
{ ".editorconfig": "root = true\n[*]\ninsert_final_newline = true\nindent_size = 4\n", "a.js": "if (a) b;\n" },
["--check", "a.js"],
);
- expect(result.stderr).toBe("");
+ expect(result.stderr).toBe("1 file is formatted.");
expect(result.exitCode).toBe(0);
});
@@ -2564,7 +3161,7 @@ try {
// In a directory the others are passed over.
const directory = await format(files, ["bin"], { reads });
expect(directory.files).toEqual(after);
- expect(directory.stderr).not.toContain("[error]");
+ expect(directory.stderr).not.toMatch(anError);
expect(directory.exitCode).toBe(0);
const named = await format(files, reads, { reads });
expect(named.files).toEqual(after);
@@ -2583,7 +3180,7 @@ try {
};
const result = await format(files, ["bin/a", "bin/b"], { reads: ["bin/a", "bin/b"] });
expect(result.files).toEqual({ ...files, "bin/a": `#!/usr/bin/env ${interpreter}\na;\n` });
- expect(result.stderr).toContain("[error] bin/b: SyntaxError:");
+ expect(result.stderr).toContain("error: bin/b: SyntaxError:");
expect(result.exitCode).toBe(2);
},
);
@@ -2592,9 +3189,12 @@ try {
test("what a tool has written and Prettier does not read", async () => {
const names = ["composer.lock", "Pipfile.lock", "flake.lock", "deno.lock", "mcmod.info", "MODULE.bazel.lock"];
const files = Object.fromEntries(names.map(name => [name, '{"a": 1}\n']));
- const directory = await format({ ...files, "glide.lock": "a: 1\n" }, [], { reads: [...names, "glide.lock"] });
+ // Prettier reads glide.lock as YAML. Without a Prettier config, Bun skips it like every other lock file.
+ const all = { ...files, "glide.lock": "a: 1\n" };
+ const directory = await format({ ...all, ".prettierrc": "{}\n" }, [], { reads: [...names, "glide.lock"] });
expect(directory.files).toEqual({ ...files, "glide.lock": "a: 1\n" });
expect(directory.exitCode).toBe(0);
+ expect((await format(all, [], { reads: [...names, "glide.lock"] })).files).toEqual(all);
const named = await format(files, names, { reads: names });
expect(named.files).toEqual(files);
expect(named.stderr.split("\n").filter(line => line.includes("No parser could be inferred")).length).toBe(
@@ -2616,7 +3216,7 @@ try {
const files = { "FOO": "x y\n", "a.xyz": "x y\n" };
for (const named of ["FOO", "*.xyz"]) {
const result = await format(files, [...flags, named], { reads: Object.keys(files) });
- expect(result.stderr.includes("[error] No parser could be inferred for file")).toBe(exitCode === 2);
+ expect(result.stderr.includes("error: No parser could be inferred for file")).toBe(exitCode === 2);
expect(result.files).toEqual(files);
expect(result.exitCode).toBe(exitCode);
}
@@ -2634,7 +3234,7 @@ try {
])("standard input that there is no parser for: %j", async (flags, exitCode, isSaid) => {
const result = await format({}, [...flags, "--stdin-filepath", "FOO"], { stdin: "x y\n" });
expect(result.raw).toBe("");
- expect(result.stderr.includes("[error] No parser could be inferred for file")).toBe(isSaid);
+ expect(result.stderr.includes("error: No parser could be inferred for file")).toBe(isSaid);
expect(result.exitCode).toBe(exitCode);
});
@@ -2651,11 +3251,14 @@ try {
])("standard input that does not parse: %j %j", async (configuration, flags, exitCode, before) => {
const result = await format(configuration, [...flags, "--stdin-filepath", "a.ts"], { stdin: "let a: = 1;\n" });
expect(result.raw).toBe("");
+ const [first, other] = Object.keys(configuration).length === 0 ? ["error: ", ""] : ["[error] ", "[error] "];
+ // The words of the parser of each tool.
+ const why = ".oxfmtrc.json" in configuration ? "Unexpected token" : "Type expected.";
expect(result.stderr.split("\n")).toEqual([
- `[error] ${before}Type expected. (1:8)`,
- "[error] > 1 | let a: = 1;",
- "[error] | ^",
- "[error] 2 |",
+ `${first}${before}${why} (1:8)`,
+ `${other}> 1 | let a: = 1;`,
+ `${other} | ^`,
+ `${other} 2 |`,
]);
expect(result.exitCode).toBe(exitCode);
});
@@ -2671,14 +3274,14 @@ try {
])("standard input that does not parse, with --check: %s", async (name, stdin) => {
const result = await format({}, ["--check", "--stdin-filepath", name], { stdin });
expect(result.raw).toBe("");
- expect(result.stderr).toStartWith("[error] ");
+ expect(result.stderr).toStartWith("error: ");
expect(result.stderr).not.toContain(name);
expect(result.exitCode).toBe(0);
});
test.each(["--check", "--list-different"])("a file that does not parse, with %s", async flag => {
const result = await format({ "a.ts": "let a: = 1;\n" }, [flag, "a.ts"]);
- expect(result.stderr).toStartWith("[error] a.ts: SyntaxError: Type expected. (1:8)\n");
+ expect(result.stderr).toStartWith("error: a.ts: SyntaxError: Type expected. (1:8)\n");
expect(result.exitCode).toBe(2);
});
@@ -2853,7 +3456,7 @@ try {
);
const shapes = await run(index => texts[index]);
const plain = await run(() => repeated(ordinary, length / ordinary.length));
- expect(shapes.cpu / plain.cpu).toBeLessThan(4);
+ expect(slowdown(shapes, plain)).toBeLessThan(4);
}
},
120_000,
@@ -2946,7 +3549,7 @@ try {
format(Object.fromEntries(shapes.map(([ending], index) => [`${index}.${ending}`, text(index)])), ["--check"]);
const [odd, plain] = [await run(index => texts[index]), await run(() => ordinary.repeat(length / ordinary.length))];
// 3 when all is well.
- expect(odd.cpu / plain.cpu).toBeLessThan(6);
+ expect(slowdown(odd, plain)).toBeLessThan(6);
}, 120_000);
// The same for what is repeated in something. Prettier takes the square of the number of parameters.
@@ -2966,8 +3569,8 @@ try {
const run = (text: (index: number) => string) =>
format(Object.fromEntries(shapes.map((_, index) => [`${index}.scss`, text(index)])), ["--check"]);
const [odd, plain] = [await run(index => texts[index]), await run(() => ordinary.repeat(length / ordinary.length))];
- // 3 when all is well, 1,189 without the fix. Windows counts the time of the processor in steps of 15.6 ms.
- expect(odd.cpu / plain.cpu).toBeLessThan(60);
+ // 3 when all is well, 1,189 without the fix.
+ expect(slowdown(odd, plain)).toBeLessThan(60);
}, 120_000);
// What some part of reading or printing Markdown once walked again for each repetition, or took a thousand times too
@@ -3012,8 +3615,8 @@ try {
["--check"],
);
const [shapes, plain] = [await run(index => texts[index]), await run(() => prose.repeat(length / prose.length))];
- expect(shapes.stderr).not.toContain("[error]");
- expect(shapes.cpu / plain.cpu).toBeLessThan(6);
+ expect(shapes.stderr).not.toMatch(anError);
+ expect(slowdown(shapes, plain)).toBeLessThan(6);
},
120_000,
);
@@ -3085,9 +3688,9 @@ try {
];
const files = Object.fromEntries(cases.map(([ending, text], index) => [`${index}${ending}`, text]));
const result = await format(files, ["--check"]);
- const errors = result.stderr.split("\n").filter(line => /^\[error\] \d+\./.test(line));
+ const errors = result.stderr.split("\n").filter(line => /^error: \d+\./.test(line));
expect(errors.sort()).toEqual(
- cases.map(([ending, , message], index) => `[error] ${index}${ending}: SyntaxError: ${message}`).sort(),
+ cases.map(([ending, , message], index) => `error: ${index}${ending}: SyntaxError: ${message}`).sort(),
);
expect(result.exitCode).toBe(2);
});
@@ -3101,7 +3704,7 @@ try {
[],
{ reads: ["a.html", "b.vue"] },
);
- expect(result.stderr).not.toContain("[error]");
+ expect(result.stderr).not.toMatch(anError);
expect(result.files).toEqual({
"a.html": "\n",
"b.vue": "\n",
@@ -3149,6 +3752,41 @@ try {
]);
});
+ test("skips minified code and lock files unless they're named", async () => {
+ const generated = [
+ "vendor/jquery.min.js",
+ "vendor/a.min.mjs",
+ "vendor/a.min.cjs",
+ "vendor/a.min.css",
+ "package-lock.json",
+ "npm-shrinkwrap.json",
+ "sub/pnpm-lock.yaml",
+ "bun.lock",
+ "composer.lock",
+ "deno.lock",
+ "flake.lock",
+ ];
+ const unformatted = (name: string) =>
+ name.endsWith("js")
+ ? ugly
+ : name.endsWith(".css")
+ ? "a{b:c}\n"
+ : name.endsWith(".yaml")
+ ? "a: 1\n"
+ : '{"a":1}\n';
+ const all = { ...Object.fromEntries(generated.map(name => [name, unformatted(name)])), "admin.js": ugly };
+ expect(await different(all, [])).toEqual(["admin.js"]);
+ expect(await different(all, ["**/*"])).toEqual(["admin.js"]);
+ expect(await different(all, ["vendor/jquery.min.js", "package-lock.json"])).toEqual([
+ "vendor/jquery.min.js",
+ "package-lock.json",
+ ]);
+ // Prettier formats all of these that it has a parser for.
+ const withPrettier = await different({ ...all, ".prettierrc": "{}\n" }, []);
+ expect(withPrettier).toContain("vendor/jquery.min.js");
+ expect(withPrettier).toContain("package-lock.json");
+ });
+
test("files, directories, patterns, and patterns that exclude", async () => {
expect(await different(files, ["src/deep", "a.js"])).toEqual(["src/deep/e.jsx", "a.js"]);
expect(await different(files, ["src/*.{ts,mjs}"])).toEqual(["src/b.ts", "src/c.mjs"]);
@@ -3193,7 +3831,7 @@ try {
test("an argument that matches nothing fails with 2", async () => {
const result = await format(files, ["nothing/*.js", "a.js"], { reads: ["a.js"] });
expect(result.files).toEqual({ "a.js": formatted });
- expect(result.stderr).toContain('[error] No files matching the pattern were found: "nothing/*.js".');
+ expect(result.stderr).toContain('error: No files matching the pattern were found: "nothing/*.js".');
expect(result.exitCode).toBe(2);
});
@@ -3314,6 +3952,20 @@ try {
expect(result.exitCode).toBe(0);
});
+ // Both ways to a directory: it is walked into, and it is above a file that is named.
+ test.each([
+ ["package.json", ["."]],
+ ["package.json", ["src/a.ts"]],
+ [".prettierrc", ["."]],
+ ["prettier.config.js", ["src/a.ts"]],
+ ])("a directory called %s is no configuration file: %j", async (name, args) => {
+ const files = { ".prettierrc.json": `{ "semi": false }`, [`src/${name}/b.txt`]: "", "src/a.ts": ugly };
+ const result = await format(files, args, { reads: ["src/a.ts"] });
+ expect(result.stderr).toStartWith("Formatted ");
+ expect(result.files).toEqual({ "src/a.ts": noSemi });
+ expect(result.exitCode).toBe(0);
+ });
+
test.each([
[".prettierrc", `semi: [\n`],
[".prettierrc", `1\n`],
@@ -3327,6 +3979,60 @@ try {
expect(result.exitCode).toBe(2);
});
+ // Where Prettier 3.9.9 says "YAML Error in ..: Map keys must be unique at line .., column ..". A `.prettierrc` is YAML.
+ test.each<[string, string, number, number]>([
+ [".prettierrc", `{"semi": false, "semi": true}\n`, 1, 17],
+ [".prettierrc", `semi: false\nsemi: true\n`, 2, 1],
+ [".prettierrc", `"semi": false\nsemi: true\n`, 2, 1],
+ [".prettierrc", `semi: false\n"semi": true\n`, 2, 1],
+ [".prettierrc", `'semi': false\n'semi': true\n`, 2, 1],
+ [".prettierrc", `{ "semi" : false,\n "semi" : true }\n`, 2, 3],
+ [".prettierrc", `a:\n "b": 1\n "b": 2\n`, 3, 3],
+ [".prettierrc", `{"a": {"b": 1, "b": 2}, "semi": false}\n`, 1, 16],
+ [".prettierrc", `overrides:\n - files: "*.ts"\n options:\n semi: false\n semi: false\n`, 5, 7],
+ [".prettierrc", `? semi\n: false\n? semi\n: true\n`, 3, 3],
+ [".prettierrc.yaml", `semi: false\nsemi: true\n`, 2, 1],
+ [".prettierrc.yml", `semi: false\nsemi: false\n`, 2, 1],
+ ])("a key twice in %s: %j", async (name, text, line, column) => {
+ const result = await format({ [name]: text, "a.ts": ugly }, ["a.ts"], { reads: ["a.ts"] });
+ expect(result.files).toEqual({ "a.ts": ugly });
+ expect(result.stderr).toContain("Cannot load the configuration file");
+ expect(result.stderr).toContain(`Map keys must be unique at line ${line}, column ${column}:`);
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("a key twice in YAML is shown as Prettier shows it", async () => {
+ const files = { ".prettierrc": `tabWidth: 2\noverrides:\n - files: a\n files: b\n`, "a.ts": ugly };
+ const result = await format(files, ["a.ts"]);
+ const lines = result.stderr.split("\n").map(line => line.replace(/^\[error\] ?/, ""));
+ expect(lines.slice(1, 6)).toEqual([
+ "Map keys must be unique at line 4, column 5:",
+ "",
+ " - files: a",
+ " files: b",
+ " ^",
+ ]);
+ });
+
+ // Prettier 3.9.9 takes the last.
+ test.each([
+ [".prettierrc.json", `{"semi": true, "semi": false}\n`],
+ [".prettierrc.json5", `{semi: true, semi: false}\n`],
+ ])("a key twice in %s", async (name, text) => {
+ const result = await format({ [name]: text, "a.ts": ugly }, ["a.ts"], { reads: ["a.ts"] });
+ expect(result.files).toEqual({ "a.ts": noSemi });
+ expect(result.exitCode).toBe(0);
+ });
+
+ test.each([`prettier:\n semi: false\n semi: false\n`, `name: a\nname: b\nprettier:\n semi: false\n`])(
+ "a package.yaml with a key twice has no configuration: %j",
+ async text => {
+ const result = await format({ "package.yaml": text, "a.ts": ugly }, ["a.ts"], { reads: ["a.ts"] });
+ expect(result.files).toEqual({ "a.ts": formatted });
+ expect(result.exitCode).toBe(0);
+ },
+ );
+
test("a package.yaml that cannot be read has no configuration", async () => {
const files = { "package.yaml": `name: [\n`, ".prettierrc": `semi: false\n`, "a.ts": ugly };
const result = await format(files, ["a.ts"], { reads: ["a.ts"] });
@@ -3425,7 +4131,7 @@ try {
test("requirePragma and checkIgnorePragma", async () => {
const files = {
"none.js": ugly,
- // Not `format.js`: that is what `bun format` would run.
+ // Not `format.js`: that is what `bun fmt` would run.
"at-format.js": `/** @format */\n${ugly}`,
"prettier.js": `#!/usr/bin/env bun\n/**\n * Text.\n * @prettier\n */\n${ugly}`,
"in-text.js": `/** see @format */\n${ugly}`,
@@ -3605,6 +4311,31 @@ try {
});
});
+ // What Prettier 3.9.9 does with each. In a worktree `.git` is a file.
+ describe.each<[string, Record, boolean]>([
+ ["nothing", {}, false],
+ ["a folder .git", { "repo/.git/HEAD": "" }, true],
+ ["a file .git", { "repo/.git": "gitdir: ../elsewhere\n" }, true],
+ ["a folder .hg", { "repo/.hg/store": "" }, true],
+ ["a file .hg", { "repo/.hg": "" }, false],
+ ["a folder .editorconfig", { "repo/.editorconfig/a": "root = true\n" }, false],
+ ])("an .editorconfig above a directory with %s", (_, marker, isRoot) => {
+ const files = { ".editorconfig": "[*]\nindent_style = tab\n", "repo/src/a.js": ugly, ...marker };
+ const expected = isRoot ? formatted : formatted.replace(" return", "\treturn");
+
+ test.each([[["."]], [["src/a.js"]]])("%j", async args => {
+ const result = await format(files, args, { cwd: "repo", reads: ["repo/src/a.js"] });
+ expect(result.files).toEqual({ "repo/src/a.js": expected });
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("standard input", async () => {
+ const result = await format(files, ["--stdin-filepath", "src/a.js"], { cwd: "repo", stdin: ugly });
+ expect(result.raw).toBe(expected);
+ expect(result.exitCode).toBe(0);
+ });
+ });
+
describe("how an .editorconfig is read", () => {
// The one above says whether the one that is read is a root: with it, the quotes are single.
const project = {
@@ -3803,7 +4534,7 @@ try {
print({}, "--stdin-filepath", "my_node_modules/a.js"),
print({}, "--stdin-filepath", ".git/a.js"),
print({}, "--with-node-modules", "--stdin-filepath", "node_modules/x/a.js"),
- print({ "bunfig.toml": "[format]\nwithNodeModules = true\n" }, "--stdin-filepath", "node_modules/x/a.js"),
+ print({ "bunfig.toml": "[fmt]\nwithNodeModules = true\n" }, "--stdin-filepath", "node_modules/x/a.js"),
print({ ".oxfmtrc.json": "{}" }, "--stdin-filepath", "node_modules/x/a.js"),
print({}, "--flavor=oxfmt", "--stdin-filepath", "node_modules/x/a.js"),
]);
@@ -3817,6 +4548,415 @@ try {
});
});
+ // Expected values come from Prettier 3.9.9, which reads standard input whenever it gets no file arguments.
+ describe("--parser without any paths formats standard input", () => {
+ const files = {
+ "ci.yml": "jobs:\n test:\n steps:\n - run: |\n bun test\n",
+ "src/a.ts": "const a:number=1\n",
+ "package.json": `{"name":"a"}\n`,
+ ".editorconfig": "[*]\nindent_style = tab\n",
+ };
+ const reads = Object.keys(files);
+ const prettier = { ".prettierrc": "{}\n" };
+ const noSemi = { ".prettierrc": `{ "semi": false }\n` };
+ const js = `function f(){return "a"}\n`;
+ const printed = `function f() {\n return "a";\n}\n`;
+ const withoutSemi = `function f() {\n return "a"\n}\n`;
+ /** Runs `bun fmt --parser babel` with `js` on standard input. */
+ const pipe = (project: Record, flags: string[] = [], options: Options = {}) =>
+ format(project, ["--parser", "babel", ...flags], { stdin: js, ...options });
+
+ test.each([
+ ["no config", {}],
+ ["a Prettier config", { ".prettierrc": "{}\n" }],
+ ["an oxfmt config", { ".oxfmtrc.json": "{}\n" }],
+ ])("never writes to files in the working directory: %s", async (_, config) => {
+ for (const flags of [[], ["--write"], ["--check"], ["-l"]]) {
+ const result = await format({ ...files, ...config }, ["--parser", "markdown", ...flags], {
+ reads,
+ stdin: "# hi there\n",
+ });
+ expect(result.files).toEqual(files);
+ }
+ });
+
+ test.each([
+ ["babel", "const a = {b:1, c:'two'}\n", 'const a = { b: 1, c: "two" };\n'],
+ ["babel", "a = x\n", 'a = x;\n'],
+ ["babel", "// @flow\ntype A = {|a:1|}\n", "// @flow\ntype A = {| a: 1 |};\n"],
+ ["babel-flow", "type A = {|a:1|}\n", "type A = {| a: 1 |};\n"],
+ ["flow", "type A = {|a:1|}\n", "type A = {| a: 1 |};\n"],
+ ["acorn", "const a = {b:1, c:'two'}\n", 'const a = { b: 1, c: "two" };\n'],
+ ["espree", "const a = {b:1, c:'two'}\n", 'const a = { b: 1, c: "two" };\n'],
+ ["meriyah", "const a = {b:1, c:'two'}\n", 'const a = { b: 1, c: "two" };\n'],
+ ["typescript", "const a:number=1\n", "const a: number = 1;\n"],
+ ["babel-ts", "const a:number=1\n", "const a: number = 1;\n"],
+ ["css", "a{color:red}\n", "a {\n color: red;\n}\n"],
+ ["scss", "$a:1;a{b{color:$a}}\n", "$a: 1;\na {\n b {\n color: $a;\n }\n}\n"],
+ ["less", "@a:1;a{.b();color:@a}\n", "@a: 1;\na {\n .b();\n color: @a;\n}\n"],
+ ["json", '{"a":1, "b":[1,2]}\n', '{ "a": 1, "b": [1, 2] }\n'],
+ ["json5", '{"a":1, "b":[1,2]}\n', "{ a: 1, b: [1, 2] }\n"],
+ ["jsonc", '{"a":1, "b":[1,2],}\n', '{ "a": 1, "b": [1, 2] }\n'],
+ ["json-stringify", "{'a':1, b:[1,2]}\n", '{\n "a": 1,\n "b": [\n 1,\n 2\n ]\n}\n'],
+ ["yaml", "a: 1\nb:\n - 1\n", "a: 1\nb:\n - 1\n"],
+ ["markdown", "# hi there\n", "# hi there\n"],
+ ["markdown", "```js\nconst a = {b:1}\n```\n", "```js\nconst a = { b: 1 };\n```\n"],
+ ["mdx", "# hi there\n\n\n", '# hi there\n\n\n'],
+ ["html", "\na\n", "\n
a
\n"],
+ [
+ "vue",
+ "\n",
+ '\n',
+ ],
+ [
+ "angular",
+ "{{a|b}}\n",
+ '{{ a | b }}\n',
+ ],
+ ["lwc", "x\n", "x\n"],
+ ["graphql", "query { a b }\n", "query {\n a\n b\n}\n"],
+ ["glimmer", "{{b}}\n", '{{b}}'],
+ ])("%s: %j", async (parser, stdin, expected) => {
+ for (const config of [{}, prettier]) {
+ const result = await format({ ...files, ...config }, ["--parser", parser], { stdin });
+ expect(result).toMatchObject({ raw: expected, stderr: "", exitCode: 0 });
+ }
+ });
+
+ // With no extension to go by, the TypeScript parsers try with JSX and without.
+ test.each([
+ ["typescript", "a = x\n", "a = x;\n"],
+ ["typescript", "a = x\n", 'a = x;\n'],
+ ["typescript", "const f = (x:T)=>x\n", "const f = (x: T) => x;\n"],
+ ["typescript", "const a = (b: T) => {b}\n", "const a = (b: T) => {b};\n"],
+ ["typescript", "//
x
\n", 'a = x
;\n'],
+ ])("%s takes both JSX and type assertions: %j", async (parser, stdin, expected) => {
+ const result = await format(prettier, ["--parser", parser], { stdin });
+ expect(result).toMatchObject({ raw: expected, stderr: "", exitCode: 0 });
+ });
+
+ test.each([
+ ["const a = x
\nlet b: = 1\n", "(2:8)"],
+ ["const a = x
\n", "p"], ])("a NUL in %s", async (_, text, name) => { expect(await bytesAfter({ "a.html": text })).toEqual({ - errors: [`[error] a.html: SyntaxError: Opening tag "${name}" not terminated. (1:1)`], + errors: [`error: a.html: SyntaxError: Opening tag "${name}" not terminated. (1:1)`], exitCode: 2, files: { "a.html": text }, }); @@ -4207,8 +5347,7 @@ describe.concurrent("line breaks, byte order marks and encodings", () => { }); const [, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]); return { - // Not the lines of a code frame: `[error] > 2 | ..`, `[error] | ^`. - errors: stderr.split(/\r?\n/).filter(line => /^\[error\] [^ >|]/.test(line)), + errors: stderr.split(/\r?\n/).filter(line => line.startsWith("error: ")), exitCode, files: Object.fromEntries( Object.keys(files).map(name => [name, readFileSync(join(String(dir), name)).toString("latin1")]), @@ -4541,7 +5680,7 @@ describe.concurrent("upper and lower case in the name of a file", () => { stderr: "pipe", }); const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]); - expect(stderr).not.toContain("[error]"); + expect(stderr).not.toMatch(anError); expect(readFileSync(join(String(dir), "a.ts"), "utf8")).toBe("let a: number = 1;\n"); // The file that takes its place has its name, not the one that was typed. expect(readdirSync(String(dir))).toEqual(["a.ts"]); @@ -4549,10 +5688,10 @@ describe.concurrent("upper and lower case in the name of a file", () => { }); }); -describe.concurrent("a format script in package.json", () => { +describe.concurrent("a fmt script in package.json", () => { test("wins over the formatter", async () => { const result = await format( - { "package.json": JSON.stringify({ scripts: { format: "echo the script" } }), "a.js": ugly }, + { "package.json": JSON.stringify({ scripts: { fmt: "echo the script" } }), "a.js": ugly }, [], { reads: ["a.js"] }, ); @@ -4560,9 +5699,19 @@ describe.concurrent("a format script in package.json", () => { expect(result.files).toEqual({ "a.js": ugly }); }); - test("in that script, bun format is the formatter", async () => { - const script = `"${bunExe().replaceAll("\\", "/")}" format a.js`; - const result = await format({ "package.json": JSON.stringify({ scripts: { format: script } }), "a.js": ugly }, [], { + // Most projects call theirs `format`. + test("a format script does not", async () => { + const scripts = { format: "echo the script", preformat: "echo before", postformat: "echo after" }; + const files = { "package.json": JSON.stringify({ scripts }, null, 2) + "\n", "a.js": ugly }; + const result = await format(files, [], { reads: ["a.js"] }); + expect(result.stdout).toBe("a.js"); + expect(result.files).toEqual({ "a.js": formatted }); + expect(result.exitCode).toBe(0); + }); + + test("in that script, bun fmt is the formatter", async () => { + const script = `"${bunExe().replaceAll("\\", "/")}" fmt a.js`; + const result = await format({ "package.json": JSON.stringify({ scripts: { fmt: script } }), "a.js": ugly }, [], { reads: ["a.js"], }); expect(result.files).toEqual({ "a.js": formatted }); @@ -4570,11 +5719,11 @@ describe.concurrent("a format script in package.json", () => { }); }); -// What `bun format` meant before there was a formatter. -describe.concurrent("what else is called format in the project", () => { +// What `bun fmt` meant before there was a formatter. +describe.concurrent("what else is called fmt in the project", () => { test.each([ - ["a file", { "format.ts": 'console.log("the file");' }, "the file"], - ["the index of a directory", { "format/index.js": 'console.log("the index");' }, "the index"], + ["a file", { "fmt.ts": 'console.log("the file");' }, "the file"], + ["the index of a directory", { "fmt/index.js": 'console.log("the index");' }, "the index"], ])("%s wins over the formatter, and nothing is rewritten", async (_, files, printed) => { const result = await format({ ...files, "a.js": ugly }, [], { reads: ["a.js"] }); expect(result.stdout).toBe(printed); @@ -4583,10 +5732,10 @@ describe.concurrent("what else is called format in the project", () => { }); test.skipIf(isWindows)("an executable of a package wins over the formatter, and nothing is rewritten", async () => { - const files = { "node_modules/.bin/format": "#!/bin/sh\necho the executable\n", "a.js": ugly }; + const files = { "node_modules/.bin/fmt": "#!/bin/sh\necho the executable\n", "a.js": ugly }; const result = await format(files, [], { reads: ["a.js"], - before: dir => chmodSync(join(dir, "node_modules/.bin/format"), 0o755), + before: dir => chmodSync(join(dir, "node_modules/.bin/fmt"), 0o755), }); expect(result.stdout).toBe("the executable"); expect(result.files).toEqual({ "a.js": ugly }); @@ -4594,14 +5743,14 @@ describe.concurrent("what else is called format in the project", () => { }); test("a directory with nothing to run in it does not", async () => { - const result = await format({ "format/notes.txt": "x", "a.js": ugly }, [], { reads: ["a.js"] }); + const result = await format({ "fmt/notes.txt": "x", "a.js": ugly }, [], { reads: ["a.js"] }); expect(result.files).toEqual({ "a.js": formatted }); expect(result.exitCode).toBe(0); }); // On macOS a directory that can be searched is executable for `which`. test("nor beside package.json", async () => { - const files = { "package.json": "{}\n", "format/notes.txt": "x", "a.js": ugly }; + const files = { "package.json": "{}\n", "fmt/notes.txt": "x", "a.js": ugly }; const result = await format(files, [], { reads: ["a.js"] }); expect(result.files).toEqual({ "a.js": formatted }); expect(result.exitCode).toBe(0); @@ -4609,8 +5758,8 @@ describe.concurrent("what else is called format in the project", () => { }); // What the formatter takes from the process that it runs in: the terminal, the arguments, the streams, the stack, a way to run a -// configuration file that is a program. Where `bun format` is developed something else is in Bun's place for each of these. -describe.concurrent("what bun format takes from Bun", () => { +// configuration file that is a program. Where `bun fmt` is developed something else is in Bun's place for each of these. +describe.concurrent("what bun fmt takes from Bun", () => { /** `bun ...args` in a directory with `files`. */ async function bun(files: Record`;
diff --git a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.prettier.snap b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.prettier.snap
deleted file mode 100644
index e85e865a148c..000000000000
--- a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution-and-not-closed.js.prettier.snap
+++ /dev/null
@@ -1,23 +0,0 @@
-------------------
-{ printWidth: 80 }
-------------------
-a = html`<${t}>`;
-b = html`<${t} ${a}>x`;
-c = html``;
-d = html`<${t} ${a}>x`;
-e = open ? html`<${t} ${a}>` : html`<${t} ${a}>${k}`;
-f = html`<${t} ${a} />`;
-g = html``;
-
--------------------
-{ printWidth: 100 }
--------------------
-a = html`<${t} >`;
-b = html`<${t} ${a}>x`;
-c = html``;
-d = html`<${t} ${a}>x`;
-e = open ? html`<${t} ${a}>` : html`<${t} ${a}>${k}`;
-f = html`<${t} ${a} />`;
-g = html``;
-
-===================== End =====================
diff --git a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.input b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.input
new file mode 100644
index 000000000000..29d53ef6d148
--- /dev/null
+++ b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.input
@@ -0,0 +1,3 @@
+a = html`<${t} ${a}>${k}`;
+b = html`<${t} ${a} />`;
+c = html` }[] };
+ const found: Record = Object.fromEntries(Object.keys(files).map(name => [name, []]));
+ for (const { filename, code, message, labels } of JSON.parse(raw).diagnostics as Diagnostic[]) {
+ const { offset, length } = labels[0].span;
+ found[filename].push(`${code ?? "error"}: ${message} @${offset}+${length}`);
+ }
+ expect(found).toEqual(
+ Object.fromEntries(rows.map(([extension, , expected], i) => [`a${i}.${extension}`, expected])),
+ );
+ });
+
+ // tsc reports TS17021 and ESLint 10.12 "Unexpected token \\u0059".
+ test("an escape in a member of a JSX tag name is a parsing error with eslint.config.js", async () => {
+ const config = `export default [{ files: ["**/*.jsx"], languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } } }];\n`;
+ const code = "const X = { Y: () => null };\nexport const a = ;\nexport async function f(a: any) { await a; }',
+ ["error: await expression not allowed in formal parameter @45+9"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; export const f = async (a: { [await (k)]: number }) => a;',
+ ["error: await expression not allowed in formal parameter @45+9"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; export function* g(a: { [yield (k)]: number }) { yield a; }',
+ ["error: yield expression not allowed in formal parameter @40+9"],
+ ],
+ [
+ "js",
+ 'const k = "a"; async function f(a = await (k)) {} f(); export {};',
+ ["error: await expression not allowed in formal parameter @36+9"],
+ ],
+ [
+ "js",
+ 'const k = "a"; const f = async (a = await k) => {}; f(); export {};',
+ ["error: await expression not allowed in formal parameter @36+7"],
+ ],
+ // A declaration of TypeScript that is a statement by itself is outside the await context.
+ [
+ "ts",
+ 'const k = "a"; type T = { [await (k)]: number }; export {};',
+ ["error: The keyword 'await' is reserved @27+5"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; interface T { [await (k)]: number } export {};',
+ ["error: The keyword 'await' is reserved @30+5"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; abstract class C { [await (k)]: number = 1 } export {};',
+ ["error: The keyword 'await' is reserved @35+5"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; export async function f() { interface T { [await (k)]: number } return 1 as T; }',
+ ["error: The keyword 'await' is reserved @58+5"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; declare let x: { [await (k)]: number }; export {};',
+ ["eslint(no-undef): 'await' is not defined. @33+5"],
+ ],
+ [
+ "ts",
+ 'const k = "a"; declare class C { [await (k)]: number } export {};',
+ ["eslint(no-undef): 'await' is not defined. @34+5"],
+ ],
+ // Nothing says that these are modules, so `await (k)` is a call.
+ ["ts", 'const k = "a"; let x: { [await (k)]: number };', ["eslint(no-undef): 'await' is not defined. @25+5"]],
+ ["ts", "const k = 1; await (k);", ["eslint(no-undef): 'await' is not defined. @13+5"]],
+ ["js", "const k = 1; await (k);", ["eslint(no-undef): 'await' is not defined. @13+5"]],
+ ["ts", "const k = [1]; await [k];", ["eslint(no-undef): 'await' is not defined. @15+5"]],
+ // `await k` says so.
+ ["ts", "const k = 1; await (k); await k;", []],
+ ["ts", "const k = 1; await k; let x: { [await (k)]: number };", []],
+ ["mts", 'const k = "a"; let x: { [await (k)]: number };', []],
+ ];
+ const rules = { "no-undef": "error", "no-await-in-loop": "error", "unicorn/no-unnecessary-await": "error" };
+ const files = Object.fromEntries(rows.map(([extension, code], i) => [`a${i}.${extension}`, code + "\n"]));
+ const { raw } = await lint(
+ { ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, rules }), ...files },
+ ["-f", "json"],
+ );
+ type Diagnostic = { filename: string; code?: string; message: string; labels: { span: Record }[] };
+ const found: Record = Object.fromEntries(Object.keys(files).map(name => [name, []]));
+ for (const { filename, code, message, labels } of JSON.parse(raw).diagnostics as Diagnostic[]) {
+ const { offset, length } = labels[0].span;
+ found[filename].push(`${code ?? "error"}: ${message} @${offset}+${length}`);
+ }
+ expect(found).toEqual(
+ Object.fromEntries(rows.map(([extension, , expected], i) => [`a${i}.${extension}`, expected])),
+ );
+ });
+
+ // Each row is what oxlint 1.87 prints. oxc's parser reports these, so the file isn't linted. tsc leaves them to its checker
+ // (TS1308, TS1163), and typescript-estree says nothing.
+ test("with .oxlintrc.json `await` outside an async function and `yield` outside a generator are errors", async () => {
+ const all = "ts tsx mts cts js jsx mjs cjs";
+ const typescript = "ts tsx mts cts";
+ // "await@15": the error about `await`, at offset 15. "linted": no error, and the `debugger` in the last line is reported.
+ const rows: [extensions: string, code: string, found: string][] = [
+ [all, "function f() { await g(); }", "await@15"],
+ [all, "function f() { return await g; }", "await@22"],
+ [all, "function f() { await 1; }", "await@15"],
+ [all, "const f = () => { await g(); };", "await@18"],
+ [all, "const f = () => await g();", "await@16"],
+ [all, "class A { m() { await g(); } }", "await@16"],
+ [all, "class A { get x() { return await g(); } }", "await@27"],
+ [all, "class A { constructor() { await g(); } }", "await@26"],
+ [all, "const o = { m() { await g(); } };", "await@18"],
+ [all, "[1].forEach(x => { await g(x); });", "await@19"],
+ [all, "async function a() { function b() { await g(); } }", "await@36"],
+ [all, "async function a() { [1].forEach(x => { await g(x); }); }", "await@40"],
+ [all, "function* f() { await g(); }", "await@16"],
+ [all, "function f() { await using x = g(); }", "await@15"],
+ [all, "function f() { for (await using x of y) ; }", "await@20"],
+ [all, "function f() { class A { x = await g(); } }", "await@29"],
+ [all, "async function f() { class A { x = await g(); } }", "await@35"],
+ [all, "function f() { class A { [await g()]() {} } }", "await@26"],
+ [all, "function f() { function h(a = await g()) {} }", "await@30"],
+ [all, "function f(a = () => await g()) {}", "await@21"],
+ // One error: what follows the first `await` is read as if it were in an async function.
+ [all, "function f() { await await g; }", "await@15"],
+ [all, "function f() { await x(await y); }", "await@15"],
+ // In an async function, or not a keyword.
+ [all, "async function f() { await g(); }", "linted"],
+ [all, "const f = async () => await g();", "linted"],
+ [all, "function f() { return async () => await g(); }", "linted"],
+ [all, "function f() { return o.await; }", "linted"],
+ // A name in a script, reserved in a module.
+ ["ts tsx cts js jsx cjs", "function f() { await (g()); }", "linted"],
+ ["mts mjs", "function f() { await (g()); }", "The keyword 'await' is reserved @15+5"],
+ ["ts tsx cts js jsx cjs", "function f() { await; }", "linted"],
+ ["mts mjs", "function f() { await; }", "The keyword 'await' is reserved @15+5"],
+ ["ts tsx cts js jsx cjs", "function f() { return await in x; }", "linted"],
+ ["mts mjs", "function f() { return await in x; }", "The keyword 'await' is reserved @22+5"],
+ ["ts tsx cts js jsx cjs", "function f() { return await instanceof X; }", "linted"],
+ ["mts mjs", "function f() { return await instanceof X; }", "The keyword 'await' is reserved @22+5"],
+ ["ts tsx cts js jsx cjs", "function f() { for (await of x) ; }", "linted"],
+ ["mts mjs", "function f() { for (await of x) ; }", "The keyword 'await' is reserved @20+5"],
+ ["ts tsx cts js jsx cjs", "var await; await = 1;", "linted"],
+ // Outside every function: by the name of the file.
+ ["ts tsx mts js jsx mjs", "await g();", "linted"],
+ ["cts cjs", "await g();", "await@0"],
+ ["ts tsx js jsx", "class A { x = await g(); }", "linted"],
+ ["mts cts mjs cjs", "class A { x = await g(); }", "await@14"],
+ ["ts tsx mts js jsx mjs", "class A { [await g()]() {} }", "linted"],
+ ["cts cjs", "class A { [await g()]() {} }", "await@11"],
+ ["ts tsx js jsx", "function f(a = await g()) {}", "await expression not allowed in formal parameter @15+9"],
+ ["mts cts mjs cjs", "function f(a = await g()) {}", "await@15"],
+ [
+ "ts tsx mts js jsx mjs",
+ "const f = (a = await g()) => a;",
+ "await expression not allowed in formal parameter @15+9",
+ ],
+ ["cts cjs", "const f = (a = await g()) => a;", "await@15"],
+ // Yield.
+ [all, "function f() { yield 1; }", "yield@15"],
+ [all, "function f() { yield g(); }", "yield@15"],
+ [all, "const f = () => { yield 1; };", "yield@18"],
+ [all, "class A { m() { yield 1; } }", "yield@16"],
+ [all, "class A { x = yield g; }", "yield@14"],
+ [all, "async function f() { yield 1; }", "yield@21"],
+ [all, "function* a() { function b() { yield 1; } }", "yield@31"],
+ [all, "function* a() { [1].forEach(x => { yield x; }); }", "yield@35"],
+ [all, "function a(x = yield g) {}", "yield@15"],
+ [all, "yield g;", "yield@0"],
+ [all, "function f() { yield yield g; }", "yield@15"],
+ [all, "function* f() { yield 1; }", "linted"],
+ ["ts tsx cts js jsx cjs", "function f() { yield (g()); }", "linted"],
+ ["mts mjs", "function f() { yield (g()); }", "The keyword 'yield' is reserved @15+5"],
+ ["ts tsx cts js jsx cjs", "function f() { yield; }", "linted"],
+ ["mts mjs", "function f() { yield; }", "The keyword 'yield' is reserved @15+5"],
+ ["ts tsx cts js jsx cjs", "function f() { return yield in x; }", "linted"],
+ ["mts mjs", "function f() { return yield in x; }", "The keyword 'yield' is reserved @22+5"],
+ ["ts tsx cts js jsx cjs", "var yield; yield = 1;", "linted"],
+ // TypeScript.
+ [typescript, "function f(): void { await g(); }", "await@21"],
+ [typescript, "function f() { await g as any; }", "await@15"],
+ [typescript, "namespace N { await g(); }", "await@14"],
+ [typescript, "namespace N { export const x = await g(); }", "await@31"],
+ ["ts tsx mts", "export namespace N { await g(); }", "linted"],
+ ["cts", "export namespace N { await g(); }", "await@21"],
+ [typescript, "declare namespace N { const x = await g; }", "await@32"],
+ [typescript, "namespace N { yield g; }", "yield@14"],
+ ["ts tsx", "enum E { A = await g }", "linted"],
+ ["mts cts", "enum E { A = await g }", "await@13"],
+ ["ts tsx mts", "export enum E { A = await g }", "linted"],
+ ["cts", "export enum E { A = await g }", "await@20"],
+ [typescript, "function f() { enum E { A = await g } }", "await@28"],
+ [typescript, "async function f() { enum E { A = await g } }", "await@34"],
+ ["ts tsx", "type T = { [await g]: 1 };", "linted"],
+ ["mts cts", "type T = { [await g]: 1 };", "await@12"],
+ [typescript, "function f() { type T = { [await g]: 1 }; }", "await@27"],
+ ["ts tsx", "function f(): { [await g]: 1 } { return null!; }", "linted"],
+ ["mts cts", "function f(): { [await g]: 1 } { return null!; }", "await@17"],
+ [typescript, "function o() { @dec(await g()) class A {} }", "await@20"],
+ [typescript, "async function o() { @dec(await g()) class A {} }", "linted"],
+ ["ts tsx", "declare const x = await g;", "linted"],
+ ["mts cts", "declare const x = await g;", "await@18"],
+ [typescript, "function f() { let x: { [yield g]: 1 }; }", "yield@25"],
+ // Arrow parameters are read in the context around the arrow function.
+ [
+ all,
+ "async function f() { const h = (a = await g()) => a; }",
+ "await expression not allowed in formal parameter @36+9",
+ ],
+ [all, "function f() { const h = (a = await g()) => a; }", "await@30"],
+ [all, "const f = async (a = await g()) => a;", "await expression not allowed in formal parameter @21+9"],
+ [
+ all,
+ "function* f() { const h = (a = yield g) => a; }",
+ "yield expression not allowed in formal parameter @31+7",
+ ],
+ // `await` and `using` on two lines are no declaration.
+ ["ts tsx cts js jsx cjs", "function f() { await\nusing x = g(); }", "linted"],
+ ["mts mjs", "function f() { await\nusing x = g(); }", "The keyword 'await' is reserved @15+5"],
+ [
+ all,
+ "function f() { for await (const x of y) ; }",
+ "`for await` loops are only allowed within async functions and at the top levels of modules @19+5",
+ ],
+ // Static blocks.
+ [all, "class A { static { await g(); } }", "Cannot use await in class static initialization block @19+5"],
+ [all, "class A { static { await (g()); } }", "Cannot use await in class static initialization block @19+5"],
+ [
+ all,
+ "async function o() { class A { static { await g(); } } }",
+ "Cannot use await in class static initialization block @40+5",
+ ],
+ [
+ all,
+ "class A { static { class B { [await g()]() {} } } }",
+ "Cannot use await in class static initialization block @30+5",
+ ],
+ [
+ all,
+ "class A { static { for await (const x of y) ; } }",
+ "Cannot use 'for await' in class static initialization block @19+26",
+ ],
+ [
+ all,
+ "class A { static { await using x = g(); } }",
+ "Cannot use 'await using' in class static initialization block @19+20",
+ ],
+ [all, "class A { static { const f = () => await g(); } }", "await@35"],
+ [all, "class A { static { function f() { await g(); } } }", "await@34"],
+ [all, "class A { static { async function f() { await g(); } } }", "linted"],
+ [all, "class A { static { yield g; } }", "yield@19"],
+ ];
+ const cases = rows.flatMap(([extensions, code, found], i) =>
+ extensions.split(" ").map(extension => ({ name: `a${i}.${extension}`, code, found })),
+ );
+ const files = Object.fromEntries(cases.map(({ name, code }) => [name, code + "\ndebugger;\n"]));
+ const config = { categories: { correctness: "off" }, rules: { "no-debugger": "error" } };
+ const { raw } = await lint({ ".oxlintrc.json": JSON.stringify(config), ...files }, ["-f", "json"]);
+ const words: Record = {
+ "`await` is only allowed within async functions and at the top levels of modules": "await",
+ "A 'yield' expression is only allowed in a generator body.": "yield",
+ };
+ type Diagnostic = { filename: string; code?: string; message: string; labels: { span: Record }[] };
+ const found: Record = Object.fromEntries(cases.map(({ name }) => [name, []]));
+ for (const { filename, code, message, labels } of JSON.parse(raw).diagnostics as Diagnostic[]) {
+ const { offset, length } = labels[0].span;
+ if (code === "eslint(no-debugger)") found[filename].push("linted");
+ else if (message in words && length === 5) found[filename].push(`${words[message]}@${offset}`);
+ else found[filename].push(`${message} @${offset}+${length}`);
+ }
+ expect(found).toEqual(Object.fromEntries(cases.map(({ name, found }) => [name, [found]])));
+ });
+
+ // Each row is what oxlint 1.87 does. oxc can't parse Flow. Where it fails on a JavaScript file whose first comment has `@flow`,
+ // oxlint prints nothing about the file.
+ test("with .oxlintrc.json a file that doesn't parse is skipped silently if its first comment has @flow", async () => {
+ // "silent": nothing is printed. "error": only a syntax error. "linted": the `debugger` in the last line is reported.
+ const rows: [extension: string, code: string, outcome: "silent" | "error" | "linted"][] = [
+ ["js", "// @flow\ntype A = number;", "silent"],
+ ["js", "// @flow\nimport typeof X from 'x';", "silent"],
+ ["js", "// @flow\nimport typeof { X } from 'x';", "silent"],
+ ["js", "// @flow\nimport typeof * as X from 'x';", "silent"],
+ ["js", "// @flow\nimport { typeof X } from 'x';", "silent"],
+ ["js", "// @flow\ndeclare export function f(): void;", "silent"],
+ ["js", "/**\n * @flow strict\n */\nimport typeof X from 'x';", "silent"],
+ ["js", "#!/usr/bin/env node\n// @flow\nimport typeof X from 'x';", "silent"],
+ ["js", "'use strict';\n// @flow\nimport typeof X from 'x';", "silent"],
+ ["jsx", "// @flow\nimport typeof X from 'x';", "silent"],
+ ["mjs", "// @flow\nimport typeof X from 'x';", "silent"],
+ ["cjs", "// @flow\nimport typeof X from 'x';", "silent"],
+ ["js", "import /* @flow */ typeof X from 'x';", "silent"],
+ ["js", "type /* @flow */ A = number;", "silent"],
+ ["js", "foo( // @flow\n;", "silent"],
+ // Oxc's lexer hasn't come to the comment yet.
+ ["js", "import typeof /* @flow */ X from 'x';", "error"],
+ ["js", "import typeof X from 'x';\n// @flow", "error"],
+ ["js", "type A /* @flow */ = number;", "error"],
+ ["js", "type A = number; // @flow", "error"],
+ ["js", "type A = number;\n// @flow", "error"],
+ ["js", "foo(; // @flow", "error"],
+ // Only the first comment counts, and only in JavaScript.
+ ["js", "// first\n// @flow\nimport typeof X from 'x';", "error"],
+ ["js", "// @noflow\nimport typeof X from 'x';", "error"],
+ ["js", "import typeof X from 'x';", "error"],
+ ["ts", "// @flow\nimport typeof X from 'x';", "error"],
+ ["js", "// @flow\nfoo();", "linted"],
+ // Oxc goes on after these errors, to the end of the file, so it comes to the comment.
+ ["js", "function f() { await g(); }\n// @flow", "silent"],
+ ["js", "function f() { yield 1; }\n// @flow", "silent"],
+ ["js", "function f() { await g(); } // @flow\nlet = ;", "silent"],
+ ["js", "function f() { await g(); }\nlet = ;\n// @flow", "error"],
+ ["js", "function f(a: number) {}\n// @flow", "error"],
+ ["js", "// @flow\nfunction f(a: number) {}", "silent"],
+ ];
+ const files = Object.fromEntries(
+ rows.map(([extension, code], i) => [`a${i}.${extension}`, code + "\ndebugger;\n"]),
+ );
+ const config = { categories: { correctness: "off" }, rules: { "no-debugger": "error" } };
+ const { raw } = await lint({ ".oxlintrc.json": JSON.stringify(config), ...files }, ["-f", "json"]);
+ const codes: Record = Object.fromEntries(
+ Object.keys(files).map(name => [name, []]),
+ );
+ for (const { filename, code } of JSON.parse(raw).diagnostics as { filename: string; code?: string }[]) {
+ codes[filename].push(code);
+ }
+ const outcome = (found: (string | undefined)[]) =>
+ found.length === 0 ? "silent" : found.every(it => it === undefined) ? "error" : found.join();
+ expect(Object.fromEntries(Object.entries(codes).map(([name, found]) => [name, outcome(found)]))).toEqual(
+ Object.fromEntries(
+ rows.map(([extension, , expected], i) => [
+ `a${i}.${extension}`,
+ expected === "linted" ? "eslint(no-debugger)" : expected,
+ ]),
+ ),
+ );
+ });
+
+ // Each text is what oxlint 1.87 prints with --threads 1. It prints the files in no particular order in two of the formats.
+ test("with .oxlintrc.json every format has the code, the help and every occurrence of a syntax error", async () => {
+ const files = {
+ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, rules: { "no-debugger": "error" } }),
+ "f1.ts": "class A { constructor(); }\n",
+ "f2.ts": "function f() { await g(); await h(); }\n",
+ "f3.ts": "export = a;\nexport const b = 1;\n",
+ "f4.ts": "debugger;\n",
+ "f5.js": "class A { static { await g(); } }\n",
+ };
+ const names = Object.keys(files).slice(1);
+ const print = async (format: string) => {
+ const { raw, stdout, exitCode } = await lint(files, ["--threads", "1", "-f", format, ...names]);
+ expect(exitCode).toBe(1);
+ // Only this one has the directory in it.
+ return (format === "stylish" ? stdout : raw)
+ .replace(/\x1b\[[0-9;]*m/g, "")
+ .replace(/Finished in [\d.]+ms/, "Finished in Nms");
+ };
+ const [unix, github, junit, json, gitlab, stylish, checkstyle] = await Promise.all(
+ ["unix", "github", "junit", "json", "gitlab", "stylish", "checkstyle"].map(print),
+ );
+ expect(unix.split("\n")).toEqual([
+ "f1.ts:1:11: Constructor implementation is missing. [Error/TS(2390)]",
+ "f2.ts:1:16: `await` is only allowed within async functions and at the top levels of modules [Error]",
+ "f2.ts:1:27: `await` is only allowed within async functions and at the top levels of modules [Error]",
+ "f3.ts:1:1: An export assignment cannot be used in a module with other exported elements [Error/TS(2309)]",
+ "f4.ts:1:1: `debugger` statement is not allowed [Error/eslint(no-debugger)]",
+ "f5.js:1:20: Cannot use await in class static initialization block [Error]",
+ "",
+ "6 problems",
+ "",
+ ]);
+ expect(github.split("\n")).toEqual([
+ "::error file=f1.ts,line=1,endLine=1,col=11,endColumn=22,title=TS(2390)::f1.ts:1:11: Constructor implementation is missing.",
+ "::error file=f2.ts,line=1,endLine=1,col=16,endColumn=21,title=oxlint::f2.ts:1:16: `await` is only allowed within async functions and at the top levels of modules",
+ "::error file=f2.ts,line=1,endLine=1,col=27,endColumn=32,title=oxlint::f2.ts:1:27: `await` is only allowed within async functions and at the top levels of modules",
+ "::error file=f3.ts,line=1,endLine=1,col=1,endColumn=12,title=TS(2309)::f3.ts:1:1: An export assignment cannot be used in a module with other exported elements",
+ "::error file=f4.ts,line=1,endLine=1,col=1,endColumn=10,title=eslint(no-debugger)::f4.ts:1:1: `debugger` statement is not allowed",
+ "::error file=f5.js,line=1,endLine=1,col=20,endColumn=25,title=oxlint::f5.js:1:20: Cannot use await in class static initialization block",
+ "",
+ "Found 0 warnings and 6 errors.",
+ "Finished in Nms on 5 files with 1 rules using 1 threads.",
+ "",
+ ]);
+ expect(junit.split("\n")).toEqual([
+ '',
+ '',
+ ' ',
+ ' ',
+ ' line 1, column 11, Constructor implementation is missing. ',
+ " ",
+ " ",
+ ' ',
+ ' ',
+ ' line 1, column 16, `await` is only allowed within async functions and at the top levels of modules ',
+ " ",
+ ' ',
+ ' line 1, column 27, `await` is only allowed within async functions and at the top levels of modules ',
+ " ",
+ " ",
+ ' ',
+ ' ',
+ ' line 1, column 1, An export assignment cannot be used in a module with other exported elements ',
+ " ",
+ " ",
+ ' ',
+ ' ',
+ ' line 1, column 1, `debugger` statement is not allowed ',
+ " ",
+ " ",
+ ' ',
+ ' ',
+ ' line 1, column 20, Cannot use await in class static initialization block ',
+ " ",
+ " ",
+ " ",
+ "",
+ ]);
+ type Label = { span: { offset: number; length: number } };
+ const diagnostics = (JSON.parse(json).diagnostics as { labels: Label[] }[]).map(it => ({
+ ...it,
+ labels: it.labels.map(({ span }) => [span.offset, span.length]),
+ }));
+ expect(diagnostics).toEqual([
+ {
+ "message": "Constructor implementation is missing.",
+ "code": "TS(2390)",
+ "severity": "error",
+ "filename": "f1.ts",
+ "labels": [[10, 11]],
+ },
+ {
+ "message": "`await` is only allowed within async functions and at the top levels of modules",
+ "severity": "error",
+ "help": "Either remove this `await` or add the `async` keyword to the enclosing function",
+ "filename": "f2.ts",
+ "labels": [[15, 5]],
+ },
+ {
+ "message": "`await` is only allowed within async functions and at the top levels of modules",
+ "severity": "error",
+ "help": "Either remove this `await` or add the `async` keyword to the enclosing function",
+ "filename": "f2.ts",
+ "labels": [[26, 5]],
+ },
+ {
+ "message": "An export assignment cannot be used in a module with other exported elements",
+ "code": "TS(2309)",
+ "severity": "error",
+ "help":
+ "If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ "filename": "f3.ts",
+ "labels": [[0, 11]],
+ },
+ {
+ "message": "`debugger` statement is not allowed",
+ "code": "eslint(no-debugger)",
+ "severity": "error",
+ "url": "https://oxc.rs/docs/guide/usage/linter/rules/eslint/no-debugger.html",
+ "help": "Remove the debugger statement",
+ "filename": "f4.ts",
+ "labels": [[0, 9]],
+ },
+ {
+ "message": "Cannot use await in class static initialization block",
+ "severity": "error",
+ "filename": "f5.js",
+ "labels": [[19, 5]],
+ },
+ ]);
+ type Issue = Record<"check_name" | "severity" | "fingerprint" | "description", string> & {
+ location: { path: string; lines: { begin: number } };
+ };
+ expect(
+ (JSON.parse(gitlab) as Issue[]).map(it => [
+ it.location.path,
+ it.location.lines.begin,
+ it.check_name,
+ it.severity,
+ it.fingerprint,
+ it.description,
+ ]),
+ ).toEqual([
+ ["f1.ts", 1, "TS(2390)", "critical", "106845087d5c5a0f", "Constructor implementation is missing."],
+ [
+ "f2.ts",
+ 1,
+ "",
+ "critical",
+ "3f7536233e17e706",
+ "`await` is only allowed within async functions and at the top levels of modules",
+ ],
+ [
+ "f2.ts",
+ 1,
+ "",
+ "critical",
+ "3f7536233e17e706",
+ "`await` is only allowed within async functions and at the top levels of modules",
+ ],
+ [
+ "f3.ts",
+ 1,
+ "TS(2309)",
+ "critical",
+ "29f7a7c91515a896",
+ "An export assignment cannot be used in a module with other exported elements",
+ ],
+ ["f4.ts", 1, "eslint(no-debugger)", "critical", "9651ed4bad05aab3", "`debugger` statement is not allowed"],
+ ["f5.js", 1, "", "critical", "f7e9e2da0f31ec9c", "Cannot use await in class static initialization block"],
+ ]);
+ expect(stylish.trim().split("\n\n").sort()).toEqual([
+ "/f1.ts\n 1:11 error Constructor implementation is missing. TS(2390)",
+ "/f2.ts\n 1:16 error `await` is only allowed within async functions and at the top levels of modules \n 1:27 error `await` is only allowed within async functions and at the top levels of modules ",
+ "/f3.ts\n 1:1 error An export assignment cannot be used in a module with other exported elements TS(2309)",
+ "/f4.ts\n 1:1 error `debugger` statement is not allowed eslint(no-debugger)",
+ "/f5.js\n 1:20 error Cannot use await in class static initialization block ",
+ "✖ 6 problems (6 errors, 0 warnings)",
+ ]);
+ expect(checkstyle.match(//g)?.sort()).toEqual([
+ ' | ((message: string) => string),
+ config = quiet,
+ ) => {
+ const files = Object.fromEntries(rows.map(([extension, code], i) => [`a${i}.${extension}`, code + "\n"]));
+ const { raw } = await lint({ ".oxlintrc.json": config, ...files }, ["-f", "json"]);
+ const all = JSON.parse(raw).diagnostics as OxlintDiagnostic[];
+ const diagnostics = all.filter(it => it.severity === "error");
+ const short = typeof words === "function" ? words : (message: string) => words[message] ?? message;
+ const print = ({ message, labels }: OxlintDiagnostic) =>
+ `${short(message)} ${labels.map(({ span }) => `${span.offset}+${span.length}`).join(",")}`;
+ const found = rows.map(([extension, code], i): ErrorRow => {
+ const ofFile = diagnostics.filter(it => it.filename === `a${i}.${extension}`);
+ return [extension, code, ofFile.map(print).join(", ")];
+ });
+ return { found, diagnostics };
+ };
+
+ // Each row is what oxlint 1.87 prints. "" means that it lints the file. tsc and typescript-estree reject `a = 1`,
+ // `a as T = 1` and `++a`: to them a type assertion is no left-hand side.
+ test("assignment targets are checked like oxc's parser checks them", async () => {
+ const words: Record = {
+ "Cannot assign to this expression": "cannot",
+ "Invalid rest element target in destructuring assignment": "rest",
+ "A rest parameter or binding pattern may not have a trailing comma.": "comma",
+ "Spread must be last element": "last",
+ "Only '=' operator can be used for specifying default value.": "operator",
+ "Invalid left-hand side in assignment": "pattern",
+ "The left-hand side of an assignment expression must be a variable or a property access.": "instantiation",
+ };
+ const helps: Record = {
+ rest: "Expected an identifier or member expression, like `...rest` or `...obj.prop`.",
+ comma: "Remove the trailing comma here",
+ operator: "Replace this operator with `=`.",
+ };
+ const rows: ErrorRow[] = [
+ ["js", "a = 1;", ""],
+ ["ts", "a.b = 1;", ""],
+ ["js", "a[0] = 1;", ""],
+ ["ts", "(a) = 1;", ""],
+ ["js", "((a)) = 1;", ""],
+ ["ts", "(a.b) = 1;", ""],
+ ["ts", "this.a = 1;", ""],
+ ["js", "this = 1;", "cannot 0+4"],
+ ["js", "[a] = b;", ""],
+ ["ts", "[a, b] = c;", ""],
+ ["js", "[a = 1] = b;", ""],
+ ["ts", "[a.b] = c;", ""],
+ ["js", "[(a)] = b;", ""],
+ ["ts", "[(a.b)] = c;", ""],
+ ["js", "[[a]] = b;", ""],
+ ["ts", "[{a}] = b;", ""],
+ ["js", "[...a] = b;", ""],
+ ["ts", "[...a.b] = c;", ""],
+ ["js", "[...[a]] = b;", ""],
+ ["ts", "[...{a}] = b;", ""],
+ ["js", "[...a, b] = c;", "last 1+4"],
+ ["ts", "[...a,] = b;", "comma 5+1"],
+ ["js", "[...a = 1] = b;", "rest 4+5, cannot 4+5"],
+ ["ts", "[...a()] = b;", "rest 4+3, cannot 4+3"],
+ ["js", "[...(a)] = b;", ""],
+ ["ts", "[...1] = b;", "rest 4+1, cannot 4+1"],
+ ["js", "[a, ...b, ] = c;", "comma 8+1"],
+ ["ts", "[, a] = b;", ""],
+ ["js", "[a,,] = b;", ""],
+ ["ts", "[a,] = b;", ""],
+ ["js", "([a]) = b;", "cannot 0+5"],
+ ["ts", "(([a])) = b;", "cannot 1+5"],
+ ["js", "({a}) = b;", "cannot 0+5"],
+ ["ts", "(({a})) = b;", "cannot 1+5"],
+ ["js", "[([a])] = b;", "cannot 1+5"],
+ ["ts", "[({a})] = b;", "cannot 1+5"],
+ ["js", "({ a: ([b]) } = c);", "cannot 6+5"],
+ ["ts", "({ a: ({b}) } = c);", "cannot 6+5"],
+ ["js", "({a} = b);", ""],
+ ["ts", "({a, b} = c);", ""],
+ ["js", "({a: b} = c);", ""],
+ ["ts", "({a: b.c} = d);", ""],
+ ["js", "({a: (b)} = c);", ""],
+ ["ts", "({a = 1} = b);", ""],
+ ["js", "({a: b = 1} = c);", ""],
+ ["ts", "({...a} = b);", ""],
+ ["js", "({...a.b} = c);", ""],
+ ["ts", "({...(a)} = b);", ""],
+ ["js", "({...a, b} = c);", "last 2+4"],
+ ["ts", "({...a,} = b);", "comma 6+1"],
+ ["js", "({...a = 1} = b);", "rest 5+5, cannot 5+5"],
+ ["ts", "({...a()} = b);", "rest 5+3, cannot 5+3"],
+ ["js", "({...{a}} = b);", "rest 5+3"],
+ ["ts", "({...[a]} = b);", "rest 5+3"],
+ ["js", "({a() {}} = b);", "cannot 3+5"],
+ ["ts", "({get a() {}} = b);", "cannot 7+5"],
+ ["js", "({set a(v) {}} = b);", "cannot 7+6"],
+ ["ts", "({async a() {}} = b);", "cannot 9+5"],
+ ["js", "({'a': b} = c);", ""],
+ ["ts", "({[a]: b} = c);", ""],
+ ["js", "({1: b} = c);", ""],
+ ["js", "({a: 1} = b);", "cannot 5+1"],
+ ["ts", "({a: b()} = c);", "cannot 5+3"],
+ ["js", "({a: b += 1} = c);", "operator 5+6"],
+ ["ts", "[a += 1] = b;", "operator 1+6"],
+ ["js", "[a *= 1] = b;", "operator 1+6"],
+ ["ts", "({a: b ??= 1} = c);", "operator 5+7"],
+ ["js", "({a: b?.c} = d);", "cannot 5+4"],
+ ["ts", "[a?.b] = c;", "cannot 1+4"],
+ ["js", "a?.b = 1;", "cannot 0+4"],
+ ["ts", "a?.b.c = 1;", "cannot 0+6"],
+ ["js", "a?.[0] = 1;", "cannot 0+6"],
+ ["ts", "a?.() = 1;", "cannot 0+5"],
+ ["js", "(a?.b) = 1;", "cannot 1+4"],
+ ["ts", "(a?.b).c = 1;", ""],
+ ["js", "a?.b++;", "cannot 0+4"],
+ ["ts", "++a?.b;", "cannot 2+4"],
+ ["js", "a?.b += 1;", "cannot 0+4"],
+ ["ts", "1 = 2;", "cannot 0+1"],
+ ["js", "'a' = 1;", "cannot 0+3"],
+ ["ts", "`a` = 1;", "cannot 0+3"],
+ ["js", "null = 1;", "cannot 0+4"],
+ ["ts", "true = 1;", "cannot 0+4"],
+ ["js", "a() = 1;", "cannot 0+3"],
+ ["ts", "new a = 1;", "cannot 0+5"],
+ ["js", "new a() = 1;", "cannot 0+7"],
+ ["ts", "a`b` = 1;", "cannot 0+4"],
+ ["js", "(a, b) = 1;", "cannot 1+4"],
+ ["ts", "(a = 1) = 2;", "cannot 1+5"],
+ ["js", "(a ? b : c) = 1;", "cannot 1+9"],
+ ["ts", "(a + b) = 1;", "cannot 1+5"],
+ ["js", "(-a) = 1;", "cannot 1+2"],
+ ["ts", "(() => 1) = 1;", "cannot 1+7"],
+ ["js", "(function(){}) = 1;", "cannot 1+12"],
+ ["ts", "(class {}) = 1;", "cannot 1+8"],
+ ["js", "/a/ = 1;", "cannot 0+3"],
+ ["ts", "import.meta = 1;", "cannot 0+11"],
+ ["ts", "import('a') = 1;", "cannot 0+11"],
+ ["js", "a + b = 1;", "cannot 0+5"],
+ ["ts", "-a = 1;", "cannot 0+2"],
+ ["js", "!a = 1;", "cannot 0+2"],
+ ["ts", "typeof a = 1;", "cannot 0+8"],
+ ["js", "void a = 1;", "cannot 0+6"],
+ ["ts", "delete a = 1;", "cannot 0+8"],
+ ["js", "a * b = 1;", "cannot 0+5"],
+ ["ts", "a && b = 1;", "cannot 0+6"],
+ ["js", "a ?? b = 1;", "cannot 0+6"],
+ ["ts", "a in b = 1;", "cannot 0+6"],
+ ["js", "a instanceof b = 1;", "cannot 0+14"],
+ ["ts", "a < b = 1;", "cannot 0+5"],
+ ["js", "a++ = 1;", "cannot 0+3"],
+ ["ts", "++a = 1;", "cannot 0+3"],
+ ["js", "a ** b = 1;", "cannot 0+6"],
+ ["ts", "[a] += 1;", "pattern 0+3"],
+ ["js", "({a} += 1);", "pattern 1+3"],
+ ["ts", "[a] ||= 1;", "pattern 0+3"],
+ ["js", "([a]) += 1;", "cannot 0+5"],
+ ["ts", "a() += 1;", "cannot 0+3"],
+ ["js", "1 += 1;", "cannot 0+1"],
+ ["ts", "(a) += 1;", ""],
+ ["js", "(a.b) ||= 1;", ""],
+ ["ts", "a++;", ""],
+ ["js", "a.b++;", ""],
+ ["ts", "(a)++;", ""],
+ ["js", "((a))++;", ""],
+ ["ts", "(a.b)--;", ""],
+ ["js", "a()++;", "cannot 0+3"],
+ ["ts", "1++;", "cannot 0+1"],
+ ["js", "[a]++;", "cannot 0+3"],
+ ["ts", "({a})++;", "cannot 0+5"],
+ ["js", "([a])++;", "cannot 0+5"],
+ ["ts", "this++;", "cannot 0+4"],
+ ["ts", "(a++)++;", "cannot 1+3"],
+ ["js", "++a;", ""],
+ ["ts", "++a.b;", ""],
+ ["js", "++(a);", ""],
+ ["ts", "++a();", "cannot 2+3"],
+ ["js", "++1;", "cannot 2+1"],
+ ["ts", "++[a];", "cannot 2+3"],
+ ["js", "++{a};", "cannot 2+3"],
+ ["ts", "++-a;", "cannot 2+2"],
+ ["js", "++ ++a;", "cannot 0+6"],
+ ["ts", "++a++;", "cannot 2+3"],
+ ["js", "--(a, b);", "cannot 3+4"],
+ ["ts", "++this;", "cannot 2+4"],
+ ["js", "++new a;", "cannot 2+5"],
+ ["ts", "++(a = 1);", "cannot 3+5"],
+ ["js", "++typeof a;", "cannot 2+8"],
+ ["ts", "++!a;", "cannot 2+2"],
+ ["js", "for (a in b);", ""],
+ ["ts", "for (a.b in c);", ""],
+ ["js", "for ((a) in b);", ""],
+ ["ts", "for ([a] in b);", ""],
+ ["js", "for ({a} in b);", ""],
+ ["ts", "for (a() in b);", "cannot 5+3"],
+ ["js", "for (1 in b);", "cannot 5+1"],
+ ["ts", "for ([a()] in b);", "cannot 6+3"],
+ ["js", "for (([a]) in b);", "cannot 5+5"],
+ ["ts", "for (({a}) in b);", "cannot 5+5"],
+ ["js", "for (a = 1 in b);", "cannot 5+5"],
+ ["ts", "for (a, b in c);", "cannot 5+4"],
+ ["js", "for (a?.b in c);", "cannot 5+4"],
+ ["ts", "for (a + b in c);", "cannot 5+5"],
+ ["js", "for (-a in c);", "cannot 5+2"],
+ ["ts", "for (a of b);", ""],
+ ["js", "for (a.b of c);", ""],
+ ["ts", "for ((a) of b);", ""],
+ ["js", "for ([a] of b);", ""],
+ ["ts", "for ({a} of b);", ""],
+ ["js", "for (a() of b);", "cannot 5+3"],
+ ["ts", "for (1 of b);", "cannot 5+1"],
+ ["js", "for ([a()] of b);", "cannot 6+3"],
+ ["ts", "for (([a]) of b);", "cannot 5+5"],
+ ["js", "for (({a}) of b);", "cannot 5+5"],
+ ["ts", "for (a = 1 of b);", "cannot 5+5"],
+ ["js", "for (a, b of c);", "cannot 5+4"],
+ ["ts", "for (a?.b of c);", "cannot 5+4"],
+ ["js", "for ([...a, b] of c);", "last 6+4"],
+ ["ts", "for ({...a, b} of c);", "last 6+4"],
+ ["js", "for ([a = 1] of c);", ""],
+ ["ts", "for (this of c);", "cannot 5+4"],
+ ["js", "for (a + b of c);", "cannot 5+5"],
+ ["ts", "a() = 1; b() = 2;", "cannot 0+3"],
+ ["js", "[...a,] = b; c() = 1;", "comma 5+1, cannot 13+3"],
+ ["ts", "c() = 1; [...a,] = b;", "cannot 0+3"],
+ ["js", "[...a,] = b; [...c,] = d;", "comma 5+1, comma 18+1"],
+ ["ts", "({...{a}} = b); ({...[c]} = d);", "rest 5+3, rest 21+3"],
+ ["js", "x = (a() = 1);", "cannot 5+3"],
+ ["ts", "f(a() = 1);", "cannot 2+3"],
+ ["js", "[a() = 1] = b;", "cannot 1+3"],
+ ["ts", "({a: b() = 1} = c);", "cannot 5+3"],
+ ["js", "[[a()]] = b;", "cannot 2+3"],
+ ["ts", "[a, b(), c()] = d;", "cannot 4+3"],
+ ["js", "({a: 1, b: 2} = c);", "cannot 5+1"],
+ ["ts", "a = b() = 1;", "cannot 4+3"],
+ ["js", "a = [b()] = c;", "cannot 5+3"],
+ ["ts", "[a = b() = 1] = c;", "cannot 5+3"],
+ ["js", "let x = a() = 1;", "cannot 8+3"],
+ ["ts", "() => a() = 1;", "cannot 6+3"],
+ ["js", "a ? b() = 1 : c;", "cannot 4+3"],
+ ["ts", "a ? b : c() = 1;", "cannot 8+3"],
+ ["js", "async () => { await a = 1; };", "cannot 14+7"],
+ ["js", "function* g() { yield a = 1; }", ""],
+ ["ts", "async () => { (await a) = 1; };", "cannot 15+7"],
+ ["js", "async () => { ++await a; };", "cannot 16+7"],
+ ["ts", "a! = 1;", ""],
+ ["ts", "a!! = 1;", ""],
+ ["ts", "a.b! = 1;", ""],
+ ["ts", "a!.b = 1;", ""],
+ ["ts", "(a!) = 1;", ""],
+ ["ts", "(a)! = 1;", ""],
+ ["ts", "a()! = 1;", "cannot 0+4"],
+ ["ts", "a?.b! = 1;", "cannot 0+5"],
+ ["ts", "(a?.b)! = 1;", "cannot 0+7"],
+ ["ts", "[a]! = 1;", "cannot 0+4"],
+ ["ts", "([a]!) = 1;", "cannot 1+4"],
+ ["ts", "1! = 1;", "cannot 0+2"],
+ ["ts", "a!++;", ""],
+ ["ts", "++a!;", ""],
+ ["ts", "a()!++;", "cannot 0+4"],
+ ["ts", "[a!] = b;", ""],
+ ["ts", "({a: b!} = c);", ""],
+ ["ts", "[a()!] = b;", "cannot 1+4"],
+ ["ts", "[...a!] = b;", ""],
+ ["ts", "({...a!} = b);", ""],
+ ["ts", "for (a! of b);", ""],
+ ["ts", "for (a()! of b);", "cannot 5+4"],
+ ["ts", "(a as T) = 1;", ""],
+ ["ts", "(a.b as T) = 1;", ""],
+ ["ts", "(a() as T) = 1;", "cannot 1+8"],
+ ["ts", "([a] as T) = 1;", "cannot 1+8"],
+ ["ts", "({a} as T) = 1;", "cannot 1+8"],
+ ["ts", "((a) as T) = 1;", ""],
+ ["ts", "((a as T) as U) = 1;", ""],
+ ["ts", "(a as T as U) = 1;", ""],
+ ["ts", "(a! as T) = 1;", ""],
+ ["ts", "(1 as T) = 1;", "cannot 1+6"],
+ ["ts", "(a?.b as T) = 1;", "cannot 1+9"],
+ ["ts", "((a?.b) as T) = 1;", "cannot 1+11"],
+ ["ts", "(a as const) = 1;", ""],
+ ["ts", "a as T = 1;", ""],
+ ["ts", "a.b as T = 1;", ""],
+ ["ts", "a() as T = 1;", "cannot 0+8"],
+ ["ts", "[a] as T = 1;", "cannot 0+8"],
+ ["ts", "a as T as U = 1;", ""],
+ ["ts", "a as T += 1;", ""],
+ ["ts", "a as const = 1;", ""],
+ ["ts", "a + b as T = 1;", "cannot 0+10"],
+ ["ts", "-a as T = 1;", "cannot 0+7"],
+ ["ts", "a as T ? b : c = 1;", ""],
+ ["ts", "(a satisfies T) = 1;", ""],
+ ["ts", "(a() satisfies T) = 1;", "cannot 1+15"],
+ ["ts", "a satisfies T = 1;", ""],
+ ["ts", "a() satisfies T = 1;", "cannot 0+15"],
+ ["ts", "[a satisfies T] = b;", ""],
+ ["ts", "[a() satisfies T] = b;", "cannot 1+15"],
+ ["ts", "(a) = 1;", ""],
+ ["ts", "(a.b) = 1;", ""],
+ ["ts", "(a()) = 1;", "cannot 1+6"],
+ ["ts", "([a]) = 1;", "cannot 1+6"],
+ ["ts", "a = 1;", ""],
+ ["ts", "a.b = 1;", ""],
+ ["ts", "a() = 1;", "cannot 0+6"],
+ ["ts", "[a] = 1;", "cannot 0+6"],
+ ["ts", "(a) = 1;", ""],
+ ["ts", "a = 1;", ""],
+ ["ts", "a += 1;", ""],
+ ["ts", "a = 1;", ""],
+ ["ts", "a! = 1;", ""],
+ ["ts", "a as U = 1;", ""],
+ ["ts", "-a = 1;", "cannot 0+5"],
+ ["ts", "a++;", ""],
+ ["ts", "(a)++;", ""],
+ ["ts", "++a;", ""],
+ ["ts", "++a.b;", ""],
+ ["ts", "++a();", "cannot 2+6"],
+ ["ts", "--a;", ""],
+ ["ts", "++(a);", ""],
+ ["ts", "++(a as T);", ""],
+ ["ts", "(a as T)++;", ""],
+ ["ts", "(a() as T)++;", "cannot 1+8"],
+ ["ts", "++a as T;", ""],
+ ["ts", "[a] = b;", ""],
+ ["ts", "[a as T] = b;", ""],
+ ["ts", "[a() as T] = b;", "cannot 1+8"],
+ ["ts", "[a()] = b;", "cannot 1+6"],
+ ["ts", "({a: b} = c);", ""],
+ ["ts", "({a: b as T} = c);", ""],
+ ["ts", "({a: b() as T} = c);", "cannot 5+8"],
+ ["ts", "[...a as T] = b;", ""],
+ ["ts", "[...a] = b;", ""],
+ ["ts", "({...a as T} = b);", ""],
+ ["ts", "({...a} = b);", ""],
+ ["ts", "[...a() as T] = b;", "rest 4+8, cannot 4+8"],
+ ["ts", "[a as T = 1] = b;", ""],
+ ["ts", "[a = 1] = b;", ""],
+ ["ts", "({a: b as T = 1} = c);", ""],
+ ["ts", "[[a] as T] = b;", "cannot 1+8"],
+ ["ts", "[({a}) as T] = b;", "cannot 1+10"],
+ ["ts", "for (a as T of b);", ""],
+ ["ts", "for (a of b);", ""],
+ ["ts", "for (a() as T of b);", "cannot 5+8"],
+ ["ts", "for (a() of b);", "cannot 5+6"],
+ ["ts", "for (a as T in b);", ""],
+ ["ts", "for (a in b);", ""],
+ ["ts", "for ((a as T) of b);", ""],
+ ["ts", "for ([a as T] of b);", ""],
+ ["ts", "for (a satisfies T of b);", ""],
+ ["ts", "a = 1;", "instantiation 0+4"],
+ ["ts", "(a) = 1;", "instantiation 1+4"],
+ ["ts", "++a;", "instantiation 2+4"],
+ ["ts", "[a] = b;", "instantiation 1+4"],
+ ["ts", "(a as U) = 1;", ""],
+ ["ts", "y = a = 1;", ""],
+ ["ts", "a = b = 1;", ""],
+ ["ts", "f(a = 1);", ""],
+ ["ts", "() => a = 1;", ""],
+ ["ts", "x ? a = 1 : 0;", ""],
+ ["ts", "x ? 0 : a = 1;", ""],
+ ["ts", "let z = a = 1;", ""],
+ ["ts", "a = 1, b = 2;", ""],
+ ["ts", "for (a = 0;;);", ""],
+ ["ts", "this.a = 1;", ""],
+ ["ts", "a[0] = 1;", ""],
+ ["ts", "a?.b = 1;", "cannot 0+7"],
+ ["ts", "new a = 1;", "cannot 0+8"],
+ ["ts", "a`b` = 1;", "cannot 0+7"],
+ ["ts", "(a, b) = 1;", "cannot 0+9"],
+ ["ts", "{ a } = b;", "cannot 0+8"],
+ ["ts", "1 = 1;", "cannot 0+4"],
+ ["ts", "typeof a = 1;", "cannot 0+11"],
+ ["ts", "-a = 1;", "cannot 0+5"],
+ ["ts", "y = -a = 1;", "cannot 4+5"],
+ ];
+ const { found, diagnostics } = await withErrorsFound(rows, words);
+ expect(found).toEqual(rows);
+ for (const { message, help } of diagnostics) expect([message, help]).toEqual([message, helps[words[message]]]);
+ });
+
+ // The parser gives up on these in the middle of a module. Like oxlint 1.87, one error on line 2 and nothing about exports.
+ test.each([
+ "export const b = 1;\nx y;",
+ 'import { a } from "b";\nwidget W() {\n a();\n}',
+ "export { nope };\nf() {}",
+ ])("a JavaScript module that doesn't parse gets the parser's error alone: %j", async code => {
+ const { stdout, exitCode } = await lint({ ".oxlintrc.json": "{}", "a.js": code + "\n" }, ["-f", "unix"]);
+ expect(stdout.split("\n").filter(line => line.startsWith("a.js:"))).toEqual([
+ expect.stringMatching(/^a\.js:2:/),
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
+ // Which names are declared twice is found in two ways. With no-unused-vars on, the variables of every file are there to be
+ // asked. Without it the parser looks out for a file that may have such a name.
+ const waysToFindNames: [string, string][] = [
+ ["no rule needs the variables", quiet],
+ [
+ "no-unused-vars is on",
+ JSON.stringify({ categories: { correctness: "off" }, rules: { "no-unused-vars": "warn" } }),
+ ],
+ ];
+
+ describe.each(waysToFindNames)("a name that is declared twice, when %s", (_, config) => {
+ const declarations: Record = {
+ var: "var a;",
+ let: "let a;",
+ const: "const a = 1;",
+ fn: "function a() {}",
+ afn: "async function a() {}",
+ gfn: "function* a() {}",
+ cls: "class a {}",
+ using: "using a = null;",
+ imp: "import a from 'm';",
+ impns: "import * as a from 'm';",
+ impspec: "import { a } from 'm';",
+ iface: "interface a {}",
+ type: "type a = 1;",
+ enum: "enum a {}",
+ cenum: "const enum a {}",
+ ns: "namespace a {}",
+ nsv: "namespace a { export let x = 1; }",
+ dvar: "declare var a: any;",
+ dlet: "declare let a: any;",
+ dconst: "declare const a: any;",
+ dfn: "declare function a(): void;",
+ dcls: "declare class a {}",
+ denum: "declare enum a {}",
+ dns: "declare namespace a {}",
+ dnsv: "declare namespace a { let x: any; }",
+ sig: "function a(): void;",
+ acls: "abstract class a {}",
+ imptype: "import type a from 'm';",
+ imptspec: "import { type a } from 'm';",
+ impeq: "import a = require('m');",
+ impalias: "import a = b.c;",
+ };
+ const redeclared = /^Identifier `a` has already been declared$/;
+ /** How many redeclarations are printed for each file. "-": something else is printed too. */
+ const count = async (files: Record) => {
+ const { raw } = await lint({ ".oxlintrc.json": config, ...files }, ["-f", "json"]);
+ const errors = (JSON.parse(raw).diagnostics as OxlintDiagnostic[]).filter(it => it.severity === "error");
+ return (name: string) => {
+ const ofFile = errors.filter(it => it.filename === name);
+ return ofFile.every(it => redeclared.test(it.message)) ? String(ofFile.length) : "-";
+ };
+ };
+ /** Where oxlint has another error, what is printed here is not compared. */
+ const like = (expected: string[], found: string[]) =>
+ found.map((line, i) => [...line].map((cell, j) => (expected[i][j] === "-" ? "-" : cell)).join(""));
+
+ // One table for each place and kind of file. A line is the first declaration, a column the second, both in the order of
+ // `names`. A cell is how many "Identifier `a` has already been declared" oxlint 1.87 prints, or "-" if it has another error.
+ test("by two declarations: every pair, in many places", async () => {
+ const places: Record = {
+ same: "1 2",
+ block: "{ 1 2 }",
+ nsbody: "namespace W { 1 2 }",
+ mod: "export {}; 1 2",
+ inner: "1 { 2 }",
+ outer: "{ 1 } 2",
+ deepout: "{ { 1 } 2 }",
+ fnbody: "function w() { 1 2 }",
+ fnouter: "function w() { { 1 } 2 }",
+ sblock: "class W { static { 1 2 } }",
+ sw: "switch (0) { case 0: 1 case 1: 2 }",
+ strictblock: "'use strict'; { 1 2 }",
+ strictouter: "'use strict'; { 1 } 2",
+ modblock: "export {}; { 1 2 }",
+ modouter: "export {}; { 1 } 2",
+ };
+ const tables: [extension: string, place: string, names: string, cells: string[]][] = [
+ [
+ "ts",
+ "same",
+ "var let const fn afn gfn cls using imp impns impspec iface type enum cenum ns nsv dvar dlet dconst dfn dcls denum dns dnsv sig acls imptype imptspec impeq impalias",
+ [
+ "0111111-00000110101111101110000",
+ "1111111-00000110111111101110000",
+ "1111111-00000110111111101110000",
+ "0110000-00000110001100100000000",
+ "0110000-00000110001100100000000",
+ "0110000-00000110001100100000000",
+ "1110001-00001110011101100010000",
+ "--------000----------------00--",
+ "0000000011100000000000000001111",
+ "0000000011100000000000000001111",
+ "0000000011100000000000000001111",
+ "0000000-00001110000000100000000",
+ "0000001-00011110000001100010000",
+ "1111111-00011010011111000110000",
+ "1111111-00011100111111101110000",
+ "0000000-00000000000000000000000",
+ "1110000-00000010011100000000000",
+ "0111111-00000110101111101110000",
+ "1111111-00000110111111101110000",
+ "1111111-00000110111111101110000",
+ "0110000-00000110001100100000000",
+ "1110001-00001110011101100010000",
+ "1111111-00011010011111000110000",
+ "0000000-00000000000000000000000",
+ "1110000-00000010011100000000000",
+ "0110000-00000110001100100000000",
+ "1110001-00001110011101100010000",
+ "0000000011100000000000000001111",
+ "0000000011100000000000000001111",
+ "0000000-11100000000000000001111",
+ "0000000-11100000000000000001111",
+ ],
+ ],
+ [
+ "ts",
+ "block",
+ "var let const fn afn gfn cls using iface type enum cenum ns nsv dvar dlet dconst dfn dcls denum dns dnsv sig acls",
+ [
+ "011111110011--011111--11",
+ "111111110011--111111--11",
+ "111111110011--111111--11",
+ "011000010011--011001--00",
+ "011000010011--011001--00",
+ "011000010011--011001--00",
+ "111000110111--111011--01",
+ "111111110011--111111--11",
+ "000000000111--000001--00",
+ "000000101111--000011--01",
+ "111111111101--111110--11",
+ "111111111110--111111--11",
+ "------------------------",
+ "------------------------",
+ "011111110011--011111--11",
+ "111111110011--111111--11",
+ "111111110011--111111--11",
+ "011000010011--011001--00",
+ "111000110111--111011--01",
+ "111111111101--111110--11",
+ "------------------------",
+ "------------------------",
+ "011000010011--011001--00",
+ "111000110111--111011--01",
+ ],
+ ],
+ [
+ "ts",
+ "nsbody",
+ "var let const fn afn gfn cls using iface type enum cenum ns nsv dvar dlet dconst dfn dcls denum dns dnsv sig acls",
+ [
+ "011111110011010111110111",
+ "111111110011011111110111",
+ "111111110011011111110111",
+ "011000010011000110010000",
+ "011000010011000110010000",
+ "011000010011000110010000",
+ "111000110111001110110001",
+ "111111110011011111110111",
+ "000000000111000000010000",
+ "000000101111000000110001",
+ "111111111101001111100011",
+ "111111111110011111110111",
+ "000000000000000000000000",
+ "111000010001001110000000",
+ "011111110011010111110111",
+ "111111110011011111110111",
+ "111111110011011111110111",
+ "011000010011000110010000",
+ "111000110111001110110001",
+ "111111111101001111100011",
+ "000000000000000000000000",
+ "111000010001001110000000",
+ "011000010011000110010000",
+ "111000110111001110110001",
+ ],
+ ],
+ [
+ "js",
+ "same",
+ "var let const fn afn gfn cls using imp impns impspec",
+ [
+ "0110001-111",
+ "1111111-111",
+ "1111111-111",
+ "0110001-111",
+ "0110001-111",
+ "0110001-111",
+ "1111111-111",
+ "--------111",
+ "11122211111",
+ "11122211111",
+ "11122211111",
+ ],
+ ],
+ [
+ "js",
+ "mod",
+ "var let const fn afn gfn cls using imp impns impspec",
+ [
+ "01111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11122211111",
+ "11122211111",
+ "11122211111",
+ ],
+ ],
+ [
+ "mjs",
+ "same",
+ "var let const fn afn gfn cls using imp impns impspec",
+ [
+ "01111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11111111111",
+ "11122211111",
+ "11122211111",
+ "11122211111",
+ ],
+ ],
+ [
+ "cjs",
+ "same",
+ "var let const fn afn gfn cls using",
+ ["01100011", "11111111", "11111111", "01100011", "01100011", "01100011", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "block",
+ "var let const fn afn gfn cls using",
+ ["01111111", "11111111", "11111111", "11101111", "11111111", "11111111", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "inner",
+ "var let const fn afn gfn cls using",
+ ["00000000", "10000000", "10000000", "10000000", "10000000", "10000000", "10000000", "--------"],
+ ],
+ [
+ "js",
+ "outer",
+ "var let const fn afn gfn cls using",
+ ["0110001-", "0000000-", "0000000-", "0110001-", "0000000-", "0000000-", "0000000-", "0000000-"],
+ ],
+ [
+ "js",
+ "deepout",
+ "var let const fn afn gfn cls using",
+ ["01111111", "00000000", "00000000", "10000000", "00000000", "00000000", "00000000", "00000000"],
+ ],
+ [
+ "js",
+ "fnbody",
+ "var let const fn afn gfn cls using",
+ ["01100011", "11111111", "11111111", "01100011", "01100011", "01100011", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "fnouter",
+ "var let const fn afn gfn cls using",
+ ["01100011", "00000000", "00000000", "01100011", "00000000", "00000000", "00000000", "00000000"],
+ ],
+ [
+ "js",
+ "sblock",
+ "var let const fn afn gfn cls using",
+ ["01100011", "11111111", "11111111", "11100011", "11100011", "11100011", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "sw",
+ "var let const fn afn gfn cls using",
+ ["0111111-", "1111111-", "1111111-", "1110111-", "1111111-", "1111111-", "1111111-", "--------"],
+ ],
+ [
+ "js",
+ "strictblock",
+ "var let const fn afn gfn cls using",
+ ["01111111", "11111111", "11111111", "11111111", "11111111", "11111111", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "strictouter",
+ "var let const fn afn gfn cls using",
+ ["0110001-", "0000000-", "0000000-", "0000000-", "0000000-", "0000000-", "0000000-", "0000000-"],
+ ],
+ [
+ "js",
+ "modblock",
+ "var let const fn afn gfn cls using",
+ ["01111111", "11111111", "11111111", "11111111", "11111111", "11111111", "11111111", "11111111"],
+ ],
+ [
+ "js",
+ "modouter",
+ "var let const fn afn gfn cls using",
+ ["01111111", "00000000", "00000000", "00000000", "00000000", "00000000", "00000000", "00000000"],
+ ],
+ ];
+ const files: Record = {};
+ const nameOf = (extension: string, place: string, first: string, second: string) =>
+ `${place}-${first}-${second}.${extension}`;
+ for (const [extension, place, names] of tables) {
+ for (const first of names.split(" ")) {
+ for (const second of names.split(" ")) {
+ files[nameOf(extension, place, first, second)] =
+ places[place].replace("1", () => declarations[first]).replace("2", () => declarations[second]) + "\n";
+ }
+ }
+ }
+ const counted = await count(files);
+ for (const [extension, place, names, cells] of tables) {
+ const all = names.split(" ");
+ const found = all.map(first =>
+ all.map(second => counted(nameOf(extension, place, first, second))).join(""),
+ );
+ expect([extension, place, ...like(cells, found)]).toEqual([extension, place, ...cells]);
+ }
+ });
+
+ // A line is a place that has declared `a` already, a column the declaration that is put there.
+ test("by a declaration and a parameter, a catch parameter, the head of a loop, a type parameter", async () => {
+ const places: Record = {
+ param: "function w(a) { 2 }",
+ paramblock: "function w(a) { { 2 } }",
+ parampat: "function w({ a }) { 2 }",
+ paramdef: "function w(a = 1) { 2 }",
+ rest: "function w(...a) { 2 }",
+ arrowparam: "((a) => { 2 });",
+ arrow1: "(a => { 2 });",
+ methodparam: "({ w(a) { 2 } });",
+ ctorparam: "class W { constructor(a) { 2 } }",
+ setter: "class W { set w(a) { 2 } }",
+ catch: "try {} catch (a) { 2 }",
+ catchblock: "try {} catch (a) { { 2 } }",
+ catchpat: "try {} catch ({ a }) { 2 }",
+ catchpatblock: "try {} catch ([a]) { { 2 } }",
+ forlet: "for (let a;;) { 2 }",
+ forletbody: "for (let a of []) 2",
+ forvar: "for (var a;;) { 2 }",
+ forafter: "for (var a;;) {} 2",
+ fnexprname: "(function a() { 2 });",
+ clsexprname: "(class a { static { 2 } });",
+ modparam: "export {}; function w(a) { 2 }",
+ modcatch: "export {}; try {} catch (a) { 2 }",
+ tparam: "function w() { 2 }",
+ tparamarrow: "(() => { 2 });",
+ tparammethod: "class W { w() { 2 } }",
+ tparamcls: "class W { w() { 2 } }",
+ pprop: "class W { constructor(public a: any) { 2 } }",
+ };
+ const tables: [extension: string, places: string, names: string, cells: string[]][] = [
+ [
+ "js",
+ "param paramblock parampat paramdef rest arrowparam arrow1 methodparam ctorparam setter catch catchblock catchpat catchpatblock forlet forletbody forvar forafter fnexprname clsexprname modparam modcatch",
+ "var let const fn afn gfn cls using",
+ [
+ "01100011",
+ "00000000",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01100011",
+ "01111111",
+ "00000000",
+ "11111111",
+ "10000000",
+ "10000000",
+ "1-------",
+ "00000000",
+ "0110001-",
+ "00000000",
+ "00000000",
+ "01100011",
+ "01111111",
+ ],
+ ],
+ [
+ "ts",
+ "param paramblock parampat paramdef rest arrowparam arrow1 methodparam ctorparam setter catch catchblock catchpat catchpatblock forlet forletbody forvar forafter fnexprname clsexprname modparam modcatch tparam tparamarrow tparammethod tparamcls pprop",
+ "var let const fn afn gfn cls using iface type enum cenum ns nsv dvar dlet dconst dfn dcls denum dns dnsv sig acls",
+ [
+ "011111110011--011111--11",
+ "000000000000--000000--00",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "000000000000--000000--00",
+ "111111110011--111111--11",
+ "100000000000--100000--00",
+ "100000000000--100000--00",
+ "1----------1------------",
+ "000000000000--000000--00",
+ "0111111-0011010111110111",
+ "000000000000--000000--00",
+ "000000000000--000000--00",
+ "011111110011--011111--11",
+ "011111110011--011111--11",
+ "000000101111--000011--01",
+ "000000101111--000011--01",
+ "000000101111--000011--01",
+ "000000000000--000000--00",
+ "011111110011--011111--11",
+ ],
+ ],
+ ];
+ const files: Record = {};
+ for (const [extension, lines, names] of tables) {
+ for (const place of lines.split(" ")) {
+ for (const name of names.split(" ")) {
+ files[`${place}-${name}.${extension}`] = places[place].replace("2", () => declarations[name]) + "\n";
+ }
+ }
+ }
+ const counted = await count(files);
+ for (const [extension, lines, names, cells] of tables) {
+ const found = lines.split(" ").map(place =>
+ names
+ .split(" ")
+ .map(name => counted(`${place}-${name}.${extension}`))
+ .join(""),
+ );
+ expect([extension, ...like(cells, found)]).toEqual([extension, ...cells]);
+ }
+ });
+
+ // Each row is what oxlint 1.87 prints: the name, then where it is declared first and where again. "" means that it lints
+ // the file.
+ test("has oxlint's labels", async () => {
+ const rows: ErrorRow[] = [
+ ["ts", "function f() { type T = 1; }", "T 11+1,23+1"],
+ ["ts", "function f() { interface T {} }", "T 11+1,28+1"],
+ ["ts", "function f() { class T {} }", "T 11+1,24+1"],
+ ["ts", "function f() { enum T {} }", "T 11+1,23+1"],
+ ["ts", "function f() { let T; }", ""],
+ ["ts", "function f(T) {}", ""],
+ ["ts", "function f() { function T() {} }", ""],
+ ["ts", "const f = () => { type T = 1; };", "T 11+1,27+1"],
+ ["ts", "class A { m() { type T = 1; } }", "T 12+1,24+1"],
+ ["ts", "class A { m() { type T = 1; } }", ""],
+ ["ts", "class A {}", ""],
+ ["ts", "interface A {}", ""],
+ ["ts", "type A = A;", ""],
+ ["ts", "(class A {});", "A 7+1,9+1"],
+ ["ts", "function f() {}", ""],
+ ["ts", "(function f() {});", ""],
+ ["ts", "enum E { A, A }", "A 9+1,12+1"],
+ ["ts", "enum E { A, 'A' }", "A 9+1,12+3"],
+ ["ts", "enum E { 'A', 'A' }", "A 9+3,14+3"],
+ ["ts", "enum E { A } enum E { A }", ""],
+ ["ts", "const enum E { A, A }", "A 15+1,18+1"],
+ ["ts", "declare enum E { A, A }", "A 17+1,20+1"],
+ ["ts", "enum E { A, B, A, B }", "A 9+1,15+1, B 12+1,18+1"],
+ ["ts", "enum E { E }", ""],
+ ["ts", "enum E { ['A'], A }", "A 10+3,16+1"],
+ ["ts", "namespace N { var a; let a; }", "a 18+1,25+1"],
+ ["ts", "namespace N { { var a; } let a; }", "a 20+1,29+1"],
+ ["ts", "namespace N { var a; } let a;", ""],
+ ["ts", "let a; namespace N { var a; }", ""],
+ ["ts", "namespace N { export let a; export let a; }", "a 25+1,39+1"],
+ ["ts", "namespace N {} let N;", ""],
+ ["ts", "let N; namespace N {}", ""],
+ ["ts", "namespace N { let x; } let N;", "N 10+1,27+1"],
+ ["ts", "let N; namespace N { let x; }", "N 4+1,17+1"],
+ ["ts", "namespace N { type x = 1; } let N;", ""],
+ ["ts", "var N; namespace N { let x; }", "N 4+1,17+1"],
+ ["ts", "namespace N { let x; } var N;", "N 10+1,27+1"],
+ ["ts", "const enum N {} namespace N { let x; }", "N 11+1,26+1"],
+ ["ts", "namespace N { let x; } const enum N {}", "N 10+1,34+1"],
+ ["ts", "namespace A.B {} let A;", ""],
+ ["ts", "namespace A.B { let x; } let A;", "A 10+1,29+1"],
+ ["ts", "namespace A.B {} let B;", ""],
+ ["ts", "namespace A.B { let x } namespace A.B { let x }", ""],
+ ["ts", "declare module N { let x: any; } let N;", "N 15+1,37+1"],
+ ["ts", "declare namespace N { let x: any; } declare let N: any;", "N 18+1,48+1"],
+ ["ts", "function N() {} namespace N { let x; }", ""],
+ ["ts", "namespace N { let x; } function N() {}", ""],
+ ["ts", "class N {} namespace N { let x; }", ""],
+ ["ts", "namespace N { let x; } class N {}", ""],
+ ["ts", "enum N {} namespace N { let x; }", ""],
+ ["ts", "namespace N { let x; } enum N {}", ""],
+ ["ts", "import N from 'n'; namespace N { let x; }", ""],
+ ["ts", "declare global { let a: any; let a: any; } export {};", "a 21+1,33+1"],
+ ["ts", "declare module 'm' { let a: any; let a: any; }", "a 25+1,37+1"],
+ ["ts", "declare module 'm' { var a: any; let a: any; }", "a 25+1,37+1"],
+ ["ts", "class A {} let A;", "A 6+1,15+1"],
+ ["js", "class A {} let A;", "A 6+1,15+1"],
+ ["ts", "let A; class A {}", "A 4+1,13+1"],
+ ["ts", "class A {} enum A {}", "A 6+1,16+1"],
+ ["ts", "class A {} type A = 1;", "A 6+1,16+1"],
+ ["ts", "interface A {} enum A {}", "A 10+1,20+1"],
+ ["ts", "interface A {} type A = 1;", "A 10+1,20+1"],
+ ["ts", "interface A {} class A {} class A {}", "A 10+1,32+1"],
+ ["ts", "function A() {} class A {}", ""],
+ ["js", "function A() {} class A {}", "A 9+1,22+1"],
+ ["ts", "class A {} function A() {} let A;", "A 6+1,31+1"],
+ ["js", "class A {} function A() {} let A;", "A 6+1,20+1, A 6+1,31+1"],
+ ["ts", "function A() {} enum A {}", "A 9+1,21+1"],
+ ["ts", "var A; enum A {}", "A 4+1,12+1"],
+ ["ts", "enum A {} var A;", "A 5+1,14+1"],
+ ["ts", "var A; class A {}", "A 4+1,13+1"],
+ ["js", "var A; class A {}", "A 4+1,13+1"],
+ ["ts", "var A; interface A {}", ""],
+ ["ts", "var A; type A = 1;", ""],
+ ["ts", "let A; interface A {}", ""],
+ ["ts", "let A; type A = 1; let A;", "A 4+1,23+1"],
+ ["ts", "type A = 1; let A; type A = 2;", "A 5+1,24+1"],
+ ["ts", "import a from 'a'; import a = require('b');", "a 7+1,26+1"],
+ ["ts", "import a = require('a'); import a from 'b';", "a 7+1,32+1"],
+ ["ts", "import type a from 'a'; import a from 'b';", "a 12+1,31+1"],
+ ["ts", "import { type a, a } from 'a';", "a 14+1,17+1"],
+ ["ts", "import { a } from 'a'; export import a = N.b;", "a 9+1,37+1"],
+ ["ts", "import a from 'a'; enum a {}", ""],
+ ["ts", "import a from 'a'; class a {} class a {}", "a 7+1,36+1"],
+ ["js", "import a from 'a'; class a {} class a {}", "a 7+1,36+1, a 7+1,36+1"],
+ ["ts", "import a from 'a'; let a; let a;", "a 7+1,30+1"],
+ ["js", "import a from 'a'; let a; let a;", "a 7+1,30+1, a 7+1,30+1"],
+ ["ts", "let a; import a from 'a';", ""],
+ ["js", "let a; import a from 'a';", "a 4+1,14+1"],
+ ["ts", "let a; import a from 'a'; import a from 'b';", "a 4+1,33+1"],
+ ["js", "let a; import a from 'a'; import a from 'b';", "a 4+1,33+1, a 4+1,33+1"],
+ ["ts", "let a; let a; let a;", "a 4+1,11+1, a 4+1,18+1"],
+ ["ts", "let a; var a; let a;", "a 4+1,11+1, a 4+1,18+1"],
+ ["ts", "var a; let a; var a;", "a 4+1,11+1, a 4+1,18+1"],
+ ["js", "var a; let a; var a;", "a 4+1,11+1, a 4+1,18+1"],
+ ["ts", "let a, a, a;", "a 4+1,7+1, a 4+1,10+1"],
+ ["ts", "let a; { var a; var a; }", "a 4+1,13+1, a 4+1,20+1"],
+ ["ts", "{ let a; { var a; } { var a; } }", "a 6+1,15+1, a 6+1,26+1"],
+ ["js", "{ let a; { var a; } { var a; } }", "a 6+1,15+1, a 6+1,26+1"],
+ ["ts", "{ var a; } { let a; }", ""],
+ ["ts", "{ let a; } { var a; }", ""],
+ ["ts", "{ { var a; } let a; }", "a 8+1,17+1"],
+ ["js", "{ { var a; } let a; }", "a 8+1,17+1"],
+ ["ts", "{ { { var a; } } let a; }", "a 10+1,21+1"],
+ ["ts", "{ let a; { { var a; } } }", "a 6+1,17+1"],
+ ["ts", "function f() { { var a; } let a; }", "a 21+1,30+1"],
+ ["js", "function f() { { var a; } let a; }", "a 21+1,30+1"],
+ ["ts", "function f() { let a; { var a; } }", "a 19+1,28+1"],
+ ["ts", "{ function g() { var a; } let a; }", ""],
+ ["ts", "{ let a; function g() { var a; } }", ""],
+ ["js", "{ let a; function g() { var a; } }", ""],
+ ["ts", "{ let a; (() => { var a; }); }", ""],
+ ["ts", "{ let a; class C { static { var a; } } }", ""],
+ ["ts", "{ let a; class C { m() { var a; } } }", ""],
+ ["js", "{ let a; class C { m() { var a; } } }", ""],
+ ["ts", "for (let a;;) { var a; }", "a 9+1,20+1"],
+ ["ts", "for (let a;;) { let a; }", ""],
+ ["js", "for (let a;;) { let a; }", ""],
+ ["ts", "for (var a;;) { let a; }", ""],
+ ["ts", "for (var a;;) {} let a;", "a 9+1,21+1"],
+ ["ts", "for (let a of []) { { var a; } }", "a 9+1,26+1"],
+ ["js", "for (let a of []) { { var a; } }", "a 9+1,26+1"],
+ ["ts", "for (const a in {}) var a;", "a 11+1,24+1"],
+ ["ts", "for (let a;;) var a;", "a 9+1,18+1"],
+ ["ts", "let a; for (var a;;) {}", "a 4+1,16+1"],
+ ["js", "let a; for (var a;;) {}", "a 4+1,16+1"],
+ ["ts", "let a; for (var a of []) {}", "a 4+1,16+1"],
+ ["ts", "for (let [a, a] of []) {}", "a 10+1,13+1"],
+ ["ts", "for (var a of []) { var a; }", ""],
+ ["js", "for (var a of []) { var a; }", ""],
+ ["ts", "for (let a of []) for (let a of []) {}", ""],
+ ["ts", "switch (1) { case 1: var a; case 2: let a; }", "a 25+1,40+1"],
+ ["ts", "switch (1) { case 1: let a; case 2: var a; }", "a 25+1,40+1"],
+ ["js", "switch (1) { case 1: let a; case 2: var a; }", "a 25+1,40+1"],
+ ["ts", "switch (1) { case 1: { var a; } default: let a; }", "a 27+1,45+1"],
+ ["ts", "switch (1) { case 1: let a; } let a;", ""],
+ ["ts", "let a; switch (1) { case 1: var a; }", "a 4+1,32+1"],
+ ["js", "let a; switch (1) { case 1: var a; }", "a 4+1,32+1"],
+ ["ts", "switch (1) { case 1: class A {} default: class A {} }", "A 27+1,47+1"],
+ ["ts", "switch (1) { case 1: function f() {} default: let f; }", "f 30+1,50+1"],
+ ["ts", "try {} catch (e) { { var e; } }", ""],
+ ["js", "try {} catch (e) { { var e; } }", ""],
+ ["ts", "try {} catch (e) { { let e; } }", ""],
+ ["ts", "try {} catch (e) { const e = 1; }", "e 14+1,25+1"],
+ ["ts", "try {} catch (e) { class e {} }", "e 14+1,25+1"],
+ ["js", "try {} catch (e) { class e {} }", "e 14+1,25+1"],
+ ["ts", "try {} catch ({ e }) { let e; }", "e 16+1,27+1"],
+ ["ts", "try {} catch ({ e }) { var e; }", "e 16+1,27+1"],
+ ["ts", "try {} catch ([e]) { { var e; } }", "e 15+1,27+1"],
+ ["js", "try {} catch ([e]) { { var e; } }", "e 15+1,27+1"],
+ ["ts", "try {} catch (e) { var e; var e; }", ""],
+ ["ts", "try {} catch (e) { var e; let e; }", "e 14+1,30+1"],
+ ["ts", "try {} catch (e) {} let e;", ""],
+ ["js", "try {} catch (e) {} let e;", ""],
+ ["ts", "let e; try {} catch (e) {}", ""],
+ ["ts", "let e; try {} catch (e) { var e; }", ""],
+ ["ts", "var e; try {} catch (e) { var e; }", ""],
+ ["js", "var e; try {} catch (e) { var e; }", ""],
+ ["ts", "try {} catch (e) { for (var e;;) {} }", ""],
+ ["ts", "try {} catch (e) { for (var e in {}) {} }", ""],
+ ["ts", "try {} catch (e) { for (let e of []) {} }", ""],
+ ["js", "try {} catch (e) { for (let e of []) {} }", ""],
+ ["ts", "try {} catch (e) { function e() {} function e() {} }", "e 14+1,28+1, e 14+1,44+1"],
+ ["js", "try {} catch (e) { function e() {} function e() {} }", "e 14+1,28+1"],
+ ["mjs", "try {} catch (e) { function e() {} function e() {} }", "e 14+1,28+1, e 28+1,44+1"],
+ ["ts", "try {} catch (e) { type e = 1; }", ""],
+ ["ts", "try {} catch (e) { enum e {} }", "e 14+1,24+1"],
+ ["ts", "try {} catch (e) { interface e {} }", ""],
+ ["ts", "try { let a; let a; } catch {}", "a 10+1,17+1"],
+ ["js", "try { let a; let a; } catch {}", "a 10+1,17+1"],
+ ["ts", "try {} catch { let a; let a; }", "a 19+1,26+1"],
+ ["ts", "try {} finally { let a; let a; }", "a 21+1,28+1"],
+ ["ts", "try {} catch (e) { try {} catch (e) {} }", ""],
+ ["js", "try {} catch (e) { try {} catch (e) {} }", ""],
+ ["ts", "try {} catch (e) { try {} catch (e) { var e; } }", ""],
+ ["ts", "try {} catch ([e]) { try {} catch (e) { var e; } }", ""],
+ ["ts", "function f(a) { { let a; } }", ""],
+ ["js", "function f(a) { { let a; } }", ""],
+ ["ts", "function f(a) { { var a; } }", ""],
+ ["ts", "function f(a) { const a = 1; }", "a 11+1,22+1"],
+ ["ts", "function f(a) { class a {} }", "a 11+1,22+1"],
+ ["js", "function f(a) { class a {} }", "a 11+1,22+1"],
+ ["ts", "function f(a) { enum a {} }", "a 11+1,21+1"],
+ ["ts", "function f(a) { type a = 1; }", ""],
+ ["ts", "function f(a) { interface a {} }", ""],
+ ["ts", "function f([a]) { var a; }", ""],
+ ["js", "function f([a]) { var a; }", ""],
+ ["ts", "function f(...a) { let a; }", "a 14+1,23+1"],
+ ["ts", "function f(a = 1) { let a; }", "a 11+1,24+1"],
+ ["ts", "function f(a, b = () => { let a; }) {}", ""],
+ ["js", "function f(a, b = () => { let a; }) {}", ""],
+ ["ts", "function f(a, b = function (a) {}) {}", ""],
+ ["ts", "(a) => { let a; };", "a 1+1,13+1"],
+ ["ts", "a => { let a; };", "a 0+1,11+1"],
+ ["js", "a => { let a; };", "a 0+1,11+1"],
+ ["ts", "async a => { let a; };", "a 6+1,17+1"],
+ ["ts", "async (a) => { let a; };", "a 7+1,19+1"],
+ ["ts", "(a) => { var a; };", ""],
+ ["js", "(a) => { var a; };", ""],
+ ["ts", "({ m(a) { let a; } });", "a 5+1,14+1"],
+ ["ts", "({ set m(a) { let a; } });", "a 9+1,18+1"],
+ ["ts", "class A { m(a) { let a; } }", "a 12+1,21+1"],
+ ["js", "class A { m(a) { let a; } }", "a 12+1,21+1"],
+ ["ts", "class A { constructor(a) { let a; } }", "a 22+1,31+1"],
+ ["ts", "class A { constructor(public a) { let a; } }", "a 29+1,38+1"],
+ ["ts", "class A { set m(a) { let a; } }", "a 16+1,25+1"],
+ ["js", "class A { set m(a) { let a; } }", "a 16+1,25+1"],
+ ["ts", "function f(f) {}", ""],
+ ["ts", "function f() { let f; }", ""],
+ ["ts", "function f() { var f; }", ""],
+ ["js", "function f() { var f; }", ""],
+ ["ts", "(function f(f) {});", ""],
+ ["ts", "(function f() { let f; let f; });", "f 20+1,27+1"],
+ ["ts", "(function f() { function f() {} });", ""],
+ ["js", "(function f() { function f() {} });", ""],
+ ["ts", "(function f() { class f {} });", ""],
+ ["ts", "function f(this: any, a) { let a; }", "a 22+1,31+1"],
+ ["ts", "function f(a): void; function f(a) { let a; }", "a 32+1,41+1"],
+ ["ts", "declare function f(a, b): void; let a;", ""],
+ ["ts", "function f(a) { function a() {} function a() {} }", "a 11+1,25+1, a 11+1,41+1"],
+ ["js", "function f(a) { function a() {} function a() {} }", ""],
+ ["ts", "function f(a) { var a; function a() {} }", "a 11+1,32+1"],
+ ["js", "function f(a) { var a; function a() {} }", ""],
+ ["ts", "function f() { var a; function a() {} }", "a 19+1,31+1"],
+ ["js", "function f() { var a; function a() {} }", ""],
+ ["ts", "function f() { function a() {} var a; }", ""],
+ ["ts", "function f() { function a() {} function a() {} }", ""],
+ ["js", "function f() { function a() {} function a() {} }", ""],
+ ["ts", "function f() { { function a() {} var a; } }", ""],
+ ["js", "function f() { { function a() {} var a; } }", "a 26+1,37+1"],
+ ["ts", "function f() { { var a; function a() {} } }", "a 21+1,33+1"],
+ ["ts", "{ var a; function a() {} }", "a 6+1,18+1"],
+ ["js", "{ var a; function a() {} }", "a 6+1,18+1"],
+ ["ts", "{ function a() {} } var a;", ""],
+ ["ts", "{ function a() {} } let a;", ""],
+ ["js", "{ function a() {} } let a;", "a 11+1,24+1"],
+ ["mjs", "{ function a() {} } let a;", ""],
+ ["ts", "let a; { function a() {} }", ""],
+ ["js", "let a; { function a() {} }", ""],
+ ["ts", "{ function a() {} } function a() {}", ""],
+ ["ts", "var a; { function a() {} }", ""],
+ ["ts", "{ { function a() {} } let a; }", ""],
+ ["js", "{ { function a() {} } let a; }", ""],
+ ["ts", "{ let a; { function a() {} } }", ""],
+ ["ts", "if (1) function a() {} let a;", "a 16+1,27+1"],
+ ["ts", "let a; if (1) function a() {}", "a 4+1,23+1"],
+ ["js", "let a; if (1) function a() {}", ""],
+ ["ts", "l: function a() {} let a;", "a 12+1,23+1"],
+ ["ts", "class A { static { let a; { var a; } } }", "a 23+1,32+1"],
+ ["ts", "class A { static { { var a; } let a; } }", "a 25+1,34+1"],
+ ["js", "class A { static { { var a; } let a; } }", "a 25+1,34+1"],
+ ["ts", "let a; class A { static { var a; } }", ""],
+ ["ts", "class A { static { function a() {} function a() {} } }", ""],
+ ["ts", "class A { static { function a() {} var a; } }", ""],
+ ["js", "class A { static { function a() {} var a; } }", "a 28+1,39+1"],
+ ["ts", "class A { static { var a; function a() {} } }", "a 23+1,35+1"],
+ ["js", "class A { static { var a; function a() {} } }", ""],
+ ["ts", "class A { static { let A; } }", ""],
+ ["ts", "class A { static { class A {} } }", ""],
+ ["js", "class A { static { class A {} } }", ""],
+ ["ts", "export let a; export let a;", "a 11+1,25+1"],
+ ["ts", "export function f() {} export function f() {}", ""],
+ ["ts", "export class A {} export class A {}", "A 13+1,31+1"],
+ ["ts", "export default function f() {} let f;", "f 24+1,35+1"],
+ ["ts", "export default class A {} let A;", "A 21+1,30+1"],
+ ["ts", "export default class A {} class A {}", "A 21+1,32+1"],
+ ["js", "export default class A {} class A {}", "A 21+1,32+1"],
+ ["ts", "export default function f() {} function f() {}", ""],
+ ["js", "export default function f() {} function f() {}", "f 24+1,40+1"],
+ ["ts", "export const a = 1; var a;", "a 13+1,24+1"],
+ ["ts", "export var a; export var a;", ""],
+ ["ts", "export enum E {} export enum E {}", ""],
+ ["ts", "export type T = 1; export type T = 2;", "T 12+1,31+1"],
+ ["ts", "export interface I {} export type I = 1;", "I 17+1,34+1"],
+ ["ts", "export namespace N { let x } export let N;", "N 17+1,40+1"],
+ ["ts", "export declare let a: any; export declare let a: any;", "a 19+1,46+1"],
+ ["ts", "export import a = N.a; let a;", ""],
+ ["ts", "using a = b; using a = c; export {};", "a 6+1,19+1"],
+ ["ts", "{ using a = b; let a; }", "a 8+1,19+1"],
+ ["ts", "{ await using a = b; var a; } export {};", "a 14+1,25+1"],
+ ["js", "{ await using a = b; var a; } export {};", "a 14+1,25+1"],
+ ["ts", "declare const a: any; declare const a: any;", "a 14+1,36+1"],
+ ["ts", "declare var a: any; declare let a: any;", "a 12+1,32+1"],
+ ["ts", "declare function f(): void; declare let f: any;", "f 17+1,40+1"],
+ ["ts", "declare function f(): void; declare var f: any;", ""],
+ ["ts", "declare var f: any; declare function f(): void;", "f 12+1,37+1"],
+ ["ts", "declare class A {} declare function A(): void;", ""],
+ ["ts", "declare class A {} interface A {} declare namespace A {}", ""],
+ ["ts", "abstract class A {} abstract class A {}", "A 15+1,35+1"],
+ ["ts", "let \\u0061; let a;", "a 4+6,16+1"],
+ ["js", "let \\u0061; let a;", "a 4+6,16+1"],
+ ["ts", "let a; let \\u{61};", "a 4+1,11+6"],
+ ["ts", "var a; let \\u0061;", "a 4+1,11+6"],
+ ["ts", "let undefined; let undefined;", "undefined 4+9,19+9"],
+ ["js", "let undefined; let undefined;", "undefined 4+9,19+9"],
+ ["ts", "let NaN; var NaN;", "NaN 4+3,13+3"],
+ ["ts", "let a; function a(): void;", "a 4+1,16+1"],
+ ["ts", "function a(): void; let a;", "a 9+1,24+1"],
+ ["ts", "var a; function a() {} export {};", "a 4+1,16+1"],
+ ["ts", "function a() {} var a = 1; export {};", ""],
+ ["js", "function a() {} var a = 1; export {};", "a 9+1,20+5"],
+ ["ts", "{ function a() {} var a = 1; }", ""],
+ ["js", "{ function a() {} var a = 1; }", "a 11+1,22+5"],
+ ["ts", "{ function a() {} var [a] = []; }", ""],
+ ["js", "{ function a() {} var [a] = []; }", "a 11+1,22+8"],
+ ["ts", "{ function a() {} { var a; } }", ""],
+ ["js", "{ function a() {} { var a; } }", "a 11+1,24+1"],
+ ["ts", "{ { function a() {} } var a; }", ""],
+ ["js", "{ { function a() {} } var a; }", "a 13+1,26+1"],
+ ["mjs", "{ { function a() {} } var a; }", ""],
+ ["ts", "function f() { { function a() {} } let a; }", ""],
+ ["js", "function f() { { function a() {} } let a; }", "a 26+1,39+1"],
+ ["mjs", "function f() { { function a() {} } let a; }", ""],
+ ["ts", "function f() { let a; { function a() {} } }", ""],
+ ["ts", '"use strict"; { function a() {} } let a;', ""],
+ ["js", '"use strict"; { function a() {} } let a;', ""],
+ ["ts", '"use strict"; function a() {} function a() {}', ""],
+ ["mjs", '"use strict"; function a() {} function a() {}', "a 23+1,39+1"],
+ ["ts", 'function f() { "use strict"; { function a() {} function a() {} } }', ""],
+ ["js", 'function f() { "use strict"; { function a() {} function a() {} } }', "a 40+1,56+1"],
+ ["ts", 'function f() { "use strict"; function a() {} function a() {} }', ""],
+ ["js", 'function f() { "use strict"; function a() {} function a() {} }', ""],
+ ["ts", "{ function a() {} async function a() {} }", ""],
+ ["js", "{ function a() {} async function a() {} }", "a 11+1,33+1"],
+ ["ts", "{ async function a() {} function a() {} }", ""],
+ ["js", "{ async function a() {} function a() {} }", "a 17+1,33+1"],
+ ["ts", "{ function a() {} function a() {} async function a() {} }", ""],
+ ["js", "{ function a() {} function a() {} async function a() {} }", "a 27+1,49+1"],
+ ["mjs", "{ function a() {} function a() {} async function a() {} }", "a 11+1,27+1, a 27+1,49+1"],
+ ["ts", "{ async function a() {} function a() {} function a() {} }", ""],
+ ["js", "{ async function a() {} function a() {} function a() {} }", "a 17+1,33+1, a 17+1,49+1"],
+ ["mjs", "{ async function a() {} function a() {} function a() {} }", "a 17+1,33+1, a 33+1,49+1"],
+ ["ts", "{ function* a() {} function* a() {} }", ""],
+ ["js", "{ function* a() {} function* a() {} }", "a 12+1,29+1"],
+ ["ts", "{ function a() {} class a {} }", ""],
+ ["js", "{ function a() {} class a {} }", "a 11+1,24+1"],
+ ["ts", "{ class a {} function a() {} }", ""],
+ ["js", "{ class a {} function a() {} }", "a 8+1,22+1"],
+ ["ts", "{ function a() {} let a; }", "a 11+1,22+1"],
+ ["ts", "{ var a; function a() {} function a() {} }", "a 6+1,18+1, a 6+1,34+1"],
+ ["js", "{ var a; function a() {} function a() {} }", "a 6+1,18+1"],
+ ["mjs", "{ var a; function a() {} function a() {} }", "a 6+1,18+1, a 18+1,34+1"],
+ ["ts", "switch (1) { case 1: function a() {} case 2: var a; }", ""],
+ ["js", "switch (1) { case 1: function a() {} case 2: var a; }", "a 30+1,49+1"],
+ ["ts", "switch (1) { case 1: async function a() {} case 2: function a() {} }", ""],
+ ["js", "switch (1) { case 1: async function a() {} case 2: function a() {} }", "a 36+1,60+1"],
+ ["ts", "if (1) function a() {} var a;", ""],
+ ["js", "if (1) function a() {} var a;", ""],
+ ["ts", "if (1) function a() {} function a() {}", ""],
+ ["ts", "if (1) function a() {} else function a() {} let a;", "a 16+1,48+1"],
+ ["ts", "if (1) { function a() {} } let a;", ""],
+ ["js", "if (1) { function a() {} } let a;", "a 18+1,31+1"],
+ ["mjs", "if (1) { function a() {} } let a;", ""],
+ ["ts", "while (0) { function a() {} } const a = 1;", ""],
+ ["js", "while (0) { function a() {} } const a = 1;", "a 21+1,36+1"],
+ ["mjs", "while (0) { function a() {} } const a = 1;", ""],
+ ["ts", "for (;;) { function a() {} break; } let a;", ""],
+ ["js", "for (;;) { function a() {} break; } let a;", "a 20+1,40+1"],
+ ["mjs", "for (;;) { function a() {} break; } let a;", ""],
+ ["ts", "try { function a() {} } catch {} let a;", ""],
+ ["js", "try { function a() {} } catch {} let a;", "a 15+1,37+1"],
+ ["mjs", "try { function a() {} } catch {} let a;", ""],
+ ["ts", "try {} catch (a) { function a() {} }", "a 14+1,28+1"],
+ ["ts", "try {} catch (a) { { function a() {} } }", ""],
+ ["ts", "try {} catch ({ a }) { function a() {} }", "a 16+1,32+1"],
+ ["js", "try {} catch ({ a }) { function a() {} }", "a 16+1,32+1"],
+ ["ts", "l: { function a() {} } let a;", ""],
+ ["js", "l: { function a() {} } let a;", "a 14+1,27+1"],
+ ["mjs", "l: { function a() {} } let a;", ""],
+ ["ts", 'import a from "a"; { var a; }', ""],
+ ["js", 'import a from "a"; { var a; }', "a 7+1,25+1"],
+ ["ts", 'import a from "a"; { let a; }', ""],
+ ["js", 'import a from "a"; { let a; }', ""],
+ ["ts", 'import a from "a"; { function a() {} }', ""],
+ ["ts", 'import a from "a"; function f(a) {}', ""],
+ ["ts", 'import a from "a"; var a; var a;', ""],
+ ["js", 'import a from "a"; var a; var a;', "a 7+1,30+1"],
+ ["ts", 'import a from "a"; import b from "b"; let a, b;', ""],
+ ["js", 'import a from "a"; import b from "b"; let a, b;', "b 26+1,45+1, a 7+1,42+1"],
+ ["ts", 'import { a, b } from "a"; class a {} function b() {}', ""],
+ ["js", 'import { a, b } from "a"; class a {} function b() {}', "b 12+1,46+1, b 12+1,46+1, a 9+1,32+1"],
+ ["ts", 'import a from "a"; try {} catch (a) {}', ""],
+ ["js", 'import a from "a"; try {} catch (a) {}', ""],
+ ["ts", 'var a; import a from "a";', ""],
+ ["js", 'var a; import a from "a";', "a 4+1,14+1"],
+ ["ts", 'function a() {} import a from "a";', ""],
+ ["js", 'function a() {} import a from "a";', "a 9+1,23+1"],
+ ["ts", 'class a {} import a from "a";', ""],
+ ["js", 'class a {} import a from "a";', "a 6+1,18+1"],
+ ["ts", 'import * as a from "a"; import * as a from "b";', "a 12+1,36+1"],
+ ["ts", 'import a, * as a from "a";', "a 7+1,15+1"],
+ ["ts", "let a; let b; let a; let b;", "a 4+1,18+1, b 11+1,25+1"],
+ ["js", "let a; let b; let a; let b;", "a 4+1,18+1, b 11+1,25+1"],
+ ["ts", "let a; { let a; let a; } let a;", "a 13+1,20+1, a 4+1,29+1"],
+ ["ts", "function f() { let a; let a; } function g() { let a; let a; }", "a 19+1,26+1, a 50+1,57+1"],
+ ["ts", "let a; function f() { var a; let a; }", "a 26+1,33+1"],
+ ["js", "let a; function f() { var a; let a; }", "a 26+1,33+1"],
+ ["ts", "const [a, { a: b, b: a }] = [];", "a 7+1,21+1"],
+ ["ts", "let a = () => { let a; let a; };", "a 20+1,27+1"],
+ ["ts", "let a = function a() { let a; };", ""],
+ ["js", "let a = function a() { let a; };", ""],
+ ["ts", "class A { m() { let a; var a; } n() { var b; let b; } }", "a 20+1,27+1, b 42+1,49+1"],
+ ["ts", "var a, a, a; let a;", "a 4+1,17+1"],
+ ["ts", "let a; var a, a;", "a 4+1,11+1, a 4+1,14+1"],
+ ["js", "let a; var a, a;", "a 4+1,11+1, a 4+1,14+1"],
+ ["ts", "let a; for (var a, a;;) {}", "a 4+1,16+1, a 4+1,19+1"],
+ ["ts", "function f(a, b) { let a, b; }", "a 11+1,23+1, b 14+1,26+1"],
+ ["ts", "function f(a) { let a; let a; }", "a 11+1,20+1, a 11+1,27+1"],
+ ["js", "function f(a) { let a; let a; }", "a 11+1,20+1, a 11+1,27+1"],
+ ["ts", "function f({ a, b: [c] }) { const c = 1; var a; let b; }", "c 20+1,34+1"],
+ ["ts", "function f(a = () => { let a; }) { var a; }", ""],
+ ["ts", "(function (a) { let a; });", "a 11+1,20+1"],
+ ["js", "(function (a) { let a; });", "a 11+1,20+1"],
+ ["ts", "(function a(a) { let a; });", "a 12+1,21+1"],
+ ["ts", "(a, b) => { const b = 1; };", "b 4+1,18+1"],
+ ["ts", "function f(arguments) { let arguments; }", "arguments 11+9,28+9"],
+ ["js", "function f(arguments) { let arguments; }", "arguments 11+9,28+9"],
+ ["ts", "function f() { var arguments; let arguments; }", "arguments 19+9,34+9"],
+ ["ts", "class A {} class A {} class A {}", "A 6+1,17+1, A 6+1,28+1"],
+ ["ts", "class A {} var A; let A;", "A 6+1,15+1, A 6+1,22+1"],
+ ["js", "class A {} var A; let A;", "A 6+1,15+1, A 6+1,22+1"],
+ ["ts", "(class A { static { let A; var A; } });", "A 24+1,31+1"],
+ ["ts", "class A { static { let a; } static { let a; } }", ""],
+ ["ts", "class A { static { var a; } static { let a; } }", ""],
+ ["js", "class A { static { var a; } static { let a; } }", ""],
+ ["ts", "let a; a: ;", ""],
+ ["ts", "label: { let label; }", ""],
+ ["js", "label: { let label; }", ""],
+ ];
+ const short = (message: string) =>
+ /^Identifier `(.*)` has already been declared$/.exec(message)?.[1] ?? message;
+ const { found, diagnostics } = await withErrorsFound(rows, short, config);
+ expect(found).toEqual(rows);
+ for (const { labels } of diagnostics) {
+ expect(labels.map(it => it.label?.replace(/^`.*` /, ""))).toEqual([
+ "has already been declared here",
+ "It can not be redeclared here",
+ ]);
+ }
+ });
+
+ // "twice": "Duplicated export 'a'". "defaults": TS(2528), "A module cannot have multiple default exports.". "undefined":
+ // "Export 'a' is not defined", with the name of its help, "Did you mean 'b'?", in parentheses. TypeScript files have none
+ // of the three.
+ test("and what a JavaScript module exports twice, or doesn't declare", async () => {
+ const rows: ErrorRow[] = [
+ ["js", "export const a = 1; export const a = 2;", "twice a 13+1,33+1"],
+ ["ts", "export const a = 1; export const a = 2;", "declared a 13+1,33+1"],
+ ["js", "export { nope };", "undefined nope 9+4"],
+ ["js", "export default 1; export default 2;", "defaults 7+7,25+7"],
+ ["ts", "export default 1; export default 2;", ""],
+ ["js", "const a = 1; export { a, a };", "twice a 22+1,25+1"],
+ ["js", "const a = 1; export { a }; export { a };", "twice a 22+1,36+1"],
+ ["ts", "const a = 1; export { a }; export { a };", ""],
+ ["js", "const a = 1, b = 2; export { a as c, b as c };", "twice c 34+1,42+1"],
+ ["js", "const a = 1; export { a as default }; export default 2;", "defaults 27+7,45+7"],
+ ["ts", "const a = 1; export { a as default }; export default 2;", ""],
+ ["js", "export { a } from 'a'; export { a } from 'b';", "twice a 9+1,32+1"],
+ ["js", "export * as a from 'a'; export const a = 1;", "twice a 12+1,37+1"],
+ ["ts", "export * as a from 'a'; export const a = 1;", ""],
+ ["js", "export * from 'a'; export * from 'b';", ""],
+ ["js", "export function f(){} export function f(){}", "twice f 16+1,38+1"],
+ ["ts", "export function f(){} export function f(){}", ""],
+ ["js", "export { f }; function f(){}", ""],
+ ["js", "export { a }; var a;", ""],
+ ["ts", "export { a }; var a;", ""],
+ ["js", "export { a }; import a from 'a';", ""],
+ ["js", "export { Array };", "undefined Array 9+5"],
+ ["ts", "export { Array };", ""],
+ ["js", "export { undefined };", "undefined undefined 9+9"],
+ ["js", "export { a as b }; let a;", ""],
+ ["ts", "export { a as b }; let a;", ""],
+ ["js", "export { nope as x };", "undefined nope 9+4"],
+ ["js", "export { nope } from 'a';", ""],
+ ["ts", "export { nope } from 'a';", ""],
+ ["js", "export default function f(){} export { f as default };", "defaults 7+7,44+7"],
+ ["js", "const a = 1; export { a as 'x', a as 'x' };", "twice x 27+3,37+3"],
+ ["ts", "const a = 1; export { a as 'x', a as 'x' };", ""],
+ ["js", "export class A {} export { A };", "twice A 13+1,27+1"],
+ ["js", "const a = 1; export { a, a, a };", "twice a 22+1,28+1, twice a 25+1,28+1"],
+ ["ts", "const a = 1; export { a, a, a };", ""],
+ ["js", "const a = 1; export { a }; export { a }; export { a };", "twice a 22+1,50+1, twice a 36+1,50+1"],
+ ["js", "export default 1; export default 2; export default 3;", "defaults 7+7,25+7,43+7"],
+ ["ts", "export default 1; export default 2; export default 3;", ""],
+ [
+ "js",
+ "const a = 1, b = 2; export { a as default, b as default };",
+ "twice default 34+7,48+7, defaults 34+7,48+7",
+ ],
+ ["js", "export { default } from 'a'; export default 1;", "defaults 36+7,9+7"],
+ ["ts", "export { default } from 'a'; export default 1;", ""],
+ [
+ "js",
+ "export { default } from 'a'; export { default } from 'b';",
+ "twice default 9+7,38+7, defaults 9+7,38+7",
+ ],
+ ["js", "export { a as default } from 'a'; export default 1;", "defaults 41+7,14+7"],
+ ["ts", "export { a as default } from 'a'; export default 1;", ""],
+ ["js", "export default 1; export { default } from 'a';", "defaults 7+7,27+7"],
+ ["js", "import a from 'a'; export { a as default }; export default 1;", "defaults 51+7,33+7"],
+ ["ts", "import a from 'a'; export { a as default }; export default 1;", ""],
+ ["js", "import * as a from 'a'; export { a as default }; export default 1;", "defaults 38+7,56+7"],
+ ["js", "import { a } from 'a'; export default 1; export { a as default };", "defaults 30+7,55+7"],
+ ["ts", "import { a } from 'a'; export default 1; export { a as default };", ""],
+ ["js", "export * as default from 'a'; export default 1;", "defaults 37+7,12+7"],
+ [
+ "js",
+ "export * as default from 'a'; export * as default from 'b';",
+ "twice default 12+7,42+7, defaults 12+7,42+7",
+ ],
+ ["ts", "export * as default from 'a'; export * as default from 'b';", ""],
+ ["js", "export default class A {} export default class B {}", "defaults 7+7,33+7"],
+ ["js", "export default function () {} export default function () {}", "defaults 7+7,37+7"],
+ ["ts", "export default function () {} export default function () {}", ""],
+ ["js", "export default class {} export { x as default }; var x;", "defaults 7+7,38+7"],
+ ["js", "export const [a, a] = [];", "twice a 14+1,17+1"],
+ ["ts", "export const [a, a] = [];", "declared a 14+1,17+1"],
+ ["js", "export const { a, b: a } = {};", "twice a 15+1,21+1"],
+ ["ts", "export const { a, b: a } = {};", "declared a 15+1,21+1"],
+ ["js", "export const [a] = [], { a } = {};", "twice a 14+1,25+1"],
+ ["ts", "export const [a] = [], { a } = {};", "declared a 14+1,25+1"],
+ ["js", "export var a; export var a;", "twice a 11+1,25+1"],
+ ["js", "export let a; export { a };", "twice a 11+1,23+1"],
+ ["ts", "export let a; export { a };", ""],
+ ["js", "export let a, b; export { a as b };", "twice b 14+1,31+1"],
+ ["js", "export function a() {} export class a {}", "twice a 16+1,36+1"],
+ ["ts", "export function a() {} export class a {}", ""],
+ ["js", "export const a = 1; export function a() {}", "twice a 13+1,36+1"],
+ ["ts", "export const a = 1; export function a() {}", "declared a 13+1,36+1"],
+ ["js", "export async function a() {} export { a };", "twice a 22+1,38+1"],
+ ["ts", "export async function a() {} export { a };", ""],
+ ["js", "export function* a() {} export { a };", "twice a 17+1,33+1"],
+ ["js", "export { a }; { var a; }", ""],
+ ["ts", "export { a }; { var a; }", ""],
+ ["js", "export { a }; { let a; }", "undefined a 9+1"],
+ ["js", "export { a }; if (1) { var a; }", ""],
+ ["ts", "export { a }; if (1) { var a; }", ""],
+ ["js", "export { a }; for (var a;;) {}", ""],
+ ["js", "export { a }; for (let a;;) {}", "undefined a 9+1"],
+ ["ts", "export { a }; for (let a;;) {}", ""],
+ ["js", "export { a }; function f() { var a; }", "undefined a 9+1 (f)"],
+ ["js", "export { a }; { function a() {} }", "undefined a 9+1"],
+ ["ts", "export { a }; { function a() {} }", ""],
+ ["js", "export { a }; try {} catch (a) {}", "undefined a 9+1"],
+ ["js", "export { a }; class a {}", ""],
+ ["ts", "export { a }; class a {}", ""],
+ ["js", "export { a }; import * as a from 'a';", ""],
+ ["js", "export { a }; import { b as a } from 'a';", ""],
+ ["ts", "export { a }; import { b as a } from 'a';", ""],
+ ["js", "export { a }; import { a as b } from 'a';", "undefined a 9+1 (b)"],
+ ["js", "export { a }; (function a() {});", "undefined a 9+1"],
+ ["ts", "export { a }; (function a() {});", ""],
+ ["js", "export { a }; (class a {});", "undefined a 9+1"],
+ ["js", "export { a }; a: ;", "undefined a 9+1"],
+ ["ts", "export { a }; a: ;", ""],
+ ["js", "export { a }; const { a } = {};", ""],
+ ["js", "export { a }; var [[a]] = [];", ""],
+ ["ts", "export { a }; var [[a]] = [];", ""],
+ ["js", "export { a }; switch (1) { case 1: var a; }", ""],
+ ["js", "export { a, b }; let a;", "undefined b 12+1 (a)"],
+ ["js", "export { a, b };", "undefined a 9+1, undefined b 12+1"],
+ ["ts", "export { a, b };", ""],
+ ["js", "export { b, a }; export { c };", "undefined b 9+1, undefined a 12+1, undefined c 26+1"],
+ ["js", "let abc; export { abd };", "undefined abd 18+3 (abc)"],
+ ["ts", "let abc; export { abd };", ""],
+ ["js", "let abc; export { ab };", "undefined ab 18+2 (abc)"],
+ ["js", "let abc, abd; export { abe };", "undefined abe 23+3 (abc)"],
+ ["ts", "let abc, abd; export { abe };", ""],
+ ["js", "let abd, abc; export { abe };", "undefined abe 23+3 (abc)"],
+ ["js", "let abc; export { xyz };", "undefined xyz 18+3"],
+ ["ts", "let abc; export { xyz };", ""],
+ ["js", "let abcdef; export { abcd };", "undefined abcd 21+4 (abcdef)"],
+ ["js", "let abcdef; export { abc };", "undefined abc 21+3"],
+ ["ts", "let abcdef; export { abc };", ""],
+ ["js", "function foo() {} export { fooo };", "undefined fooo 27+4 (foo)"],
+ ["js", "import foo from 'a'; export { fo };", "undefined fo 30+2 (foo)"],
+ ["ts", "import foo from 'a'; export { fo };", ""],
+ ["js", "let a; export { b };", "undefined b 16+1 (a)"],
+ ["js", "let aa; export { bb };", "undefined bb 17+2 (aa)"],
+ ["ts", "let aa; export { bb };", ""],
+ ["js", "let aaa; export { abb };", "undefined abb 18+3 (aaa)"],
+ ["js", "class Foo {} export { foo };", "undefined foo 22+3 (Foo)"],
+ ["ts", "class Foo {} export { foo };", ""],
+ ["js", "let \\u0061bc; export { abd };", "undefined abd 23+3 (abc)"],
+ ["js", "let é; export { e };", "undefined e 17+1 (é)"],
+ ["ts", "let é; export { e };", ""],
+ ["js", "export { a as b, nope }; let a; export { a as b };", "twice b 14+1,46+1"],
+ ["js", "export { nope }; export default 1; export default 2;", "defaults 24+7,42+7"],
+ ["ts", "export { nope }; export default 1; export default 2;", ""],
+ ["js", "export { nope }; let a; let a;", "declared a 21+1,28+1, undefined nope 9+4"],
+ ["ts", "export { nope }; let a; let a;", "declared a 21+1,28+1"],
+ ["js", "let a; let a; export { a, a };", "twice a 23+1,26+1"],
+ ["ts", "let a; let a; export { a, a };", "declared a 4+1,11+1"],
+ ["js", "export { eval };", "undefined eval 9+4"],
+ ["js", "export { arguments };", "undefined arguments 9+9"],
+ ["ts", "export { arguments };", ""],
+ ["js", "export { a as 'b' }; let a;", ""],
+ ["js", "export {};", ""],
+ ["ts", "export {};", ""],
+ ["js", "export { };", ""],
+ ["js", "export * as a from 'a'; export * as a from 'b';", "twice a 12+1,36+1"],
+ ["ts", "export * as a from 'a'; export * as a from 'b';", ""],
+ ["js", "export * as 'a' from 'a'; export const a = 1;", "twice a 12+3,39+1"],
+ ["js", "export { a as b } from 'a'; export { c as b } from 'c';", "twice b 14+1,42+1"],
+ ["ts", "export { a as b } from 'a'; export { c as b } from 'c';", ""],
+ ["js", "export { a } from 'a'; let a; export { a };", "twice a 9+1,39+1"],
+ ["ts", "function f() { export { a }; }", ""],
+ ["js", "export { a }; export { a as b }; let a;", ""],
+ ["ts", "export { a }; export { a as b }; let a;", ""],
+ ["js", "export { x as a, y as b, x as c }; let x, y;", ""],
+ ["js", "let a; export { a as default, a as b };", ""],
+ ["ts", "let a; export { a as default, a as b };", ""],
+ ["js", "export default a; let a;", ""],
+ ["js", "export default nope;", ""],
+ ["ts", "export default nope;", ""],
+ ["js", "export default (nope);", ""],
+ ];
+ const short = (message: string) =>
+ message
+ .replace(/^Duplicated export '(.*)'$/, "twice $1")
+ .replace(/^A module cannot have multiple default exports\.$/, "defaults")
+ .replace(/^Export '(.*)' is not defined$/, "undefined $1")
+ .replace(/^Identifier `(.*)` has already been declared$/, "declared $1");
+ const { found, diagnostics } = await withErrorsFound(rows, short, config);
+ const helps = (text: string) => text.replace(/ \([^)]*\)/g, "");
+ expect(found).toEqual(rows.map(([extension, code, errors]): ErrorRow => [extension, code, helps(errors)]));
+ const suggested = diagnostics.filter(it => it.help).map(it => `${it.message} ${it.help}`);
+ expect(suggested.sort()).toEqual(
+ rows
+ .flatMap(([, , errors]) => [...errors.matchAll(/undefined (\S+) \S+ \(([^)]*)\)/g)])
+ .map(([, name, other]) => `Export '${name}' is not defined Did you mean '${other}'?`)
+ .sort(),
+ );
+ });
+ });
+
// oxlint 1.87.0: "Identifier `a` has already been declared", at the first of the two. The parser, which has the names in
// hand, says that a file may have such a list: no other file is looked at.
test.each([
@@ -1114,7 +3313,6 @@ describe.concurrent("bun lint", () => {
["a.js", "class A { accessor b = 1 }"],
["a.js", "@d class A {}"],
["a.ts", "let a!: string;"],
- ["a.ts", "function f<>() {}"],
["a.ts", "for (const a in b);"],
["a.js", "for (const a of b);"],
])("what OXC takes is linted: %s: %j", async (name, code) => {
@@ -1207,7 +3405,8 @@ describe.concurrent("bun lint", () => {
(await lint(files, [...flags, "a.js"], { reads: ["a.js"] })).files["a.js"];
expect(await after("--fix")).toBe("done; suggested;\n");
expect(await after("--fix", "--quiet")).toBe("done; suggested;\n");
- expect(await after("--fix-suggestions")).toBe("fixed; done;\n");
+ // oxlint 1.87 applies a JS plugin's fixes under any of the three flags.
+ expect(await after("--fix-suggestions")).toBe("done; done;\n");
expect(await after("--fix", "--fix-suggestions")).toBe("done; done;\n");
expect(await after("--fix-dangerously")).toBe("done; done;\n");
},
@@ -1375,9 +3574,9 @@ describe.concurrent("bun lint", () => {
test("is there, however many problems there are", async () => {
const [few, many, all] = await Promise.all([
- print("let _a;\n".repeat(3), ["a.js"]),
- print("let _a;\n".repeat(60), ["a.js"]),
- print("let _a;\n".repeat(60), ["--all", "a.js"]),
+ print("{ let _a; }\n".repeat(3), ["a.js"]),
+ print("{ let _a; }\n".repeat(60), ["a.js"]),
+ print("{ let _a; }\n".repeat(60), ["--all", "a.js"]),
]);
expect([few, many, all].map(it => times(it.raw))).toEqual([3, 1, 60]);
// The one that stands for all is printed like the first of all.
@@ -1625,14 +3824,14 @@ describe.concurrent("bun lint", () => {
const rules = JSON.parse(raw);
const find = (scope: string, value: string) =>
rules.find((it: any) => it.scope === scope && it.value === value);
- expect(find("eslint", "no-debugger")).toEqual({
+ expect(find("eslint", "no-debugger")).toMatchObject({
scope: "eslint",
value: "no-debugger",
category: "correctness",
type_aware: false,
fix: "none",
default: true,
- docs_url: "https://oxc.rs/docs/guide/usage/linter/rules/eslint/no-debugger.html",
+ docs_url: "https://bun.com/docs/lint/rules/eslint/no-debugger",
});
expect(find("typescript", "no-floating-promises").type_aware).toBe(true);
// Each once. A rule of the React Compiler is `react-hooks/purity` too, which has suggestions: oxlint's has none.
@@ -1946,48 +4145,237 @@ describe.concurrent("bun lint", () => {
);
});
- test("the rules that ESLint has given up and oxlint has in `node` run if that plugin is on", async () => {
- const texts: Record = {
- "callback-return": "function f(err, callback) {\n if (err) {\n callback(err);\n }\n callback();\n}\n",
- "global-require": 'function f() {\n require("a");\n}\n',
- "handle-callback-err": "function f(err) {}\n",
- "no-mixed-requires": 'var a = require("a"),\n b = 1;\n',
- "no-new-require": 'new require("a");\n',
- "no-path-concat": '__dirname + "/a";\n',
- "no-process-env": "process.env.A;\n",
- "no-sync": "fs.readFileSync();\n",
+ // Recorded from oxlint 1.87.0.
+ test("-A, -W and -D also change rules that come from `extends`, but never JS plugin rules", async () => {
+ const rule = `{ create: context => ({ DebuggerStatement: node => context.report({ node, message: "no" }) }) }`;
+ const files = {
+ ".oxlintrc.json": rc({
+ extends: ["./shared/base.json"],
+ jsPlugins: ["./plugin.js"],
+ rules: { "no-console": "warn", "no-var": "error", "local/own": "error" },
+ }),
+ "shared/base.json": JSON.stringify({
+ extends: ["./deep.json"],
+ rules: { "no-debugger": "warn", "no-alert": "error", "no-console": "error", "local/inherited": "warn" },
+ }),
+ "shared/deep.json": JSON.stringify({ rules: { eqeqeq: ["warn", "smart"], "no-alert": "off" } }),
+ "plugin.js": `const rule = ${rule};\nexport default { meta: { name: "local" }, rules: { own: rule, inherited: rule } };\n`,
+ "a.js": "var a = 1;\ndebugger;\nalert(a);\nconsole.log(a);\nif (a == null) a = 2;\nif (a == 1) a = 2;\n",
};
- const files: Record = { ".oxlintrc.json": rc({ rules: {} }) };
- for (const [directory, prefix, plugins] of [
- ["bare-on", "", ["node"]],
- ["bare-off", "", []],
- ["node-on", "node/", ["node"]],
- ["node-off", "node/", []],
- ] as const) {
- const rules = Object.fromEntries(Object.keys(texts).map(it => [prefix + it, "warn"]));
- files[`${directory}/.oxlintrc.json`] = rc({ plugins, rules });
- for (const [name, text] of Object.entries(texts)) files[`${directory}/${name}.js`] = text;
- }
- const { raw, exitCode } = await lint(files, ["-f", "json"]);
- // oxlint 1.87.0 calls them node(no-sync) and so on.
- const found = places(raw).map((it: string) => it.replace(/ \w+\((.*)\) /, " $1 "));
- const lines = { "callback-return": 3, "global-require": 2 };
- expect(found).toEqual(
- ["bare-on", "node-on"].flatMap(directory =>
- Object.keys(texts).map(it => `${directory}/${it}.js:${lines[it as keyof typeof lines] ?? 1} ${it} warning`),
- ),
- );
- expect(exitCode).toBe(0);
+ const local = ["a.js:2 local(inherited) warning", "a.js:2 local(own) error"];
+ const [noVar, noDebugger] = ["a.js:1 eslint(no-var) error", "a.js:2 eslint(no-debugger) warning"];
+ const [noAlert, noConsole] = ["a.js:3 eslint(no-alert) error", "a.js:4 eslint(no-console) warning"];
+ const eqeqeq = "a.js:6 eslint(eqeqeq) warning";
+ const unchanged = [noVar, noDebugger, ...local, noAlert, noConsole, eqeqeq];
+ const rows: [string[], string[]][] = [
+ [[], unchanged],
+ [["-A", "all"], local],
+ [
+ ["-A", "all", "-D", "no-debugger"],
+ ["a.js:2 eslint(no-debugger) error", ...local],
+ ],
+ [
+ ["-A", "correctness"],
+ [noVar, ...local, noAlert, noConsole, eqeqeq],
+ ],
+ [
+ ["-D", "correctness"],
+ [noVar, "a.js:2 eslint(no-debugger) error", ...local, noAlert, noConsole, eqeqeq],
+ ],
+ [
+ ["-W", "restriction"],
+ [
+ "a.js:1 eslint(no-implicit-globals) warning",
+ "a.js:1 eslint(no-var) warning",
+ noDebugger,
+ ...local,
+ "a.js:3 eslint(no-alert) warning",
+ noConsole,
+ "a.js:5 eslint(no-eq-null) warning",
+ eqeqeq,
+ ],
+ ],
+ // "smart" stays, so line 5 is still fine.
+ [
+ ["-D", "pedantic"],
+ [noVar, noDebugger, ...local, noAlert, noConsole, "a.js:6 eslint(eqeqeq) error"],
+ ],
+ [
+ ["-D", "eqeqeq"],
+ [noVar, noDebugger, ...local, noAlert, noConsole, "a.js:6 eslint(eqeqeq) error"],
+ ],
+ // -A forgets the rule, so "smart" is gone when -D or -W turns it on again.
+ [
+ ["-A", "eqeqeq", "-D", "eqeqeq"],
+ [
+ noVar,
+ noDebugger,
+ ...local,
+ noAlert,
+ noConsole,
+ "a.js:5 eslint(eqeqeq) error",
+ "a.js:6 eslint(eqeqeq) error",
+ ],
+ ],
+ [
+ ["-A", "all", "-W", "pedantic"],
+ [...local, "a.js:5 eslint(eqeqeq) warning", "a.js:6 eslint(eqeqeq) warning"],
+ ],
+ [["-A", "local/own", "-A", "local/inherited"], unchanged],
+ [["-W", "local/own", "-D", "local/inherited"], unchanged],
+ ];
+ const results = await Promise.all(rows.map(([args]) => lint(files, [...args, "-f", "json", "a.js"])));
+ expect(results.map(it => places(it.raw))).toEqual(rows.map(it => it[1]));
+ expect(results.map(it => it.exitCode)).toEqual(rows.map(() => 1));
});
- // The projects of oracle/plugins/oxlint. expected.json is what oxlint 1.87.0 with tsgolint 7.0.2003 reports for them.
- const found = (raw: string, names: string[]) => {
- const byProject = Object.fromEntries(names.map((it): [string, Set] => [it, new Set()]));
- for (const it of JSON.parse(raw).diagnostics) {
- // A syntax error.
- if (!it.code) continue;
- const name = names.find(name => it.filename.startsWith(name + "/"))!;
- const { line, column } = it.labels[0].span;
+ // Recorded from oxlint 1.87.0 with tsgolint.
+ test("a type-aware rule reports with the severity of the ESLint rule of the same name, if that one is on", async () => {
+ const texts = {
+ "tsconfig.json": JSON.stringify({ compilerOptions: { strict: true } }),
+ "a.ts": 'setTimeout("alert(1)", 1);\nexport async function f() {\n return 1;\n}\n',
+ };
+ const rows: [object, string[]][] = [
+ [
+ { categories: { correctness: "error", suspicious: "warn" } },
+ ["a.ts:1 typescript(no-implied-eval) warning"],
+ ],
+ [{ categories: { correctness: "warn", suspicious: "error" } }, ["a.ts:1 typescript(no-implied-eval) error"]],
+ [{ categories: { correctness: "error", suspicious: "off" } }, ["a.ts:1 typescript(no-implied-eval) error"]],
+ [
+ { rules: { "eslint/no-implied-eval": "off", "typescript/no-implied-eval": "warn" } },
+ ["a.ts:1 typescript(no-implied-eval) warning"],
+ ],
+ [
+ { rules: { "eslint/require-await": "warn", "typescript/require-await": "error" } },
+ ["a.ts:2 eslint(require-await) warning", "a.ts:2 typescript(require-await) warning"],
+ ],
+ [
+ { rules: { "typescript/require-await": "warn", "eslint/require-await": "error" } },
+ ["a.ts:2 eslint(require-await) error", "a.ts:2 typescript(require-await) error"],
+ ],
+ ];
+ const results = await Promise.all(
+ rows.map(([config]) =>
+ lint({ ".oxlintrc.json": rc({ rules: {}, ...config }), ...texts }, ["--type-aware", "-f", "json", "a.ts"]),
+ ),
+ );
+ expect(results.map(it => places(it.raw))).toEqual(rows.map(it => it[1]));
+ });
+
+ // Recorded from oxlint 1.87.0.
+ test("--fix-suggestions alone applies the fixes of JS plugins, but not those of built-in rules", async () => {
+ const report = (more: string) => `node => context.report({ node, message: "no", ${more} })`;
+ const project = {
+ ".oxlintrc.json": rc({
+ jsPlugins: ["./plugin.js"],
+ rules: { "local/fixes": "error", "local/suggests": "error", "local/both": "error", "no-var": "error" },
+ }),
+ "plugin.js": `export default { meta: { name: "local" }, rules: {
+ fixes: { meta: { fixable: "code" }, create: context => ({
+ DebuggerStatement: ${report("fix: fixer => fixer.remove(node)")} }) },
+ suggests: { meta: { hasSuggestions: true }, create: context => ({
+ EmptyStatement: ${report('suggest: [{ desc: "remove", fix: fixer => fixer.remove(node) }]')} }) },
+ both: { meta: { fixable: "code", hasSuggestions: true }, create: context => ({
+ ThrowStatement: ${report('fix: fixer => fixer.replaceText(node, "fixed();"), suggest: [{ desc: "other", fix: fixer => fixer.replaceText(node, "suggested();") }]')} }) },
+ } };`,
+ "a.js": "var a = 1;\ndebugger;\n;\nthrow a;\n",
+ };
+ const { stdout, files, exitCode } = await lint(project, ["--fix-suggestions", "-f", "unix", "a.js"], {
+ reads: ["a.js"],
+ });
+ expect(stdout.split("\n").filter(it => it.includes("["))).toEqual([
+ "a.js:1:1: Unexpected var, use let or const instead. [Error/eslint(no-var)]",
+ ]);
+ expect(files["a.js"]).toBe("var a = 1;\n\n\nfixed();\n");
+ expect(exitCode).toBe(1);
+ });
+
+ // Recorded from oxlint 1.87.0.
+ test('"off" in `globals` does not hide a variable that an `env` defines', async () => {
+ const rules = { "no-undef": "error" };
+ const text = { "a.js": "alert(1);\nArray(2);\nmine(3);\n" };
+ const [alert, mine] = ["a.js:1 eslint(no-undef) error", "a.js:3 eslint(no-undef) error"];
+ const rows: [object, string[]][] = [
+ [{ env: { browser: true }, globals: { alert: "off" } }, [mine]],
+ [{ globals: { alert: "off", Array: "off", mine: "off" } }, [alert, mine]],
+ [{ globals: { alert: "readonly", mine: "readonly" } }, []],
+ [
+ {
+ env: { browser: true },
+ globals: { alert: "readonly" },
+ overrides: [
+ { files: ["*.js"], globals: { alert: "off", mine: "readonly" } },
+ { files: ["a.js"], globals: { mine: "off" } },
+ ],
+ },
+ [mine],
+ ],
+ ];
+ const results = await Promise.all(
+ rows.map(([config]) => lint({ ".oxlintrc.json": rc({ rules, ...config }), ...text }, ["-f", "json", "a.js"])),
+ );
+ expect(results.map(it => places(it.raw))).toEqual(rows.map(it => it[1]));
+ });
+
+ // Recorded from oxlint 1.87.0. The two fixes overlap, so --fix leaves the second report.
+ test("use-isnan reports both sides of NaN == NaN", async () => {
+ const files = {
+ ".oxlintrc.json": rc({ rules: { "use-isnan": "error" } }),
+ "a.js": "if (NaN == NaN) {\n}\nif (NaN !== (NaN)) {\n}\nx = a == NaN;\n",
+ };
+ const { stdout, exitCode } = await lint(files, ["-f", "unix", "a.js"]);
+ expect(
+ stdout
+ .split("\n")
+ .filter(it => it.includes("use-isnan"))
+ .map(it => it.split(": ")[0]),
+ ).toEqual(["a.js:1:5", "a.js:1:12", "a.js:3:5", "a.js:3:13", "a.js:5:10"]);
+ expect(exitCode).toBe(1);
+ });
+
+ test("the rules that ESLint has given up and oxlint has in `node` run if that plugin is on", async () => {
+ const texts: Record = {
+ "callback-return": "function f(err, callback) {\n if (err) {\n callback(err);\n }\n callback();\n}\n",
+ "global-require": 'function f() {\n require("a");\n}\n',
+ "handle-callback-err": "function f(err) {}\n",
+ "no-mixed-requires": 'var a = require("a"),\n b = 1;\n',
+ "no-new-require": 'new require("a");\n',
+ "no-path-concat": '__dirname + "/a";\n',
+ "no-process-env": "process.env.A;\n",
+ "no-sync": "fs.readFileSync();\n",
+ };
+ const files: Record = { ".oxlintrc.json": rc({ rules: {} }) };
+ for (const [directory, prefix, plugins] of [
+ ["bare-on", "", ["node"]],
+ ["bare-off", "", []],
+ ["node-on", "node/", ["node"]],
+ ["node-off", "node/", []],
+ ] as const) {
+ const rules = Object.fromEntries(Object.keys(texts).map(it => [prefix + it, "warn"]));
+ files[`${directory}/.oxlintrc.json`] = rc({ plugins, rules });
+ for (const [name, text] of Object.entries(texts)) files[`${directory}/${name}.js`] = text;
+ }
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ // oxlint 1.87.0 calls them node(no-sync) and so on.
+ const found = places(raw).map((it: string) => it.replace(/ \w+\((.*)\) /, " $1 "));
+ const lines = { "callback-return": 3, "global-require": 2 };
+ expect(found).toEqual(
+ ["bare-on", "node-on"].flatMap(directory =>
+ Object.keys(texts).map(it => `${directory}/${it}.js:${lines[it as keyof typeof lines] ?? 1} ${it} warning`),
+ ),
+ );
+ expect(exitCode).toBe(0);
+ });
+
+ // The projects of oracle/plugins/oxlint. expected.json is what oxlint 1.87.0 with tsgolint 7.0.2003 reports for them.
+ const found = (raw: string, names: string[]) => {
+ const byProject = Object.fromEntries(names.map((it): [string, Set] => [it, new Set()]));
+ for (const it of JSON.parse(raw).diagnostics) {
+ // A syntax error.
+ if (!it.code) continue;
+ const name = names.find(name => it.filename.startsWith(name + "/"))!;
+ const { line, column } = it.labels[0].span;
byProject[name].add(`${it.filename.slice(name.length + 1)}:${line}:${column} ${it.code}`);
}
return Object.fromEntries(names.map(it => [it, [...byProject[it]].sort()]));
@@ -2110,6 +4498,26 @@ describe.concurrent("bun lint", () => {
expect(lost.map(it => it[0].trim())).toEqual([]);
});
+ test("the help table refers to lines of oxlint_help.txt", () => {
+ const root = join(import.meta.dir, "../../../src/lint");
+ const lines = readFileSync(join(root, "oxlint_help.txt"), "utf8").split("\n");
+ const table = readFileSync(join(root, "oxlint_help.rs"), "utf8");
+ const entries = [
+ ...table.matchAll(/^ {4}\(0x[0-9A-F]{8}, (One|Three|of_the_fix)\((?:\w+, \w+, )?(\d+)\), (\d)\), \/\//gm),
+ ];
+ expect(entries.length).toBe(table.match(/^ {4}\(0x/gm)!.length);
+ const wrong = entries.filter(([, kind, line, withValues]) => {
+ // Lines count from 1. A fix's note is optional, and 0 stands for none.
+ const at = Number(line) - 1;
+ if (kind === "of_the_fix" && at < 0) return withValues !== "0";
+ // By part: the help, the label, the note.
+ const texts = kind === "Three" ? lines.slice(at, at + 3) : kind === "One" ? [lines[at]] : ["", "", lines[at]];
+ const bits = texts.reduce((bits, text, part) => bits | (Number(text?.includes("{{")) << part), 0);
+ return !texts.some(Boolean) || bits !== Number(withValues);
+ });
+ expect(wrong.map(it => it[0])).toEqual([]);
+ });
+
// What oxlint 1.87.0 with tsgolint 7.0.2003 reports.
test("JavaScript is linted with types without allowJs, and is `any` to the TypeScript that imports it", async () => {
const { raw } = await lint(
@@ -2187,6 +4595,36 @@ describe.concurrent("bun lint", () => {
expect(exitCode).toBe(1);
});
+ // The order is oxlint 1.87.0's, with --fix and without types.
+ test.each([[["--fix"]], [["--fix", "--type-aware"]]])(
+ "what %j leaves is printed in the order in which the rules ran",
+ async flags => {
+ const names = ["eqeqeq", "no-empty", "no-unused-vars", "no-var", "no-debugger", "prefer-const"];
+ const { stdout, exitCode, files } = await lint(
+ {
+ ".oxlintrc.json": rc({ rules: Object.fromEntries(names.map(it => [it, "error"])) }),
+ "tsconfig.json": `{"compilerOptions":{"strict":true}}`,
+ "a.ts":
+ "export function f(a: number, b: number) {\n if (a == b) {\n }\n var left = 1;\n let kept = 2;\n" +
+ " debugger;\n return a != b;\n}\n",
+ },
+ ["-f", "unix", ...flags],
+ { reads: ["a.ts"] },
+ );
+ const found = [...stdout.matchAll(/^a\.ts:(\d+:\d+): .*\((.*)\)\]$/gm)].map(it => `${it[1]} ${it[2]}`);
+ expect(found).toEqual([
+ "4:7 no-unused-vars",
+ "5:7 no-unused-vars",
+ "2:9 eqeqeq",
+ "2:15 no-empty",
+ "6:3 no-debugger",
+ "7:12 eqeqeq",
+ ]);
+ expect(files["a.ts"]).toContain(" const left = 1;\n const kept = 2;\n");
+ expect(exitCode).toBe(1);
+ },
+ );
+
// What oxlint 1.87.0 with tsgolint 7.0.2003 does. Added to the project as root files, the two .mjs would be errors of the
// program (6504), and the tsconfig.json would be refused for them.
test("--tsconfig is the project of the files that it includes, the others are in no project", async () => {
@@ -2798,6 +5236,294 @@ describe.concurrent("bun lint", () => {
});
});
+ // A rule for ESLint that takes the first reference to a name in a scope gets the one the scope manager makes first. That isn't
+ // always the one that is written first: it visits a type after the value, type arguments after the arguments, type parameters
+ // after the parameters, decorators after the member, and the `b` of `[a[b]] = c` before `a`. The two rules here take the first
+ // reference. What they report is what ESLint 10.12.0 reports with typescript-eslint 8.71.1 and eslint-plugin-react 7.37.5.
+ describe("the references of a scope are in the order in which the scope manager makes them", () => {
+ const reported = async (plugin: string, name: string, rule: string, sources: Record) => {
+ const configuration = `export default [{
+ files: ["**/*.ts"],
+ plugins: { "${plugin}": { meta: { name: "${name}" } } },
+ languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } },
+ settings: { react: { version: "18.0" } },
+ rules: { "${plugin}/${rule}": "error" },
+ }];`;
+ const files = Object.fromEntries(Object.entries(sources).map(([name, source]) => [`${name}.ts`, source]));
+ const { stdout } = await lint({ "eslint.config.mjs": configuration, ...files }, [
+ "-f",
+ "unix",
+ ...Object.keys(files),
+ ]);
+ return [...stdout.matchAll(/([\w-]+)\.ts:\d+:\d+: /g)].map(it => it[1]).sort();
+ };
+
+ // `size` is a type outside the class and a parameter property in it. The last line of the constructor is reported if the
+ // first reference to `size` in the constructor is to the parameter.
+ test("types", async () => {
+ const box = (parameters: string, body: string, typeParameters = "") =>
+ `type size = number;\ndeclare function g(x?: unknown): T;\nexport class Box {\n constructor${typeParameters}(public size: number${parameters}) {\n ${body}\n this.size = size;\n }\n}\n`;
+ const theParameterIsFirst = {
+ "nothing-else": box("", ""),
+ "variable": box("", "const w: size = size;"),
+ "variable-and-call": box("", "const w: size = g(size);"),
+ "call-in-variable": box("", "const w: number = g(size);"),
+ "call": box("", "g(size);"),
+ "optional-call": box("", "g?.(size);"),
+ "nested-calls": box("", "g>(g(size));"),
+ "new": box("", "new Set([size]);"),
+ "tagged-template": box("", "g`${size}`;"),
+ "parameter": box(", w: size = size", ""),
+ "pattern-parameter": box(", { w = size }: size = size", ""),
+ "type-parameters": box(", w = size", "", ""),
+ "type-parameters-and-type": box(", w: number = size", "", ""),
+ "angle-brackets": box("", "size;"),
+ "as": box("", "size as size;"),
+ "satisfies-assigned-to": box("", "(size satisfies size) = 0;"),
+ "as-and-non-null-assigned-to": box("", "((size as size)!) = 0;"),
+ "another-scope": box("", "const f = (w: size = size) => w;"),
+ };
+ const theTypeIsFirst = {
+ "variable-without-value": box("", "let w: size;"),
+ "type-parameters-alone": box("", "", ""),
+ "as-assigned-to": box("", "(size as size) = 0;"),
+ "as-added-to": box("", "(size as size) += 0;"),
+ "as-incremented": box("", "(size as size)++;"),
+ "member-as-assigned-to": box("", "(this.size as size) = size;"),
+ "member-as-incremented": box("", "let n = { m: 0 }; (n.m as size)++; size;"),
+ "angle-brackets-assigned-to": box("", "(size) = 0;"),
+ "angle-brackets-incremented": box("", "(size)++;"),
+ };
+ const found = await reported(
+ "@typescript-eslint",
+ "@typescript-eslint/eslint-plugin",
+ "no-unnecessary-parameter-property-assignment",
+ { ...theParameterIsFirst, ...theTypeIsFirst },
+ );
+ expect(found).toEqual(Object.keys(theParameterIsFirst).sort());
+ });
+
+ // `useState` is a parameter of the function, and `useMemo` is React's. The call of `useState` is reported if the first reference
+ // in its scope to one of the two is to `useMemo`.
+ test("members in patterns, decorators, and what a class extends", async () => {
+ const panel = (body: string) =>
+ `import { useMemo, useState } from "react";\nexport function Panel(useState: any, rows: any) {\n ${body}\n}\n`;
+ const call = "const a = useState(0);";
+ const useMemoIsFirst = {
+ "written-first": panel(`useMemo; ${call}`),
+ "array-pattern": panel(`[useState[useMemo]] = rows; ${call}`),
+ "object-pattern": panel(`({ a: useState[useMemo] } = rows); ${call}`),
+ "nested-patterns": panel(`[{ a: [useState[useMemo]] }] = rows; ${call}`),
+ "with-default": panel(`[useState[useMemo] = 1] = rows; ${call}`),
+ "rest": panel(`[...useState[useMemo]] = rows; ${call}`),
+ "non-null": panel(`[useState[useMemo]!] = rows; ${call}`),
+ "last-index": panel(`[rows[useState][useMemo]] = rows; ${call}`),
+ "for-of": panel(`for (useState[useMemo] of rows); ${call}`),
+ "for-in": panel(`for (useState[useMemo] in rows); ${call}`),
+ "decorated-method": panel("class A { @useState(0) [useMemo]() {} }"),
+ "decorated-getter": panel("class A { @useState(0) get [useMemo]() { return 1; } }"),
+ "decorated-property": panel("class A { @useState(0) [useMemo] = 1; }"),
+ "decorated-static-property": panel("class A { @useState(0) static [useMemo] = 1; }"),
+ "decorated-accessor": panel("class A { @useState(0) accessor [useMemo] = 1; }"),
+ "decorated-parameter": panel("class A { @useState(0) a(@useMemo b: any) {} }"),
+ "decorated-class": panel("@useState(0) class A extends useMemo {}"),
+ };
+ const useStateIsFirst = {
+ "written-last": panel(`${call} useMemo;`),
+ "assignment": panel(`useState[useMemo] = rows; ${call}`),
+ "array": panel(`[useState[useMemo]]; ${call}`),
+ "index-before-a-name": panel(`[useState[useMemo].a] = rows; ${call}`),
+ "type-of-decorated-property": panel("class A { @useState(0) a: typeof useMemo = 1; }"),
+ "type-parameters-of-class": panel("class A extends useState(0) {}"),
+ };
+ const found = await reported("react", "eslint-plugin-react", "hook-use-state", {
+ ...useMemoIsFirst,
+ ...useStateIsFirst,
+ });
+ expect(found).toEqual(Object.keys(useMemoIsFirst).sort());
+ });
+ });
+
+ // typescript-eslint's scope manager doesn't visit the type of a `catch` parameter or the options of an import type: for it there
+ // are no scopes, no variables and no references in them. oxc visits both. For both, `["a"]` in an enum declares `a`.
+ describe("what only one of the two scope analyses visits", () => {
+ const sources = {
+ "catch-type.ts": `type Shape = unknown;\nconst width = 1;\ntry {} catch (e: Shape) { e; }\ntry {} catch (e: typeof width) { e; }\ntry {} catch (e: typeof missing) { e; }\ntry {} catch (e: (width: number) => void) { e; }\nexport {};\n`,
+ "import-type.ts": `const kind = "a";\nexport type A = import("./m", { with: { k: kind } });\nexport type B = import("./m", { with: { k: function (left: unknown) { const right = 1; return missing; } } });\nexport type C = import("./m", { with: { k: function (kind: unknown) { return kind; } } });\nexport type D = import("./m", { with: { k: class kind {} } });\n`,
+ };
+ const rules = (prefix: string) => ({
+ [`${prefix}no-unused-vars`]: "error",
+ [`${prefix}no-shadow`]: "error",
+ "no-undef": "error",
+ });
+ const reported = async (files: Record) => {
+ const names = Object.keys(files).filter(it => it.endsWith(".ts"));
+ const { stdout } = await lint(files, ["-f", "unix", ...names]);
+ const found = [...stdout.matchAll(/([\w-]+\.ts:\d+:\d+): .*?([\w-]+)\)?\]$/gm)];
+ return found.map(it => `${it[1]} ${it[2]}`).sort();
+ };
+
+ test("as ESLint 10.12.0 with typescript-eslint 8.71.1", async () => {
+ const configuration = `export default [{
+ files: ["**/*.ts"],
+ plugins: { "@typescript-eslint": { meta: { name: "@typescript-eslint/eslint-plugin" } } },
+ languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } },
+ rules: ${JSON.stringify(rules("@typescript-eslint/"))},
+ }];`;
+ expect(await reported({ "eslint.config.mjs": configuration, ...sources })).toEqual([
+ "catch-type.ts:1:6 no-unused-vars",
+ "import-type.ts:1:7 no-unused-vars",
+ ]);
+ });
+
+ test("as oxlint 1.87", async () => {
+ const configuration = JSON.stringify({ categories: { correctness: "off" }, rules: rules("") });
+ const enums = {
+ "enum-shadows.ts": `const size = 1;\nenum E { ["size"] = 1, other = size as any }\nexport { E };\n`,
+ "enum-declares.ts": `enum E { ["size"] = 1, other = size as any }\nenum F { a = 1, other = size as any }\nexport { E, F };\n`,
+ };
+ expect(await reported({ ".oxlintrc.json": configuration, ...sources, ...enums })).toEqual([
+ "catch-type.ts:5:25 no-undef",
+ "enum-declares.ts:2:25 no-undef",
+ "enum-shadows.ts:1:7 no-unused-vars",
+ "enum-shadows.ts:2:11 no-shadow",
+ "import-type.ts:3:54 no-unused-vars",
+ "import-type.ts:3:77 no-unused-vars",
+ "import-type.ts:3:95 no-undef",
+ "import-type.ts:4:54 no-shadow",
+ "import-type.ts:5:50 no-shadow",
+ ]);
+ });
+ });
+
+ // oxlint analyses a file twice. Its own rules see the scopes of oxc, a rule of a plugin in JavaScript those of typescript-eslint. They
+ // differ about `namespace A.B {}`, about a function in a block of sloppy JavaScript, and about what is in the type of a `catch`
+ // parameter and in the options of an import type. A rule that is built in here and that oxlint lacks, as `no-catch-shadow`, is
+ // one that oxlint could only run from a plugin. What is expected is what oxlint 1.87 reports, and for `no-catch-shadow` what
+ // it reports for the plugin's copy of that rule.
+ describe("with an oxlint config, which scopes a rule sees doesn't depend on the other rules", () => {
+ const sources = {
+ "namespace.ts": `let Inner = 0;\nnamespace Outer.Inner { Inner = 1; export const x = Inner; try {} catch (Inner) {} }\nconsole.log(Inner, Outer);\n`,
+ "namespace-used.ts": `namespace Shapes.Round { export const sides = 0; }\nexport { Shapes };\n`,
+ "block.cjs": `{ function helper() {} }\nhelper();\ntry {} catch (helper) {}\n`,
+ "block.js": `{ function helper() {} }\nhelper();\ntry {} catch (helper) {}\n`,
+ "switch.cjs": `switch (kind) { case 1: function helper() {} }\nhelper;\nfunction outer() { { function inner() {} } inner(); try {} catch (inner) {} }\nouter();\n`,
+ "import-type.ts": `export type A = import("./m", { with: { k: function (left: unknown) { try {} catch (left) {} } } });\n`,
+ "catch-type.ts": `type Shape = unknown;\ntry {} catch (e: (v: Shape) => void) { e; }\nexport {};\n`,
+ "empty.mjs": `export default { meta: { name: "q" }, rules: {} };\n`,
+ "plugin.mjs": `const shadow = { create(context) { return { CatchClause(node) {
+ let scope = context.sourceCode.getScope(node);
+ if (scope.block === node) scope = scope.upper;
+ for (; scope; scope = scope.upper) if (scope.set.has(node.param.name)) return context.report({ node, message: "shadows" });
+} }; } };
+const scopes = { create(context) { return { Program(node) {
+ const declared = it => it.variables.filter(it => it.defs.length).map(it => it.name);
+ context.report({ node, message: context.sourceCode.scopeManager.scopes.map(it => it.type + "[" + declared(it) + "]").join(" ") });
+} }; } };
+export default { meta: { name: "q" }, rules: { shadow, scopes } };\n`,
+ };
+ const ofOxlint = {
+ "no-undef": "error",
+ "no-unused-vars": "error",
+ "no-shadow": "error",
+ "prefer-const": "error",
+ "no-use-before-define": "error",
+ "no-useless-assignment": "error",
+ };
+ const reported = async (more: object, rules: object) => {
+ const configuration = {
+ categories: { correctness: "off" },
+ env: { node: true },
+ globals: { kind: "readonly" },
+ ignorePatterns: ["*.mjs"],
+ ...more,
+ rules: { ...ofOxlint, ...rules },
+ };
+ const { stdout } = await lint({ ".oxlintrc.json": JSON.stringify(configuration), ...sources }, ["-f", "unix"]);
+ const found = [...stdout.matchAll(/^([\w-]+\.\w+:\d+:\d+): (.*) \[Error\/(\w+)\(([\w-]+)\)\]$/gm)];
+ const all = found.map(it => `${it[1]} ${it[4]}` + (it[3] === "q" ? ` ${it[2]}` : "")).sort();
+ const isOfOxlint = (it: string) => it.split(" ")[1] in ofOxlint;
+ return { ofOxlint: all.filter(isOfOxlint), others: all.filter(it => !isOfOxlint(it)) };
+ };
+ const expected = [
+ "block.cjs:3:15 no-shadow",
+ "block.cjs:3:15 no-unused-vars",
+ "block.js:3:15 no-shadow",
+ "block.js:3:15 no-unused-vars",
+ "import-type.ts:1:54 no-unused-vars",
+ "import-type.ts:1:85 no-shadow",
+ "import-type.ts:1:85 no-unused-vars",
+ "namespace.ts:1:5 prefer-const",
+ "namespace.ts:2:17 no-shadow",
+ "namespace.ts:2:74 no-shadow",
+ "namespace.ts:2:74 no-unused-vars",
+ "switch.cjs:3:67 no-shadow",
+ "switch.cjs:3:67 no-unused-vars",
+ ];
+
+ test("only oxlint's rules", async () => {
+ expect(await reported({}, {})).toEqual({ ofOxlint: expected, others: [] });
+ });
+
+ test("beside a plugin without rules", async () => {
+ expect(await reported({ jsPlugins: ["./empty.mjs"] }, {})).toEqual({ ofOxlint: expected, others: [] });
+ });
+
+ test("beside a plugin that asks the scopes", async () => {
+ const rules = { "q/shadow": "error", "q/scopes": "error" };
+ expect(await reported({ jsPlugins: ["./plugin.mjs"] }, rules)).toEqual({
+ ofOxlint: expected,
+ others: [
+ "block.cjs:1:1 scopes global[] function[] block[helper] function[] block[] catch[helper] block[]",
+ "block.js:1:1 scopes global[] block[helper] function[] block[] catch[helper] block[]",
+ "catch-type.ts:1:1 scopes global[] module[Shape] block[] catch[e] block[]",
+ "import-type.ts:1:1 scopes global[] module[A]",
+ "namespace-used.ts:1:1 scopes global[] module[] tsModule[sides]",
+ "namespace.ts:1:1 scopes global[Inner] tsModule[x] block[] catch[Inner] block[]",
+ "namespace.ts:2:67 shadow shadows",
+ "switch.cjs:1:1 scopes global[] function[outer] switch[helper] function[] function[] block[inner] function[] block[] catch[inner] block[]",
+ ],
+ });
+ });
+
+ // The mark is on the plugin's variable.
+ test("`markVariableAsUsed` in a plugin doesn't silence oxlint's no-unused-vars", async () => {
+ const files = {
+ ".oxlintrc.json": JSON.stringify({
+ categories: { correctness: "off" },
+ jsPlugins: ["./marks.mjs"],
+ ignorePatterns: ["*.mjs"],
+ rules: { "no-unused-vars": "error", "q/marks": "error", "q/marked": "error" },
+ }),
+ "marks.mjs": `const marks = { create(context) { return { Program(node) {
+ for (const name of ["first", "work", "Kind"]) context.sourceCode.markVariableAsUsed(name, node);
+} }; } };
+const marked = { create(context) { return { "Program:exit"(node) {
+ const all = context.sourceCode.scopeManager.scopes.flatMap(it => it.variables).filter(it => it.defs.length);
+ context.report({ node, message: all.map(it => it.name + "=" + !!it.eslintUsed).join(" ") });
+} }; } };
+export default { meta: { name: "q" }, rules: { marks, marked } };\n`,
+ "marked.ts": `const first = 1;\nconst second = 2;\nfunction work() {}\ntype Kind = 1;\nexport {};\n`,
+ };
+ const { stdout } = await lint(files, ["-f", "unix"]);
+ const found = [...stdout.matchAll(/^marked\.ts:(\d+:\d+): (.*) \[Error\/(\w+)\(([\w-]+)\)\]$/gm)];
+ expect(found.map(it => `${it[1]} ${it[4]}` + (it[3] === "q" ? ` ${it[2]}` : "")).sort()).toEqual([
+ "1:1 marked first=true second=false work=true Kind=true",
+ "1:7 no-unused-vars",
+ "2:7 no-unused-vars",
+ "3:10 no-unused-vars",
+ "4:6 no-unused-vars",
+ ]);
+ });
+
+ test("beside a built-in rule that oxlint lacks", async () => {
+ expect(await reported({}, { "no-catch-shadow": "error" })).toEqual({
+ ofOxlint: expected,
+ others: ["namespace.ts:2:67 no-catch-shadow"],
+ });
+ });
+ });
+
// `namespace A.B { .. }` is one node, and what is between the braces is its body: a rule that looks at the statements beside a
// statement says there what it says in `namespace B { .. }` and in `namespace A { export namespace B { .. } }`.
describe("the statements of a namespace with dots in its name", () => {
@@ -2931,7 +5657,7 @@ describe.concurrent("bun lint", () => {
const result = await lint(files, ["--fix", "-f", format, "."], { reads: ["a.js", "b.js"] });
expect(result.files).toEqual({ "a.js": files["a.js"].replace("var", "let"), "b.js": files["b.js"] });
expect(result.stderr).toContain(
- "Fixes of mine/breaks would leave a.js with a syntax error. They are not applied.",
+ "Fixes from mine/breaks were not applied to a.js because they would cause a syntax error",
);
expect(result.exitCode).toBe(1);
},
@@ -3436,7 +6162,7 @@ describe.concurrent("bun lint", () => {
describe("fixes after which the text cannot be parsed are not written", () => {
const warning = (rules: string, file: string) =>
- `warn: Fixes of ${rules} would leave ${file} with a syntax error. They are not applied.`;
+ `warn: Fixes from ${rules} were not applied to ${file} because they would cause a syntax error`;
// oxlint 1.87 writes `foo(,);`, `await x ^= y;` and "declare module String.raw`a\\b` {}".
test.each([
@@ -3590,7 +6316,9 @@ describe.concurrent("bun lint", () => {
]);
expect([named.files, found.files, withoutRepository.files]).toEqual([outside, outside, outside]);
for (const { stdout, stderr } of [named, found, withoutRepository]) {
- expect(stdout + stderr).toContain("Cannot write /project/c/d.js: A link leads out of the repository.");
+ expect(stdout + stderr).toContain(
+ "Cannot write /project/c/d.js: it is a symlink to a file outside the repository",
+ );
}
// Beside an .oxlintrc.json what fails ends the run as it ends oxlint's.
expect([named.exitCode, found.exitCode, withoutRepository.exitCode]).toEqual([2, 1, 2]);
@@ -4320,7 +7048,7 @@ describe.concurrent("bun lint", () => {
test("an unknown format fails with 2", async () => {
const { stderr, exitCode } = await lint(files, ["-f", "nothing"]);
- expect(stderr).toContain('There is no formatter "nothing"');
+ expect(stderr).toContain('Unknown format "nothing"\n');
expect(exitCode).toBe(2);
});
@@ -4405,14 +7133,17 @@ describe.concurrent("bun lint", () => {
.split("\n")
.filter(line => line.endsWith("]"))
.sort(),
- ).toEqual(Object.entries(cases).flatMap(([name, [, at]]) => (at ? [`${name}:${at}: ${refused} [Error]`] : [])));
+ ).toEqual(
+ Object.entries(cases).flatMap(([name, [, at]]) => (at ? [`${name}:${at}: ${refused} [Error/TS(2309)]`] : [])),
+ );
});
// The same.
test("only a namespace can be deferred, as for oxc", async () => {
- const [ofDefault, ofNamed] = ["Default imports", "Named imports"].map(
- it => `1:8: ${it} are not allowed in a deferred import.`,
- );
+ const [ofDefault, ofNamed] = [
+ ["Default imports", 18058],
+ ["Named imports", 18059],
+ ].map(([it, code]) => `1:8: ${it} are not allowed in a deferred import. [Error/TS(${code})]`);
const cases: Record = {
"a0.ts": ['import defer x from "m";', ofDefault],
"a1.ts": ['import defer { a } from "m";', ofNamed],
@@ -4435,13 +7166,13 @@ describe.concurrent("bun lint", () => {
.split("\n")
.filter(line => line.endsWith("]"))
.sort(),
- ).toEqual(Object.entries(cases).flatMap(([name, [, refusal]]) => (refusal ? [`${name}:${refusal} [Error]`] : [])));
+ ).toEqual(Object.entries(cases).flatMap(([name, [, refusal]]) => (refusal ? [`${name}:${refusal}`] : [])));
});
// The same.
test("`declare` in what is ambient already, and `for await` where nothing waits, are refused as oxc refuses them", async () => {
- const declared = "A 'declare' modifier cannot be used in an already ambient context.";
- const waits = "`for await` loops are only allowed within async functions and at the top levels of modules";
+ const declared = "A 'declare' modifier cannot be used in an already ambient context. [Error/TS(1038)]";
+ const waits = "`for await` loops are only allowed within async functions and at the top levels of modules [Error]";
const cases: Record = {
"a0.ts": ["declare namespace A { declare const b: 1; }", `1:23: ${declared}`],
"a1.ts": ['declare module "m" { declare function f(): void; }', `1:22: ${declared}`],
@@ -4478,7 +7209,7 @@ describe.concurrent("bun lint", () => {
.split("\n")
.filter(line => line.endsWith("]"))
.sort(),
- ).toEqual(Object.entries(cases).flatMap(([name, [, refusal]]) => (refusal ? [`${name}:${refusal} [Error]`] : [])));
+ ).toEqual(Object.entries(cases).flatMap(([name, [, refusal]]) => (refusal ? [`${name}:${refusal}`] : [])));
});
// The same.
@@ -4576,7 +7307,7 @@ describe.concurrent("bun lint", () => {
return stderr.split("\n").filter(it => it.startsWith("note: "));
};
expect(await notes("5.8.3")).toEqual([
- "note: typescript 5.8.3 is installed; bun lint checks types as TypeScript 7.",
+ "note: typescript 5.8.3 is installed, but bun lint checks types like TypeScript 7",
]);
expect(await notes("7.0.2")).toEqual([]);
expect(await notes("5.8.3", {}, "--quiet")).toEqual([]);
@@ -4645,7 +7376,7 @@ describe.concurrent("bun lint", () => {
const reported = (stdout: string, rule: string) =>
stdout
.split("\n")
- .filter(it => it.endsWith(`[Error/${rule}]`))
+ .filter(it => it.endsWith(`/${rule}]`))
.map(it => `${it.split(":")[0].replace("/", "")} ${/'([^']+)'/.exec(it)![1]}`);
test.concurrent.each([
@@ -4686,7 +7417,7 @@ describe.concurrent("bun lint", () => {
["fromTypes", "mineConst", "mineFn", "MineClass", "Array"].map(it => `a.js ${it}`),
);
expect(reported(stdout, "no-undef")).toEqual([]);
- expect(exitCode).toBe(1);
+ expect(exitCode).toBe(0);
});
test("a project in which no file can declare a global has its libraries and its types", async () => {
@@ -5879,7 +8610,7 @@ describe.concurrent("bun lint", () => {
"c.tsx": "/a.js
4:11 error Irregular whitespace not allowed no-irregular-whitespace
@@ -6613,14 +9346,15 @@ describe.concurrent("regular expressions in a configuration", () => {
11:4 error Irregular whitespace not allowed no-irregular-whitespace
/b.ts
- 1:1 error Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free @typescript-eslint/ban-ts-comment
+ 1:1 warning Use "@ts-expect-error" instead of "@ts-ignore", as "@ts-ignore" will do nothing if the following line is error-free @typescript-eslint/ban-ts-comment
- ✖ 5 problems (5 errors, 0 warnings)"
+ ✖ 5 problems (4 errors, 1 warning)"
`);
expect(stderr).not.toContain("JSC options");
expect(exitCode).toBe(1);
- const own = await lint(files, ["--rule", 'no-fallthrough: [error, { commentPattern: "fall +through" }]'], { env });
+ const pattern = 'no-fallthrough: [error, { commentPattern: "fall +through" }]';
+ const own = await lint(files, ["-f", "stylish", "--rule", pattern], { env });
expect(own.stdout).toMatch(/ 5:3 +error +Expected a 'break' statement before 'case' +no-fallthrough\n/);
expect(own.stderr).toContain("JSC options");
});
@@ -6777,7 +9511,7 @@ describe.concurrent("a lint script in package.json", () => {
});
// What the linter takes from the process that it runs in. Where `bun lint` is developed something else is in Bun's place for each
-// of these. See "what bun format takes from Bun" in test/cli/format/format.test.ts.
+// of these. See "what bun fmt takes from Bun" in test/cli/format/format.test.ts.
describe.concurrent("what bun lint takes from Bun", () => {
const files = {
"eslint.config.js": basic,
@@ -7054,8 +9788,11 @@ describe("bun lint on Windows, macOS and Linux", () => {
.map(it => it.filePath.slice(String(dir).length + 1).replaceAll(sep, "/"))
.sort();
/** The same for oxlint's `json`, which has the path from the working directory. */
- const reportedToOxlint = (stdout: string) =>
- [...new Set((JSON.parse(stdout).diagnostics as { filename: string }[]).map(it => it.filename))].sort();
+ const reportedToOxlint = (stdout: string) => {
+ // The message shows the output if it isn't JSON.
+ expect(() => JSON.parse(stdout), stdout).not.toThrow();
+ return [...new Set((JSON.parse(stdout).diagnostics as { filename: string }[]).map(it => it.filename))].sort();
+ };
const swapCase = (text: string) =>
text.replace(/[a-z]/gi, letter => (letter === letter.toLowerCase() ? letter.toUpperCase() : letter.toLowerCase()));
@@ -7573,7 +10310,8 @@ foo(b)
lint(forOxlint, ["--threads", "8", "--fix", "-f", "json"]),
lint(forEslint, [...eslint, "-f", "json"]),
]);
- expect(asOxlint.stderr).not.toContain("Cannot write");
+ // Like oxlint, it says what went wrong on standard output.
+ expect(asOxlint.stdout).not.toContain("Cannot write");
expect(reportedToOxlint(asOxlint.stdout).length).toBe(32);
expect(reported(asEslint.stdout, forEslint).length).toBe(16);
expect(everythingIn(join(String(forOxlint), "real")).length).toBe(16);
@@ -7723,8 +10461,8 @@ foo(b)
};
const isRunning = (pid: number) => {
try {
- // One that has ended, and that nobody has asked about yet, still has its number.
- if (isLinux) return !/^\d+ \(.*\) Z /s.test(readFileSync(`/proc/${pid}/stat`, "utf8"));
+ // An exited process keeps its pid until it's reaped: state Z (zombie), then briefly X (dead).
+ if (isLinux) return !/^\d+ \(.*\) [ZX] /s.test(readFileSync(`/proc/${pid}/stat`, "utf8"));
process.kill(pid, 0);
return true;
} catch {
@@ -7740,8 +10478,21 @@ foo(b)
proc.kill("SIGKILL");
await proc.exited;
expect(await until(() => !isRunning(pid))).toBe(true);
+ // Windows reports a process as gone while it still holds its working directory, which can't be removed until then.
+ const isRemoved = () => {
+ try {
+ rmSync(String(dir), { recursive: true, force: true });
+ return true;
+ } catch {
+ return false;
+ }
+ };
+ expect(await until(isRemoved)).toBe(true);
} finally {
- if (isRunning(pid)) process.kill(pid, "SIGKILL");
+ // It may exit at any moment, so don't check first. ESRCH means it's already gone.
+ try {
+ process.kill(pid, "SIGKILL");
+ } catch {}
}
},
timeout,
@@ -7749,537 +10500,59 @@ foo(b)
});
});
-// A key of `[lint]` is the default of the flag of the same name.
-describe.concurrent("[lint] in bunfig.toml", () => {
- /** What a run leaves behind: what it prints but for the times, how it ends, and the files. */
- async function run(files: Record, args: string[]) {
- const reads = Object.keys(files).filter(name => name !== "bunfig.toml");
- const result = await lint(files, args, { reads, mayFail: true });
- // In JSON the `\\` of a path of Windows are doubled, so the directory is not found in it and its random end stays.
- const text = (printed: string) => printed.replace(/\d+(\.\d+)?m?s\b/g, "0ms").replace(/\bbun-lint_\w+/g, "");
- return { stdout: text(result.stdout), stderr: text(result.stderr), exitCode: result.exitCode, files: result.files };
- }
+// The rules of some plugins are built in, and run in place of those of the package that the configuration loads.
+describe.concurrent("nativePluginRules", () => {
+ // A debug build takes seconds to start an engine for JavaScript.
+ const timeout = isDebug || isASAN ? 120_000 : 10_000;
- const eslint = { "eslint.config.js": basic, "a.js": bad };
- const oxlint = { ".oxlintrc.json": `{ "rules": { "no-debugger": "error", "no-var": "warn" } }`, "a.js": bad };
- const typed = {
- ".oxlintrc.json": `{ "rules": { "typescript/no-floating-promises": "error" } }`,
- "tsconfig.json": `{ "compilerOptions": { "strict": true }, "include": ["*.ts"] }`,
- "a.ts": "async function f() {}\nf();\nconst a: string = 1;\n",
+ /** A package that is called `name`, whose rules report at the top of every file that they have run. */
+ const standIn = (name: string, rules: string[], report = `context.report({ node, message: "the package ran" })`) => ({
+ [`node_modules/${name}/package.json`]: JSON.stringify({ name, version: "99.0.0", main: "index.js" }),
+ [`node_modules/${name}/index.js`]: `module.exports = {
+ meta: { name: ${JSON.stringify(name)}, version: "99.0.0" },
+ rules: Object.fromEntries(${JSON.stringify(rules)}.map(rule => [rule, { create: context => ({ Program(node) { ${report}; } }) }])),
+ };\n`,
+ });
+ const packages = {
+ ...standIn("eslint-plugin-react-hooks", ["rules-of-hooks"]),
+ ...standIn("eslint-plugin-import", ["order"]),
+ };
+ const rules = { "react-hooks/rules-of-hooks": "error", "import/order": "error", "no-debugger": "error" };
+ const source = {
+ "a.js": `import b from "./b.js";\nimport fs from "fs";\nfunction f() {\n if (b) useState(fs);\n}\ndebugger;\n`,
+ "b.js": "export default 1;\n",
+ };
+ const flat = {
+ ...packages,
+ ...source,
+ "eslint.config.js": `const hooks = require("eslint-plugin-react-hooks");\nconst imports = require("eslint-plugin-import");\nmodule.exports = [{ plugins: { "react-hooks": hooks, import: imports }, rules: ${JSON.stringify(rules)} }];\n`,
+ };
+ const legacy = {
+ ...packages,
+ ...source,
+ ".eslintrc.json": JSON.stringify({
+ root: true,
+ parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+ plugins: ["react-hooks", "import"],
+ rules,
+ }),
};
- const many = Array.from({ length: 60 }, () => "debugger;\n").join("");
- const suppressions = JSON.stringify({
- "a.js": { "no-debugger": { count: 1 }, eqeqeq: { count: 1 }, yoda: { count: 1 } },
- });
-
- // Lines of the section, the flags that say the same, flags that say otherwise, the files, and the arguments.
- const keys: [lines: string, flags: string[], opposite: string[], files: Record, args: string[]][] = [
- [
- `config = "other.config.js"`,
- ["--config", "other.config.js"],
- ["-c", "eslint.config.js"],
- { ...eslint, "other.config.js": config({ "no-var": "error" }) },
- ["a.js"],
- ],
- [`configLookup = false`, ["--no-config-lookup"], ["--config-lookup"], eslint, ["a.js"]],
- [`flavor = "oxlint"`, ["--flavor=oxlint"], ["--flavor=eslint"], { ...eslint, ...oxlint }, ["a.js"]],
- [`flavor = "eslint"`, ["--flavor=eslint"], ["--flavor=oxlint"], { ...eslint, ...oxlint }, ["a.js"]],
- [`ext = [".foo"]`, ["--ext", ".foo"], [], { ...eslint, "b.foo": bad }, ["."]],
- [`ext = ".foo"`, ["--ext", ".foo"], [], { ...eslint, "b.foo": bad }, ["."]],
- [
- `ignorePatterns = ["b.js", "sub/"]`,
- ["--ignore-pattern", "b.js", "--ignore-pattern=sub/"],
- [],
- { ...eslint, "b.js": bad, "sub/c.js": bad },
- ["."],
- ],
- [`ignorePath = "mine"`, ["--ignore-path", "mine"], [], { ...oxlint, "b.js": bad, mine: "b.js\n" }, ["."]],
- [
- `ignore = false`,
- ["--no-ignore"],
- ["--ignore"],
- {
- "eslint.config.js": `export default [{ ignores: ["a.js"] }, { rules: { "no-debugger": "error" } }];`,
- "a.js": bad,
- },
- ["a.js"],
- ],
- [
- `warnIgnored = false`,
- ["--no-warn-ignored"],
- ["--warn-ignored"],
- { "eslint.config.js": `export default [{ ignores: ["a.js"] }];`, "a.js": bad, "b.js": "" },
- ["a.js", "b.js"],
- ],
- [`quiet = true`, ["--quiet"], ["--no-quiet"], eslint, ["a.js"]],
- [`silent = true`, ["--silent"], ["--no-silent"], oxlint, ["a.js"]],
- [
- `maxWarnings = 0`,
- ["--max-warnings", "0"],
- ["--max-warnings=10"],
- { ...eslint, "a.js": "var a = 1;\na;\n" },
- ["a.js"],
- ],
- [
- `denyWarnings = true`,
- ["--deny-warnings"],
- ["--no-deny-warnings"],
- { ...oxlint, "a.js": "var a = 1;\na;\n" },
- ["a.js"],
- ],
- [`format = "unix"`, ["-f", "unix"], ["--format=json"], eslint, ["a.js"]],
- [`all = true`, ["--all"], ["--no-all"], { ...eslint, "a.js": many }, ["-f", "pretty", "a.js"]],
- [
- `inlineConfig = false`,
- ["--no-inline-config"],
- ["--inline-config"],
- { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\ndebugger;\n" },
- ["a.js"],
- ],
- [
- `reportUnusedDisableDirectives = true`,
- ["--report-unused-disable-directives"],
- ["--report-unused-disable-directives-severity=off"],
- { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\na;\n" },
- ["a.js"],
- ],
- [
- `reportUnusedDisableDirectives = "off"`,
- ["--report-unused-disable-directives-severity", "off"],
- ["--report-unused-disable-directives"],
- { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\na;\n" },
- ["a.js"],
- ],
- [
- `reportUnusedInlineConfigs = "error"`,
- ["--report-unused-inline-configs=error"],
- ["--report-unused-inline-configs=off"],
- { ...eslint, "a.js": "/* eslint no-debugger: error */\na;\n" },
- ["a.js"],
- ],
- [
- `suppressionsLocation = "known.json"`,
- ["--suppressions-location", "known.json"],
- ["--suppressions-location=none.json"],
- { ...eslint, "known.json": suppressions },
- ["a.js"],
- ],
- [
- `passOnUnprunedSuppressions = true`,
- ["--pass-on-unpruned-suppressions"],
- ["--no-pass-on-unpruned-suppressions"],
- { ...eslint, "a.js": "a;\n", "eslint-suppressions.json": suppressions },
- ["a.js"],
- ],
- [
- `errorOnUnmatchedPattern = false`,
- ["--no-error-on-unmatched-pattern"],
- ["--error-on-unmatched-pattern"],
- eslint,
- ["none.js"],
- ],
- [`passOnNoPatterns = true`, ["--pass-on-no-patterns"], ["--no-pass-on-no-patterns"], eslint, []],
- [
- `exitOnFatalError = true`,
- ["--exit-on-fatal-error"],
- ["--no-exit-on-fatal-error"],
- { ...eslint, "a.js": "a(" },
- ["a.js"],
- ],
- [
- `allowUnsupported = true`,
- ["--allow-unsupported"],
- ["--no-allow-unsupported"],
- { ".eslintrc.json": `{ "rules": { "no-debugger": "error", "require-jsdoc": "warn" } }`, "a.js": bad },
- ["a.js"],
- ],
- [
- `inferGlobals = true`,
- ["--infer-globals"],
- ["--no-infer-globals"],
- {
- "eslint.config.js": config({ "no-undef": "error" }),
- "tsconfig.json": `{ "compilerOptions": { "allowJs": true }, "include": ["*.ts", "*.js"] }`,
- "globals.d.ts": "declare const mine: number;\n",
- "a.js": "mine;\nother;\n",
- },
- ["a.js"],
- ],
- [`typeAware = true`, ["--type-aware"], ["--no-type-aware"], typed, ["a.ts"]],
- [
- `typeAware = false`,
- ["--no-type-aware"],
- ["--type-aware"],
- {
- ...typed,
- ".oxlintrc.json": `{ "options": { "typeAware": true }, "rules": { "typescript/no-floating-promises": "error" } }`,
- },
- ["a.ts"],
- ],
- [`typeCheck = true`, ["--type-check"], ["--no-type-check"], typed, ["--type-aware", "a.ts"]],
- [`project = "none.json"`, ["--project", "none.json"], ["-p", "tsconfig.json"], typed, ["--type-aware", "a.ts"]],
- [
- `disableNestedConfig = true`,
- ["--disable-nested-config"],
- ["--no-disable-nested-config"],
- { ...oxlint, "sub/.oxlintrc.json": `{ "rules": { "no-debugger": "off" } }`, "sub/a.js": bad },
- ["sub/a.js"],
- ],
- [
- `fixType = ["suggestion"]`,
- ["--fix-type", "suggestion"],
- [],
- { "eslint.config.js": config({ "unicode-bom": ["error", "always"], "no-var": "error" }), "a.js": bad },
- ["--fix", "a.js"],
- ],
- [
- `[lint.rules]\n"no-debugger" = "off"\neqeqeq = ["error", "smart"]\n"no-eval" = 2`,
- ["--rule", `{"no-debugger": "off", "eqeqeq": ["error", "smart"], "no-eval": 2}`],
- ["--rule", "no-debugger: warn"],
- { ...eslint, "a.js": `${bad}eval(a == null);\n` },
- ["a.js"],
- ],
- [
- `[lint.rules]\n"no-debugger" = "off"\n"no-eval" = "error"`,
- ["--rule", `{"no-debugger": "off", "no-eval": "error"}`, "--flavor=oxlint"],
- ["--rule", "no-debugger: warn"],
- { ...oxlint, "a.js": `${bad}eval(a);\n` },
- ["a.js"],
- ],
- [
- `[lint.rules]\n"no-restricted-imports" = ["error", { paths = ["lodash"], patterns = [{ group = ["a\\nb*"], message = "it's \\"so\\"" }] }]`,
- ["--rule", `{"no-restricted-imports": ["error", { "paths": ["lodash"] }]}`],
- [],
- { ...eslint, "a.js": `import "lodash";\n` },
- ["a.js"],
- ],
- [
- `[lint.globals]\nmine = "readonly"\nyours = true\ntheirs = false\nours = "writable"`,
- ["--global", "mine,yours:true", "--global", "theirs,ours:true"],
- [],
- {
- "eslint.config.js": config({ "no-undef": "error", "no-global-assign": "error" }),
- "a.js": "mine = yours = theirs = ours = other;\n",
- },
- ["a.js"],
- ],
- [
- `[lint.parserOptions]\necmaFeatures = { jsx = true }`,
- ["--parser-options", "ecmaFeatures: { jsx: true }"],
- ["--parser-options", "ecmaFeatures: { jsx: false }"],
- { ...eslint, "a.js": ";\n" },
- ["a.js"],
- ],
- [
- `[lint.categories]\nstyle = "warn"\nall = "off"\ncorrectness = "error"`,
- ["-A", "all", "-W", "style", "-D", "correctness"],
- [],
- { ".oxlintrc.json": "{}", "a.js": `${bad}for (;;) {}\n` },
- ["a.js"],
- ],
- ];
-
- test.each(keys)("%s", async (lines, flags, opposite, files, args) => {
- const bunfig = { "bunfig.toml": lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n` };
- const [plain, byKey, byFlag, underFlag, byOtherFlag] = await Promise.all([
- run(files, args),
- run({ ...files, ...bunfig }, args),
- run(files, [...flags, ...args]),
- run({ ...files, ...bunfig }, [...opposite, ...args]),
- // What takes a list or a table is added to.
- run(files, [...(opposite.length === 0 || /^\[|= \[/.test(lines) ? flags : []), ...opposite, ...args]),
- ]);
- expect(byKey).toEqual(byFlag);
- expect(byKey).not.toEqual(plain);
- expect(underFlag).toEqual(byOtherFlag);
- });
-
- test("threads", async () => {
- const [byKey, byFlag, wrong] = await Promise.all([
- run({ ...eslint, "bunfig.toml": "[lint]\nthreads = 1\n" }, ["a.js"]),
- run(eslint, ["--threads=1", "a.js"]),
- run({ ...eslint, "bunfig.toml": "[lint]\nthreads = -1\n" }, ["a.js"]),
- ]);
- expect(byKey).toEqual(byFlag);
- expect(wrong.stderr).toContain(`--threads takes a number, not "-1".`);
- expect(wrong.exitCode).toBe(2);
- });
-
- // 288 bytes for each: 19 GB, and more than there is to address.
- test.each(["67108864", "9007199254740991", "9223372036854775808"])(
- "%s threads are as many as there can be",
- async count => {
- const [byKey, byFlag, few] = await Promise.all([
- run({ ...eslint, "bunfig.toml": `[lint]\nthreads = ${count}\n` }, ["a.js"]),
- run(eslint, [`--threads=${count}`, "a.js"]),
- run(eslint, ["--threads=1", "a.js"]),
- ]);
- // Beyond 2^53 - 1 the file is refused before anybody asks for the key.
- if (Number.isSafeInteger(Number(count))) expect(byKey).toEqual(few);
- expect(byFlag).toEqual(few);
- },
- );
-
- // ESLint refuses the flag in a run that fixes nothing.
- test("fixType waits for a run that fixes", async () => {
- const files = { ...eslint, "bunfig.toml": `[lint]\nfixType = ["layout"]\n` };
- const [without, plain, dry, dryByFlag] = await Promise.all([
- run(files, ["a.js"]),
- run(eslint, ["a.js"]),
- run(files, ["--fix-dry-run", "-f", "json", "a.js"]),
- run(eslint, ["--fix-dry-run", "--fix-type=layout", "-f", "json", "a.js"]),
- ]);
- expect(without).toEqual(plain);
- expect(dry).toEqual(dryByFlag);
- });
-
- // A flag that only one of the two tools has says whom a command line was written for. A key was written for Bun.
- test("a key does not say which tool the run stands in for", async () => {
- const both = { ...eslint, ...oxlint };
- const asks = "Say which one this run is for: --flavor=oxlint or --flavor=eslint.";
- const results = await Promise.all(
- [
- `denyWarnings = true`,
- `typeAware = true`,
- `ext = [".js"]`,
- `[lint.rules]\n"no-var" = "off"`,
- `[lint.categories]\nstyle = "warn"`,
- ].map(lines =>
- run({ ...both, "bunfig.toml": lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n` }, ["a.js"]),
- ),
- );
- for (const result of results) {
- expect(result.stderr).toContain(asks);
- expect(result.exitCode).toBe(2);
- }
- // With the configuration of ESLint alone, neither makes it a run of oxlint.
- const [byKey, byFlag, plain] = await Promise.all([
- run({ ...eslint, "bunfig.toml": "[lint]\ndenyWarnings = true\n" }, ["-f", "unix", "a.js"]),
- run(eslint, ["--deny-warnings", "-f", "unix", "a.js"]),
- run(eslint, ["-f", "unix", "a.js"]),
- ]);
- expect(byKey.stdout).toBe(plain.stdout);
- expect(byFlag.stdout).toBe(plain.stdout);
- });
-
- test("bun/format holds a file against what bun format prints, with [format]", async () => {
- const files = { "a.js": "a('b')\n", "bunfig.toml": "[format]\nsemi = false\nsingleQuote = true\n" };
- const rule = (...options: unknown[]) => ({
- ".oxlintrc.json": JSON.stringify({ rules: { "bun/format": ["error", ...options] } }),
- });
- const [withSection, without, overridden] = await Promise.all([
- run({ ...files, ...rule() }, ["-f", "unix", "a.js"]),
- run({ "a.js": files["a.js"], ...rule() }, ["-f", "unix", "a.js"]),
- run({ ...files, ...rule({ semi: true }) }, ["-f", "unix", "a.js"]),
- ]);
- expect(withSection.stdout).toBe("");
- expect(withSection.exitCode).toBe(0);
- expect(without.stdout).toContain(`Replace \`'b')\` with \`"b");\``);
- expect(overridden.stdout).toContain("Insert `;`");
- expect(overridden.stdout).not.toContain("Replace");
- });
-
- test("the file is that of the working directory, after --cwd", async () => {
- const files = {
- ...eslint,
- "sub/a.js": bad,
- "bunfig.toml": `[lint]\nformat = "unix"\n`,
- "sub/bunfig.toml": `[lint]\nquiet = true\nformat = "json"\n`,
- };
- const [above, below] = await Promise.all([run(files, ["sub/a.js"]), run(files, ["--cwd=sub", "a.js"])]);
- expect(above.stdout).toContain("[Warning/no-var]");
- expect(JSON.parse(below.stdout)[0].warningCount).toBe(0);
- });
-
- /** `bun ...args` in a directory with `files`. */
- async function bun(files: Record, args: string[]) {
- using dir = tempDir("bun-lint-bunfig", files);
- const stdio = { stdin: "ignore", stdout: "pipe", stderr: "pipe" } as const;
- await using proc = spawn({ cmd: [bunExe(), ...args], env, cwd: String(dir), ...stdio });
- const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
- return { stdout, stderr, exitCode };
- }
-
- test("--config= before lint names another file than bunfig.toml", async () => {
- const files = {
- ...eslint,
- "bunfig.toml": `[lint]\nformat = "unix"\n`,
- "other.toml": `[lint]\nformat = "json"\n`,
- };
- const results = await Promise.all([
- bun(files, ["lint", "a.js"]),
- bun(files, ["--config=other.toml", "lint", "a.js"]),
- bun(files, ["-c=other.toml", "lint", "a.js"]),
- // What follows `lint` is the linter's.
- bun(files, ["--config=other.toml", "lint", "-c", "eslint.config.js", "a.js"]),
- bun(files, ["--config=none.toml", "lint", "a.js"]),
- ]);
- expect(results.map(it => [it.stdout.startsWith("[{"), it.exitCode])).toEqual([
- [false, 1],
- [true, 1],
- [true, 1],
- [true, 1],
- [false, 2],
- ]);
- expect(results[4].stderr).toContain(`while reading config "`);
- });
-
- test("what is wrong with [lint] is shown where it is, as for every other section", async () => {
- const bunfig = `[lint]\nquiet = true\n\n[lint.rules]\neqeqeq = ["error", "smart"]\n"no-var" = "always"\n`;
- const result = await bun({ ...eslint, "bunfig.toml": bunfig }, ["lint", "a.js"]);
- expect(result.stderr).toContain(`6 | "no-var" = "always"\n`);
- expect(result.stderr).toMatch(
- /error: Option rules: 'always' not one of off, warn, error, 0, 1, or 2\.\n\s+at .*bunfig\.toml:6:12\n/,
- );
- expect(result.stdout).toBe("");
- expect(result.exitCode).toBe(2);
- });
-
- // The flags that say what one run does.
- test.each([
- ["fix = true", "--fix"],
- ["fixDryRun = true", "--fix-dry-run"],
- ["fixSuggestions = true", "--fix-suggestions"],
- ["fixDangerously = true", "--fix-dangerously"],
- ["init = true", "--init"],
- ["stdin = true", "--stdin"],
- [`stdinFilename = "a.js"`, "--stdin-filename"],
- [`printConfig = "a.js"`, "--print-config"],
- ["suppressAll = true", "--suppress-all"],
- [`suppressRule = ["no-var"]`, "--suppress-rule"],
- ["pruneSuppressions = true", "--prune-suppressions"],
- [`outputFile = "report.txt"`, "--output-file"],
- ["color = true", "--color"],
- ["timing = true", "--timing"],
- [`cwd = "sub"`, "--cwd"],
- ])("%s is refused, and nothing is written", async (line, flag) => {
- const key = line.split(" ")[0];
- const result = await run({ ...eslint, "bunfig.toml": `[lint]\n${line}\n` }, ["a.js"]);
- expect(result.stderr).toContain(
- `"${key}" cannot be set in bunfig.toml, it says what one run does. Pass ${flag} on the command line`,
- );
- expect(result.stdout).toBe("");
- expect(result.files["a.js"]).toBe(bad);
- expect(result.exitCode).toBe(2);
- });
-
- test.each([
- ["quiet = 1", "expected boolean but received number"],
- [`maxWarnings = "0"`, "expected number but received string"],
- ["maxWarnings = 1.5", "Invalid value for option 'max-warnings' - expected type Int, received value: 1.5."],
- ["config = false", "expected string but received boolean"],
- ["ignorePatterns = true", "expected array but received boolean"],
- ["ignorePatterns = [1]", "expected string but received number"],
- [`flavor = "biome"`, "Option flavor: 'biome' not one of eslint or oxlint."],
- [`format = "fancy"`, `There is no formatter "fancy". Those that exist: stylish, pretty, json,`],
- [`fixType = ["all"]`, `'fixTypes' must be an array of any of "directive", "problem", "suggestion", and "layout".`],
- [`reportUnusedDisableDirectives = "loud"`, "'loud' not one of off, warn, error, 0, 1, or 2."],
- ["reportUnusedDisableDirectives = 1", "expected string but received number"],
- [`reportUnusedInlineConfigs = true`, "expected string but received boolean"],
- ["rules = true", "expected object but received boolean"],
- [`[lint.rules]\neqeqeq = "always"`, "Option rules: 'always' not one of off, warn, error, 0, 1, or 2."],
- [`[lint.rules]\neqeqeq = ["smart"]`, "Option rules: 'smart' not one of off, warn, error, 0, 1, or 2."],
- [`[lint.rules]\neqeqeq = []`, "expected string but received array"],
- [`[lint.rules]\neqeqeq = true`, "expected string but received boolean"],
- [`[lint.globals]\na = "off"`, `expected "readonly" or "writable" but received string`],
- [`[lint.globals]\na = 1`, `expected "readonly" or "writable" but received number`],
- [`[lint.categories]\nstyles = "warn"`, `unknown category "styles"`],
- [`[lint.categories]\nstyle = "deny"`, "Option categories: 'deny' not one of off, warn, error, 0, 1, or 2."],
- ["maxWarning = 0", `unknown key "maxWarning" in [lint]. Did you mean "maxWarnings"?`],
- ["max-warnings = 0", `unknown key "max-warnings" in [lint]. Did you mean "maxWarnings"?`],
- [`ignorePattern = ["a"]`, `unknown key "ignorePattern" in [lint]. Did you mean "ignorePatterns"?`],
- [`plugins = ["import"]`, `unknown key "plugins" in [lint].`],
- [`extends = ["a"]`, `unknown key "extends" in [lint].`],
- ["overrides = []", `unknown key "overrides" in [lint].`],
- ["cache = true", `unknown key "cache" in [lint].`],
- [`env = ["node"]`, `unknown key "env" in [lint].`],
- ])("%s is refused: %s", async (lines, message) => {
- const bunfig = lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n`;
- const result = await run({ ...eslint, "bunfig.toml": bunfig }, ["a.js"]);
- expect(result.stderr).toContain(message);
- expect(result.stdout).toBe("");
- expect(result.exitCode).toBe(2);
- });
-
- test("every flag in the help is a key, or is refused as a key with its name", async () => {
- const help = await lint({}, ["--help"]);
- const flags = [...help.stdout.matchAll(/^\s+(?:-\w, )?--([a-z-]+)/gm)].map(it => it[1]);
- expect(flags.length).toBeGreaterThan(50);
- const renamed: Record = {
- "ignore-pattern": "ignorePatterns",
- "report-unused-disable-directives-severity": "reportUnusedDisableDirectives",
- rule: "rules",
- global: "globals",
- allow: "categories",
- warn: "categories",
- deny: "categories",
- };
- const answers = await Promise.all(
- flags.map(async flag => {
- const positive = flag.replace(/^no-/, "");
- const key = renamed[positive] ?? positive.replace(/-(\w)/g, (_, it) => it.toUpperCase());
- // Of a type that no key takes: one that exists says what it expects.
- const { stderr } = await run({ "bunfig.toml": `[lint]\n${key} = [[1]]\n` }, ["--list-files"]);
- return [flag, /expected .+ but received|cannot be set in bunfig\.toml/.test(stderr)];
- }),
- );
- expect(answers.filter(it => !it[1])).toEqual([]);
- });
-});
-
-// The rules of some plugins are built in, and run in place of those of the package that the configuration loads.
-describe.concurrent("nativePluginRules", () => {
- // A debug build takes seconds to start an engine for JavaScript.
- const timeout = isDebug || isASAN ? 120_000 : 10_000;
-
- /** A package that is called `name`, whose rules report at the top of every file that they have run. */
- const standIn = (name: string, rules: string[], report = `context.report({ node, message: "the package ran" })`) => ({
- [`node_modules/${name}/package.json`]: JSON.stringify({ name, version: "99.0.0", main: "index.js" }),
- [`node_modules/${name}/index.js`]: `module.exports = {
- meta: { name: ${JSON.stringify(name)}, version: "99.0.0" },
- rules: Object.fromEntries(${JSON.stringify(rules)}.map(rule => [rule, { create: context => ({ Program(node) { ${report}; } }) }])),
- };\n`,
- });
- const packages = {
- ...standIn("eslint-plugin-react-hooks", ["rules-of-hooks"]),
- ...standIn("eslint-plugin-import", ["order"]),
- };
- const rules = { "react-hooks/rules-of-hooks": "error", "import/order": "error", "no-debugger": "error" };
- const source = {
- "a.js": `import b from "./b.js";\nimport fs from "fs";\nfunction f() {\n if (b) useState(fs);\n}\ndebugger;\n`,
- "b.js": "export default 1;\n",
- };
- const flat = {
- ...packages,
- ...source,
- "eslint.config.js": `const hooks = require("eslint-plugin-react-hooks");\nconst imports = require("eslint-plugin-import");\nmodule.exports = [{ plugins: { "react-hooks": hooks, import: imports }, rules: ${JSON.stringify(rules)} }];\n`,
- };
- const legacy = {
- ...packages,
- ...source,
- ".eslintrc.json": JSON.stringify({
- root: true,
- parserOptions: { ecmaVersion: 2022, sourceType: "module" },
- plugins: ["react-hooks", "import"],
- rules,
- }),
- };
-
- /** For each rule that reports: whether it is that of the package. */
- async function who(files: Record, args: string[] = []) {
- const { raw, stderr, exitCode } = await lint(files, ["-f", "json", ...args, "a.js"], { mayFail: true });
- if (exitCode !== 1) return { stderr, exitCode };
- const messages: { ruleId: string; message: string }[] = JSON.parse(raw)[0].messages;
- return Object.fromEntries(
- messages.map(it => [it.ruleId, it.message === "the package ran" ? "package" : "built in"]),
- );
- }
- const bunfig = (value: string) => ({ "bunfig.toml": `[lint]\nnativePluginRules = ${value}\n` });
- const all = (hooks: string, imports: string) => ({
- "react-hooks/rules-of-hooks": hooks,
- "import/order": imports,
- // Of no package.
- "no-debugger": "built in",
+
+ /** For each rule that reports: whether it is that of the package. */
+ async function who(files: Record, args: string[] = []) {
+ const { raw, stderr, exitCode } = await lint(files, ["-f", "json", ...args, "a.js"], { mayFail: true });
+ if (exitCode !== 1) return { stderr, exitCode };
+ const messages: { ruleId: string; message: string }[] = JSON.parse(raw)[0].messages;
+ return Object.fromEntries(
+ messages.map(it => [it.ruleId, it.message === "the package ran" ? "package" : "built in"]),
+ );
+ }
+ const bunfig = (value: string) => ({ "bunfig.toml": `[lint]\nnativePluginRules = ${value}\n` });
+ const all = (hooks: string, imports: string) => ({
+ "react-hooks/rules-of-hooks": hooks,
+ "import/order": imports,
+ // Of no package.
+ "no-debugger": "built in",
});
describe.each([
@@ -8672,7 +10945,9 @@ describe.concurrent("nativePluginRules", () => {
lint({ ...flat, ...bunfig(`["import"]`) }, ["--print-config", "a.js"]),
]);
expect(builtIn.stderr).toBe("");
- expect(mixed.stderr).toBe("note: in JavaScript: react-hooks/rules-of-hooks. All other rules are built in.");
+ expect(mixed.stderr).toBe(
+ "note: these rules run in JavaScript: react-hooks/rules-of-hooks. All other rules are built in.",
+ );
expect(JSON.parse(mixed.raw)).toEqual(JSON.parse(builtIn.raw));
},
timeout,
@@ -8690,7 +10965,7 @@ describe.concurrent("nativePluginRules", () => {
};
const result = await lint({ ...files, ...bunfig("false") }, ["a.js"], { mayFail: true });
expect(result.stderr).toContain(
- "1 rule in JavaScript did not run, only the built-in rules have types: @typescript-eslint/no-floating-promises. With --native-plugin-rules=@typescript-eslint the built-in ones run",
+ "1 rule did not run because rules that run in JavaScript cannot use type information: @typescript-eslint/no-floating-promises\n Use --native-plugin-rules=@typescript-eslint to run the built-in versions.",
);
expect(result.exitCode).toBe(2);
},
@@ -8703,7 +10978,7 @@ describe.concurrent("nativePluginRules", () => {
lint(files, ["-f", "unix", "a.ts"]),
lint({ ...files, ...bunfig("false") }, ["-f", "unix", "a.ts"]),
]);
- expect(plain.stdout).toContain("[Error/@typescript-eslint/no-explicit-any]");
+ expect(plain.stdout).toContain("[Warning/@typescript-eslint/no-explicit-any]");
expect(off.stdout).toBe(plain.stdout);
});
@@ -8741,10 +11016,10 @@ describe.concurrent("nativePluginRules", () => {
test.each([
[
`["imprt"]`,
- "Option native-plugin-rules: 'imprt' not one of @typescript-eslint, react-hooks, import, n, react, prettier.",
+ 'Unknown plugin "imprt" in --native-plugin-rules\n Available plugins: @typescript-eslint, react-hooks, import, n, react, prettier\n',
],
- [`["unicorn"]`, "Option native-plugin-rules: 'unicorn' not one of"],
- [`["true"]`, "Option native-plugin-rules: 'true' not one of"],
+ [`["unicorn"]`, 'Unknown plugin "unicorn" in --native-plugin-rules'],
+ [`["true"]`, 'Unknown plugin "true" in --native-plugin-rules'],
[`"import"`, "expected boolean or array but received string"],
["[1]", "expected string but received number"],
])("nativePluginRules = %s is refused", async (value, message) => {
@@ -8753,3 +11028,8798 @@ describe.concurrent("nativePluginRules", () => {
expect(result.exitCode).toBe(2);
});
});
+// tsc reports these errors from its checker (`checkGrammar*`). oxc reports them from its parser or its semantic pass, and oxlint
+// doesn't lint a file that has one. Every row was run on oxlint 1.87 with `-f json`.
+describe("TypeScript grammar errors under .oxlintrc.json", () => {
+ type Reported = {
+ filename: string;
+ code?: string;
+ message: string;
+ help?: string;
+ labels: { label?: string; span: { offset: number; length: number } }[];
+ };
+ /** `TS(1016) The message. @15+1 "what the label says", 3+2 help: The help.` */
+ const print = ({ code, message, help, labels }: Reported) => {
+ const places = labels.map(({ label, span }) => `${span.offset}+${span.length}${label ? ` "${label}"` : ""}`);
+ return `${code ? `${code} ` : ""}${message} @${places.join(", ")}${help ? ` help: ${help}` : ""}`;
+ };
+ const run = async (files: Record, config: Record) => {
+ const { raw, exitCode } = await lint({ ...config, ...files }, ["-f", "json"]);
+ const errors: Record = {};
+ for (const it of JSON.parse(raw).diagnostics as Reported[]) (errors[it.filename] ??= []).push(print(it));
+ return { errors, exitCode };
+ };
+ const oxlintrc = { ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" } }) };
+
+ const rejected: Record = {
+ "ts": [
+ [
+ "await (x) => 1; import.meta;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @13+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "function f(a?, b, c? = 1) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ "TS(1015) A parameter cannot have a question mark and an initializer. @18+1",
+ ],
+ [
+ "function f(a? = 1, b, c) {}",
+ "TS(1015) A parameter cannot have a question mark and an initializer. @11+1",
+ "TS(1016) A required parameter cannot follow an optional parameter. @19+1",
+ "TS(1016) A required parameter cannot follow an optional parameter. @22+1",
+ ],
+ [
+ "function f(a?, b, ...c?) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ "TS(1047) A rest parameter cannot be optional @22+1 help: Remove this `?`. The default value is an empty array",
+ ],
+ [
+ "function f(a?, b, ...c, d) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ "A rest parameter must be last in a parameter list @18+4",
+ ],
+ [
+ "function f(...a? = []) {}",
+ "TS(1047) A rest parameter cannot be optional @15+1 help: Remove this `?`. The default value is an empty array",
+ "A rest parameter cannot have an initializer. @14+7",
+ ],
+ [
+ "function f(...a?: any = []) {}",
+ "TS(1047) A rest parameter cannot be optional @15+1 help: Remove this `?`. The default value is an empty array",
+ 'Expected `,` or `)` but found `=` @22+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "function f(a?, b, ...c = []) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ "A rest parameter cannot have an initializer. @21+6",
+ ],
+ [
+ "function f(a?, b = (x?, y) => 1, c) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @24+1",
+ "TS(1016) A required parameter cannot follow an optional parameter. @33+1",
+ ],
+ [
+ "function f(private a?, b) {}",
+ "TS(1090) 'private' modifier cannot appear on a parameter. @11+7 help: No modifiers are allowed here.",
+ "TS(1016) A required parameter cannot follow an optional parameter. @23+1",
+ ],
+ [
+ "class A { constructor(private a?, b, public c? = 1) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @34+1",
+ "TS(1015) A parameter cannot have a question mark and an initializer. @44+1",
+ ],
+ [
+ "class A { constructor(a?, private b) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @26+9",
+ ],
+ [
+ "class A { constructor(a?, @d b) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @26+4",
+ ],
+ [
+ "function f(a?, b): asserts b is string {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ ],
+ [
+ "function f(a?, /* c */ b /* d */ : number /* e */, c?) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @23+18",
+ ],
+ [
+ "function f(...a /* x */ ? /* y */ : any) {}",
+ "TS(1047) A rest parameter cannot be optional @24+1 help: Remove this `?`. The default value is an empty array",
+ ],
+ [
+ "function f(a /* x */ ? /* y */ : any = 1) {}",
+ "TS(1015) A parameter cannot have a question mark and an initializer. @11+1",
+ ],
+ [
+ "function f([a, b] ? : any = 1) {}",
+ "TS(1015) A parameter cannot have a question mark and an initializer. @11+6",
+ ],
+ ["function f(...[a, b] = []) {}", "A rest parameter cannot have an initializer. @14+11"],
+ ["function f(... /*x*/ a = []) {}", "A rest parameter cannot have an initializer. @21+6"],
+ ["function f(...a: any[] /*x*/, b) {}", "A rest parameter must be last in a parameter list @11+11"],
+ [
+ "function f(...a /*x*/ , /*y*/ ) {}",
+ "A rest parameter or binding pattern may not have a trailing comma. @22+1 help: Remove the trailing comma here",
+ ],
+ ["function f(a?, this) {}", "Identifier expected. 'this' is a reserved word that cannot be used here. @15+4"],
+ [
+ "function f(a, this: any, b?, c) {}",
+ "Identifier expected. 'this' is a reserved word that cannot be used here. @14+4",
+ ],
+ [
+ "type F = (a?, this: any) => void;",
+ "Identifier expected. 'this' is a reserved word that cannot be used here. @14+4",
+ ],
+ [
+ "function f(this: any, this: any) {}",
+ "Identifier expected. 'this' is a reserved word that cannot be used here. @22+4",
+ ],
+ [
+ "let x = { m(a?, b) {}, set s(a?) {}, get g(a?) { return 1 } };",
+ "TS(1016) A required parameter cannot follow an optional parameter. @16+1",
+ "TS(1051) A 'set' accessor cannot have an optional parameter. @29+2",
+ "A 'get' accessor must not have any formal parameters. @42+4 help: Remove these parameters here",
+ ],
+ ["declare const a: number = 1;", "TS(1039) Initializers are not allowed in ambient contexts. @26+1"],
+ ["declare let a = 1;", "TS(1039) Initializers are not allowed in ambient contexts. @16+1"],
+ ["declare var a = 1;", "TS(1039) Initializers are not allowed in ambient contexts. @16+1"],
+ [
+ "declare class A { readonly y = 1; readonly z: number = 1; readonly w = f(); readonly v = -1; readonly u = [] }",
+ "TS(1039) Initializers are not allowed in ambient contexts. @55+1",
+ ],
+ [
+ "declare namespace N { export default 1; }",
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @22+17",
+ ],
+ [
+ 'declare module "m" { export default function f() {} }',
+ "TS(1183) An implementation cannot be declared in ambient contexts. @49+0",
+ ],
+ [
+ 'declare module "m" { export default class { m() {} } }',
+ "TS(1183) An implementation cannot be declared in ambient contexts. @48+0",
+ ],
+ ["declare global { var a = 1; a; }", "TS(1039) Initializers are not allowed in ambient contexts. @25+1"],
+ ["declare function* g(): any;", "TS(1221) Generators are not allowed in an ambient context. @16+11"],
+ ["declare async function* f(): any;", "TS(1221) Generators are not allowed in an ambient context. @22+11"],
+ ["function* g(): any;", "TS(1222) An overload signature cannot be declared as a generator. @0+19"],
+ [
+ "function* g(): any; function* g() {}",
+ "TS(1222) An overload signature cannot be declared as a generator. @0+19",
+ ],
+ ["class A { *g(): any; *g() {} }", "TS(1222) An overload signature cannot be declared as a generator. @10+10"],
+ [
+ "declare class A { *g(): any; async m(): any; async *n(): any }",
+ "TS(1221) Generators are not allowed in an ambient context. @18+10",
+ "TS(1221) Generators are not allowed in an ambient context. @51+9",
+ ],
+ [
+ "declare const f = function () { a; let b = 1; function g() {} };",
+ "TS(1039) Initializers are not allowed in ambient contexts. @43+1",
+ "TS(1183) An implementation cannot be declared in ambient contexts. @59+0",
+ ],
+ [
+ "declare const c = class { m() {} x = 1 };",
+ "TS(1183) An implementation cannot be declared in ambient contexts. @30+0",
+ "TS(1039) Initializers are not allowed in ambient contexts. @37+1",
+ ],
+ [
+ "declare namespace N { namespace M { a; function f() {} } }",
+ "TS(1036) Statements are not allowed in ambient contexts. @36+2",
+ "TS(1183) An implementation cannot be declared in ambient contexts. @52+0",
+ ],
+ [
+ "namespace N { declare const a = 1; declare function f() {} }",
+ "TS(1183) An implementation cannot be declared in ambient contexts. @56+0",
+ ],
+ [
+ 'declare namespace N { import a = b.c; export import d = b.c; export { a }; export * from "x"; }',
+ "TS(1194) Export declarations are not permitted in a namespace. @75+18",
+ ],
+ [
+ "class A { a!: number = 1; }",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @11+1",
+ ],
+ [
+ "class A { a! = 1; }",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @11+1",
+ ],
+ [
+ "class A { a!; }",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @11+1",
+ ],
+ [
+ "class A { static a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @18+1",
+ ],
+ [
+ "abstract class A { abstract a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @29+1",
+ ],
+ [
+ "declare class A { a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @19+1",
+ ],
+ [
+ "class A { declare a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @19+1",
+ ],
+ [
+ "class A { accessor a!: number; accessor b?: number; accessor c! = 1; accessor d!; }",
+ "TS(1276) An 'accessor' property cannot be declared optional. @41+1 help: Remove this `?`",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @62+1",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @79+1",
+ ],
+ [
+ "declare class A { accessor a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @28+1",
+ ],
+ [
+ "class A { declare accessor a!: number; }",
+ "TS(1243) 'accessor' modifier cannot be used with 'declare' modifier. @10+7 help: Allowed modifiers are: private, protected, public, static, abstract, override",
+ ],
+ [
+ "abstract class A { abstract accessor a!: number; abstract accessor b = 1; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @38+1",
+ ],
+ [
+ "let a!: number = 1;",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @5+1",
+ ],
+ ["let a! = 1;", "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @5+1"],
+ ["let a!;", "TS(1264) Declarations with definite assignment assertions must also have type annotations. @5+1"],
+ [
+ "const a!: number = 1;",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @7+1",
+ ],
+ [
+ "declare let a!: number;",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @13+1",
+ ],
+ [
+ "class A { m(): void; }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { m(): void; n() {} }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { m(): void; m(): void; }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @21+1",
+ ],
+ [
+ "class A { m(): void; x = 1; m() {} }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { [m](): void; [n](): void; }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @24+1",
+ ],
+ [
+ "class A { m(): void; m = 1 }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { m(): void; abstract m(): void }",
+ "TS(1244) Abstract methods can only appear within an abstract class. @30+1",
+ ],
+ [
+ "abstract class A { abstract m(): void; m(): void; }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @39+1",
+ ],
+ ["class A { constructor(); }", "TS(2390) Constructor implementation is missing. @10+11"],
+ ["class A { constructor(); m() {} }", "TS(2390) Constructor implementation is missing. @10+11"],
+ ["class A { constructor(); constructor(a); }", "TS(2390) Constructor implementation is missing. @25+11"],
+ [
+ "class A { m(): void; static {} m() {} }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "(class { m(): void; });",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @9+1",
+ ],
+ [
+ "class A { get a(): number; set a(v: number); }",
+ "Getters and setters must have an implementation. @14+1",
+ "Getters and setters must have an implementation. @31+1",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @31+1",
+ ],
+ [
+ "class A { declare m(): void; }",
+ "TS(1031) 'declare' modifier cannot appear on class elements of this kind. @10+7 help: Allowed modifiers are: private, protected, public, static, abstract, override, async",
+ ],
+ ["class A { get a(): number; get a() { return 1 } }", "Getters and setters must have an implementation. @14+1"],
+ [
+ "class A { m(); }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { m() }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ [
+ "class A { m()\n n() {} }",
+ "TS(2391) Function implementation is missing or not immediately following the declaration. @10+1",
+ ],
+ ["interface I { set a(v): void }", "TS(1095) A 'set' accessor cannot have a return type annotation. @22+6"],
+ ["interface I { set a(v?) }", "TS(1051) A 'set' accessor cannot have an optional parameter. @20+2"],
+ ["declare class A { set a(v = 1); }", "A 'set' accessor cannot have an initializer. @23+7"],
+ ["declare class A { set a(v): void; }", "TS(1095) A 'set' accessor cannot have a return type annotation. @26+6"],
+ ["abstract class A { abstract set a(v = 1); }", "A 'set' accessor cannot have an initializer. @33+7"],
+ [
+ "abstract class A { abstract set a(v): void; }",
+ "TS(1095) A 'set' accessor cannot have a return type annotation. @36+6",
+ ],
+ ["class A { set a(v = 1); }", "A 'set' accessor cannot have an initializer. @15+7"],
+ ['declare module "m" { namespace N { a; } }', "TS(1036) Statements are not allowed in ambient contexts. @35+2"],
+ ["declare global { namespace N { a; } }", "TS(1036) Statements are not allowed in ambient contexts. @31+2"],
+ ["let o = { set a(v): void {} };", "TS(1095) A 'set' accessor cannot have a return type annotation. @18+6"],
+ ["let o = { get a() { return 1 } };", "TS(1094) An accessor cannot have type parameters. @15+3"],
+ [
+ "class A { constructor(): void; constructor() {} }",
+ "TS(1093) Type annotation cannot appear on a constructor declaration. @25+4",
+ ],
+ ["class A { constructor(): A {} }", "TS(1093) Type annotation cannot appear on a constructor declaration. @25+1"],
+ [
+ "declare class A { constructor(): A; }",
+ "TS(1093) Type annotation cannot appear on a constructor declaration. @33+1",
+ ],
+ [
+ "class A { constructor(); constructor() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @21+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "let x: number?;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @7+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "let x: ?number;",
+ "TS(17020) '?' at the start of a type is not valid TypeScript syntax. @7+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "let x: number!;",
+ "TS(17019) '!' at the end of a type is not valid TypeScript syntax. @7+7 help: Did you mean to write 'number'?",
+ ],
+ [
+ "let x: !number;",
+ "TS(17020) '!' at the start of a type is not valid TypeScript syntax. @7+7 help: Did you mean to write 'number'?",
+ ],
+ [
+ "let x: { a: number? };",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @12+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "let x: [a: number?];",
+ "TS(5086) A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type. @11+7",
+ ],
+ [
+ "let x: [number?, string];",
+ 'TS(1257) A required element cannot follow an optional element. @17+6 "Required element here", 8+7 "Optional element seen here"',
+ ],
+ [
+ "let x: [a?: number, b: string];",
+ 'TS(1257) A required element cannot follow an optional element. @20+9 "Required element here", 8+10 "Optional element seen here"',
+ ],
+ [
+ "let x: [number?, ...string[], boolean];",
+ 'TS(1257) A required element cannot follow an optional element. @30+7 "Required element here", 8+7 "Optional element seen here"',
+ ],
+ ["let x: [...a?: string[]];", "TS(5085) A tuple member cannot be both optional and rest. @8+15"],
+ [
+ "let x: [a: ...string[]];",
+ "TS(5087) A labeled tuple element is declared as rest with a '...' before the name, rather than before the type. @11+11",
+ ],
+ [
+ "let x: [a?: number?];",
+ "TS(5086) A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type. @12+7",
+ ],
+ [
+ "let x: asserts a;",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @7+9",
+ ],
+ [
+ "let x: asserts a is string;",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @7+19",
+ ],
+ [
+ "let x: this is string;",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @7+14",
+ ],
+ [
+ "class A { get g(): this is string { return 1 } }",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @19+14",
+ ],
+ [
+ "let o = { m(a): a is string { return true }, get g(): a is string { return 1 } };",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @54+11",
+ ],
+ [
+ "type F = new (a) => a is string;",
+ "TS(1228) A type predicate is only allowed in return type position for functions and methods. @20+11",
+ ],
+ [
+ "let x: infer U;",
+ "TS(1338) 'infer' declarations are only permitted in the 'extends' clause of a conditional type. @7+7",
+ ],
+ [
+ "type T = infer U;",
+ "TS(1338) 'infer' declarations are only permitted in the 'extends' clause of a conditional type. @9+7",
+ ],
+ [
+ "type T = A extends string ? infer U : never;",
+ "TS(1338) 'infer' declarations are only permitted in the 'extends' clause of a conditional type. @31+7",
+ ],
+ [
+ "type T = infer U extends string ? 1 : 2;",
+ "TS(1338) 'infer' declarations are only permitted in the 'extends' clause of a conditional type. @12+7",
+ ],
+ [
+ "let x: readonly number;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ ],
+ [
+ "let x: readonly Array;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ ],
+ [
+ "let x: readonly (number[]);",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ ],
+ [
+ "let x: readonly readonly number[];",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ ],
+ [
+ "let x: readonly string[] | readonly number;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @27+8",
+ ],
+ ["let x: A<>;", "TS(1099) Type argument list cannot be empty. @8+2"],
+ ["f<>();", "TS(1099) Type argument list cannot be empty. @1+2"],
+ ["new A<>();", "TS(1099) Type argument list cannot be empty. @5+2"],
+ ["let x = f<>;", "TS(1099) Type argument list cannot be empty. @9+2"],
+ ["class A extends B<> {}", "TS(1099) Type argument list cannot be empty. @17+2"],
+ ["class A implements B<> {}", "TS(1099) Type argument list cannot be empty. @20+2"],
+ ["interface A extends B<> {}", "TS(1099) Type argument list cannot be empty. @21+2"],
+ ["function f<>() {}", "TS(1098) Type parameter list cannot be empty. @10+2"],
+ ["class A<> {}", "TS(1098) Type parameter list cannot be empty. @7+2"],
+ ["interface A<> {}", "TS(1098) Type parameter list cannot be empty. @11+2"],
+ ["type A<> = 1;", "TS(1098) Type parameter list cannot be empty. @6+2"],
+ ["let x: <>() => void;", "TS(1098) Type parameter list cannot be empty. @7+2"],
+ ["let x: typeof a<>;", "TS(1099) Type argument list cannot be empty. @15+2"],
+ ['let x: import("a")<>;', "TS(1099) Type argument list cannot be empty. @18+2"],
+ ["f<>``;", "TS(1099) Type argument list cannot be empty. @1+2"],
+ ["let x: import(a);", "TS(1141) String literal expected. @14+1"],
+ ["let x: import(`a`);", "TS(1141) String literal expected. @14+3"],
+ ["let x: typeof import(a);", "TS(1141) String literal expected. @21+1"],
+ ["let x: { [k: string] };", "TS(1021) An index signature must have a type annotation. @9+11"],
+ ["let x: { [k?: string]: number };", "TS(1019) An index signature parameter cannot have a question mark. @11+1"],
+ ["let x: { [...k: string[]]: number };", "Unexpected token @10+3"],
+ ["let x: { [public k: string]: number };", "Unexpected token @17+1"],
+ [
+ 'let x: { [k: string = "a"]: number };',
+ 'Expected `,` or `]` but found `=` @20+1 "`,` or `]` expected", 9+1 "Opened here"',
+ ],
+ [
+ "let x: { [k: string, j: string]: number };",
+ "TS(1096) An index signature must have exactly one parameter. @9+22",
+ ],
+ [
+ "let x: { [k: string,]: number };",
+ "Index signature declarations may not have a trailing comma. @19+1 help: Remove the trailing comma here",
+ ],
+ ["let x: { []: number };", "Unexpected token @10+1"],
+ [
+ "let x: { [k: boolean]: number };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+10",
+ ],
+ [
+ 'let x: { [k: "a"]: number };',
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+3",
+ ],
+ [
+ "let x: { [k: 1]: number };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+1",
+ ],
+ ["class A { [k: string]; }", "TS(1021) An index signature must have a type annotation. @10+11"],
+ ["interface I { [k: string] }", "TS(1021) An index signature must have a type annotation. @14+11"],
+ ["enum E { [a] }", "TS(1164) Computed property names are not allowed in enums. @10+1"],
+ ["enum E { [`a${b}`] }", "TS(1164) Computed property names are not allowed in enums. @10+7"],
+ ["enum E { [1] }", "TS(2452) An enum member cannot have a numeric name. @10+1"],
+ ["enum E { 1 }", "TS(2452) An enum member cannot have a numeric name. @9+1"],
+ ["enum E { 1.5 = 2 }", "TS(2452) An enum member cannot have a numeric name. @9+3"],
+ ["enum E { 1n }", "TS(2452) An enum member cannot have a numeric name. @9+2"],
+ ["enum E { #a }", "Unexpected token @9+2"],
+ ["enum E { A = 'x', B }", "Enum member must have initializer. @18+1"],
+ ["enum E { A = f(), B }", "Enum member must have initializer. @18+1"],
+ ["enum E { A = `x`, B }", "Enum member must have initializer. @18+1"],
+ ["enum E { A = x as number, B }", "Enum member must have initializer. @26+1"],
+ [
+ "enum E { A = 'x', B, C }",
+ "Enum member must have initializer. @18+1",
+ "Enum member must have initializer. @21+1",
+ ],
+ ["declare enum E { A = 'x', B }", "Enum member must have initializer. @26+1"],
+ ["const enum E { A = 'x', B }", "Enum member must have initializer. @24+1"],
+ [
+ "enum E { A, A }",
+ 'Identifier `A` has already been declared @9+1 "`A` has already been declared here", 12+1 "It can not be redeclared here"',
+ ],
+ ["enum any {}", "TS(2431) Enum name cannot be 'any' @5+3"],
+ [
+ "class A implements B extends C {}",
+ "TS(1173) 'extends' clause must precede 'implements' clause @8+10 \"'implements' clause found here\", 21+7 \"'extends' clause found here\" help: Move the 'extends' clause before the 'implements' clause",
+ ],
+ [
+ "class A implements B implements C {}",
+ "TS(1175) 'implements' clause already seen @8+10, 21+10 help: Merge the two 'implements' clauses into one by a ','",
+ ],
+ ["class A extends B extends C {}", "TS(1172) 'extends' clause already seen @18+7"],
+ [
+ "class A extends B, C {}",
+ "TS(1174) Classes can only extend a single class. @19+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ ["class A extends B implements C extends D {}", "TS(1172) 'extends' clause already seen @31+7"],
+ ["class A implements {}", "Unexpected token @19+1"],
+ [
+ "class A extends B implements C implements D implements E {}",
+ "TS(1175) 'implements' clause already seen @18+10, 31+10 help: Merge the two 'implements' clauses into one by a ','",
+ "TS(1175) 'implements' clause already seen @18+10, 44+10 help: Merge the two 'implements' clauses into one by a ','",
+ ],
+ ["interface A implements B {}", "TS(1176) Interface declaration cannot have 'implements' clause. @12+10"],
+ [
+ "interface A extends B implements C {}",
+ "TS(1176) Interface declaration cannot have 'implements' clause. @22+10",
+ ],
+ ["interface A extends B extends C {}", "TS(1172) 'extends' clause already seen @22+7"],
+ ["interface A extends {}", "TS(1097) 'extends' list cannot be empty. @12+7"],
+ [
+ "interface A extends f() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends a?.b {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends a[b] {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends (a) {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends this {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "(class implements B extends C {});",
+ "TS(1173) 'extends' clause must precede 'implements' clause @7+10 \"'implements' clause found here\", 20+7 \"'extends' clause found here\" help: Move the 'extends' clause before the 'implements' clause",
+ ],
+ ["interface string {}", "TS(2427) Interface name cannot be 'string' @10+6"],
+ ["type number = 1;", "TS(2457) Type alias name cannot be 'number' @5+6"],
+ ["class any {}", "TS(2414) Class name cannot be 'any' @6+3"],
+ ["class A {}", "TS(2368) Type parameter name cannot be 'any' @8+3"],
+ ["type undefined = 1;", "TS(2457) Type alias name cannot be 'undefined' @5+9"],
+ ["interface object {}", "TS(2427) Interface name cannot be 'object' @10+6"],
+ ["type T = 1;", "TS(2368) Type parameter name cannot be 'string' @7+6"],
+ ["type never = 1;", "TS(2457) Type alias name cannot be 'never' @5+5"],
+ ["module 'a' {}", "TS(1035) Only ambient modules can use quoted names. @7+3"],
+ ["module 'a';", "TS(1035) Only ambient modules can use quoted names. @7+3"],
+ ["namespace N { module 'a' {} }", "TS(1035) Only ambient modules can use quoted names. @21+3"],
+ [
+ "namespace N { declare module 'a' {} }",
+ "TS(2435) Ambient modules cannot be nested in other modules or namespaces. @14+21",
+ ],
+ [
+ "declare namespace N { module 'a' {} }",
+ "TS(2435) Ambient modules cannot be nested in other modules or namespaces. @22+13",
+ ],
+ [
+ "declare global { module 'b' {} }",
+ "TS(2435) Ambient modules cannot be nested in other modules or namespaces. @17+13",
+ ],
+ [
+ "function f() { declare module 'a' {} }",
+ "TS(1234) An ambient module declaration is only allowed at the top level in a file. @15+21",
+ ],
+ ["function f() { module 'a' {} }", "TS(1035) Only ambient modules can use quoted names. @22+3"],
+ [
+ "{ declare module 'a' {} }",
+ "TS(1234) An ambient module declaration is only allowed at the top level in a file. @2+21",
+ ],
+ [
+ "if (1) { declare module 'a' {} }",
+ "TS(1234) An ambient module declaration is only allowed at the top level in a file. @9+21",
+ ],
+ [
+ "global {}",
+ "TS(2670) Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context. @0+6",
+ ],
+ [
+ "namespace N { global {} }",
+ "TS(2670) Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context. @14+6",
+ ],
+ [
+ "function f() { declare global {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @15+17",
+ ],
+ [
+ "function f() { global {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @15+9",
+ "TS(2670) Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context. @15+6",
+ ],
+ [
+ "{ global {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @2+9",
+ "TS(2670) Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context. @2+6",
+ ],
+ [
+ "function f() { namespace N {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @15+14",
+ ],
+ [
+ "{ namespace N {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @2+14",
+ ],
+ [
+ "if (1) { namespace N {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @9+14",
+ ],
+ [
+ "if (1) namespace N {}",
+ "Declaration cannot appear in a single-statement context @7+14 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "class A { static { namespace N {} } }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @19+14",
+ ],
+ [
+ "class A { m() { namespace N {} } }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @16+14",
+ ],
+ [
+ "namespace A { { namespace B {} } }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @16+14",
+ ],
+ [
+ "label: namespace N {}",
+ "Declaration cannot appear in a single-statement context @7+14 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "function f() { { namespace N {} } }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @17+14",
+ ],
+ [
+ "let f = () => { namespace N {} };",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @16+14",
+ ],
+ [
+ "namespace N { export default 1; }",
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @14+17",
+ ],
+ [
+ "namespace N { export default class {} }",
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @14+23",
+ ],
+ [
+ "namespace N { export default function f() {} }",
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @14+30",
+ ],
+ ["namespace N { export = a; }", "TS(1063) An export assignment cannot be used in a namespace. @14+11"],
+ [
+ 'namespace N { export { a } from "b"; }',
+ "TS(1194) Export declarations are not permitted in a namespace. @14+22",
+ ],
+ ['namespace N { export * from "b"; }', "TS(1194) Export declarations are not permitted in a namespace. @14+18"],
+ [
+ 'namespace N { export * as c from "b"; }',
+ "TS(1194) Export declarations are not permitted in a namespace. @14+23",
+ ],
+ ["namespace N { export as namespace X; }", "TS(1316) Global module exports may only appear at top level. @14+22"],
+ ['namespace N { import "a"; }', "TS(1147) Import declarations in a namespace cannot reference a module. @14+11"],
+ [
+ 'namespace N { import a from "a"; }',
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+18",
+ ],
+ [
+ 'namespace N { import * as a from "a"; }',
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+23",
+ ],
+ [
+ 'namespace N { import type a from "a"; }',
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+23",
+ ],
+ [
+ 'namespace N { import a = require("a"); }',
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+24",
+ ],
+ [
+ 'namespace N { export import a = require("a"); }',
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+31",
+ ],
+ [
+ 'namespace N { export type { a } from "b"; }',
+ "TS(1194) Export declarations are not permitted in a namespace. @14+27",
+ ],
+ [
+ 'namespace N { namespace M { export default 1; import a from "a" } }',
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @28+17",
+ "TS(1147) Import declarations in a namespace cannot reference a module. @46+17",
+ ],
+ [
+ "declare module 'a' { namespace M { export default 1; import a from \"a\" } }",
+ "TS(1319) A default export can only be used in an ECMAScript-style module. @35+17",
+ "TS(1147) Import declarations in a namespace cannot reference a module. @53+17",
+ ],
+ ["import type a = b.c;", "TS(1392) An import alias cannot use 'import type' @0+20"],
+ [
+ 'import type a, { b } from "a";',
+ "TS(1363) A type-only import can specify a default import or named bindings, but not both. @12+1",
+ ],
+ [
+ 'import type a, * as b from "a";',
+ "TS(1363) A type-only import can specify a default import or named bindings, but not both. @12+1",
+ ],
+ [
+ 'import type { type a } from "a";',
+ "TS(2206) The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement. @14+4 help: Remove this 'type' modifier",
+ ],
+ [
+ 'export type { type a } from "a";',
+ "TS(2207) The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement. @14+4 help: Remove this 'type' modifier",
+ ],
+ [
+ "export type { type a };",
+ "TS(2207) The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement. @14+4 help: Remove this 'type' modifier",
+ ],
+ [
+ "let x: [a?: 1, b?: 2, c: 3];",
+ 'TS(1257) A required element cannot follow an optional element. @22+4 "Required element here", 15+5 "Optional element seen here"',
+ ],
+ [
+ "let x: [a?: 1, b: 2, c: 3];",
+ 'TS(1257) A required element cannot follow an optional element. @15+4 "Required element here", 8+5 "Optional element seen here"',
+ 'TS(1257) A required element cannot follow an optional element. @21+4 "Required element here", 8+5 "Optional element seen here"',
+ ],
+ [
+ "let x: [a?: 1, b: 2, c?: 3, d: 4];",
+ 'TS(1257) A required element cannot follow an optional element. @15+4 "Required element here", 8+5 "Optional element seen here"',
+ 'TS(1257) A required element cannot follow an optional element. @28+4 "Required element here", 21+5 "Optional element seen here"',
+ ],
+ [
+ "let x: [1?, ...2[], 3?, 4];",
+ 'TS(1257) A required element cannot follow an optional element. @24+1 "Required element here", 20+2 "Optional element seen here"',
+ ],
+ [
+ "interface I { readonly m(): void }",
+ "TS(1024) 'readonly' modifier can only appear on a property declaration or index signature. @14+8",
+ ],
+ [
+ "interface I { readonly m?(): void }",
+ "TS(1024) 'readonly' modifier can only appear on a property declaration or index signature. @14+8",
+ ],
+ [
+ "interface I { readonly new (): void }",
+ "TS(1024) 'readonly' modifier can only appear on a property declaration or index signature. @14+8",
+ ],
+ [
+ "type T = { readonly m(): void };",
+ "TS(1024) 'readonly' modifier can only appear on a property declaration or index signature. @11+8",
+ ],
+ ["interface I { get a(): number }", 'Expected `(` but found `<` @19+1 "`(` expected"'],
+ ["interface I { set a(v) }", 'Expected `(` but found `<` @19+1 "`(` expected"'],
+ ["type T = { get a(): number };", 'Expected `(` but found `<` @16+1 "`(` expected"'],
+ [
+ "class A { constructor(private a?, b); constructor(a) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @34+1",
+ ],
+ [
+ "class A { constructor(readonly a); constructor(a) {} }",
+ "TS(2369) A parameter property is only allowed in a constructor implementation. @22+10",
+ ],
+ [
+ "class A { constructor(override a); constructor(a) {} }",
+ "TS(2369) A parameter property is only allowed in a constructor implementation. @22+10",
+ ],
+ [
+ "class A { constructor(private a, public b); constructor(a) {} }",
+ "TS(2369) A parameter property is only allowed in a constructor implementation. @22+9",
+ "TS(2369) A parameter property is only allowed in a constructor implementation. @33+8",
+ ],
+ [
+ "interface A {}",
+ "TS(1277) 'const' modifier can only appear on a type parameter of a function, method or class @25+7",
+ ],
+ [
+ "type A = 1;",
+ "TS(1277) 'const' modifier can only appear on a type parameter of a function, method or class @13+7",
+ ],
+ [
+ "function f() {}",
+ "TS(1274) 'in' modifier can only appear on a type parameter of a class, interface or type alias. @20+2",
+ ],
+ [
+ "class A { m() {} }",
+ "TS(1274) 'out' modifier can only appear on a type parameter of a class, interface or type alias. @21+3",
+ ],
+ [
+ "type T = A extends infer const U ? 1 : 2;",
+ "Identifier expected. 'const' is a reserved word that cannot be used here. @28+5",
+ ],
+ ["function f() {}", "Identifier expected. 'const' is a reserved word that cannot be used here. @14+5"],
+ ["function f() {}", "TS(1273) 'public' modifier cannot be used on a type parameter. @11+6"],
+ ["function f() {}", "TS(1273) 'public' modifier cannot be used on a type parameter. @17+6"],
+ [
+ "function f() {}",
+ "TS(1030) 'const' modifier already seen. @17+5 help: Remove the duplicate modifier.",
+ ],
+ [
+ "interface A {}",
+ "TS(1277) 'const' modifier can only appear on a type parameter of a function, method or class @12+10",
+ ],
+ [
+ "let x: number ?;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @7+8 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "let x: ? number;",
+ "TS(17020) '?' at the start of a type is not valid TypeScript syntax. @7+8 help: Did you mean to write ' number | null | undefined'?",
+ ],
+ [
+ "let x: /*a*/ number /*b*/ ? /*c*/;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @13+14 help: Did you mean to write 'number /*b*/ | null | undefined'?",
+ ],
+ [
+ "let f = (): number! => 1;",
+ "TS(17019) '!' at the end of a type is not valid TypeScript syntax. @12+7 help: Did you mean to write 'number'?",
+ ],
+ [
+ "function f(a: number!) {}",
+ "TS(17019) '!' at the end of a type is not valid TypeScript syntax. @14+7 help: Did you mean to write 'number'?",
+ ],
+ [
+ "class A { a: number!; m(): string! {} }",
+ "TS(17019) '!' at the end of a type is not valid TypeScript syntax. @13+7 help: Did you mean to write 'number'?",
+ "TS(17019) '!' at the end of a type is not valid TypeScript syntax. @27+7 help: Did you mean to write 'string'?",
+ ],
+ [
+ "let x: { [k: string]: number? };",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @22+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "try {} catch (e: any?) {}",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @17+4 help: Did you mean to write 'any | null | undefined'?",
+ ],
+ [
+ "function f(this: number?) {}",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @17+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "let x: (number)?;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @7+9 help: Did you mean to write '(number) | null | undefined'?",
+ ],
+ [
+ "abstract class A { abstract a: number?; }",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @31+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "declare let x: number?;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @15+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "type F = (a: number?) => void;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @13+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ [
+ "type F = () => number?;",
+ "TS(17019) '?' at the end of a type is not valid TypeScript syntax. @15+7 help: Did you mean to write 'number | null | undefined'?",
+ ],
+ ["function f<>() {}", "TS(1098) Type parameter list cannot be empty. @10+2"],
+ ["export function f<>() {}", "TS(1098) Type parameter list cannot be empty. @17+2"],
+ ["declare function f<>(): void;", "TS(1098) Type parameter list cannot be empty. @18+2"],
+ ["(function <>() {});", "TS(1098) Type parameter list cannot be empty. @10+2"],
+ ["(function f<>() {});", "TS(1098) Type parameter list cannot be empty. @11+2"],
+ ["class A { m<>() {} }", "TS(1098) Type parameter list cannot be empty. @11+2"],
+ ["class A { static m<>() {} }", "TS(1098) Type parameter list cannot be empty. @18+2"],
+ ["class A { m<>(): void; m() {} }", "TS(1098) Type parameter list cannot be empty. @11+2"],
+ ["abstract class A { abstract m<>(): void }", "TS(1098) Type parameter list cannot be empty. @29+2"],
+ ["const o = { m<>() {} };", "TS(1098) Type parameter list cannot be empty. @13+2"],
+ ["class A<> {}", "TS(1098) Type parameter list cannot be empty. @7+2"],
+ ["(class <> {});", "TS(1098) Type parameter list cannot be empty. @7+2"],
+ ["(class A<> {});", "TS(1098) Type parameter list cannot be empty. @8+2"],
+ ["interface I<> {}", "TS(1098) Type parameter list cannot be empty. @11+2"],
+ ["type T<> = 1;", "TS(1098) Type parameter list cannot be empty. @6+2"],
+ ["interface I { <>(): void }", "TS(1098) Type parameter list cannot be empty. @14+2"],
+ ["interface I { new <>(): void }", "TS(1098) Type parameter list cannot be empty. @18+2"],
+ ["interface I { m<>(): void }", "TS(1098) Type parameter list cannot be empty. @15+2"],
+ ["type F = <>() => void;", "TS(1098) Type parameter list cannot be empty. @9+2"],
+ ["type F = new <>() => void;", "TS(1098) Type parameter list cannot be empty. @13+2"],
+ ["f<>();", "TS(1099) Type argument list cannot be empty. @1+2"],
+ ["new A<>();", "TS(1099) Type argument list cannot be empty. @5+2"],
+ ["new A<>;", "TS(1099) Type argument list cannot be empty. @5+2"],
+ ["f<>``;", "TS(1099) Type argument list cannot be empty. @1+2"],
+ ["let x = f<>;", "TS(1099) Type argument list cannot be empty. @9+2"],
+ ["let x: A<>;", "TS(1099) Type argument list cannot be empty. @8+2"],
+ ["let x: typeof f<>;", "TS(1099) Type argument list cannot be empty. @15+2"],
+ ['let x: import("a").B<>;', "TS(1099) Type argument list cannot be empty. @20+2"],
+ ["class A extends B<> {}", "TS(1099) Type argument list cannot be empty. @17+2"],
+ ["class A implements B<> {}", "TS(1099) Type argument list cannot be empty. @20+2"],
+ ["interface I extends B<> {}", "TS(1099) Type argument list cannot be empty. @21+2"],
+ ["function f< >() {}", "TS(1098) Type parameter list cannot be empty. @10+3"],
+ ["function f() {}", "TS(1098) Type parameter list cannot be empty. @10+6"],
+ ["let x: A< >;", "TS(1099) Type argument list cannot be empty. @8+3"],
+ [
+ "if (1) enum E {}",
+ "Declaration cannot appear in a single-statement context @7+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) interface I {}",
+ "Declaration cannot appear in a single-statement context @7+14 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) type T = 1;",
+ "Declaration cannot appear in a single-statement context @7+11 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) module N {}",
+ "Declaration cannot appear in a single-statement context @7+11 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) declare var a: number;",
+ "Declaration cannot appear in a single-statement context @7+22 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) declare function f(): void;",
+ "Declaration cannot appear in a single-statement context @7+27 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) declare enum E {}",
+ "Declaration cannot appear in a single-statement context @7+17 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) declare namespace N {}",
+ "Declaration cannot appear in a single-statement context @7+22 help: Wrap this declaration in a block statement",
+ ],
+ [
+ 'if (1) declare module "m" {}',
+ "Declaration cannot appear in a single-statement context @7+21 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) declare global {}",
+ "Declaration cannot appear in a single-statement context @7+17 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) global {}",
+ "Declaration cannot appear in a single-statement context @7+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "if (1) {} else enum E {}",
+ "Declaration cannot appear in a single-statement context @15+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "while (1) enum E {}",
+ "Declaration cannot appear in a single-statement context @10+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "do enum E {} while (1)",
+ "Declaration cannot appear in a single-statement context @3+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "for (;;) type T = 1;",
+ "Declaration cannot appear in a single-statement context @9+11 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "for (a in b) interface I {}",
+ "Declaration cannot appear in a single-statement context @13+14 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "for (a of b) enum E {}",
+ "Declaration cannot appear in a single-statement context @13+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "with (a) enum E {}",
+ "Declaration cannot appear in a single-statement context @9+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "label: enum E {}",
+ "Declaration cannot appear in a single-statement context @7+9 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "label: type T = 1;",
+ "Declaration cannot appear in a single-statement context @7+11 help: Wrap this declaration in a block statement",
+ ],
+ [
+ "label: interface I {}",
+ "Declaration cannot appear in a single-statement context @7+14 help: Wrap this declaration in a block statement",
+ ],
+ ["if (1) async function f() {}", "Async functions can only be declared at the top level or inside a block @7+18"],
+ ["function f(@d a) {}", "Decorators are not valid here. @11+2"],
+ ["function f(@d() a, @e.f b) {}", "Decorators are not valid here. @11+4", "Decorators are not valid here. @19+4"],
+ ["const f = function (@d a) {};", "Decorators are not valid here. @20+2"],
+ ["const o = { m(@d a) {} };", "Decorators are not valid here. @14+2"],
+ ["interface I { m(@d a): void }", "Decorators are not valid here. @16+2"],
+ [
+ "class A { @d m(): void; m() {} }",
+ "TS(1249) A decorator can only decorate a method implementation, not an overload. @10+2 help: Move this after all the overloads",
+ ],
+ [
+ "class A { @d m(): void; @d m() {} }",
+ "TS(1249) A decorator can only decorate a method implementation, not an overload. @10+2 help: Move this after all the overloads",
+ ],
+ ["class A { @d static {} }", "Decorators are not valid here. @10+2"],
+ ["class A { @d [k: string]: any }", "Decorators are not valid here. @10+2"],
+ [
+ "abstract class A { @d abstract m(): void; @d abstract a: number }",
+ "TS(1249) A decorator can only decorate a method implementation, not an overload. @19+2 help: Move this after all the overloads",
+ ],
+ [
+ "declare class A { @d m(): void; @d a: number }",
+ "TS(1249) A decorator can only decorate a method implementation, not an overload. @18+2 help: Move this after all the overloads",
+ ],
+ ["@d function f() {}", "Unexpected token @3+8"],
+ ["@d const a = 1;", "Unexpected token @3+5"],
+ ["@d enum E {}", "Unexpected token @3+4"],
+ ["@d interface I {}", "Unexpected token @3+9"],
+ ["@d type T = 1;", "Unexpected token @3+4"],
+ ["@d namespace N {}", "Unexpected token @3+9"],
+ [
+ "@d export @e class A {}",
+ "Decorators may not appear after 'export' or 'export default' if they also appear before 'export'. @10+2",
+ ],
+ [
+ "let x: { [k: object]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+9",
+ ],
+ [
+ "let x: { [k: null]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+7",
+ ],
+ [
+ "let x: { [k: undefined]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+12",
+ ],
+ [
+ "let x: { [k: void]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+7",
+ ],
+ [
+ "let x: { [k: never]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+8",
+ ],
+ [
+ "let x: { [k: unknown]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+10",
+ ],
+ [
+ "let x: { [k: bigint]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+9",
+ ],
+ [
+ "let x: { [k: true]: 1 };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+4",
+ ],
+ [
+ "let x: { [k: false]: 1 };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+5",
+ ],
+ [
+ "let x: { [k: -1]: 1 };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+2",
+ ],
+ [
+ "let x: { [k: 1n]: 1 };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+2",
+ ],
+ [
+ "let x: { [k: this]: 1 };",
+ "TS(1268) An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type. @10+7",
+ ],
+ [
+ "let x: { [k: `a`]: 1 };",
+ "TS(1337) An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead. @13+3",
+ ],
+ [
+ "let [...a,] = b;",
+ "A rest parameter or binding pattern may not have a trailing comma. @9+1 help: Remove the trailing comma here",
+ ],
+ [
+ "let {...a,} = b;",
+ "A rest parameter or binding pattern may not have a trailing comma. @9+1 help: Remove the trailing comma here",
+ ],
+ [
+ "function f([...a,]) {}",
+ "A rest parameter or binding pattern may not have a trailing comma. @16+1 help: Remove the trailing comma here",
+ ],
+ [
+ "[...a,] = b;",
+ "A rest parameter or binding pattern may not have a trailing comma. @5+1 help: Remove the trailing comma here",
+ ],
+ [
+ "({...a,} = b);",
+ "A rest parameter or binding pattern may not have a trailing comma. @6+1 help: Remove the trailing comma here",
+ ],
+ [
+ "switch (a) { default: default: }",
+ "TS(1113) A 'default' clause cannot appear more than once in a 'switch' statement. @13+8 \"First 'default' clause is here.\", 22+8 \"Another 'default' clause cannot appear here.\"",
+ ],
+ [
+ "switch (a) { default: case 1: default: break; default: }",
+ "TS(1113) A 'default' clause cannot appear more than once in a 'switch' statement. @13+8 \"First 'default' clause is here.\", 30+15 \"Another 'default' clause cannot appear here.\"",
+ ],
+ [
+ "import.foo;",
+ "The only valid property accesses on import are `import.meta`, `import.source()`, and `import.defer()` @0+10",
+ ],
+ ["new.foo;", "The only valid meta property for new is new.target @0+7"],
+ ["function f() { new.foo; }", "The only valid meta property for new is new.target @15+7"],
+ [
+ "let x: { get a() { return 1 } };",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @16+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "interface I { get a() { return 1 } set a(v) {} }",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @21+0 help: Try inserting a semicolon here",
+ ],
+ ["let x: *;", "Unexpected token @7+1"],
+ ["let x: A.;", "Unexpected token @9+1"],
+ [
+ "class A extends B, C, D {}",
+ "TS(1174) Classes can only extend a single class. @19+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ "TS(1174) Classes can only extend a single class. @22+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "class A extends B extends C extends D {}",
+ "TS(1172) 'extends' clause already seen @18+7",
+ "TS(1172) 'extends' clause already seen @28+7",
+ ],
+ [
+ "interface I extends A extends B extends C {}",
+ "TS(1172) 'extends' clause already seen @22+7",
+ "TS(1172) 'extends' clause already seen @32+7",
+ ],
+ ["class A extends B implements {}", "Unexpected token @29+1"],
+ [
+ "class A<> extends B<> {}",
+ "TS(1098) Type parameter list cannot be empty. @7+2",
+ "TS(1099) Type argument list cannot be empty. @19+2",
+ ],
+ ["let x: { [a: string, b: string]: 1 };", "TS(1096) An index signature must have exactly one parameter. @9+22"],
+ ["let x: { []: 1 };", "Unexpected token @10+1"],
+ ["class A { [a: string, b: string]: 1 }", "TS(1096) An index signature must have exactly one parameter. @10+22"],
+ [
+ "switch (a) { default: default: } let x: readonly number;",
+ "TS(1113) A 'default' clause cannot appear more than once in a 'switch' statement. @13+8 \"First 'default' clause is here.\", 22+8 \"Another 'default' clause cannot appear here.\"",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @40+8",
+ ],
+ [
+ "switch (a) { default: default: default: }",
+ "TS(1113) A 'default' clause cannot appear more than once in a 'switch' statement. @13+8 \"First 'default' clause is here.\", 22+8 \"Another 'default' clause cannot appear here.\"",
+ ],
+ [
+ "switch (a) { default: a; default: b; case 1: c; default: d; }",
+ "TS(1113) A 'default' clause cannot appear more than once in a 'switch' statement. @13+11 \"First 'default' clause is here.\", 25+11 \"Another 'default' clause cannot appear here.\"",
+ ],
+ [
+ "let [...a,] = b; let x: readonly number;",
+ "A rest parameter or binding pattern may not have a trailing comma. @9+1 help: Remove the trailing comma here",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @24+8",
+ ],
+ ["let x: *; let y: readonly number;", "Unexpected token @7+1"],
+ ["let x: A.; let y: readonly number;", "Unexpected token @9+1"],
+ [
+ "let x: { get a() { return 1 } }; let y: readonly number;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @16+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "import.foo; let y: readonly number;",
+ "The only valid property accesses on import are `import.meta`, `import.source()`, and `import.defer()` @0+10",
+ ],
+ ["class A implements {} let y: readonly number;", "Unexpected token @19+1"],
+ ["let x: { []: 1 }; let y: readonly number;", "Unexpected token @10+1"],
+ [
+ "interface A extends {} let y: readonly number;",
+ "TS(1097) 'extends' list cannot be empty. @12+7",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @30+8",
+ ],
+ ["let x: Array<*>;", "Unexpected token @13+1"],
+ [
+ "a ?? b || c;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a || b ?? c;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a && b ?? c;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a ?? b && c;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a ?? b || c ?? d;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a || b ?? c || d;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+16 help: Wrap either expression by parentheses",
+ ],
+ [
+ "x = a ?? b || c;",
+ "Logical expressions and coalesce expressions cannot be mixed @4+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "a ?? (b) || c;",
+ "Logical expressions and coalesce expressions cannot be mixed @0+13 help: Wrap either expression by parentheses",
+ ],
+ ["a?.`x`;", "Tagged template expressions are not permitted in an optional chain @3+3"],
+ ["a?.b`x`;", "Tagged template expressions are not permitted in an optional chain @4+3"],
+ ["a?.b.c`x`;", "Tagged template expressions are not permitted in an optional chain @6+3"],
+ ["a?.()`x`;", "Tagged template expressions are not permitted in an optional chain @5+3"],
+ ["a?.[b]`x`;", "Tagged template expressions are not permitted in an optional chain @6+3"],
+ ["a?.b`x`;", "Tagged template expressions are not permitted in an optional chain @7+3"],
+ ["a?.b!`x`;", "Tagged template expressions are not permitted in an optional chain @5+3"],
+ ["for (let a = 1 of []) {}", "for-of loop variable declaration may not have an initializer @5+9"],
+ ["for (var a = 1 of []) {}", "for-of loop variable declaration may not have an initializer @5+9"],
+ ["for (const a = 1 of []) {}", "for-of loop variable declaration may not have an initializer @5+11"],
+ ["for (let a = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @5+9"],
+ ["for (const a = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @5+11"],
+ ["for (var [a] = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @5+11"],
+ ["for (var {a} = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @5+11"],
+ ["'use strict'; for (var a = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @19+9"],
+ ["export {}; for (var a = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @16+9"],
+ ["for (let a, b of []) {}", "Only a single declaration is allowed in a `for...of` statement @5+8"],
+ [
+ "for (let a: number = 1 of []) {}",
+ "for-of loop variable declaration may not have an initializer @5+17",
+ "TS(2483) The left-hand side of a 'for...of' statement cannot use a type annotation. @9+1 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ ["for (using a = 1 of []) {}", "for-of loop variable declaration may not have an initializer @5+11"],
+ ["a\n=> 1;", "Line terminator not permitted before arrow @2+2 help: Remove the line break before here"],
+ ["(a, b)\n=> 1;", "Line terminator not permitted before arrow @7+2 help: Remove the line break before here"],
+ ["()\n=> 1;", "Line terminator not permitted before arrow @3+2 help: Remove the line break before here"],
+ ["async a\n=> 1;", "Line terminator not permitted before arrow @8+2 help: Remove the line break before here"],
+ ["async (a)\n=> 1;", "Line terminator not permitted before arrow @10+2 help: Remove the line break before here"],
+ [
+ "(a): number\n=> 1;",
+ "Line terminator not permitted before arrow @12+2 help: Remove the line break before here",
+ ],
+ ["(a)\n=> 1;", "Line terminator not permitted before arrow @7+2 help: Remove the line break before here"],
+ ["(a) /*\n*/ => 1;", "Line terminator not permitted before arrow @10+2 help: Remove the line break before here"],
+ ["throw\n1;", 'Illegal newline after throw @0+5 "throw starts here", 6+1 "A newline is not expected here"'],
+ [
+ "throw /*\n*/ 1;",
+ 'Illegal newline after throw @0+5 "throw starts here", 12+1 "A newline is not expected here"',
+ ],
+ ["throw // c\n1;", 'Illegal newline after throw @0+5 "throw starts here", 11+1 "A newline is not expected here"'],
+ ["import();", "import() requires a specifier. @0+8"],
+ ["import(...a);", "TS(1325) Argument of dynamic import cannot be a spread element. @7+3"],
+ ['import("a", ...b);', "TS(1325) Argument of dynamic import cannot be a spread element. @12+3"],
+ [
+ 'import("a", "b", "c");',
+ "Dynamic imports can only accept a module specifier and an optional set of attributes as arguments @0+16",
+ ],
+ ['new import("a");', "Cannot use new with dynamic import @4+11 help: Wrap this with parenthesis"],
+ ['new import("a")();', "Cannot use new with dynamic import @4+13 help: Wrap this with parenthesis"],
+ ["import.defer();", "import() requires a specifier. @0+14"],
+ [
+ 'import.defer("a", "b", "c");',
+ "Dynamic imports can only accept a module specifier and an optional set of attributes as arguments @0+22",
+ ],
+ [
+ "class A { static { return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @19+6",
+ ],
+ [
+ "class A { static { return 1; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @19+6",
+ ],
+ [
+ "class A { static { if (a) return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @26+6",
+ ],
+ [
+ "let [a];",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "let {a};",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "const [a];",
+ "Missing initializer in destructuring declaration @6+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "var [a];",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "let [a], b;",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "let a, [b];",
+ "Missing initializer in destructuring declaration @7+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "let [a]: number[];",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "for (let [a];;) {}",
+ "Missing initializer in destructuring declaration @9+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "export let [a];",
+ "Missing initializer in destructuring declaration @11+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ ["`\\01`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["`\\1`;", "Bad escape sequence in untagged template literal @1+2"],
+ ["`\\08`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["`\\u`;", "Bad escape sequence in untagged template literal @1+2"],
+ ["`\\u{110000}`;", "Bad escape sequence in untagged template literal @1+10"],
+ ["`\\xg`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["`\\u{}`;", "Bad escape sequence in untagged template literal @1+4"],
+ ["`${a}\\01`;", "Bad escape sequence in untagged template literal @5+3"],
+ ["`\\01${a}`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["type T = `\\01`;", "Bad escape sequence in untagged template literal @10+3"],
+ ["type T = `\\u`;", "Bad escape sequence in untagged template literal @10+2"],
+ [
+ "for (async of []) {}",
+ "The left-hand side of a `for...of` statement may not be `async` @5+5 help: Did you mean to use a for await...of statement?",
+ ],
+ [
+ "for await (async of []) {}",
+ "`for await` loops are only allowed within async functions and at the top levels of modules @4+5 help: Either remove this `await` or add the `async` keyword to the enclosing function",
+ ],
+ ["for (let of []) {}", 'Expected `;` but found `[` @12+1 "`;` expected"'],
+ ["for (let.a of []) {}", "The left-hand side of a `for...of` statement may not start with `let` @5+5"],
+ [
+ "let zz; let zz; a ?? b || c; let y: readonly number;",
+ "Logical expressions and coalesce expressions cannot be mixed @16+11 help: Wrap either expression by parentheses",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @36+8",
+ ],
+ [
+ "let zz; let zz; a?.b`x`; let y: readonly number;",
+ "Tagged template expressions are not permitted in an optional chain @20+3",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @32+8",
+ ],
+ [
+ "let zz; let zz; for (let a = 1 of []) {} let y: readonly number;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @48+8",
+ ],
+ [
+ "let zz; let zz; for (let a = 1 of []) {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "for-of loop variable declaration may not have an initializer @21+9",
+ ],
+ [
+ "let zz; let zz; for (let a = 1 in {}) {}",
+ "for-in loop variable declaration may not have an initializer @21+9",
+ ],
+ [
+ "let zz; let zz; (a)\n=> 1; let y: readonly number;",
+ "Line terminator not permitted before arrow @20+2 help: Remove the line break before here",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @33+8",
+ ],
+ [
+ "let zz; let zz; throw\n1; let y: readonly number;",
+ 'Illegal newline after throw @16+5 "throw starts here", 22+1 "A newline is not expected here"',
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @32+8",
+ ],
+ ["let zz; let zz; import(); let y: readonly number;", "import() requires a specifier. @16+8"],
+ [
+ "let zz; let zz; import(...a); let y: readonly number;",
+ "TS(1325) Argument of dynamic import cannot be a spread element. @23+3",
+ ],
+ [
+ 'let zz; let zz; import("a", "b", "c"); let y: readonly number;',
+ "Dynamic imports can only accept a module specifier and an optional set of attributes as arguments @16+16",
+ ],
+ [
+ 'let zz; let zz; new import("a"); let y: readonly number;',
+ "Cannot use new with dynamic import @20+11 help: Wrap this with parenthesis",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @40+8",
+ ],
+ [
+ "let zz; let zz; class A { static { return; } } let y: readonly number;",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @35+6",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @54+8",
+ ],
+ [
+ "let zz; let zz; let [a]; let y: readonly number;",
+ "Missing initializer in destructuring declaration @20+3 help: Add an initializer (e.g. ` = undefined`) here",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @32+8",
+ ],
+ [
+ "let zz; let zz; `\\01`; let y: readonly number;",
+ "Bad escape sequence in untagged template literal @17+3",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @30+8",
+ ],
+ [
+ "let zz; let zz; for (async of []) {} let y: readonly number;",
+ "The left-hand side of a `for...of` statement may not be `async` @21+5 help: Did you mean to use a for await...of statement?",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @44+8",
+ ],
+ [
+ "let zz; let zz; for (let a: number of []) {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "TS(2483) The left-hand side of a 'for...of' statement cannot use a type annotation. @25+1 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ [
+ "let zz; let zz; for (let a, b of []) {} let y: readonly number;",
+ "Only a single declaration is allowed in a `for...of` statement @21+8",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @47+8",
+ ],
+ [
+ "let zz; let zz; for (let a = 1 in {}) {} let y: readonly number;",
+ "for-in loop variable declaration may not have an initializer @21+9",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @48+8",
+ ],
+ [
+ "let zz; let zz; for (const a = 1 in {}) {} let y: readonly number;",
+ "for-in loop variable declaration may not have an initializer @21+11",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @50+8",
+ ],
+ [
+ "let zz; let zz; for (var [a] = 1 in {}) {} let y: readonly number;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @50+8",
+ ],
+ [
+ "let zz; let zz; for (var [a] = 1 in {}) {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "for-in loop variable declaration may not have an initializer @21+11",
+ ],
+ [
+ "let zz; let zz; 'use strict'; for (var a = 1 in {}) {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ ],
+ [
+ "let zz; let zz; export {}; for (var a = 1 in {}) {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "for-in loop variable declaration may not have an initializer @32+9",
+ ],
+ [
+ "let zz; let zz; function f() { 'use strict'; for (var a = 1 in {}) {} }",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "for-in loop variable declaration may not have an initializer @50+9",
+ ],
+ [
+ "let zz; let zz; class A { m() { for (var a = 1 in {}) {} } }",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "for-in loop variable declaration may not have an initializer @37+9",
+ ],
+ [
+ "for (let a: number of []) {}",
+ "TS(2483) The left-hand side of a 'for...of' statement cannot use a type annotation. @9+1 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ [
+ "for (let a: number in {}) {}",
+ "TS(2404) The left-hand side of a 'for...in' statement cannot use a type annotation. @9+1 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ [
+ "for (const [a]: number[] of []) {}",
+ "TS(2483) The left-hand side of a 'for...of' statement cannot use a type annotation. @11+3 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ ["for (var a: number of [], b) {}", 'Expected `)` but found `,` @24+1 "`)` expected", 4+1 "Opened here"'],
+ ["for (let a: number = 1 in {}) {}", "for-in loop variable declaration may not have an initializer @5+17"],
+ [
+ "for (using a: number of []) {}",
+ "TS(2483) The left-hand side of a 'for...of' statement cannot use a type annotation. @11+1 help: This iterator's type will be inferred from the iterable. You can safely remove the type annotation.",
+ ],
+ ["for (var a = 1, b in {}) {}", "Only a single declaration is allowed in a `for...in` statement @5+12"],
+ ["for (let a = 1, b of []) {}", "Only a single declaration is allowed in a `for...of` statement @5+12"],
+ ["`ab\\01cd`;", "Bad escape sequence in untagged template literal @1+7"],
+ [
+ "`ab\\01cd${a}ef\\u`;",
+ "Bad escape sequence in untagged template literal @1+7",
+ "Bad escape sequence in untagged template literal @12+4",
+ ],
+ [
+ "`${a}\\u${b}\\x`;",
+ "Bad escape sequence in untagged template literal @5+2",
+ "Bad escape sequence in untagged template literal @11+2",
+ ],
+ [
+ "`\\01` + `\\u`;",
+ "Bad escape sequence in untagged template literal @1+3",
+ "Bad escape sequence in untagged template literal @9+2",
+ ],
+ [
+ "let zz; let zz; `\\u`; `\\x`; let y: readonly number;",
+ "Bad escape sequence in untagged template literal @17+2",
+ "Bad escape sequence in untagged template literal @23+2",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @35+8",
+ ],
+ ["type T = `a${B}\\u`;", "Bad escape sequence in untagged template literal @15+2"],
+ ["type T = `a\\u${B}`;", "Bad escape sequence in untagged template literal @10+3"],
+ ["let x: `\\x`;", "Bad escape sequence in untagged template literal @8+2"],
+ ["let o = { [`\\u`]: 1 };", "Bad escape sequence in untagged template literal @12+2"],
+ ["class A { [`\\u`]() {} }", "Bad escape sequence in untagged template literal @12+2"],
+ ["import(`\\u`);", "Bad escape sequence in untagged template literal @8+2"],
+ ["f(`\\8`);", "Bad escape sequence in untagged template literal @3+2"],
+ ["f(`\\9`);", "Bad escape sequence in untagged template literal @3+2"],
+ ["f(`\\00`);", "Bad escape sequence in untagged template literal @3+3"],
+ ["`\\u{`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["`\\u{1`;", "Bad escape sequence in untagged template literal @1+4"],
+ ["`\\u12`;", "Bad escape sequence in untagged template literal @1+4"],
+ ["`\\x1`;", "Bad escape sequence in untagged template literal @1+3"],
+ ["throw;", "Unexpected token @5+1"],
+ ["function f() { throw }", "Unexpected token @21+1"],
+ ["throw\n/a/;", 'Illegal newline after throw @0+5 "throw starts here", 6+1 "A newline is not expected here"'],
+ ["throw\n+1;", 'Illegal newline after throw @0+5 "throw starts here", 6+1 "A newline is not expected here"'],
+ [
+ "throw\nclass A {};",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+5 "A newline is not expected here"',
+ ],
+ ["for (let().a of []) {}", "The left-hand side of a `for...of` statement may not start with `let` @5+7"],
+ ["for (let.a.b of []) {}", "The left-hand side of a `for...of` statement may not start with `let` @5+7"],
+ [
+ "let zz; let zz; for (let.a of []) {} let y: readonly number;",
+ "The left-hand side of a `for...of` statement may not start with `let` @21+5",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @44+8",
+ ],
+ [
+ "let zz; let zz; for (let.a of []) {}",
+ "The left-hand side of a `for...of` statement may not start with `let` @21+5",
+ ],
+ [
+ "x = async a\n=> 1;",
+ "Line terminator not permitted before arrow @12+2 help: Remove the line break before here",
+ ],
+ ["f(async a\n=> 1);", "Line terminator not permitted before arrow @10+2 help: Remove the line break before here"],
+ [
+ "let zz; let zz; async a\n=> 1; let y: readonly number;",
+ "Line terminator not permitted before arrow @24+2 help: Remove the line break before here",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @37+8",
+ ],
+ ["a?.b!.c`x`;", "Tagged template expressions are not permitted in an optional chain @7+3"],
+ ["a?.b!!`x`;", "Tagged template expressions are not permitted in an optional chain @6+3"],
+ ["a?.b![0]`x`;", "Tagged template expressions are not permitted in an optional chain @8+3"],
+ ["a?.b!`x`;", "Tagged template expressions are not permitted in an optional chain @8+3"],
+ ["a!?.b`x`;", "Tagged template expressions are not permitted in an optional chain @5+3"],
+ ["a?.()!`x`;", "Tagged template expressions are not permitted in an optional chain @6+3"],
+ ["a?.[0]!`x`;", "Tagged template expressions are not permitted in an optional chain @7+3"],
+ [
+ "class A { static { if (a) return; else return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @26+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @39+6",
+ ],
+ [
+ "class A { static { for (;;) return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @28+6",
+ ],
+ [
+ "class A { static { try { return; } catch { return; } finally { return; } } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @25+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @43+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @63+6",
+ ],
+ [
+ "class A { static { switch (a) { case 1: return; } } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @40+6",
+ ],
+ [
+ "class A { static { a: return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @22+6",
+ ],
+ [
+ "class A { static { { return; } } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @21+6",
+ ],
+ [
+ "class A { static { while (a) return; do return; while (a) } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @29+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @40+6",
+ ],
+ [
+ "class A { static { with (a) return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @28+6",
+ ],
+ [
+ "class A { static { for (a in b) return; for (a of b) return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @32+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @53+6",
+ ],
+ [
+ "class A { static { return; return; } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @19+6",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @27+6",
+ ],
+ [
+ "class A { static { class B { static { return; } } } }",
+ "TS(18041) A 'return' statement cannot be used inside a class static block. @38+6",
+ ],
+ [
+ "static class A {}",
+ "'static' modifier cannot be used here. @0+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "static function f() {}",
+ "'static' modifier cannot be used here. @0+6 help: Allowed modifiers are: declare, async",
+ ],
+ ["static let a;", "'static' modifier cannot be used here. @0+6 help: Only 'declare' modifier is allowed here."],
+ ["type as any = 1;", 'Expected `=` but found `any` @8+3 "`=` expected"'],
+ ["namespace as any = 1;", 'Expected `{` but found `any` @13+3 "`{` expected"'],
+ ["module as any = 1;", 'Expected `{` but found `any` @10+3 "`{` expected"'],
+ ["interface as any = 1;", 'Expected `{` but found `any` @13+3 "`{` expected"'],
+ ["export = await;", "Unexpected token @14+1"],
+ ["export {}; export = await;", "Unexpected token @25+1"],
+ ["export {}; let x: await;", "The keyword 'await' is reserved @18+5"],
+ [
+ "async function w() { x as T ? await y : z; }",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @29+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "function f() { throw\n}",
+ 'Illegal newline after throw @15+5 "throw starts here", 21+1 "A newline is not expected here"',
+ "Unexpected token @21+1",
+ ],
+ ['import("a",,);', "Unexpected token @11+1"],
+ ['import("a");', 'Expected `from` but found `<` @6+1 "`from` expected"'],
+ [
+ 'let zz; let zz; import("a"); let y: readonly number;',
+ 'Expected `from` but found `<` @22+1 "`from` expected"',
+ ],
+ [
+ 'declare module "m" { export default 1; a; export = a; }',
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @42+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export default 1; export = a; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @39+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export default 1; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export const b: number; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export { b }; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export * from \"b\"; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export type T = 1; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export interface I {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export import b = c; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export function f(): void; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export class C {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export namespace N {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export enum E {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export type { T }; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export type * from \"b\"; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export declare const b: number; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export const b: number; } declare module 'b' { export = a; export const b: number; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @80+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export const b: number; } export = c; export const d = 1;",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @59+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare namespace N { export = a; export const b: number; }",
+ "TS(1063) An export assignment cannot be used in a namespace. @22+11",
+ ],
+ [
+ "namespace N { export = a; export const b = 1; }",
+ "TS(1063) An export assignment cannot be used in a namespace. @14+11",
+ ],
+ [
+ "let zz; let zz; declare module 'a' { export = a; export const b: number; }",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @37+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "let zz; let zz; declare module 'a' { export = a; export const b: number; } let y: readonly number;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @82+8",
+ ],
+ [
+ "class A { 'constructor'() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ 'class A { "constructor"() {} }',
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(): void {} }",
+ "TS(1093) Type annotation cannot appear on a constructor declaration. @27+4",
+ ],
+ [
+ "class A { 'constructor'() {} constructor() {} }",
+ 'Multiple constructor implementations are not allowed. @10+13 "constructor has already been declared here", 29+11 "it cannot be redeclared here"',
+ ],
+ [
+ "class A { 'constructor'(); }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ ["class A { get 'constructor'() { return 1 } }", "Constructor can't have get/set modifier @14+13"],
+ ["class A { async 'constructor'() {} }", "Constructor can't be an async method @16+13"],
+ ["class A { *'constructor'() {} }", "Constructor can't be a generator @11+13"],
+ ["class A { 'constructor': number; }", "Classes can't have a field named 'constructor' @10+13"],
+ [
+ "declare class A { 'constructor'(); }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @31+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(a?, b) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @28+1",
+ ],
+ [
+ "class A { abstract 'constructor'() {} }",
+ "TS(1242) 'abstract' modifier can only appear on a class, method, or property declaration. @19+13",
+ ],
+ ["class A { 'constructor'(); }", "TS(2390) Constructor implementation is missing. @10+13"],
+ [
+ "class A { m(private a) {} }",
+ "TS(1090) 'private' modifier cannot appear on a parameter. @12+7 help: No modifiers are allowed here.",
+ ],
+ ["class A implements f() {}", 'Expected `{` but found `(` @20+1 "`{` expected"'],
+ ["class A implements a?.b {}", 'Expected `{` but found `?.` @20+2 "`{` expected"'],
+ ["class A implements B, {} {}", "Unexpected token @22+1"],
+ ["class A implements B, {}", "Unexpected token @22+1"],
+ ["class A implements B, { }", "Unexpected token @22+1"],
+ ["class A implements {} {}", "Unexpected token @19+1"],
+ ["class A implements a.b() {}", 'Expected `{` but found `(` @22+1 "`{` expected"'],
+ ["class A implements a[b] {}", 'Expected `{` but found `[` @20+1 "`{` expected"'],
+ ["class A implements a! {}", 'Expected `{` but found `!` @20+1 "`{` expected"'],
+ ["class A implements (a) {}", "Unexpected token @19+1"],
+ ["class A implements 1 {}", "Unexpected token @19+1"],
+ ['class A implements "a" {}', "Unexpected token @19+3"],
+ ["class A implements function() {} {}", 'Expected `{` but found `(` @27+1 "`{` expected"'],
+ ["class A implements new B {}", 'Expected `{` but found `Identifier` @23+1 "`{` expected"'],
+ ["class A implements B, {} { m() {} }", "Unexpected token @22+1"],
+ ["class A implements B C {}", 'Expected `{` but found `Identifier` @21+1 "`{` expected"'],
+ ["class A implements B, , C {}", "Unexpected token @22+1"],
+ ["class A implements B, {", "Unexpected token @22+1"],
+ ["class A implements a.#b {}", "Unexpected token @21+2"],
+ ['class A implements import("a") {}', 'Expected `{` but found `(` @25+1 "`{` expected"'],
+ ["class A implements typeof a {}", 'Expected `{` but found `Identifier` @26+1 "`{` expected"'],
+ ["class A implements B | C {}", 'Expected `{` but found `|` @21+1 "`{` expected"'],
+ ["class A implements B[] {}", 'Expected `{` but found `[` @20+1 "`{` expected"'],
+ ["class A implements a`b` {}", 'Expected `{` but found `${}` @20+3 "`{` expected"'],
+ ["class A implements a() {}", 'Expected `{` but found `(` @23+1 "`{` expected"'],
+ ["class A implements a as b {}", 'Expected `{` but found `as` @21+2 "`{` expected"'],
+ ["class A implements [] {}", "Unexpected token @19+1"],
+ ["class A implements yield {}", "The keyword 'yield' is reserved @19+5"],
+ ["class A implements let {}", "The keyword 'let' is reserved @19+3"],
+ [
+ "class A extends B, {} {}",
+ "TS(1174) Classes can only extend a single class. @19+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "class A extends B, {}",
+ "TS(1174) Classes can only extend a single class. @19+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ 'Expected `{` but found `EOF` @22+0 "`{` expected"',
+ ],
+ [
+ "class A extends B, {} { m() {} }",
+ "TS(1174) Classes can only extend a single class. @19+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "class A extends B, f() {}",
+ "TS(1174) Classes can only extend a single class. @19+3 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ ["class A extends B, {", 'Expected `}` but found `EOF` @21+0 "`}` expected"'],
+ ["class A extends B, , C {}", "Unexpected token @19+1"],
+ [
+ "class A extends B, {} implements C {}",
+ "TS(1174) Classes can only extend a single class. @19+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "class A extends B, 1 {}",
+ "TS(1174) Classes can only extend a single class. @19+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "class A extends B, class {} {}",
+ "TS(1174) Classes can only extend a single class. @19+8 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ [
+ "let x = class extends B, {} {};",
+ "TS(1174) Classes can only extend a single class. @25+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ ["let x = class implements B, {} {};", "Unexpected token @28+1"],
+ ["interface A extends B, {} {}", "TS(1009) Trailing comma not allowed. @21+1"],
+ ["interface A extends B, {}", "TS(1009) Trailing comma not allowed. @21+1"],
+ ["interface A extends B, { }", "TS(1009) Trailing comma not allowed. @21+1"],
+ ["interface A extends B, { a: 1 }", "TS(1009) Trailing comma not allowed. @21+1"],
+ ["interface A extends B, , C {}", "Unexpected token @23+1"],
+ ["interface A extends {} {}", "TS(1097) 'extends' list cannot be empty. @12+7"],
+ [
+ "interface A extends B, f() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+3",
+ ],
+ [
+ "interface A extends B, 1 {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+1",
+ ],
+ [
+ "interface A extends 1 {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+1",
+ ],
+ ["interface A extends B, {}", "TS(1009) Trailing comma not allowed. @24+1"],
+ [
+ "let zz; let zz; interface A extends B, {} let y: readonly number;",
+ "TS(1009) Trailing comma not allowed. @37+1",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @49+8",
+ ],
+ ["let zz; let zz; class A implements B, {} let y: readonly number;", "Unexpected token @38+1"],
+ [
+ "let zz; let zz; class A extends B, {} let y: readonly number;",
+ "TS(1174) Classes can only extend a single class. @35+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ 'Expected `{` but found `let` @38+3 "`{` expected"',
+ ],
+ [
+ "let zz; let zz; class A implements f() {} let y: readonly number;",
+ 'Expected `{` but found `(` @36+1 "`{` expected"',
+ ],
+ [
+ "let zz; let zz; class A { 'constructor'() {} } let y: readonly number;",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @39+3 help: Instead, add type parameters to the class itself",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @57+8",
+ ],
+ [
+ "export @d default class {}",
+ "'default' modifier cannot be used here. @10+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export @d default class A {}",
+ "'default' modifier cannot be used here. @10+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ ["export @d default function f() {}", 'Expected `{` but found `(` @28+1 "`{` expected"'],
+ [
+ "export @d @e default class A {}",
+ "'default' modifier cannot be used here. @13+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "@d export @e default class A {}",
+ "Decorators may not appear after 'export' or 'export default' if they also appear before 'export'. @10+2",
+ "'default' modifier cannot be used here. @13+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ ["export @d function f() {}", 'Expected `{` but found `(` @20+1 "`{` expected"'],
+ ["export @d const a = 1;", 'Expected `{` but found `=` @18+1 "`{` expected"'],
+ [
+ "export @d default abstract class A {}",
+ "'default' modifier cannot be used here. @10+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export @d default interface I {}",
+ "'default' modifier cannot be used here. @10+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export @d() default class A {}",
+ "'default' modifier cannot be used here. @12+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export @d.e default class A {}",
+ "'default' modifier cannot be used here. @12+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "let zz; let zz; export @d default class A {} let y: readonly number;",
+ "'default' modifier cannot be used here. @26+7 help: Allowed modifiers are: declare, abstract",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @52+8",
+ ],
+ ["import(...a, b);", "TS(1325) Argument of dynamic import cannot be a spread element. @7+3"],
+ [
+ 'import("a", b, ...c);',
+ "Dynamic imports can only accept a module specifier and an optional set of attributes as arguments @0+14",
+ ],
+ ["import.defer(...a);", "TS(1325) Argument of dynamic import cannot be a spread element. @13+3"],
+ ["import.source(...a);", "TS(1325) Argument of dynamic import cannot be a spread element. @14+3"],
+ ["let x: import(...a);", "Unexpected token @14+3"],
+ ["let x = import(...a);", "TS(1325) Argument of dynamic import cannot be a spread element. @15+3"],
+ ["f(import(...a));", "TS(1325) Argument of dynamic import cannot be a spread element. @9+3"],
+ [
+ "throw\n;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+1 "A newline is not expected here"',
+ "Unexpected token @6+1",
+ ],
+ [
+ "throw\n",
+ 'Illegal newline after throw @0+5 "throw starts here", 7+0 "A newline is not expected here"',
+ "Unexpected token @7+0",
+ ],
+ [
+ "{ throw\n}",
+ 'Illegal newline after throw @2+5 "throw starts here", 8+1 "A newline is not expected here"',
+ "Unexpected token @8+1",
+ ],
+ [
+ "throw\n) ;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+1 "A newline is not expected here"',
+ "Unexpected token @6+1",
+ ],
+ [
+ "throw\n=> 1;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+2 "A newline is not expected here"',
+ "Unexpected token @6+2",
+ ],
+ [
+ "throw\nif (a) b;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+2 "A newline is not expected here"',
+ "Unexpected token @6+2",
+ ],
+ [
+ "throw\nlet a;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+3 "A newline is not expected here"',
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @9+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "throw\nvar a;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+3 "A newline is not expected here"',
+ "Unexpected token @6+3",
+ ],
+ [
+ "throw\nreturn;",
+ 'Illegal newline after throw @0+5 "throw starts here", 6+6 "A newline is not expected here"',
+ "Unexpected token @6+6",
+ ],
+ [
+ "let zz; let zz; throw\n} let y: readonly number;",
+ 'Illegal newline after throw @16+5 "throw starts here", 22+1 "A newline is not expected here"',
+ "Unexpected token @22+1",
+ ],
+ ["f(a,,b);", "Unexpected token @4+1"],
+ ["f(,a);", "Unexpected token @2+1"],
+ ["f(,);", "Unexpected token @2+1"],
+ ["new F(a,,b);", "Unexpected token @8+1"],
+ ["import(,);", "Unexpected token @7+1"],
+ ['import(,"a");', "Unexpected token @7+1"],
+ ['x = import("a");', "Unexpected token @10+1"],
+ ['f(import("a"));', "Unexpected token @8+1"],
+ ["import;", 'Expected `from` but found `<` @6+1 "`from` expected"'],
+ ['import("a").then();', 'Expected `from` but found `<` @6+1 "`from` expected"'],
+ ["x = import;", "Unexpected token @10+1"],
+ ["x = import;", "Unexpected token @10+1"],
+ ["import;", 'Expected `from` but found `;` @6+1 "`from` expected"'],
+ ["for (let of x) {}", 'Expected `;` but found `Identifier` @12+1 "`;` expected"'],
+ [
+ "for (let?.a of []) {}",
+ "The left-hand side of a `for...of` statement may not start with `let` @5+6",
+ "Cannot assign to this expression @5+6",
+ ],
+ [
+ "static foo;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @6+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "private foo;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "readonly foo;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @8+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "accessor foo;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @8+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "static of;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @6+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "public static;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @6+0 help: Try inserting a semicolon here",
+ ],
+ ["export {}; static as any = 1;", "The keyword 'static' is reserved @11+6"],
+ ["'use strict'; static as any = 1;", "The keyword 'static' is reserved @14+6"],
+ ["class A { m() { static as any = 1; } }", "The keyword 'static' is reserved @16+6"],
+ ["export {}; namespace await {}", "The keyword 'await' is reserved @21+5"],
+ ["export {}; export declare namespace await {}", "Cannot use `await` as an identifier in an async context @36+5"],
+ ["export {}; export namespace await {}", "Cannot use `await` as an identifier in an async context @28+5"],
+ [
+ "async function f() { declare namespace await {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @21+26",
+ ],
+ [
+ "async function f() { namespace await {} }",
+ "TS(1235) A namespace declaration is only allowed at the top level of a namespace or module. @21+18",
+ ],
+ ["function* f() { namespace yield {} }", "Cannot use `yield` as an identifier in a generator context @26+5"],
+ [
+ "declare module 'w' { export = await a; }",
+ "`await` is only allowed within async functions and at the top levels of modules @30+5 help: Either remove this `await` or add the `async` keyword to the enclosing function",
+ ],
+ [
+ "declare namespace N { export = await; }",
+ "TS(1063) An export assignment cannot be used in a namespace. @22+15",
+ ],
+ ["export {}; let x: A;", "The keyword 'await' is reserved @20+5"],
+ ["class W { static { let x: A; } }", "Cannot use await in class static initialization block @28+5"],
+ [
+ "async function w() { class A extends await {} }",
+ "Cannot use `await` as an identifier in an async context @37+5",
+ ],
+ ["function* w() { class A implements yield {} }", "The keyword 'yield' is reserved @35+5"],
+ ["export {}; class A implements await {}", "The keyword 'await' is reserved @30+5"],
+ ["({ async get a(){} });", "'async' modifier cannot be used here. @3+5 help: No modifiers are allowed here."],
+ ["({ async set a(v){} });", "'async' modifier cannot be used here. @3+5 help: No modifiers are allowed here."],
+ ["({ static a: 1 });", "'static' modifier cannot be used here. @3+6 help: No modifiers are allowed here."],
+ ["({ private a: 1 });", "'private' modifier cannot be used here. @3+7 help: No modifiers are allowed here."],
+ ["({ async a: 1 });", "'async' modifier cannot be used here. @3+5 help: No modifiers are allowed here."],
+ [
+ "({ public m() {} });",
+ "'public' modifier cannot be used here. @3+6 help: Only 'async' modifier is allowed here.",
+ ],
+ ["({ readonly a });", "'readonly' modifier cannot be used here. @3+8 help: No modifiers are allowed here."],
+ [
+ "let zz; let zz; ({ async get a(){} });",
+ "'async' modifier cannot be used here. @19+5 help: No modifiers are allowed here.",
+ ],
+ [
+ "namespace N { import a from 'a'; }",
+ "TS(1147) Import declarations in a namespace cannot reference a module. @14+18",
+ ],
+ [
+ "declare using a: any;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare await using a: any;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare using a;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare using\na;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare namespace N { using a: any; }",
+ "TS(1545) 'using' declarations are not allowed in ambient contexts. @28+1",
+ ],
+ ["let x: { [K in 'a']: 1; b: 2 };", 'Expected `}` but found `Identifier` @24+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1\n b: 2 };", 'Expected `}` but found `Identifier` @24+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1; [L in 'b']: 2 };", 'Expected `}` but found `[` @24+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1; m(): void };", 'Expected `}` but found `Identifier` @24+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1; \"b\": 2 };", 'Expected `}` but found `string` @24+3 "`}` expected"'],
+ [
+ "class A { declare constructor: Function; }",
+ "TS(1031) 'declare' modifier cannot appear on a constructor declaration. @10+7",
+ 'Expected `(` but found `:` @29+1 "`(` expected"',
+ ],
+ ["class A { constructor: Function; }", 'Expected `(` but found `:` @21+1 "`(` expected"'],
+ [
+ "class A { declare constructor; }",
+ "TS(1031) 'declare' modifier cannot appear on a constructor declaration. @10+7",
+ 'Expected `(` but found `;` @29+1 "`(` expected"',
+ ],
+ ["class A { private constructor: Function; }", 'Expected `(` but found `:` @29+1 "`(` expected"'],
+ [
+ "class A { readonly constructor: Function; }",
+ "TS(1024) 'readonly' modifier can only appear on a property declaration or index signature. @10+8",
+ 'Expected `(` but found `:` @30+1 "`(` expected"',
+ ],
+ ["class A { constructor = 1; }", 'Expected `(` but found `=` @22+1 "`(` expected"'],
+ [
+ "class A { declare constructor() {} }",
+ "TS(1031) 'declare' modifier cannot appear on a constructor declaration. @10+7",
+ ],
+ [
+ "declare foo;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare foo bar;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare 1;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ 'declare "a";',
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare {};",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare using;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare await;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare await using;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare async;",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @7+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "declare module 'a' { export = a; export const b: number; let q; let q; } let zz; let zz;",
+ 'Identifier `q` has already been declared @61+1 "`q` has already been declared here", 68+1 "It can not be redeclared here"',
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ 'Identifier `zz` has already been declared @77+2 "`zz` has already been declared here", 85+2 "It can not be redeclared here"',
+ ],
+ [
+ "let zz; let zz; declare module 'a' { let q; let q; export = a; export const b: number; }",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ 'Identifier `q` has already been declared @41+1 "`q` has already been declared here", 48+1 "It can not be redeclared here"',
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @51+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export const b: number; namespace N { let q; let q; } }",
+ 'Identifier `q` has already been declared @75+1 "`q` has already been declared here", 82+1 "It can not be redeclared here"',
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { namespace N { export = a; export const b: number; } }",
+ "TS(1063) An export assignment cannot be used in a namespace. @35+11",
+ ],
+ [
+ "declare module 'a' { export = a; export default class {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export default function f(): void; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export default interface I {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export abstract class C {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export const enum E {} }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export import b = require(\"b\"); }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export { b } from \"b\"; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "declare module 'a' { export = a; export * as b from \"b\"; }",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @21+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "class A { constructor(); }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @21+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { constructor() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @21+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(); 'constructor'() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @43+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(a?, b) {} }",
+ "TS(1016) A required parameter cannot follow an optional parameter. @31+1",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { private 'constructor'() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @31+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(): void {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'<>() {} }",
+ "TS(1098) Type parameter list cannot be empty. @23+2",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+2 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'(private a) {} }",
+ "TS(1090) 'private' modifier cannot appear on a parameter. @27+7 help: No modifiers are allowed here.",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ ["class A implements implements {}", "The keyword 'implements' is reserved @19+10"],
+ ["class A implements B. {}", "Unexpected token @22+1"],
+ ["class A implements B.1 {}", 'Expected `{` but found `float` @20+2 "`{` expected"'],
+ ["class A implements B {}", 'Expected `{` but found `<` @23+1 "`{` expected"'],
+ ["class A implements B C {}", 'Expected `{` but found `Identifier` @24+1 "`{` expected"'],
+ [
+ "interface A extends null {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends new B {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+5",
+ ],
+ [
+ 'interface A extends import("a") {}',
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+11",
+ ],
+ [
+ 'interface A extends "a" {}',
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends [] {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends a! {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends a`b` {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends a() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+6",
+ ],
+ [
+ "interface A extends a.#b {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ ["interface A extends B, C, {}", "TS(1009) Trailing comma not allowed. @24+1"],
+ ["interface A extends , B {}", "Unexpected token @20+1"],
+ [
+ "class A extends B, implements C {}",
+ "TS(1174) Classes can only extend a single class. @19+10 help: Remove the extra base class or use interfaces for multiple inheritance",
+ 'Expected `{` but found `Identifier` @30+1 "`{` expected"',
+ ],
+ ["class A extends , B {}", "Unexpected token @16+1"],
+ [
+ "class A extends B, C, {}",
+ "TS(1174) Classes can only extend a single class. @19+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ "TS(1174) Classes can only extend a single class. @22+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ 'Expected `{` but found `EOF` @25+0 "`{` expected"',
+ ],
+ [
+ "class A extends B, {} , C {}",
+ "TS(1174) Classes can only extend a single class. @19+2 help: Remove the extra base class or use interfaces for multiple inheritance",
+ "TS(1174) Classes can only extend a single class. @24+1 help: Remove the extra base class or use interfaces for multiple inheritance",
+ ],
+ ["class A implements , B {}", "Unexpected token @19+1"],
+ ["class A implements B, C, {}", "Unexpected token @25+1"],
+ ["class A implements B, implements C {}", 'Expected `{` but found `Identifier` @33+1 "`{` expected"'],
+ ["class A implements B, extends C {}", 'Expected `{` but found `Identifier` @30+1 "`{` expected"'],
+ ["@d let a;", "Unexpected token @3+3"],
+ ["@d export function f() {}", "Decorators are not valid here. @0+2"],
+ ["@d export default function f() {}", "Decorators are not valid here. @0+2"],
+ ["@d export const a = 1;", "Decorators are not valid here. @0+2"],
+ ["@d export default 1;", "Decorators are not valid here. @0+2"],
+ ["@d export interface I {}", "Decorators are not valid here. @0+2"],
+ ["@d export type T = 1;", "Decorators are not valid here. @0+2"],
+ ["@d export enum E {}", "Decorators are not valid here. @0+2"],
+ ["@d export namespace N {}", "Decorators are not valid here. @0+2"],
+ ["@d export declare function f(): void;", "Decorators are not valid here. @0+2"],
+ ["@d @e export function f() {}", "Decorators are not valid here. @0+2", "Decorators are not valid here. @3+2"],
+ [
+ "@d export function f() {} let y: readonly number;",
+ "Decorators are not valid here. @0+2",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @33+8",
+ ],
+ ["let zz; let zz; @d export function f() {}", "Decorators are not valid here. @16+2"],
+ ["@d declare function f(): void;", "Unexpected token @11+8"],
+ ['@d import a from "a";', "Unexpected token @3+6"],
+ ["@d async function f() {}", "Unexpected token @9+8"],
+ [
+ "@d static class A {}",
+ "'static' modifier cannot be used here. @3+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "@d export static class A {}",
+ "'static' modifier cannot be used here. @10+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export @d static class A {}",
+ "'static' modifier cannot be used here. @10+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ ["export @d async function f() {}", 'Expected `{` but found `(` @26+1 "`{` expected"'],
+ ["export @d default function () {}", 'Expected `{` but found `(` @27+1 "`{` expected"'],
+ ["export @d let a;", 'Expected `{` but found `;` @15+1 "`{` expected"'],
+ ["export @d type T = 1;", 'Expected `{` but found `=` @17+1 "`{` expected"'],
+ ["export default @d function f() {}", "Decorators are not valid here. @15+2"],
+ ["();", "Empty parenthesized expression @0+2"],
+ ["( );", "Empty parenthesized expression @0+4"],
+ ["a = ();", "Empty parenthesized expression @4+2"],
+ ["if () {}", "Unexpected token @4+1"],
+ ["while () {}", "Unexpected token @7+1"],
+ ["switch () {}", "Unexpected token @8+1"],
+ ["do {} while ();", "Unexpected token @13+1"],
+ ["with () {}", "Unexpected token @6+1"],
+ ["for (;;()) {}", "Empty parenthesized expression @7+2"],
+ ["for (() of a) {}", "Empty parenthesized expression @5+2"],
+ ["f(());", "Empty parenthesized expression @2+2"],
+ ["[()];", "Empty parenthesized expression @1+2"],
+ ["new ();", "Empty parenthesized expression @4+2"],
+ ["() + 1;", "Empty parenthesized expression @0+2"],
+ ["a ? () : b;", 'Expected `=>` but found `;` @10+1 "`=>` expected"'],
+ ["`${()}`;", "Empty parenthesized expression @3+2"],
+ ["async function f() { await (); }", "Empty parenthesized expression @27+2"],
+ ["function* f() { yield (); }", "Empty parenthesized expression @22+2"],
+ ["let zz; let zz; (); let y: readonly number;", "Empty parenthesized expression @16+2"],
+ [
+ "a ?? b || c; ();",
+ "Logical expressions and coalesce expressions cannot be mixed @0+11 help: Wrap either expression by parentheses",
+ "Empty parenthesized expression @13+2",
+ ],
+ ["(/* c */);", "Empty parenthesized expression @0+9"],
+ ["class A { get a?() { return 1; } }", 'Expected `(` but found `?` @15+1 "`(` expected"'],
+ ["class A { set a?(v) {} }", 'Expected `(` but found `?` @15+1 "`(` expected"'],
+ ["class A { constructor?() {} }", 'Expected `(` but found `?` @21+1 "`(` expected"'],
+ ["class A { `constructor`() {} }", "Unexpected token @10+13"],
+ [
+ "interface A extends B C {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+1",
+ 'Expected `{` but found `Identifier` @22+1 "`{` expected"',
+ ],
+ ["interface A extends B, extends C {}", "Unexpected token @23+7"],
+ ["export @d default 1;", 'Expected `{` but found `;` @19+1 "`{` expected"'],
+ ["`\\", "Unterminated string @0+3"],
+ ["`;", "Unterminated string @0+3"],
+ ["enum E { `\\u` }", "TS(1164) Computed property names are not allowed in enums. @9+4"],
+ [
+ "export declare using a: any;",
+ "Using declarations cannot be exported directly. @7+15 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ ["let x: { [K in 'a']: 1, b: 2 };", 'Expected `}` but found `,` @22+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1;; };", 'Expected `}` but found `;` @23+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1, };", 'Expected `}` but found `,` @22+1 "`}` expected"'],
+ ["let x: { [K in 'a']: 1 b: 2 };", 'Expected `}` but found `Identifier` @23+1 "`}` expected"'],
+ ["class A { static constructor: Function; }", "Classes can't have a field named 'constructor' @17+11"],
+ [
+ "class A { async 'constructor'() {} }",
+ "Constructor can't be an async method @16+13",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @29+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A { 'constructor'() {} constructor() {} }",
+ "TS(1092) Type parameters cannot appear on a constructor declaration @23+3 help: Instead, add type parameters to the class itself",
+ ],
+ [
+ "class A implements implements implements {}",
+ "TS(1175) 'implements' clause already seen @8+10, 30+10 help: Merge the two 'implements' clauses into one by a ','",
+ "Unexpected token @41+1",
+ ],
+ ["class A implements B.C {}", 'Expected `{` but found `.` @23+1 "`{` expected"'],
+ [
+ "interface A extends void {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ 'Expected `{` but found `EOF` @28+0 "`{` expected"',
+ ],
+ [
+ "interface A extends B, void {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+7",
+ 'Expected `{` but found `EOF` @31+0 "`{` expected"',
+ ],
+ [
+ "interface A extends typeof a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+8",
+ ],
+ [
+ "interface A extends class {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+8",
+ 'Expected `{` but found `EOF` @29+0 "`{` expected"',
+ ],
+ [
+ "interface A extends B, implements C {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+10",
+ 'Expected `{` but found `Identifier` @34+1 "`{` expected"',
+ ],
+ ["interface A implements B, {}", "Unexpected token @26+1"],
+ ["export @d const { a } = b;", "Unexpected token @22+1"],
+ [
+ "export @d export class A {}",
+ "'export' modifier cannot be used here. @10+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ ["x = @d function() {};", "Unexpected token @7+8"],
+ [
+ "class A { default default a; }",
+ "TS(1030) 'default' modifier already seen. @18+7 help: Remove the duplicate modifier.",
+ ],
+ [
+ "class A { default [k: string]: any; }",
+ "TS(1071) 'default' modifier cannot appear on an index signature. @10+7 help: Allowed modifiers are: static, readonly",
+ ],
+ ["class A { default static {} }", "TS(1184) Modifiers cannot appear here. @10+7"],
+ ["class A { static constructor; }", "Classes can't have a field named 'constructor' @17+11"],
+ ["class A { static constructor = 1; }", "Classes can't have a field named 'constructor' @17+11"],
+ ["class A { static readonly constructor: Function; }", "Classes can't have a field named 'constructor' @26+11"],
+ ["class A { static 'constructor': Function; }", "Classes can't have a field named 'constructor' @17+13"],
+ ["class A { 'constructor': Function; }", "Classes can't have a field named 'constructor' @10+13"],
+ ["class A { 'constructor'; }", "Classes can't have a field named 'constructor' @10+13"],
+ ["class A { static constructor?: Function; }", "Classes can't have a field named 'constructor' @17+11"],
+ [
+ "class A { accessor constructor = 1; }",
+ "TS(1275) 'accessor' modifier can only appear on a property declaration. @10+8",
+ 'Expected `(` but found `=` @31+1 "`(` expected"',
+ ],
+ [
+ "export export class A {}",
+ "TS(1030) 'export' modifier already seen. @7+6 help: Remove the duplicate modifier.",
+ ],
+ [
+ "export @d export default class A {}",
+ "'export' modifier cannot be used here. @10+6 help: Allowed modifiers are: declare, abstract",
+ "'default' modifier cannot be used here. @17+7 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "@d export export class A {}",
+ "TS(1030) 'export' modifier already seen. @10+6 help: Remove the duplicate modifier.",
+ ],
+ [
+ "export @d declare export class A {}",
+ "TS(1029) 'export' modifier must precede 'declare' modifier. @18+6",
+ "'export' modifier cannot be used here. @18+6 help: Allowed modifiers are: declare, abstract",
+ ],
+ [
+ "export using a = b;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export declare using a;",
+ "Using declarations cannot be exported directly. @7+15 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export declare using a = b;",
+ "Using declarations cannot be exported directly. @7+15 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export declare using a: any, b: any;",
+ "Using declarations cannot be exported directly. @7+15 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export declare await using a: any;",
+ "Using declarations cannot be exported directly. @7+21 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export using a: any = b;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export await using a = b;",
+ "Using declarations cannot be exported directly. @7+13 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export using a = b, c = d;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export using a = b; let y: readonly number;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "let y: readonly number; export using a = b;",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ "Using declarations cannot be exported directly. @31+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ ["export using;", "Unexpected token @7+5"],
+ [
+ "export using a;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "namespace N { export using a = b; }",
+ "Using declarations cannot be exported directly. @21+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "export declare using a: any; let y: readonly number;",
+ "Using declarations cannot be exported directly. @7+15 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ [
+ "interface A extends B, C D {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+1",
+ 'Expected `{` but found `Identifier` @25+1 "`{` expected"',
+ ],
+ [
+ "interface A extends B.C D {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ 'Expected `{` but found `Identifier` @24+1 "`{` expected"',
+ ],
+ [
+ "interface A extends B D {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+6",
+ ],
+ [
+ "interface A extends B 1 {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+1",
+ 'Expected `{` but found `decimal` @22+1 "`{` expected"',
+ ],
+ [
+ "interface A extends B;",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+1",
+ 'Expected `{` but found `;` @21+1 "`{` expected"',
+ ],
+ ["interface A extends B", 'Expected `{` but found `EOF` @22+0 "`{` expected"'],
+ [
+ "interface A extends B = {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+6",
+ 'Expected `{` but found `EOF` @27+0 "`{` expected"',
+ ],
+ [
+ "interface A extends B, C;",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+1",
+ 'Expected `{` but found `;` @24+1 "`{` expected"',
+ ],
+ [
+ "interface A extends B.C.D E {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+5",
+ 'Expected `{` but found `Identifier` @26+1 "`{` expected"',
+ ],
+ [
+ "interface A extends -a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends !a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends +a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends ~a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+2",
+ ],
+ [
+ "interface A extends delete a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+8",
+ ],
+ [
+ "interface A extends ++a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends a++ {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends a + b {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+5",
+ ],
+ [
+ "interface A extends new B() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ ],
+ [
+ "interface A extends a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends void a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+6",
+ ],
+ [
+ "interface A extends void a, B {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+6",
+ ],
+ [
+ "interface A extends B, typeof a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @23+8",
+ ],
+ [
+ "interface A extends typeof a, B {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+8",
+ ],
+ [
+ "interface A extends typeof a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+14",
+ 'Expected `{` but found `EOF` @35+0 "`{` expected"',
+ ],
+ [
+ "interface A extends function() {} {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+13",
+ ],
+ [
+ "interface A extends class {} {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+8",
+ ],
+ [
+ "interface A extends true {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends import.meta {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+11",
+ ],
+ ["interface A extends if {}", "Unexpected token @20+2"],
+ ["interface A extends in {}", "Unexpected token @20+2"],
+ ["interface A extends var {}", "Unexpected token @20+3"],
+ ["interface A extends B, if {}", "Unexpected token @23+2"],
+ ["interface A extends B, extends {}", "Unexpected token @23+7"],
+ ["interface A extends extends B {}", "Unexpected token @20+7"],
+ [
+ "interface A extends implements B {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+10",
+ 'Expected `{` but found `Identifier` @31+1 "`{` expected"',
+ ],
+ ["interface A implements B, C {}", "TS(1176) Interface declaration cannot have 'implements' clause. @12+10"],
+ ["interface A implements {}", "Unexpected token @23+1"],
+ [
+ "interface A implements B extends C {}",
+ "TS(1173) 'extends' clause must precede 'implements' clause @12+10 \"'implements' clause found here\", 25+7 \"'extends' clause found here\" help: Move the 'extends' clause before the 'implements' clause",
+ "TS(1176) Interface declaration cannot have 'implements' clause. @12+10",
+ ],
+ ["interface A implements void {}", "TS(1176) Interface declaration cannot have 'implements' clause. @12+10"],
+ ["interface A implements f() {}", 'Expected `{` but found `(` @24+1 "`{` expected"'],
+ ["interface A implements B C {}", 'Expected `{` but found `Identifier` @25+1 "`{` expected"'],
+ ["interface A extends B, C extends D {}", "TS(1172) 'extends' clause already seen @25+7"],
+ [
+ "let zz; let zz; interface A extends typeof a {} let y: readonly number;",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+8",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @55+8",
+ ],
+ [
+ "let zz; let zz; interface A extends B C {} let y: readonly number;",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+1",
+ 'Expected `{` but found `Identifier` @38+1 "`{` expected"',
+ ],
+ [
+ "interface A extends a?.b c {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ 'Expected `{` but found `Identifier` @25+1 "`{` expected"',
+ ],
+ [
+ "interface A extends a[0] {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+4",
+ ],
+ [
+ "interface A extends a() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends `a` {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends @d class {} {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+11",
+ ],
+ ["class A { static declare constructor: Function; }", "Classes can't have a field named 'constructor' @25+11"],
+ [
+ "class A { static constructor!: Function; }",
+ "Classes can't have a field named 'constructor' @17+11",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @28+1",
+ ],
+ [
+ "export using {a} = b;",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { { }` as a separate statement to export the declaration",
+ ],
+ ["interface A extends B {", 'Expected `}` but found `EOF` @24+0 "`}` expected", 22+1 "Opened here"'],
+ [
+ "interface A extends await a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ ],
+ [
+ "interface A extends super {}",
+ "'super' can only be used with function calls or in property accesses @20+5 help: Replace with `super()` or `super.prop` or `super[prop]`",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+5",
+ ],
+ ["interface A extends #b {}", 'Expected `in` but found `{` @23+1 "`in` expected"'],
+ ["interface A extends / {}", "Unterminated regular expression @20+5"],
+ [
+ "class A { static 'a'!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @20+1",
+ ],
+ [
+ "class A { static get!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @20+1",
+ ],
+ [
+ "class A { static static!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @23+1",
+ ],
+ [
+ "class A { static readonly a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @27+1",
+ ],
+ [
+ "class A { static declare a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @26+1",
+ ],
+ [
+ "class A { static accessor a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @27+1",
+ ],
+ [
+ "class A { static a!; }",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @18+1",
+ ],
+ [
+ "class A { static a! = 1; }",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @18+1",
+ ],
+ [
+ "class A { static a!: number = 1; }",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @18+1",
+ ],
+ [
+ "declare class A { static a!: number; }",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @26+1",
+ ],
+ [
+ "abstract class A { static abstract a!: number; }",
+ "TS(1243) 'static' modifier cannot be used with 'abstract' modifier. @26+8",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @36+1",
+ ],
+ ["export using [a] = b;", "Unexpected token @7+5"],
+ ["export using\na = b;", "Unexpected token @7+5"],
+ ["export using in b;", "Unexpected token @7+5"],
+ [
+ "export using of = b;",
+ "Using declarations cannot be exported directly. @7+8 help: Remove the `export` here and add `export { of }` as a separate statement to export the declaration",
+ ],
+ [
+ "export using await = b;",
+ "Using declarations cannot be exported directly. @7+11 help: Remove the `export` here and add `export { await }` as a separate statement to export the declaration",
+ ],
+ [
+ "export using a",
+ "Using declarations cannot be exported directly. @7+7 help: Remove the `export` here and add `export { a }` as a separate statement to export the declaration",
+ ],
+ ['export using "a";', "Unexpected token @7+5"],
+ ["export using 1;", "Unexpected token @7+5"],
+ ["export using (a);", "Unexpected token @7+5"],
+ [
+ "export await using {a} = b;",
+ "Using declarations cannot be exported directly. @7+13 help: Remove the `export` here and add `export { { }` as a separate statement to export the declaration",
+ ],
+ [
+ "export default interface\nA {}",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @26+0 help: Try inserting a semicolon here",
+ ],
+ ["export default interface\nA\n{}", "The keyword 'interface' is reserved @15+9"],
+ [
+ "interface A extends #b in c {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ ],
+ [
+ "interface A extends /a/ {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+3",
+ ],
+ [
+ "interface A extends super.a {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ ],
+ [
+ "interface A extends super() {}",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @20+7",
+ ],
+ ["x = / {}", "Unterminated regular expression @4+5", "Unexpected token @4+5"],
+ ["class A extends / {}", "Unterminated regular expression @16+5"],
+ ["interface A extends B, / {}", "Unterminated regular expression @23+5"],
+ ["interface A extends /a", "Unterminated regular expression @20+3"],
+ ["f(/ {}", "Unterminated regular expression @2+5"],
+ ["class A implements / {}", "Unexpected token @19+1"],
+ ["let x: / {}", "Unexpected token @7+1"],
+ [
+ "class A { accessor a!; }",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @20+1",
+ ],
+ [
+ "class A { accessor a! = 1; }",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @20+1",
+ ],
+ [
+ "export = a; export const b = 1; export = c;",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @0+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ "TS(2309) An export assignment cannot be used in a module with other exported elements @32+11 help: If you want to use `export =`, remove other `export`s and put all of them to the right hand value of `export =`. If you want to use `export`s, remove `export =` statement.",
+ ],
+ [
+ "interface A extends B, {",
+ "TS(1009) Trailing comma not allowed. @21+1",
+ 'Expected `}` but found `EOF` @25+0 "`}` expected", 23+1 "Opened here"',
+ ],
+ [
+ "for await (let.a of []) {}",
+ "The left-hand side of a `for...of` statement may not start with `let` @11+5",
+ "`for await` loops are only allowed within async functions and at the top levels of modules @4+5 help: Either remove this `await` or add the `async` keyword to the enclosing function",
+ ],
+ ["for (const of a);", 'Expected `;` but found `Identifier` @14+1 "`;` expected"'],
+ [
+ "declare namespace N { a b; }",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @23+0 help: Try inserting a semicolon here",
+ ],
+ ["000000k000;", "Invalid characters after number @6+1"],
+ ["0k0;", "Invalid characters after number @1+1"],
+ ["class {}", "A class name is required. @0+5"],
+ [
+ "class {} a ?? b || c;",
+ "Logical expressions and coalesce expressions cannot be mixed @9+11 help: Wrap either expression by parentheses",
+ ],
+ [
+ "let zz; let zz; class {}",
+ 'Identifier `zz` has already been declared @4+2 "`zz` has already been declared here", 12+2 "It can not be redeclared here"',
+ "A class name is required. @16+5",
+ ],
+ ["export class {}", "A class name is required. @7+5"],
+ ["{ class {} }", "A class name is required. @2+5"],
+ ["abstract class {}", "A class name is required. @0+5"],
+ ["declare class {}", "A class name is required. @0+5"],
+ ["class {} let a = ;", "Unexpected token @17+1"],
+ ["namespace N { export class {} }", "A class name is required. @21+5"],
+ ["class implements A {}", "A class name is required. @0+5"],
+ ["declare namespace N { a; b; }", "TS(1036) Statements are not allowed in ambient contexts. @22+2"],
+ [
+ "(static satisfies any) = 1;",
+ "TS(1090) 'static' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `any` @18+3 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(public a b);",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @10+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(readonly a b);",
+ "TS(1090) 'readonly' modifier cannot appear on a parameter. @1+8 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @12+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(declare a b);",
+ "TS(1090) 'declare' modifier cannot appear on a parameter. @1+7 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @11+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(abstract a b);",
+ "TS(1090) 'abstract' modifier cannot appear on a parameter. @1+8 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @12+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(override a b);",
+ "TS(1090) 'override' modifier cannot appear on a parameter. @1+8 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @12+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(static a, b c);",
+ "TS(1090) 'static' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @13+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(static static a b);",
+ "TS(1090) 'static' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @15+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ ["(async a b);", 'Expected `,` or `)` but found `Identifier` @7+1 "`,` or `)` expected", 0+1 "Opened here"'],
+ ["(a, static b c);", 'Expected `,` or `)` but found `Identifier` @11+1 "`,` or `)` expected", 0+1 "Opened here"'],
+ [
+ "(static a);",
+ "TS(1090) 'static' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `=>` but found `;` @10+1 "`=>` expected"',
+ ],
+ [
+ "(static a) = 1;",
+ "TS(1090) 'static' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `=>` but found `=` @11+1 "`=>` expected"',
+ ],
+ [
+ "(public a) => 1;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ ],
+ [
+ "(public a, b c) => 1;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @13+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(yield a b);",
+ "A 'yield' expression is only allowed in a generator body. @1+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ 'Expected `,` or `)` but found `Identifier` @9+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "(yield as any)++;",
+ "A 'yield' expression is only allowed in a generator body. @1+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ 'Expected `,` or `)` but found `any` @10+3 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "{ (yield as any)++; }",
+ "A 'yield' expression is only allowed in a generator body. @3+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ 'Expected `,` or `)` but found `any` @12+3 "`,` or `)` expected", 2+1 "Opened here"',
+ ],
+ [
+ "f(yield a b);",
+ "A 'yield' expression is only allowed in a generator body. @2+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ 'Expected `,` or `)` but found `Identifier` @10+1 "`,` or `)` expected", 1+1 "Opened here"',
+ ],
+ [
+ "[yield a b];",
+ "A 'yield' expression is only allowed in a generator body. @1+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ 'Expected `,` or `]` but found `Identifier` @9+1 "`,` or `]` expected", 0+1 "Opened here"',
+ ],
+ [
+ "x = yield a b;",
+ "A 'yield' expression is only allowed in a generator body. @4+5 help: Either remove this `yield` or change the enclosing function to a generator function (`function*`)",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @11+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "function f() { (await a b); }",
+ "`await` is only allowed within async functions and at the top levels of modules @16+5 help: Either remove this `await` or add the `async` keyword to the enclosing function",
+ 'Expected `,` or `)` but found `Identifier` @24+1 "`,` or `)` expected", 15+1 "Opened here"',
+ ],
+ ["(await as any)++;", 'Expected `,` or `)` but found `any` @10+3 "`,` or `)` expected", 0+1 "Opened here"'],
+ [
+ "class A { a?! }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @12+1",
+ ],
+ [
+ "class A { a?!; b c }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ "TS(1264) Declarations with definite assignment assertions must also have type annotations. @12+1",
+ 'Expected `;` but found `Identifier` @17+1 "`;` expected"',
+ ],
+ [
+ "class A { a?!: number; b c }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ 'Expected `;` but found `Identifier` @25+1 "`;` expected"',
+ ],
+ [
+ "class A { a?!: number; m() { const a; } }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ "Missing initializer in const declaration @35+1 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ [
+ "class A { a?!(): void }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ 'Expected `;` but found `(` @13+1 "`;` expected"',
+ ],
+ [
+ "let a?!: number;",
+ "Optional declaration is not allowed here @5+1 help: Remove the `?`",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @6+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "class A { a?!: number; }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ ],
+ ["class A { a!?: number; }", 'Expected `;` but found `?` @12+1 "`;` expected"'],
+ [
+ "class A { a?! = 1; }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ "TS(1263) Declarations with initializers cannot also have definite assignment assertions. @12+1",
+ ],
+ [
+ "class A { static a?!: number; }",
+ "A property cannot be both optional and definite. @18+2 help: Remove either the `?` or the `!`",
+ "TS(1255) A definite assignment assertion '!' is not permitted in this context. @19+1",
+ ],
+ [
+ "class A { a? !: number; }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ ],
+ [
+ "class A { a?\n!: number; }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ ],
+ ["let a?: number;", "Optional declaration is not allowed here @5+1 help: Remove the `?`"],
+ ["let a?;", "Optional declaration is not allowed here @5+1 help: Remove the `?`"],
+ ["let a? = 1;", "Optional declaration is not allowed here @5+1 help: Remove the `?`"],
+ ["const a?: number = 1;", "Optional declaration is not allowed here @7+1 help: Remove the `?`"],
+ ["let a, b?: number;", "Optional declaration is not allowed here @8+1 help: Remove the `?`"],
+ [
+ "let [a]?: number;",
+ "Optional declaration is not allowed here @7+1 help: Remove the `?`",
+ "Missing initializer in destructuring declaration @4+3 help: Add an initializer (e.g. ` = undefined`) here",
+ ],
+ ["for (let a? of b) {}", "Optional declaration is not allowed here @10+1 help: Remove the `?`"],
+ [
+ "let a?: number; let y: readonly number;",
+ "Optional declaration is not allowed here @5+1 help: Remove the `?`",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @23+8",
+ ],
+ ["import {", 'Expected `}` but found `EOF` @9+0 "`}` expected"'],
+ ["function enum() {}", 'Expected `Identifier` but found `enum` @9+4 "`Identifier` expected"'],
+ [
+ "(public a, b) => 1;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ ],
+ [
+ "(public a b) => 1;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @10+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "function f(public a b) {}",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @20+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "function f(public a, b c) {}",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @23+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "class A { m(public a b) {} }",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @12+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @21+1 "`,` or `)` expected", 11+1 "Opened here"',
+ ],
+ [
+ "function f(a?, b c) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ 'Expected `,` or `)` but found `Identifier` @17+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "function f(a?, b, c d) {}",
+ "TS(1016) A required parameter cannot follow an optional parameter. @15+1",
+ "TS(1016) A required parameter cannot follow an optional parameter. @18+1",
+ 'Expected `,` or `)` but found `Identifier` @20+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "(public a b",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @1+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @10+1 "`,` or `)` expected", 0+1 "Opened here"',
+ ],
+ [
+ "function f(public a) {} x y;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @25+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "function f(public a, b = ) {}",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ "Unexpected token @25+1",
+ ],
+ [
+ "function f(public a) { x y; }",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ "Expected a semicolon or an implicit semicolon after a statement, but found none @24+0 help: Try inserting a semicolon here",
+ ],
+ [
+ "function f(public a, b c) { }",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @23+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "function f(public a, b: ) { }",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ "Unexpected token @24+1",
+ ],
+ [
+ "function f(public a, 1) { }",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ "Unexpected token @21+1",
+ ],
+ [
+ "function f(public a b) { } let y: readonly number;",
+ "TS(1090) 'public' modifier cannot appear on a parameter. @11+6 help: No modifiers are allowed here.",
+ 'Expected `,` or `)` but found `Identifier` @20+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ [
+ "let y: readonly number; function f(a b) { }",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @7+8",
+ 'Expected `,` or `)` but found `Identifier` @37+1 "`,` or `)` expected", 34+1 "Opened here"',
+ ],
+ [
+ "function f(y: readonly number, a b) { }",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @14+8",
+ 'Expected `,` or `)` but found `Identifier` @33+1 "`,` or `)` expected", 10+1 "Opened here"',
+ ],
+ ["function* enum() {}", 'Expected `Identifier` but found `enum` @10+4 "`Identifier` expected"'],
+ ["function* if() {}", 'Expected `Identifier` but found `if` @10+2 "`Identifier` expected"'],
+ [
+ "function* () {}",
+ "Expected function name @10+1 help: Function name is required in function declaration or named export",
+ ],
+ ["function* f();", "TS(1222) An overload signature cannot be declared as a generator. @0+14"],
+ [
+ "function* f(); let y: readonly number;",
+ "TS(1222) An overload signature cannot be declared as a generator. @0+14",
+ "TS(1354) 'readonly' type modifier is only permitted on array and tuple literal types. @22+8",
+ ],
+ ["class A { *enum(); }", "TS(1222) An overload signature cannot be declared as a generator. @10+8"],
+ ["a?.<;", "Identifier expected after '?.' @1+2 help: Add an identifier after '?.'"],
+ ["class A { a: T() }", 'Expected `;` but found `(` @14+1 "`;` expected"'],
+ ["class A { a: T(); }", 'Expected `;` but found `(` @14+1 "`;` expected"'],
+ ["class A { a!() {} }", 'Expected `;` but found `(` @12+1 "`;` expected"'],
+ [
+ "class A { a?!() {} }",
+ "A property cannot be both optional and definite. @11+2 help: Remove either the `?` or the `!`",
+ 'Expected `;` but found `(` @13+1 "`;` expected"',
+ ],
+ ["class A { a: T(b) {} }", 'Expected `;` but found `(` @14+1 "`;` expected"'],
+ [
+ "function* w() { interface A extends yield {} }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+8",
+ 'Expected `{` but found `}` @45+1 "`{` expected"',
+ ],
+ [
+ "function* w() { interface A extends yield { a: 1 } }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+14",
+ 'Expected `{` but found `}` @51+1 "`{` expected"',
+ ],
+ [
+ "function* w() { interface A extends yield {} x; }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+8",
+ 'Expected `{` but found `Identifier` @45+1 "`{` expected"',
+ ],
+ [
+ "function* w() { interface A extends yield {} {} }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+8",
+ ],
+ [
+ "function* w() { interface A extends yield {} { a: 1 } }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+8",
+ ],
+ [
+ "function* w() { interface A extends yield, B {} }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+5",
+ ],
+ [
+ "function* w() { interface A extends yield\n{} }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @36+5",
+ ],
+ [
+ "function* w() { interface A extends B, yield {} }",
+ "TS(2499) An interface can only extend an identifier/qualified-name with optional type arguments. @39+8",
+ 'Expected `{` but found `}` @48+1 "`{` expected"',
+ ],
+ [
+ "function* w() { interface A extends yield
`;
diff --git a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.prettier.snap b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.prettier.snap
new file mode 100644
index 000000000000..98cff6a5a94b
--- /dev/null
+++ b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.prettier.snap
@@ -0,0 +1,15 @@
+------------------
+{ printWidth: 80 }
+------------------
+a = html`<${t} ${a}>${k}`;
+b = html`<${t} ${a} />`;
+c = html``;
+
+-------------------
+{ printWidth: 100 }
+-------------------
+a = html`<${t} ${a}>${k}`;
+b = html`<${t} ${a} />`;
+c = html``;
+
+===================== End =====================
diff --git a/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.snap b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.snap
new file mode 100644
index 000000000000..98cff6a5a94b
--- /dev/null
+++ b/test/cli/format/own/cases/html/template-whose-tag-is-a-substitution.js.snap
@@ -0,0 +1,15 @@
+------------------
+{ printWidth: 80 }
+------------------
+a = html`<${t} ${a}>${k}`;
+b = html`<${t} ${a} />`;
+c = html``;
+
+-------------------
+{ printWidth: 100 }
+-------------------
+a = html`<${t} ${a}>${k}`;
+b = html`<${t} ${a} />`;
+c = html``;
+
+===================== End =====================
diff --git a/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.input b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.input
new file mode 100644
index 000000000000..1e314e611e63
--- /dev/null
+++ b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.input
@@ -0,0 +1,9 @@
+type A = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });
+type B = import("./a", { with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) } });
+import data from "./d.json" with { type: "json" };
+type C = import("./m", { with: { a: 0 as import("./n", { with: { x: () => q } }), b: 0 as import("./o", { with: { y: () => q } }), c: () => q } });
+type D = import("./m", { with: { a: 0 as import("./n", { with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q } }), c: () => q } });
+type E = import("./m", { with: { a: () => { let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } }); return u; } } });
+type F = import("./a", { with: { "k": 0 as import("./c", { with: { "inner": "v1" } }), "outer": "v2" } });
+type G = import("./a", { with: { outer: "1" } });
+type H = import("./a");
diff --git a/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.prettier.snap b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.prettier.snap
new file mode 100644
index 000000000000..89c356ebe2f2
--- /dev/null
+++ b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.prettier.snap
@@ -0,0 +1,75 @@
+------------------
+{ printWidth: 80 }
+------------------
+type A = import("./a", {
+ with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 },
+});
+type B = import("./a", {
+ with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) },
+});
+import data from "./d.json" with { type: "json" };
+type C = import("./m", {
+ with: {
+ a: 0 as import("./n", { with: { x: () => q } }),
+ b: 0 as import("./o", { with: { y: () => q } }),
+ c: () => q,
+ },
+});
+type D = import("./m", {
+ with: {
+ a: 0 as import("./n", {
+ with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q },
+ }),
+ c: () => q,
+ },
+});
+type E = import("./m", {
+ with: {
+ a: () => {
+ let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } });
+ return u;
+ },
+ },
+});
+type F = import("./a", {
+ with: { k: 0 as import("./c", { with: { inner: "v1" } }), outer: "v2" },
+});
+type G = import("./a", { with: { outer: "1" } })<
+ import("./c", { with: { inner: "2" } })
+>;
+type H = import("./a");
+
+-------------------
+{ printWidth: 100 }
+-------------------
+type A = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });
+type B = import("./a", { with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) } });
+import data from "./d.json" with { type: "json" };
+type C = import("./m", {
+ with: {
+ a: 0 as import("./n", { with: { x: () => q } }),
+ b: 0 as import("./o", { with: { y: () => q } }),
+ c: () => q,
+ },
+});
+type D = import("./m", {
+ with: {
+ a: 0 as import("./n", {
+ with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q },
+ }),
+ c: () => q,
+ },
+});
+type E = import("./m", {
+ with: {
+ a: () => {
+ let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } });
+ return u;
+ },
+ },
+});
+type F = import("./a", { with: { k: 0 as import("./c", { with: { inner: "v1" } }), outer: "v2" } });
+type G = import("./a", { with: { outer: "1" } });
+type H = import("./a");
+
+===================== End =====================
diff --git a/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.snap b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.snap
new file mode 100644
index 000000000000..98411dba3007
--- /dev/null
+++ b/test/cli/format/own/cases/types/options-of-an-import-type-in-the-options-of-another.ts.snap
@@ -0,0 +1,97 @@
+------------------
+{ printWidth: 80 }
+------------------
+type A = import(
+ "./a",
+ { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } }
+);
+type B = import(
+ "./a",
+ { with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) } }
+);
+import data from "./d.json" with { type: "json" };
+type C = import(
+ "./m",
+ {
+ with: {
+ a: 0 as import("./n", { with: { x: () => q } }),
+ b: 0 as import("./o", { with: { y: () => q } }),
+ c: () => q,
+ },
+ }
+);
+type D = import(
+ "./m",
+ {
+ with: {
+ a: 0 as import(
+ "./n",
+ {
+ with: {
+ x: 0 as import("./o", { with: { y: () => q } }),
+ x2: () => q,
+ },
+ }
+ ),
+ c: () => q,
+ },
+ }
+);
+type E = import("./m", {
+ with: {
+ a: () => {
+ let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } });
+ return u;
+ },
+ },
+});
+type F = import(
+ "./a",
+ { with: { k: 0 as import("./c", { with: { inner: "v1" } }), outer: "v2" } }
+);
+type G = import("./a", { with: { outer: "1" } })<
+ import("./c", { with: { inner: "2" } })
+>;
+type H = import("./a");
+
+-------------------
+{ printWidth: 100 }
+-------------------
+type A = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });
+type B = import("./a", { with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) } });
+import data from "./d.json" with { type: "json" };
+type C = import(
+ "./m",
+ {
+ with: {
+ a: 0 as import("./n", { with: { x: () => q } }),
+ b: 0 as import("./o", { with: { y: () => q } }),
+ c: () => q,
+ },
+ }
+);
+type D = import(
+ "./m",
+ {
+ with: {
+ a: 0 as import(
+ "./n",
+ { with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q } }
+ ),
+ c: () => q,
+ },
+ }
+);
+type E = import("./m", {
+ with: {
+ a: () => {
+ let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } });
+ return u;
+ },
+ },
+});
+type F = import("./a", { with: { k: 0 as import("./c", { with: { inner: "v1" } }), outer: "v2" } });
+type G = import("./a", { with: { outer: "1" } });
+type H = import("./a");
+
+===================== End =====================
diff --git a/test/cli/format/own/sync.ts b/test/cli/format/own/sync.ts
index f82c099893cc..ffea350ce708 100644
--- a/test/cli/format/own/sync.ts
+++ b/test/cli/format/own/sync.ts
@@ -34,7 +34,7 @@ for (const [path, bytes] of files) {
rmSync(directory, { recursive: true });
}
writeFileSync(join(import.meta.dir, `${name}.prettier.snap`), render(asPrettier));
- // `.todo`: `bun format` does not print that yet, and it is not compared.
+ // `.todo`: `bun fmt` does not print that yet, and it is not compared.
const snapshot = join(import.meta.dir, `${name}.snap`);
if (asOxfmt.length > 0) writeFileSync(existsSync(`${snapshot}.todo`) ? `${snapshot}.todo` : snapshot, render(asOxfmt));
}
diff --git a/test/cli/format/oxfmt-cli/cases.json b/test/cli/format/oxfmt-cli/cases.json
index 0de69f2c8222..a9b50b307bb4 100644
--- a/test/cli/format/oxfmt-cli/cases.json
+++ b/test/cli/format/oxfmt-cli/cases.json
@@ -145,15 +145,6 @@
"root.js": "const introduce = \"I am root.js\"\n",
"foo/file.js": "const message = 2\n"
},
- "init": {
- ".gitkeep": ""
- },
- "init_already_exists": {
- ".oxfmtrc.json": "{}"
- },
- "init_with_schema": {
- "node_modules/oxfmt/configuration_schema.json": "{}"
- },
"insert_final_newline": {
"editorconfig_only/.editorconfig": "root = true\n\n[*]\ninsert_final_newline = false\n",
"editorconfig_only/test.css": ".foo { color: red }\n",
@@ -1507,37 +1498,6 @@
"root.js"
]
},
- {
- "name": "init",
- "index": 0,
- "args": [
- "--init"
- ],
- "exitCode": 0,
- "changed": {
- ".oxfmtrc.json": "{\n \"ignorePatterns\": []\n}\n"
- }
- },
- {
- "name": "init_already_exists",
- "index": 0,
- "args": [
- "--init"
- ],
- "exitCode": 1,
- "changed": {}
- },
- {
- "name": "init_with_schema",
- "index": 0,
- "args": [
- "--init"
- ],
- "exitCode": 0,
- "changed": {
- ".oxfmtrc.json": "{\n \"$schema\": \"./node_modules/oxfmt/configuration_schema.json\",\n \"ignorePatterns\": []\n}\n"
- }
- },
{
"name": "insert_final_newline",
"index": 0,
diff --git a/test/cli/format/oxfmt-cli/oxfmt-cli.test.ts b/test/cli/format/oxfmt-cli/oxfmt-cli.test.ts
index 63756c6262f6..07b3ebc23619 100644
--- a/test/cli/format/oxfmt-cli/oxfmt-cli.test.ts
+++ b/test/cli/format/oxfmt-cli/oxfmt-cli.test.ts
@@ -3,7 +3,7 @@
// `cases.json` is written by `test/cli/lint/oracle/driver/oxfmt-fixtures.mjs --record`.
import { afterAll, describe, expect, test } from "bun:test";
import { bunEnv, bunExe, isWindows, tempDir } from "harness";
-import { existsSync, readFileSync, symlinkSync } from "node:fs";
+import { readFileSync, symlinkSync } from "node:fs";
import { join } from "node:path";
import { endChildren, spawn } from "../../children";
import { cases, fixtures } from "./cases.json";
@@ -11,17 +11,17 @@ import { cases, fixtures } from "./cases.json";
afterAll(endChildren);
type Files = Record;
-// A fixture has `experimentalTailwindcss`, which has no effect here. That `bun format` says so is tested elsewhere.
-const command = [bunExe(), "format", "--allow-unsupported"];
+// A fixture has `experimentalTailwindcss`, which has no effect here. That `bun fmt` says so is tested elsewhere.
+const command = [bunExe(), "fmt", "--allow-unsupported"];
const env = { NO_COLOR: "1", AGENT: "0", CLAUDECODE: undefined };
-describe.concurrent("bun format does what oxfmt does", () => {
+describe.concurrent("bun fmt does what oxfmt does", () => {
for (const it of cases) {
const files = { ...(fixtures as Record)[it.name], ...it.gitignore } as Files;
const links = Object.entries(files).filter(([, file]) => typeof file !== "string") as [string, { link: string }][];
test.skipIf(isWindows && links.length > 0)(`${it.name}/${it.index}: ${it.args.join(" ")}`, async () => {
const texts = Object.entries(files).filter(([, file]) => typeof file === "string") as [string, string][];
- // Without a configuration file `bun format` is like Prettier. An empty one above the fixtures makes it like oxfmt.
+ // Without a configuration file `bun fmt` is like Prettier. An empty one above the fixtures makes it like oxfmt.
using dir = tempDir("oxfmt-cli", {
".oxfmtrc.json": "{}\n",
...Object.fromEntries(texts.map(([name, text]) => [`fixtures/${name}`, text])),
@@ -37,10 +37,8 @@ describe.concurrent("bun format does what oxfmt does", () => {
stderr: "pipe",
});
const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
- // Also what `--init` makes.
- const made = Object.keys(it.changed).filter(name => !(name in files) && existsSync(join(root, name)));
- const changed = [...texts, ...made.map(name => [name, undefined])].flatMap(([name, text]) => {
- const after = readFileSync(join(root, name as string), "utf8");
+ const changed = texts.flatMap(([name, text]) => {
+ const after = readFileSync(join(root, name), "utf8");
return after === text ? [] : [[name, after]];
});
const named = (stdout + stderr)
diff --git a/test/cli/format/oxfmt/README.md b/test/cli/format/oxfmt/README.md
index c31262112df8..67d1abcf052a 100644
--- a/test/cli/format/oxfmt/README.md
+++ b/test/cli/format/oxfmt/README.md
@@ -10,7 +10,7 @@ which Prettier. oxc is under the MIT license: `LICENSE`.
Every input is formatted with each set of options of the nearest `options.json`, at `printWidth` 80 and 100, as oxc's test harness does.
-- `.prettier.snap` is what `bun format` has to print. `oxfmt-ignore` says nothing to Prettier, and nothing to `bun format` in its flavor.
+- `.prettier.snap` is what `bun fmt` has to print. `oxfmt-ignore` says nothing to Prettier, and nothing to `bun fmt` in its flavor.
- `.snap` is what it has to print for whoever has an `.oxfmtrc.json` (`flavor: oxfmt`).
```sh
diff --git a/test/cli/format/prettier-cli/prettier-cli.test.ts b/test/cli/format/prettier-cli/prettier-cli.test.ts
index 8fd061347818..7247a9c80e7b 100644
--- a/test/cli/format/prettier-cli/prettier-cli.test.ts
+++ b/test/cli/format/prettier-cli/prettier-cli.test.ts
@@ -1,6 +1,6 @@
// The command lines of Prettier's own integration tests (`runCli("cli/..", [..])` in `tests/integration/__tests__/*.js` of
// prettier/prettier, MIT: see LICENSE), with what Prettier 3.9 does in each: the exit code, the files afterwards, the files that
-// `--check` and `--list-different` name, and what is printed for standard input. `bun format` writes unless told otherwise, so
+// `--check` and `--list-different` name, and what is printed for standard input. `bun fmt` writes unless told otherwise, so
// Prettier was given `--write` where the command line only prints.
// `cases.json` is written by `test/cli/lint/oracle/driver/prettier-fixtures.mjs --record`.
import { afterAll, describe, expect, test } from "bun:test";
@@ -13,12 +13,12 @@ import { cases, fixtures } from "./cases.json";
afterAll(endChildren);
type Files = Record;
-const command = [bunExe(), "format"];
-// The languages that `bun format` leaves alone.
+const command = [bunExe(), "fmt"];
+// The languages that `bun fmt` leaves alone.
const notCompared = /\.mdx$/;
const env = { ...bunEnv, NO_COLOR: "1", AGENT: "0", CLAUDECODE: undefined };
-describe.concurrent("bun format does what Prettier does", () => {
+describe.concurrent("bun fmt does what Prettier does", () => {
for (const it of cases) {
const top = it.directory.split("/").slice(0, 2).join("/");
const files = (fixtures as Record)[top];
diff --git a/test/cli/format/prettier/README.md b/test/cli/format/prettier/README.md
index 519cbc3b793b..447fe4d68208 100644
--- a/test/cli/format/prettier/README.md
+++ b/test/cli/format/prettier/README.md
@@ -1,6 +1,6 @@
# Prettier's tests
-`bun format` prints what [Prettier](https://github.com/prettier/prettier) prints. `bundle.zst` holds `tests/format/{js,jsx,typescript,flow,json,css,less,scss,graphql,yaml,markdown,mdx,handlebars,html,vue,angular,lwc,mjml,misc}` of Prettier: all 19 directories, unchanged: the inputs, and the snapshots
+`bun fmt` prints what [Prettier](https://github.com/prettier/prettier) prints. `bundle.zst` holds `tests/format/{js,jsx,typescript,flow,json,css,less,scss,graphql,yaml,markdown,mdx,handlebars,html,vue,angular,lwc,mjml,misc}` of Prettier: all 19 directories, unchanged: the inputs, and the snapshots
(`__snapshots__/format.test.js.snap`), which also say with which options each input is formatted. One file after the other, compressed with zstd: see `../bundle.ts`. `sync.ts` writes it, and `version.json` says from which
commit. Prettier is under the MIT license: `LICENSE`.
diff --git a/test/cli/format/sort-imports.test.ts b/test/cli/format/sort-imports.test.ts
new file mode 100644
index 000000000000..2e57c1a7b64f
--- /dev/null
+++ b/test/cli/format/sort-imports.test.ts
@@ -0,0 +1,799 @@
+// Tests for `sortImports` in bunfig.toml's `[fmt]` and for `--sort-imports`. On top of oxfmt's `sortImports`, they sort the
+// names inside braces and merge imports from the same module. Neither has an option.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+async function run(cwd: string, args: string[]) {
+ await using proc = spawn({
+ cmd: [bunExe(), "fmt", "--log-level=warn", ...args],
+ env: bunEnv,
+ cwd,
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+/** Formats `files` twice. `--debug-check` comes first, which fails if sorting changes what a file imports. */
+async function format(files: Record, args: string[] = []) {
+ using dir = tempDir("bun-format-sort-imports", files);
+ const checked = await run(String(dir), [...args, "--debug-check", "."]);
+ const written = await run(String(dir), [...args, "."]);
+ const first = checked.exitCode === 0 ? written : checked;
+ const read = () =>
+ Object.fromEntries(Object.keys(files).map(name => [name, readFileSync(join(String(dir), name), "utf8")]));
+ const after = read();
+ const second = await run(String(dir), [...args, "."]);
+ return { ...first, files: after, second: { ...second, files: read() } };
+}
+
+const bunfig = { "bunfig.toml": "[fmt]\nsortImports = true\n" };
+
+const cases: [name: string, input: string, output: string][] = [
+ [
+ "sorts names case-insensitively, with numbers in natural order, ignoring inline `type`",
+ `import { b, a, C, a10, a2, type T, type d, _e, $f } from "x";
+`,
+ `import { $f, _e, a, a2, a10, b, C, type d, type T } from "x";
+`,
+ ],
+ [
+ "sorts `a as z` by the imported name",
+ `import { z as a, b as y, a as z, default as d, c } from "x";
+`,
+ `import { a as z, b as y, c, default as d, z as a } from "x";
+`,
+ ],
+ [
+ "sorts string names by their contents",
+ `import { "b-c" as c, "a-b" as b, a } from "x";
+`,
+ `import { a, "a-b" as b, "b-c" as c } from "x";
+`,
+ ],
+ [
+ "sorts names in `import type`",
+ `import type { B, a } from "x";
+`,
+ `import type { a, B } from "x";
+`,
+ ],
+ [
+ "merges two imports from the same module",
+ `import { b } from "x";
+import { a } from "x";
+`,
+ `import { a, b } from "x";
+`,
+ ],
+ [
+ "merges three imports with another module between them",
+ `import { c } from "x";
+import { y } from "y";
+import { a } from "x";
+import { b } from "x";
+`,
+ `import { a, b, c } from "x";
+import { y } from "y";
+`,
+ ],
+ [
+ "treats 'x' and \"x\" as the same module",
+ `import { b } from 'x';
+import { a } from "x";
+`,
+ `import { a, b } from "x";
+`,
+ ],
+ [
+ "merges a default import with named imports",
+ `import x from "x";
+import { a } from "x";
+`,
+ `import x, { a } from "x";
+`,
+ ],
+ [
+ "merges named imports with a later default import",
+ `import { a } from "x";
+import x from "x";
+`,
+ `import x, { a } from "x";
+`,
+ ],
+ [
+ "merges names into an import that has a default and names",
+ `import x, { b } from "x";
+import { a } from "x";
+`,
+ `import x, { a, b } from "x";
+`,
+ ],
+ [
+ "keeps two different default imports separate",
+ `import x from "x";
+import y from "x";
+import { a } from "x";
+`,
+ `import x, { a } from "x";
+import y from "x";
+`,
+ ],
+ [
+ "doesn't merge a default import with a namespace import",
+ `import x from "x";
+import * as y from "x";
+`,
+ `import x from "x";
+import * as y from "x";
+`,
+ ],
+ [
+ "doesn't merge a namespace import with named imports",
+ `import * as y from "x";
+import { b, a } from "x";
+import { c } from "x";
+`,
+ `import * as y from "x";
+import { a, b, c } from "x";
+`,
+ ],
+ [
+ "doesn't merge names into `import x, * as y`",
+ `import x, * as y from "x";
+import { a } from "x";
+`,
+ `import x, * as y from "x";
+import { a } from "x";
+`,
+ ],
+ [
+ "keeps `import type` separate from value imports",
+ `import type { B } from "x";
+import { a } from "x";
+import type { A } from "x";
+import { b } from "x";
+`,
+ `import type { A, B } from "x";
+import { a, b } from "x";
+`,
+ ],
+ [
+ "merges `{ type B }` with value imports",
+ `import { type B } from "x";
+import { a } from "x";
+`,
+ `import { a, type B } from "x";
+`,
+ ],
+ [
+ "doesn't merge `import type X` with `import type { A }`",
+ `import type X from "x";
+import type { A } from "x";
+`,
+ `import type X from "x";
+import type { A } from "x";
+`,
+ ],
+ [
+ "drops duplicate names",
+ `import { a, b, a } from "x";
+import { b } from "x";
+`,
+ `import { a, b } from "x";
+`,
+ ],
+ [
+ "keeps the same name under different aliases",
+ `import { a as c } from "x";
+import { a as b, a } from "x";
+`,
+ `import { a, a as b, a as c } from "x";
+`,
+ ],
+ [
+ "merges imports with equal import attributes",
+ `import { b } from "x" with { type: "json" };
+import { a } from "x" with { "type": 'json' };
+`,
+ `import { a, b } from "x" with { type: "json" };
+`,
+ ],
+ [
+ "doesn't merge imports with different import attributes",
+ `import b from "x" with { type: "json" };
+import { a } from "x";
+import { c } from "x" with { type: "css" };
+`,
+ `import b from "x" with { type: "json" };
+import { a } from "x";
+import { c } from "x" with { type: "css" };
+`,
+ ],
+ [
+ "never moves or merges anything across a side-effect import",
+ `import { z } from "z";
+import { b } from "x";
+import "./setup";
+import { a } from "x";
+import { c } from "a";
+import "./more";
+import "./again";
+import { d } from "a";
+`,
+ `import { b } from "x";
+import { z } from "z";
+import "./setup";
+import { c } from "a";
+import { a } from "x";
+import "./more";
+import "./again";
+import { d } from "a";
+`,
+ ],
+ [
+ "never merges side-effect imports",
+ `import "x";
+import "x";
+import { a } from "x";
+`,
+ `import "x";
+import "x";
+import { a } from "x";
+`,
+ ],
+ [
+ "merges other imports into the one that has a comment above it",
+ `import { c } from "x";
+// about b
+import { b } from "x";
+import { a } from "x";
+`,
+ `// about b
+import { a, b, c } from "x";
+`,
+ ],
+ [
+ "doesn't merge two imports that both have a comment above them",
+ `// about b
+import { b } from "x";
+// about a
+import { a } from "x";
+`,
+ `// about b
+import { b } from "x";
+// about a
+import { a } from "x";
+`,
+ ],
+ [
+ "merges other imports into the one that has a trailing comment",
+ `import { b } from "x"; // about b
+import { a } from "x";
+`,
+ `import { a, b } from "x"; // about b
+`,
+ ],
+ [
+ "ignores a comment separated from the import by a blank line",
+ `import { b } from "x";
+
+// about nothing
+
+import { a } from "x";
+`,
+ `import { a, b } from "x";
+
+// about nothing
+`,
+ ],
+ [
+ "moves comments inside the braces with their names",
+ `import {
+ // before c
+ c,
+ b, // behind b
+ /* before a */ a,
+} from "x";
+`,
+ `import {
+ /* before a */ a,
+ b, // behind b
+ // before c
+ c,
+} from "x";
+`,
+ ],
+ [
+ "moves comments inside the braces with their names across a merge",
+ `import { d, c /* behind c */ } from "x";
+import {
+ b, // behind b
+ // before a
+ a,
+} from "x";
+`,
+ `import {
+ // before a
+ a,
+ b, // behind b
+ c /* behind c */,
+ d,
+} from "x";
+`,
+ ],
+ [
+ "keeps a line comment after the last name from swallowing the brace",
+ `import { b, // behind b
+ a // behind a
+} from "x";
+`,
+ `import {
+ a, // behind a
+ b, // behind b
+} from "x";
+`,
+ ],
+ [
+ "keeps a comment before the closing brace at the end after a merge",
+ `import {
+ b,
+ a,
+ // the end
+} from "x";
+import { c } from "x";
+`,
+ `import {
+ a,
+ b,
+ c,
+ // the end
+} from "x";
+`,
+ ],
+ [
+ "moves comments right outside the braces with the first and last name",
+ `import /* why */ { b, a } from "x";
+import { c } from "x";
+import { e, d } /* why */ from "y";
+import { f } from "y";
+`,
+ `import { a, /* why */ b, c } from "x";
+import { d /* why */, e, f } from "y";
+`,
+ ],
+ [
+ "wraps a merged import that no longer fits on one line",
+ `import { someRatherLongName, anotherRatherLongName } from "some-module";
+import { yetAnotherRatherLongName, theLastName } from "some-module";
+`,
+ `import {
+ anotherRatherLongName,
+ someRatherLongName,
+ theLastName,
+ yetAnotherRatherLongName,
+} from "some-module";
+`,
+ ],
+ [
+ "leaves `export .. from` alone",
+ `export { b, a } from "x";
+export { c } from "x";
+import { e, d } from "x";
+`,
+ `export { b, a } from "x";
+export { c } from "x";
+import { d, e } from "x";
+`,
+ ],
+ [
+ "leaves a prettier-ignore'd import alone and doesn't merge across it",
+ `import { b } from "x";
+// prettier-ignore
+import { d, c } from "x";
+import { a } from "x";
+`,
+ `import { b } from "x";
+// prettier-ignore
+import { d, c } from "x";
+import { a } from "x";
+`,
+ ],
+ [
+ "doesn't merge across other statements",
+ `import { b } from "x";
+f();
+import { a } from "x";
+`,
+ `import { b } from "x";
+f();
+import { a } from "x";
+`,
+ ],
+ [
+ "leaves `import {}` alone and treats `import x, {}` as `import x`",
+ `import {} from "x";
+import { a } from "x";
+import x, {} from "y";
+import { b } from "y";
+`,
+ `import {} from "x";
+import { a } from "x";
+import x, { b } from "y";
+`,
+ ],
+ [
+ "merges imports that share a line",
+ `import { b } from "x"; import { a } from "x"; import y from "y";
+`,
+ `import { a, b } from "x";
+import y from "y";
+`,
+ ],
+ [
+ "works after a directive and a top-of-file comment",
+ `// @ts-check
+"use client";
+import { b } from "x";
+import { a } from "x";
+`,
+ `// @ts-check
+"use client";
+import { a, b } from "x";
+`,
+ ],
+ [
+ "handles CRLF line endings",
+ `import { b } from "x";\r
+import {\r
+ d, // d\r
+ a,\r
+} from "x";\r
+`,
+ `import {
+ a,
+ b,
+ d, // d
+} from "x";
+`,
+ ],
+ [
+ "groups, sorts names and merges in one pass",
+ `import { z } from "./z";
+import fs, { readFileSync } from "node:fs";
+import { b } from "pkg";
+import { existsSync } from "node:fs";
+import type { T } from "pkg";
+import { a } from "pkg";
+import { y } from "./z";
+`,
+ `import fs, { existsSync, readFileSync } from "node:fs";
+
+import { a, b } from "pkg";
+import type { T } from "pkg";
+
+import { y, z } from "./z";
+`,
+ ],
+ [
+ "moves comments right outside the braces across a merge",
+ `import { c } from "x";
+import /* first */ { b, a } /* last */ from "x";
+`,
+ `import { a /* last */, /* first */ b, c } from "x";
+`,
+ ],
+ [
+ "merges two imports that both have a comment before the brace",
+ `import /* one */ { d, c } from "x";
+import /* two */ { b, a } from "x";
+`,
+ `import { a, /* two */ b, c, /* one */ d } from "x";
+`,
+ ],
+ [
+ "keeps a comment next to a default import in place",
+ `import x /* why */ from "x";
+import { a } from "x";
+import /* why */ y from "y";
+import { b } from "y";
+`,
+ `import x /* why */, { a } from "x";
+import /* why */ y, { b } from "y";
+`,
+ ],
+ [
+ "keeps a comment next to the module specifier in place",
+ `import { b } from /* why */ "x";
+import { a } from "x";
+`,
+ `import { a, b } from /* why */ "x";
+`,
+ ],
+ [
+ "moves a line comment before the brace with the first name",
+ `import // why
+{ b, a } from "x";
+import { c } from "x";
+`,
+ `import {
+ a,
+ // why
+ b,
+ c,
+} from "x";
+`,
+ ],
+ [
+ "keeps a comment before the closing brace",
+ `import {
+ b,
+ a,
+ // keep
+} from "x";
+`,
+ `import {
+ a,
+ b,
+ // keep
+} from "x";
+`,
+ ],
+ [
+ "moves a trailing line comment with its name",
+ `import {
+ b, // about b
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ b, // about b
+} from "x";
+`,
+ ],
+ [
+ "moves a block comment after a name with that name",
+ `import { c /* about c */, b, a } from "x";
+`,
+ `import { a, b, c /* about c */ } from "x";
+`,
+ ],
+ [
+ "moves a comment on its own line with the name below it",
+ `import {
+ c,
+ // about b
+ b,
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ // about b
+ b,
+ c,
+} from "x";
+`,
+ ],
+ [
+ "moves a comment before the first name with that name",
+ `import {
+ // about b
+ b,
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ // about b
+ b,
+} from "x";
+`,
+ ],
+ [
+ "keeps a comment before the closing brace when another import merges in",
+ `import {
+ b,
+ a,
+ // keep
+} from "x";
+import { c } from "x";
+`,
+ `import {
+ a,
+ b,
+ c,
+ // keep
+} from "x";
+`,
+ ],
+ [
+ "keeps a comment before the closing brace of an import that gets merged away",
+ `import { c } from "x";
+import {
+ b,
+ a,
+ // keep
+} from "x";
+`,
+ `import {
+ a,
+ b,
+ c,
+ // keep
+} from "x";
+`,
+ ],
+ [
+ "moves a trailing line comment with its name across a merge",
+ `import { c } from "x";
+import {
+ b, // about b
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ b, // about b
+ c,
+} from "x";
+`,
+ ],
+ [
+ "moves a block comment after a name with that name across a merge",
+ `import { d } from "x";
+import { c /* about c */, b, a } from "x";
+`,
+ `import { a, b, c /* about c */, d } from "x";
+`,
+ ],
+ [
+ "moves a comment on its own line with the name below it across a merge",
+ `import { d } from "x";
+import {
+ c,
+ // about b
+ b,
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ // about b
+ b,
+ c,
+ d,
+} from "x";
+`,
+ ],
+ [
+ "moves a comment before the first name with that name across a merge",
+ `import { c } from "x";
+import {
+ // about b
+ b,
+ a,
+} from "x";
+`,
+ `import {
+ a,
+ // about b
+ b,
+ c,
+} from "x";
+`,
+ ],
+ [
+ "keeps comments from both imports when they merge",
+ `import {
+ // about d
+ d,
+ c, // about c
+} from "x";
+import {
+ b /* about b */,
+ // about a
+ a,
+} from "x";
+`,
+ `import {
+ // about a
+ a,
+ b /* about b */,
+ c, // about c
+ // about d
+ d,
+} from "x";
+`,
+ ],
+];
+
+describe("sortImports", () => {
+ // All cases share one run.
+ const name = (index: number) => `${index}.ts`;
+ const done = format({ ...bunfig, ...Object.fromEntries(cases.map((it, index) => [name(index), it[1]])) });
+
+ test("formats every case without errors", async () => {
+ const { stderr, exitCode, second } = await done;
+ expect(stderr).toBe("");
+ expect(exitCode).toBe(0);
+ expect(second.stderr).toBe("");
+ expect(second.exitCode).toBe(0);
+ });
+
+ test.each(cases.map((it, index) => [it[0], index] as const))("%s", async (_, index) => {
+ const { files, second } = await done;
+ expect(files[name(index)]).toBe(cases[index][2]);
+ // No comment gets lost or duplicated.
+ const comments = (code: string) => (code.match(/\/\/.*|\/\*.*?\*\//g) ?? []).sort();
+ expect(comments(files[name(index)])).toEqual(comments(cases[index][1]));
+ // A second run changes nothing.
+ expect(second.files[name(index)]).toBe(cases[index][2]);
+ });
+});
+
+describe.concurrent("sortImports sources", () => {
+ const input = `import { c } from "x";\nimport "./setup";\nimport { b, a } from "x";\nimport { d } from "a";\n`;
+ const tidy = `import { c } from "x";\nimport "./setup";\nimport { d } from "a";\nimport { a, b } from "x";\n`;
+ // oxfmt doesn't sort names or merge, and it keeps a side-effect import at its index while others move around it.
+ const asOxfmt = `import { d } from "a";\n\nimport "./setup";\nimport { c } from "x";\nimport { b, a } from "x";\n`;
+
+ test("the key, the table and the flag all sort names and merge", async () => {
+ const [key, table, flag] = await Promise.all([
+ format({ ...bunfig, "a.ts": input }),
+ format({ "bunfig.toml": "[fmt.sortImports]\nnewlinesBetween = false\n", "a.ts": input }),
+ format({ "a.ts": input }, ["--sort-imports"]),
+ ]);
+ expect([key.files["a.ts"], table.files["a.ts"], flag.files["a.ts"]]).toEqual([tidy, tidy, tidy]);
+ });
+
+ test("sortImports in .oxfmtrc.json keeps oxfmt's behavior unless --sort-imports is passed", async () => {
+ const files = { ".oxfmtrc.json": `{ "sortImports": true }`, "a.ts": input };
+ const [oxfmt, flag] = await Promise.all([format(files), format(files, ["--sort-imports"])]);
+ expect(oxfmt.files["a.ts"]).toBe(asOxfmt);
+ expect(flag.files["a.ts"]).toBe(tidy);
+ });
+
+ test("sortSideEffects = true lets side-effect imports move", async () => {
+ const result = await format({ "bunfig.toml": "[fmt.sortImports]\nsortSideEffects = true\n", "a.ts": input });
+ expect(result.files["a.ts"]).toBe(
+ `import { d } from "a";\nimport { c } from "x";\nimport { a, b } from "x";\n\nimport "./setup";\n`,
+ );
+ });
+
+ test("works in JavaScript, JSX and Vue scripts", async () => {
+ const code = `import { b } from "x";\nimport { a } from "x";\n`;
+ const merged = `import { a, b } from "x";\n`;
+ const result = await format({
+ ...bunfig,
+ "a.js": code,
+ "a.mjs": code,
+ "a.jsx": code,
+ "a.vue": `\n`,
+ "b.vue": `\n`,
+ });
+ expect(result.stderr).toBe("");
+ expect(result.files).toMatchObject({
+ "a.js": merged,
+ "a.mjs": merged,
+ "a.jsx": merged,
+ "a.vue": `\n`,
+ "b.vue": `\n`,
+ });
+ expect(result.second.files).toEqual(result.files);
+ });
+
+ test("skips a file with a syntax error", async () => {
+ const code = `import { b, a } from "x";\nimport { from "x";\n`;
+ const result = await format({ ...bunfig, "a.ts": code });
+ expect(result.files["a.ts"]).toBe(code);
+ expect(result.exitCode).toBe(2);
+ });
+});
diff --git a/test/cli/format/sort-imports/LICENSE b/test/cli/format/sort-imports/LICENSE
new file mode 100644
index 000000000000..261eeb9e9f8b
--- /dev/null
+++ b/test/cli/format/sort-imports/LICENSE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
diff --git a/test/cli/format/sort-imports/sort-imports.test.ts b/test/cli/format/sort-imports/sort-imports.test.ts
index 07110108afac..b4ccc0f12f84 100644
--- a/test/cli/format/sort-imports/sort-imports.test.ts
+++ b/test/cli/format/sort-imports/sort-imports.test.ts
@@ -26,7 +26,7 @@ const tools = {
async function format(files: Record, names: string[], flags: string[] = []) {
using dir = tempDir("bun-format-sort-imports", files);
await using proc = spawn({
- cmd: [bunExe(), "format", "--log-level=warn", ...flags, "."],
+ cmd: [bunExe(), "fmt", "--log-level=warn", ...flags, "."],
env: bunEnv,
cwd: String(dir),
stdout: "pipe",
diff --git a/test/cli/format/tailwind/cases.json b/test/cli/format/tailwind/cases.json
index d973b4ee4f30..5dad5f4f8371 100644
--- a/test/cli/format/tailwind/cases.json
+++ b/test/cli/format/tailwind/cases.json
@@ -1025,8 +1025,8 @@
"options": {
"sortTailwindcss": {}
},
- "input": "\n\n\n\n\n\n, string[]?]>([
+ ["its name", config({})],
+ ["a path", { ".prettierrc": `{ "plugins": ["./node_modules/${plugin}/index.mjs"] }` }],
+ ["require.resolve()", { "prettier.config.cjs": `module.exports = { plugins: [require.resolve("${plugin}")] };` }],
+ [
+ "import.meta.resolve()",
+ { "prettier.config.mjs": `export default { plugins: [import.meta.resolve("${plugin}")] };` },
+ ],
+ ["a URL", { "prettier.config.mjs": `export default { plugins: [new URL(import.meta.resolve("${plugin}"))] };` }],
+ ["the module", { "prettier.config.mjs": `import * as it from "${plugin}";\nexport default { plugins: [it] };` }],
+ ["import()", { "prettier.config.mjs": `export default { plugins: [await import("${plugin}")] };` }],
+ ["require()", { "prettier.config.cjs": `module.exports = { plugins: [require("${plugin}")] };` }],
+ [
+ "an override",
+ { ".prettierrc": `{ "overrides": [{ "files": "*.jsx", "options": { "plugins": ["${plugin}"] } }] }` },
+ ],
+ ["--plugin", {}, ["--plugin", plugin]],
+ ["--plugin beside a config", { ".prettierrc": "{}" }, [`--plugin=${plugin}`]],
+ ["package.json", { "package.json": `{ "prettier": { "plugins": ["${plugin}"] } }` }],
+ ["YAML", { ".prettierrc.yaml": `plugins:\n - ${plugin}\n` }],
+ ["TOML", { ".prettierrc.toml": `plugins = ["${plugin}"]\n` }],
+ [
+ "a shared config",
+ { "package.json": '{ "prettier": "@acme/config" }', ...shared("a.json", `{ "plugins": ["${plugin}"] }`) },
+ ],
+ [
+ "a shared config in JavaScript",
+ {
+ ".prettierrc": '"@acme/config"',
+ ...shared("a.js", `module.exports = { plugins: [require.resolve("${plugin}")] };`),
+ },
+ ],
+ ])("is named by %s", async (_, files, flags = []) => {
+ const result = await format({ ...project, ...files, "a.jsx": input }, ["a.jsx"], flags);
+ expect(result).toMatchObject({ stderr: "", files: [sorted], exitCode: 0 });
+ });
+
+ test("counts for the files whose list of plugins has it", async () => {
+ const overrides = [
+ { files: "off/**", options: { plugins: [] } },
+ { files: "*.tsx", options: { tailwindPreserveDuplicates: true } },
+ ];
+ const twice = ';\n';
+ const files = { ...config({ overrides }), "a.jsx": input, "off/a.jsx": input, "a.tsx": twice, "b.jsx": twice };
+ const result = await format({ ...project, ...files }, ["a.jsx", "off/a.jsx", "a.tsx", "b.jsx"]);
+ expect(result).toMatchObject({
+ stderr: "",
+ files: [sorted, input, ';\n', ';\n'],
+ exitCode: 0,
+ });
+ });
+
+ test.each<[object, string, string]>([
+ // No function takes classes unless the config says so.
+ [{}, 'cn("p-4 flex");\nclsx("p-4 flex");\ntwMerge("p-4 flex");\ntw`p-4 flex`;\n', ""],
+ [
+ { tailwindFunctions: ["cn"] },
+ 'cn("p-4 flex");\nclsx("p-4 flex");\ncn`p-4 flex`;\n',
+ 'cn("flex p-4");\nclsx("p-4 flex");\ncn`flex p-4`;\n',
+ ],
+ [
+ { tailwindFunctions: ["cn"], overrides: [{ files: "*.jsx", options: { tailwindFunctions: ["tw"] } }] },
+ 'cn("p-4 flex");\ntw("p-4 flex");\n',
+ 'cn("p-4 flex");\ntw("flex p-4");\n',
+ ],
+ [
+ { tailwindAttributes: ["mine"] },
+ ';\n',
+ ';\n',
+ ],
+ [{}, ';\n', ';\n'],
+ [
+ { tailwindPreserveWhitespace: true },
+ ';\n',
+ ';\n',
+ ],
+ [{ tailwindPreserveDuplicates: true }, ';\n', ';\n'],
+ ])("has its options and its defaults: %j", async (options, before, after) => {
+ const result = await format({ ...project, ...config(options), "a.jsx": before }, ["a.jsx"]);
+ expect(result).toMatchObject({ stderr: "", files: [after || before], exitCode: 0 });
+ });
+
+ // The plugin says the same, behind the directory of the config and without the `[warn]`.
+ const deprecated = (name: string) =>
+ `[warn] Deprecated: Use the \`tailwindStylesheet\` option for v4 projects instead of \`${name}\`.\n`;
+ const both =
+ "[warn] You have specified a Tailwind CSS stylesheet and a Tailwind CSS config at the same time. Use stylesheetPath unless you are using v3. Preferring the stylesheet.\n";
+ test.each<[object, string]>([
+ [{ tailwindStylesheet: "./css/app.css" }, ""],
+ [{ tailwindStylesheet: "css/app.css" }, ""],
+ [{ tailwindEntryPoint: "./css/app.css" }, deprecated("tailwindEntryPoint")],
+ [{ tailwindConfig: "./css/app.css" }, deprecated("tailwindConfig")],
+ [{ tailwindStylesheet: "./css/app.css", tailwindEntryPoint: "./none.css", tailwindConfig: "./none.js" }, both],
+ [{ overrides: [{ files: "src/**", options: { tailwindStylesheet: "./css/app.css" } }] }, ""],
+ ])("a path is relative to the config: %j", async (options, stderr) => {
+ const files = { ...config(options), "css/app.css": "/* reversed */\n", "src/a.jsx": sorted };
+ using dir = tempDir("bun-format-tailwind", { ...project, ...files });
+ const result = await formatIn(join(String(dir), "src"), ["a.jsx"], ["a.jsx"]);
+ expect(result).toMatchObject({ stderr, files: [reversed], exitCode: 0 });
+ });
+
+ test.each(["tailwindStylesheet", "tailwindEntryPoint", "tailwindConfig"])("an empty %s is none", async name => {
+ const result = await format({ ...project, ...config({ [name]: "" }), "a.jsx": input }, ["a.jsx"]);
+ expect(result).toMatchObject({ stderr: "", files: [sorted], exitCode: 0 });
+ });
+
+ test("a path is relative to the working directory if the config is the one that --config names", async () => {
+ const files = {
+ "config/.prettierrc": config({ tailwindStylesheet: "./app.css" })[".prettierrc"],
+ "a.jsx": sorted,
+ };
+ const flags = ["--config", "config/.prettierrc"];
+ const beside = await format({ ...project, ...files, "app.css": "/* reversed */\n" }, ["a.jsx"], flags);
+ expect(beside).toMatchObject({ stderr: "", files: [reversed], exitCode: 0 });
+ const elsewhere = await format({ ...project, ...files, "config/app.css": "/* reversed */\n" }, ["a.jsx"], flags);
+ expect(elsewhere).toMatchObject({ files: [sorted], exitCode: 2 });
+ expect(elsewhere.stderr).toContain("app.css");
+ });
+
+ test("tailwindConfig is what Tailwind CSS 3 is loaded with", async () => {
+ const files = { ...version3, ...installed, ...config({ tailwindConfig: "./other.js" }), "src/a.jsx": sorted };
+ const result = await format({ ...files, "other.js": "module.exports = { reversed: true };\n" }, ["src/a.jsx"]);
+ expect(result).toMatchObject({ stderr: "", files: [reversed], exitCode: 0 });
+ });
+
+ test("tailwindPackageName is what Tailwind CSS is called", async () => {
+ const renamed = Object.fromEntries(
+ Object.entries(version4).map(([name, text]) => [name.replace("/tailwindcss/", "/@acme/tw/"), text]),
+ );
+ const files = { ...renamed, ...installed, ...config({ tailwindPackageName: "@acme/tw" }), "a.jsx": input };
+ expect(await format(files, ["a.jsx"])).toMatchObject({ stderr: "", files: [sorted], exitCode: 0 });
+ });
+
+ test.each([
+ [
+ { tailwindFunctions: "cn" },
+ 'Invalid tailwindFunctions value. Expected an array of a string, but received "cn".',
+ ],
+ [
+ { tailwindAttributes: [1] },
+ "Invalid tailwindAttributes value. Expected an array of a string, but received [1].",
+ ],
+ [
+ { tailwindPreserveWhitespace: "yes" },
+ 'Invalid tailwindPreserveWhitespace value. Expected true or false, but received "yes".',
+ ],
+ [{ tailwindStylesheet: 1 }, "Invalid tailwindStylesheet value. Expected a string, but received 1."],
+ [{ tailwindStylesheet: null }, "Invalid tailwindStylesheet value. Expected a string, but received null."],
+ [{ tailwindConfig: null }, "Invalid tailwindConfig value. Expected a string, but received null."],
+ [{ tailwindEntryPoint: null }, "Invalid tailwindEntryPoint value. Expected a string, but received null."],
+ [{ tailwindPackageName: null }, "Invalid tailwindPackageName value. Expected a string, but received null."],
+ [
+ { tailwindFunctions: null },
+ "Invalid tailwindFunctions value. Expected an array of a string, but received null.",
+ ],
+ [
+ { tailwindAttributes: null },
+ "Invalid tailwindAttributes value. Expected an array of a string, but received null.",
+ ],
+ [
+ { tailwindPreserveWhitespace: null },
+ "Invalid tailwindPreserveWhitespace value. Expected true or false, but received null.",
+ ],
+ [
+ { tailwindPreserveDuplicates: null },
+ "Invalid tailwindPreserveDuplicates value. Expected true or false, but received null.",
+ ],
+ ])("a value of the wrong type is refused: %j", async (options, refusal) => {
+ const result = await format({ ...project, ...config(options), "a.jsx": input }, ["a.jsx"]);
+ expect(result.stderr).toBe(`[error] ${refusal}\n`);
+ expect(result.files).toEqual([input]);
+ expect(result.exitCode).not.toBe(0);
+ });
+
+ test("without it its options are unknown, and with it an option that it does not have is", async () => {
+ const options = { tailwindFunctions: ["cn"], tailwindConfig: "./x.js", tailwindPreserveWhitespace: true };
+ const without = await format({ ...project, ".prettierrc": JSON.stringify(options), "a.jsx": input }, ["a.jsx"]);
+ expect(without).toMatchObject({
+ stderr:
+ '[warn] Ignored unknown option { tailwindFunctions: ["cn"] }.\n' +
+ '[warn] Ignored unknown option { tailwindConfig: "./x.js" }.\n' +
+ "[warn] Ignored unknown option { tailwindPreserveWhitespace: true }.\n",
+ files: [input],
+ exitCode: 0,
+ });
+ const unknown = await format({ ...project, ...config({ tailwindOther: 1 }), "a.jsx": input }, ["a.jsx"]);
+ expect(unknown).toMatchObject({
+ stderr: "[warn] Ignored unknown option { tailwindOther: 1 }.\n",
+ files: [sorted],
+ exitCode: 0,
+ });
+ });
+
+ test("another plugin beside it is still refused, by its name", async () => {
+ const files = { ".prettierrc": JSON.stringify({ plugins: [plugin, "prettier-plugin-other"] }), "a.jsx": input };
+ const result = await format({ ...project, ...files }, ["a.jsx"], ["--log-level=log", "--check"]);
+ expect(result.stderr).toContain("plugins that bun fmt does not include: prettier-plugin-other\n");
+ // That it has no effect is said in a run that goes on without it.
+ expect(result.stderr).not.toContain("has no effect");
+ // Nothing is said about files that have not been looked at.
+ expect(result.stdout).toBe("Checking formatting...\n");
+ expect(result.files).toEqual([input]);
+ expect(result.exitCode).toBe(2);
+ });
+
+ const names = { tailwindFunctions: ["cn", "/^tw/"], tailwindAttributes: ["mine", "/^data-cls/"] };
+
+ test("where classes are is what it says, not oxfmt", async () => {
+ // The lines of a file, before and after.
+ const rows: Record = {
+ "a.jsx": [
+ // However deep in an argument or in the value of an attribute.
+ ['cn(other("p-4 flex"));', 'cn(other("flex p-4"));'],
+ [';', ';'],
+ ['cn(a === "p-4 flex" && "flex m-2");', 'cn(a === "flex p-4" && "m-2 flex");'],
+ ['cn();', 'cn();'],
+ ["cn(other`p-4 flex`);", "cn(other`flex p-4`);"],
+ [
+ 'cn({ "p-4 flex": a, [`p-1 m-2`]: b, ["p-2 m-3"]: c });',
+ 'cn({ "flex p-4": a, [`m-2 p-1`]: b, ["m-3 p-2"]: c });',
+ ],
+ // In chains.
+ ['cn("p-4 flex").b("p-4 flex");', 'cn("flex p-4").b("flex p-4");'],
+ ['cn.a.b.c("p-4 flex").d("p-4 flex").e("p-4 flex");', 'cn.a.b.c("flex p-4").d("flex p-4").e("flex p-4");'],
+ ['x.cn("p-4 flex");', ""],
+ ['new cn("p-4 flex");', ""],
+ // Patterns.
+ ['twx("p-4 flex");', 'twx("flex p-4");'],
+ [
+ ';',
+ ';',
+ ],
+ // To Babel a call in an optional chain is another kind of node.
+ ['cn?.("p-4 flex");', ""],
+ ['cn?.x.y("p-4 flex");', ""],
+ // What is added to stays apart, up to the innermost function.
+ ['cn(a + (b ? " p-4 flex " : c));', 'cn(a + (b ? " flex p-4" : c));'],
+ ['cn("x " + cn(" p-4 flex "));', 'cn("x " + cn("flex p-4"));'],
+ ['"x " + cn` p-4 flex ` + " y";', '"x " + cn` flex p-4 ` + " y";'],
+ // Of the texts of a template it looks at the wrong ends, which leaves more blanks than are needed.
+ ['cn(`x ${" p-4 flex "} y`);', 'cn(`x ${" flex p-4 "} y`);'],
+ ['cn(`${" p-4 flex "}`);', 'cn(`${" flex p-4 "}`);'],
+ ['cn(` ${" p-4 flex "} `);', 'cn(` ${"flex p-4"} `);'],
+ ["cn(`p-4 flex${a}m-2 p-1`);", ""],
+ ["cn(` p-4 flex ${a} p-1 m-2 `);", "cn(`flex p-4 ${a} m-2 p-1`);"],
+ // A list that was on several lines does not keep the element open.
+ ['("p-4 flex" as string);', 'cn("flex p-4" as string);'],
+ // In this tree it does not find the texts of a template.
+ ['cn(`x ${" p-4 flex "} y`);', 'cn(`x ${"flex p-4"} y`);'],
+ ['cn(`${" p-4 flex "}`);', 'cn(`${"flex p-4"}`);'],
+ ['cn(`x${`p-4 flex ${" p-1 m-2 "} p-2 m-3`}y`);', 'cn(`x${`flex p-4 ${"m-2 p-1"} m-3 p-2`}y`);'],
+ ],
+ "a.css": [["a {\n @apply p-4 /* c */ flex;\n}", "a {\n @apply /* c */ flex p-4;\n}"]],
+ "a.html": [[' = {
+ "a.tsx": [
+ [
+ ';',
+ ';',
+ ';',
+ ],
+ [
+ ';',
+ ';',
+ ';',
+ ],
+ ['cn(`x${" p-4 flex "}y`);', 'cn(`x${" flex p-4 "}y`);', 'cn(`x${"flex p-4"}y`);'],
+ ['cn(`${a}${" p-4 flex "}${b}`);', 'cn(`${a}${" flex p-4 "}${b}`);', 'cn(`${a}${"flex p-4"}${b}`);'],
+ ["cn(`x${` p-4 flex `} e`);", "cn(`x${` flex p-4`} e`);", "cn(`x${`flex p-4`} e`);"],
+ ],
+ "a.jsx": [
+ ['cn(`x ${a} b${" p-4 flex "} e`);', 'cn(`x ${a} b${" flex p-4 "} e`);', 'cn(`x ${a} b${"flex p-4 "} e`);'],
+ ['cn(` x${" p-4 flex "} e`);', 'cn(` x${" flex p-4 "} e`);', 'cn(` x${"flex p-4 "} e`);'],
+ ['cn(`x${ " p-4 flex "} e`);', 'cn(`x${" flex p-4 "} e`);', 'cn(`x${"flex p-4 "} e`);'],
+ ],
+ "a.vue": [
+ [
+ "\n \n",
+ "\n \n",
+ "\n \n",
+ ],
+ ],
+ };
+ const text = (at: 0 | 1) => (lines: string[][]) => lines.map(it => it[at]).join("\n") + "\n";
+ for (const lines of Object.values(rows)) for (const it of lines) expect(it[1]).not.toBe(it[2]);
+ const files = Object.fromEntries(Object.entries(rows).map(([name, lines]) => [name, text(0)(lines)]));
+ const result = await format({ ...project, ...config(names), ...files }, Object.keys(rows));
+ expect(result.stderr).toBe("");
+ expect(result.files).toEqual(Object.values(rows).map(text(1)));
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("with @prettier/plugin-oxc before it, it looks at the tree of that, and behind that it does nothing", async () => {
+ const code = 'cn?.("p-4 flex");\ncn(`x ${" p-4 flex "} y`);\n';
+ const sortedCode = 'cn?.("flex p-4");\ncn(`x ${" flex p-4 "} y`);\n';
+ const inVue = (text: string, lang = "") => `\n${text}\n`;
+ const files = { "a.js": code, "a.ts": code, "a.vue": inVue(code), "b.vue": inVue(code, ' lang="ts"') };
+ const run = (plugins: string[]) =>
+ format(
+ { ...project, ".prettierrc": JSON.stringify({ plugins, tailwindFunctions: ["cn"] }), ...files },
+ Object.keys(files),
+ );
+ // It does not read the JavaScript in HTML.
+ const byBabel = inVue('cn?.("p-4 flex");\ncn(`x ${" flex p-4 "} y`);\n');
+ expect(await run(["@prettier/plugin-oxc", plugin])).toMatchObject({
+ stderr: "",
+ files: [sortedCode, sortedCode, byBabel, inVue(sortedCode, ' lang="ts"')],
+ });
+ expect(await run([plugin, "@prettier/plugin-oxc"])).toMatchObject({
+ stderr: "",
+ files: [code, code, byBabel, inVue(code, ' lang="ts"')],
+ });
+ });
+
+ test("in Angular it looks at the texts of a template as they are written", async () => {
+ const before = "\n";
+ const after =
+ "\n";
+ const result = await format({ ...project, ...config({}), "a.component.html": before }, ["a.component.html"]);
+ expect(result).toMatchObject({ stderr: "", files: [after], exitCode: 0 });
+ });
+
+ describe("the Tailwind CSS that it brings along", () => {
+ /** Its `createSorter`, which knows what is in order.json. A file with `reversed` in it turns the order around. */
+ const withSorter = {
+ ...installed,
+ [`node_modules/${plugin}/package.json`]: JSON.stringify({
+ name: plugin,
+ type: "module",
+ exports: { ".": "./index.mjs", "./sorter": "./sorter.mjs" },
+ }),
+ [`node_modules/${plugin}/sorter.mjs`]: `import { readFileSync } from "node:fs";
+const order = ${JSON.stringify(order)};
+export async function createSorter({ configPath, stylesheetPath }) {
+ const files = [configPath, stylesheetPath].filter(Boolean).map(it => readFileSync(it, "utf8"));
+ const sign = files.join().includes("reversed") ? -1 : 1;
+ const at = name => (order.includes(name) ? sign * order.indexOf(name) : -Infinity);
+ const sortClassLists = lists =>
+ lists.map(list => list.toSorted((a, z) => at(a) - at(z)).filter((it, i, all) => !order.includes(it) || all.indexOf(it) === i));
+ return { sortClassLists };
+}
+`,
+ };
+ const flipped = "module.exports = { reversed: true };\n";
+
+ test.each<[string, Record, string]>([
+ ["there is no tailwindcss", config({}), sorted],
+ [
+ "there is no tailwindcss, with the nearest tailwind.config.js",
+ { ...config({}), "tailwind.config.js": flipped },
+ reversed,
+ ],
+ [
+ "there is no tailwindcss, with a style sheet",
+ { ...config({ tailwindStylesheet: "a.css" }), "a.css": "/* reversed */" },
+ reversed,
+ ],
+ [
+ "tailwindConfig is set and version 4 is installed",
+ { ...version4, ...config({ tailwindConfig: "a.js" }), "a.js": flipped },
+ reversed,
+ ],
+ [
+ "tailwindStylesheet is set and version 3 is installed",
+ { ...version3, ...config({ tailwindStylesheet: "a.css" }), "a.css": "/* reversed */" },
+ reversed,
+ ],
+ ])("is asked if %s", async (_, files, expected) => {
+ const before = ';\n';
+ const result = await format({ ...withSorter, ...files, "src/a.jsx": before }, ["src/a.jsx"]);
+ expect(result).toMatchObject({ stderr: "", files: [expected.replace('"', '"x x ')], exitCode: 0 });
+ });
+
+ test.each<[Record, string[]]>([
+ [config({}), ["the tailwindcss package was not found from ", " Run bun add -d tailwindcss"]],
+ [
+ { ...version4, ...config({ tailwindConfig: "a.js" }), "a.js": flipped },
+ [
+ "tailwindConfig is for Tailwind CSS 3, and another version is in ",
+ ` Run bun add -d ${plugin}, which brings its own`,
+ ],
+ ],
+ [
+ { ...version3, ...config({ tailwindStylesheet: "a.css" }), "a.css": "" },
+ [
+ "tailwindStylesheet is for Tailwind CSS 4, and another version is in ",
+ ` Run bun add -d ${plugin}, which brings its own`,
+ ],
+ ],
+ ])("has to be installed for that: %#", async (files, said) => {
+ const result = await format({ ...files, "a.jsx": input }, ["a.jsx"]);
+ for (const line of said)
+ expect(result.stderr).toContain(`[error] ${line.startsWith(" ") ? "" : "sortTailwindcss: "}${line}`);
+ expect(result.files).toEqual([input]);
+ expect(result.exitCode).toBe(2);
+ });
+ });
+
+ // Each stream has what Prettier's has.
+ test("--check says on standard output that an error occurred, and on standard error what it is", async () => {
+ const files = { ...config({}), "tailwind.config.js": 'throw new Error("boom");\n', "a.jsx": input };
+ using dir = tempDir("bun-format-tailwind", { ...version3, ...installed, ...files });
+ const result = await formatIn(String(dir), [], ["--log-level=log", "--check", "a.jsx"]);
+ expect(result.stdout).toBe(
+ "Checking formatting...\nError occurred when checking code style in the above file.\n",
+ );
+ expect(result.stderr.split("\n")).toEqual([
+ `[error] a.jsx: ${unknown} It was not formatted.`,
+ expect.stringMatching(/^\[error\] sortTailwindcss: \S+tailwind\.config\.js: boom$/),
+ "[error] 1 file with classes was not formatted.",
+ "",
+ ]);
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("a flag or [fmt] counts for more", async () => {
+ const files = { ...config({}), "bunfig.toml": '[fmt.sortTailwindcss]\nfunctions = ["mine"]\n' };
+ const result = await format({ ...project, ...files, "a.jsx": 'mine("p-4 flex");\n' }, ["a.jsx"]);
+ expect(result).toMatchObject({ stderr: "", files: ['mine("flex p-4");\n'], exitCode: 0 });
+ });
+ });
});
diff --git a/test/cli/format/toml-layout.test.ts b/test/cli/format/toml-layout.test.ts
new file mode 100644
index 000000000000..2b7144ca81d3
--- /dev/null
+++ b/test/cli/format/toml-layout.test.ts
@@ -0,0 +1,536 @@
+// Tests for Bun's own TOML layout, which applies when there's no oxfmt config. `toml.test.ts` covers TOML under an oxfmt config.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+async function run(cwd: string, args: string[]) {
+ await using proc = spawn({
+ cmd: [bunExe(), "fmt", "--log-level=warn", ...args],
+ env: { ...bunEnv, NO_COLOR: "1" },
+ cwd,
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const cases: [name: string, input: string, output: string][] = [
+ [
+ "keeps a hugged table with a trailing comment as it is",
+ `[lint.rules]
+"prefer-const" = ["warn", {
+ destructuring = "any", # "any" or "all"
+ ignoreReadBeforeAssign = false,
+}]
+`,
+ `[lint.rules]
+"prefer-const" = ["warn", {
+ destructuring = "any", # "any" or "all"
+ ignoreReadBeforeAssign = false,
+}]
+`,
+ ],
+ [
+ "puts one entry per line when an inline table has a comment",
+ `a = ["warn",{destructuring="any", # c
+b=false}]
+`,
+ `a = ["warn", {
+ destructuring = "any", # c
+ b = false,
+}]
+`,
+ ],
+ [
+ "keeps a comment after the opening brace on that line",
+ `a = { # first
+ b = 1,
+}
+`,
+ `a = { # first
+ b = 1,
+}
+`,
+ ],
+ [
+ "keeps a comment before the closing brace",
+ `a = {
+ b = 1,
+ # last
+}
+`,
+ `a = {
+ b = 1,
+ # last
+}
+`,
+ ],
+ [
+ "keeps a comment after the last entry and its trailing comma",
+ `a = {
+ b = 1, # c
+}
+`,
+ `a = {
+ b = 1, # c
+}
+`,
+ ],
+ [
+ "adds the trailing comma before a comment after the last entry",
+ `a = {
+ b = 1 # c
+}
+`,
+ `a = {
+ b = 1, # c
+}
+`,
+ ],
+ [
+ "keeps a comment on its own line between entries",
+ `a = {
+ b = 1,
+ # about c
+ c = 2,
+}
+`,
+ `a = {
+ b = 1,
+ # about c
+ c = 2,
+}
+`,
+ ],
+ [
+ "keeps a table that only holds a comment",
+ `a = {
+ # nothing
+}
+b = { # nothing
+}
+c = [{
+ # nothing
+}]
+`,
+ `a = {
+ # nothing
+}
+b = { # nothing
+}
+c = [{
+ # nothing
+}]
+`,
+ ],
+ [
+ "collapses an empty table with line breaks",
+ `a = {
+}
+b = {
+
+}
+`,
+ `a = {}
+b = {}
+`,
+ ],
+ [
+ "handles tables in arrays in tables",
+ `a = {
+ b = [
+ { c = 1 }, # one
+ {
+ d = [1, 2], # two
+ e = { f = 1, # three
+ },
+ },
+ ],
+}
+`,
+ `a = {
+ b = [
+ { c = 1 }, # one
+ {
+ d = [1, 2], # two
+ e = {
+ f = 1, # three
+ },
+ },
+ ],
+}
+`,
+ ],
+ [
+ "breaks an array that has its own comment next to a multi-line table",
+ `a = [
+ "x", # about x
+ {
+ b = 1, # about b
+ },
+]
+c = ["x", {
+ b = 1,
+}, # after the table
+]
+d = [ # first
+ {
+ b = 1,
+ }
+]
+`,
+ `a = [
+ "x", # about x
+ {
+ b = 1, # about b
+ },
+]
+c = [
+ "x",
+ {
+ b = 1,
+ }, # after the table
+]
+d = [ # first
+ {
+ b = 1,
+ },
+]
+`,
+ ],
+ [
+ "breaks an array whose multi-line table isn't last",
+ `a = [{
+ b = 1,
+}, "x"]
+`,
+ `a = [
+ {
+ b = 1,
+ },
+ "x",
+]
+`,
+ ],
+ [
+ "breaks an array with two multi-line tables",
+ `a = [{
+ b = 1,
+}, {
+ c = 2,
+}]
+`,
+ `a = [
+ {
+ b = 1,
+ },
+ {
+ c = 2,
+ },
+]
+`,
+ ],
+ [
+ "joins a table whose first entry is on the brace's line, if it fits",
+ `a = { b = 1,
+ c = 2 }
+`,
+ `a = { b = 1, c = 2 }
+`,
+ ],
+ [
+ "puts one entry per line when a table with line breaks doesn't fit",
+ `a = { bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = 1,
+ ccccccccccccccccccccccccccccccccccccccccccccccccccc = 2 }
+`,
+ `a = {
+ bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = 1,
+ ccccccccccccccccccccccccccccccccccccccccccccccccccc = 2,
+}
+`,
+ ],
+ [
+ "never adds line breaks to a one-line table, because TOML 1.0 rejects them",
+ `a = { bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = 1, ccccccccccccccccccccccccccccccccccccccccccccccccccc = 2 }
+`,
+ `a = { bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb = 1, ccccccccccccccccccccccccccccccccccccccccccccccccccc = 2 }
+`,
+ ],
+ [
+ "breaks only the array in the last entry of a one-line table that's too long",
+ `serde = { version = "1.0.200", default-features = false, features = ["derive", "rc", "alloc", "std"] }
+`,
+ `serde = { version = "1.0.200", default-features = false, features = [
+ "derive",
+ "rc",
+ "alloc",
+ "std",
+] }
+`,
+ ],
+ [
+ "handles CRLF",
+ `a = ["warn", {\r
+ b = "any", # c\r
+ d = false,\r
+}]\r
+`,
+ `a = ["warn", {
+ b = "any", # c
+ d = false,
+}]
+`,
+ ],
+ [
+ "removes empty lines next to the braces and keeps at most two between entries",
+ `a = {
+
+ b = 1,
+
+
+
+ c = 2,
+
+}
+`,
+ `a = {
+ b = 1,
+
+
+ c = 2,
+}
+`,
+ ],
+ [
+ "doesn't take a # in a key or a string for a comment",
+ `a = {
+ "b#c".d = "# not a comment", # comment
+ e = '#',
+}
+`,
+ `a = {
+ "b#c".d = "# not a comment", # comment
+ e = '#',
+}
+`,
+ ],
+ [
+ "keeps a multi-line string in a table as it is",
+ `a = {
+ b = """
+x # y
+""",
+ c = 1,
+}
+`,
+ `a = {
+ b = """
+x # y
+""",
+ c = 1,
+}
+`,
+ ],
+ [
+ "doesn't hug when the first line would be too long",
+ `"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" = ["bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", {
+ c = 1,
+}]
+`,
+ `"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" = [
+ "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+ {
+ c = 1,
+ },
+]
+`,
+ ],
+ [
+ "hugs at every level",
+ `a = ["x", {
+ b = ["y", {
+ c = 1,
+ }],
+}]
+`,
+ `a = ["x", {
+ b = ["y", {
+ c = 1,
+ }],
+}]
+`,
+ ],
+ [
+ "keeps a comment after a hugged array",
+ `a = ["x", {
+ b = 1,
+}] # after
+`,
+ `a = ["x", {
+ b = 1,
+}] # after
+`,
+ ],
+ [
+ "works under an array-of-tables header",
+ `[[x]]
+a = { # c
+ b = 1 }
+`,
+ `[[x]]
+a = { # c
+ b = 1,
+}
+`,
+ ],
+ [
+ "removes empty lines next to an array's brackets",
+ `a = [
+
+ 1, # c
+
+
+
+ 2,
+
+]
+`,
+ `a = [
+ 1, # c
+
+
+ 2,
+]
+`,
+ ],
+ [
+ "keeps an array on the line when more entries follow it in a one-line table",
+ `a = { features = ["derive", "rc", "alloc", "std", "unstable"], version = "1.0.200", default-features = false }
+`,
+ `a = { features = ["derive", "rc", "alloc", "std", "unstable"], version = "1.0.200", default-features = false }
+`,
+ ],
+ [
+ "doesn't break arrays in a one-line table that's too long before they start",
+ `"react/sort-comp" = ["error", { order = ["lifecycle", "everything-else", "handlers", "rendering"], groups = { handlers = ["/^handle.+$/"], rendering = ["/^render.+$/", "render"] } }]
+`,
+ `"react/sort-comp" = [
+ "error",
+ { order = ["lifecycle", "everything-else", "handlers", "rendering"], groups = { handlers = ["/^handle.+$/"], rendering = ["/^render.+$/", "render"] } },
+]
+`,
+ ],
+ [
+ "lets each array decide whether it fits",
+ `a = {
+ short = [1, 2],
+ long = ["aaaaaaaaaaaaaaaaaaaa", "bbbbbbbbbbbbbbbbbbbbbbbb", "cccccccccccccccccccccccc", "dddd"],
+ empty = [],
+}
+`,
+ `a = {
+ short = [1, 2],
+ long = [
+ "aaaaaaaaaaaaaaaaaaaa",
+ "bbbbbbbbbbbbbbbbbbbbbbbb",
+ "cccccccccccccccccccccccc",
+ "dddd",
+ ],
+ empty = [],
+}
+`,
+ ],
+];
+
+describe("TOML layout", () => {
+ // All cases share one directory: format, check, format again.
+ const name = (index: number) => `${index}.toml`;
+ const done = (async () => {
+ using dir = tempDir("bun-format-toml", Object.fromEntries(cases.map((it, index) => [name(index), it[1]])));
+ const read = () => cases.map((_, index) => readFileSync(join(String(dir), name(index)), "utf8"));
+ const first = await run(String(dir), ["."]);
+ const files = read();
+ const check = await run(String(dir), ["--check", "."]);
+ const second = await run(String(dir), ["."]);
+ return { first, files, check, second, again: read() };
+ })();
+
+ test("formats every case without errors, and --check passes afterwards", async () => {
+ const { first, check, second } = await done;
+ expect([first.stderr, check.stderr, second.stderr]).toEqual(["", "", ""]);
+ expect([first.exitCode, check.exitCode, second.exitCode]).toEqual([0, 0, 0]);
+ });
+
+ test.each(cases.map((it, index) => [it[0], index] as const))("%s", async (_, index) => {
+ const { files, again } = await done;
+ const [, input, output] = cases[index];
+ expect(files[index]).toBe(output);
+ // A second run changes nothing.
+ expect(again[index]).toBe(output);
+ expect(Bun.TOML.parse(output)).toEqual(Bun.TOML.parse(input));
+ });
+
+ test("respects trailingComma, useTabs and endOfLine in a multi-line table", async () => {
+ using dir = tempDir("bun-format-toml", {
+ "bunfig.toml": `[fmt]\ntrailingComma = "none"\nuseTabs = true\nendOfLine = "crlf"\n`,
+ "a.toml": `a = ["x", {\n b = 1, # c\n d = 2,\n}]\n`,
+ });
+ const result = await run(String(dir), ["a.toml"]);
+ expect(result.stderr).toBe("");
+ expect(readFileSync(join(String(dir), "a.toml"), "utf8")).toBe(`a = ["x", {\r\n\tb = 1, # c\r\n\td = 2\r\n}]\r\n`);
+ });
+});
+
+describe.concurrent("a table with a comment", () => {
+ // oxfmt 0.72 joins these lines, which comments out the second entry: `{ b = 1 # c, d = 2 },`.
+ const commented = `a = ["x", {\n b = 1, # c\n d = 2,\n}]\n`;
+ const expanded = `a = [\n "x",\n {\n b = 1, # c\n d = 2,\n },\n]\n`;
+
+ test("with an oxfmt config it has one entry per line", async () => {
+ using dir = tempDir("bun-format-toml", { ".oxfmtrc.json": "{}\n", "a.toml": commented, "b.toml": expanded });
+ const result = await run(String(dir), ["."]);
+ expect(result.stderr).toBe("");
+ expect(readFileSync(join(String(dir), "a.toml"), "utf8")).toBe(expanded);
+ expect(readFileSync(join(String(dir), "b.toml"), "utf8")).toBe(expanded);
+ expect(result.exitCode).toBe(0);
+ });
+
+ // The table, what Bun makes of it, and what oxfmt 0.72 makes of it.
+ test.each([
+ ["a = { # c\n b = 1 }\n", "a = { # c\n b = 1,\n}\n", "a = { # c b = 1 }\n"],
+ ["a = { b = 1 # c\n, d = 2 }\n", "a = {\n b = 1, # c\n d = 2,\n}\n", "a = { b = 1 # c, d = 2 }\n"],
+ ["a = { b = 1,\n # c\n d = 2 }\n", "a = {\n b = 1,\n # c\n d = 2,\n}\n", "a = { b = 1 # c, d = 2 }\n"],
+ ["a = { b = 1, d = 2 # c\n }\n", "a = {\n b = 1,\n d = 2, # c\n}\n", "a = { b = 1, d = 2 # c }\n"],
+ ])("wherever the comment is: %j", async (before, after, ofOxfmt) => {
+ expect(after).not.toBe(ofOxfmt);
+ using dir = tempDir("bun-format-toml", { ".oxfmtrc.json": "{}\n", "a.toml": before, "b.toml": after });
+ const checked = await run(String(dir), ["--debug-check", "."]);
+ expect(checked.stderr).toBe("");
+ expect(checked.exitCode).toBe(0);
+ const result = await run(String(dir), ["."]);
+ expect(result.stderr).toBe("");
+ expect(readFileSync(join(String(dir), "a.toml"), "utf8")).toBe(after);
+ expect(readFileSync(join(String(dir), "b.toml"), "utf8")).toBe(after);
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("--debug-check has nothing to say about it", async () => {
+ using dir = tempDir("bun-format-toml", { ".oxfmtrc.json": "{}\n", "a.toml": commented });
+ const result = await run(String(dir), ["--debug-check", "."]);
+ expect(result.stderr).toBe("");
+ expect(readFileSync(join(String(dir), "a.toml"), "utf8")).toBe(commented);
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("without an oxfmt config the same file is already formatted", async () => {
+ using dir = tempDir("bun-format-toml", { "a.toml": commented });
+ const result = await run(String(dir), ["--check", "."]);
+ expect(result.stderr).toBe("");
+ expect(result.exitCode).toBe(0);
+ });
+});
diff --git a/test/cli/format/toml.test.ts b/test/cli/format/toml.test.ts
index 0fe3efc1cebc..52c595af1387 100644
--- a/test/cli/format/toml.test.ts
+++ b/test/cli/format/toml.test.ts
@@ -10,7 +10,7 @@ afterAll(endChildren);
async function format(files: Record, config: object, args: string[] = []) {
using dir = tempDir("bun-format-toml", { ...files, ".oxfmtrc.json": JSON.stringify(config) });
await using proc = spawn({
- cmd: [bunExe(), "format", ...args],
+ cmd: [bunExe(), "fmt", ...args],
env: { ...bunEnv, NO_COLOR: "1" },
cwd: String(dir),
stdout: "pipe",
diff --git a/test/cli/format/words.test.ts b/test/cli/format/words.test.ts
new file mode 100644
index 000000000000..86a88a262a0c
--- /dev/null
+++ b/test/cli/format/words.test.ts
@@ -0,0 +1,176 @@
+// Tests for what `bun fmt` prints when there's no Prettier or oxfmt config.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+const env = { ...bunEnv, NO_COLOR: undefined, FORCE_COLOR: undefined };
+const ugly = "a ;\n";
+const formatted = "a;\n";
+
+async function format(files: Record, args: string[], more: Record = {}) {
+ using dir = tempDir("bun-format-words", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "fmt", ...args],
+ env: { ...env, ...more },
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ const after = Object.keys(files).map(name => [name, readFileSync(join(String(dir), name), "utf8")]);
+ return { stdout, stderr: stderr.replace(/ \[\d+(\.\d+)?m?s\]/g, ""), exitCode, files: Object.fromEntries(after) };
+}
+
+describe.concurrent("bun fmt --check", () => {
+ test("lists the files that need formatting, writes nothing and exits with 1", async () => {
+ const files = { "a.js": ugly, "b.js": formatted, "src/c.ts": ugly, "d.json": "{}\n" };
+ expect(await format(files, ["--check"])).toEqual({
+ stdout: "a.js\nsrc/c.ts\n",
+ stderr: "2 files need formatting. Run bun fmt to fix them.\n",
+ exitCode: 1,
+ files,
+ });
+ });
+
+ test("uses the singular for one file", async () => {
+ const files = { "a.js": ugly, "b.js": formatted };
+ expect(await format(files, ["--check"])).toEqual({
+ stdout: "a.js\n",
+ stderr: "1 file needs formatting. Run bun fmt to fix it.\n",
+ exitCode: 1,
+ files,
+ });
+ });
+
+ test("exits with 0 if every file is formatted", async () => {
+ const [four, one] = await Promise.all([
+ format({ "a.js": formatted, "b.ts": formatted, "c.json": "{}\n", "d.css": "a {\n}\n" }, ["--check"]),
+ format({ "a.js": formatted }, ["--check"]),
+ ]);
+ expect(four).toMatchObject({ stdout: "", stderr: "All 4 files are formatted.\n", exitCode: 0 });
+ expect(one).toMatchObject({ stdout: "", stderr: "1 file is formatted.\n", exitCode: 0 });
+ });
+
+ test("files with syntax errors are counted separately", async () => {
+ const { stdout, stderr, exitCode } = await format(
+ { "a.js": ugly, "b.js": formatted, "broken.js": "const = 1;\n" },
+ ["--check"],
+ );
+ expect(stdout).toBe("a.js\n");
+ expect(stderr).toStartWith("error: broken.js: SyntaxError: ");
+ expect(stderr).toContain("\n> 1 | const = 1;\n");
+ expect(stderr).not.toContain("[error]");
+ expect(stderr).toEndWith("\n1 file needs formatting. Run bun fmt to fix it.\nCould not check 1 file.\n");
+ expect(exitCode).toBe(2);
+ });
+
+ test("[fmt] in bunfig.toml and an .editorconfig don't change the wording", async () => {
+ const files = {
+ "a.js": "a;\n",
+ "b.js": "if (a) {\n b\n}\n",
+ "bunfig.toml": "[fmt]\nsemi = false\n",
+ ".editorconfig": "[*]\nindent_size = 4\n",
+ };
+ expect(await format(files, ["--check", "a.js", "b.js"])).toMatchObject({
+ stdout: "a.js\n",
+ stderr: "1 file needs formatting. Run bun fmt to fix it.\n",
+ exitCode: 1,
+ });
+ });
+
+ test("--log-level", async () => {
+ const files = { "a.js": ugly, "b.js": formatted };
+ const [silent, error, warn] = await Promise.all(
+ ["silent", "error", "warn"].map(level => format(files, ["--check", "--log-level", level])),
+ );
+ expect(silent).toMatchObject({ stdout: "", stderr: "", exitCode: 1 });
+ expect(error).toMatchObject({ stdout: "", stderr: "", exitCode: 1 });
+ expect(warn).toMatchObject({
+ stdout: "a.js\n",
+ stderr: "1 file needs formatting. Run bun fmt to fix it.\n",
+ exitCode: 1,
+ });
+ });
+
+ test("colored output has the same text", async () => {
+ const files = { "a.js": ugly, "b.js": formatted };
+ const [plain, colored] = await Promise.all([
+ format(files, ["--check"]),
+ format(files, ["--check"], { FORCE_COLOR: "1" }),
+ ]);
+ expect(colored.stderr).toContain("\x1b[");
+ expect(Bun.stripANSI(colored.stderr)).toBe(plain.stderr);
+ expect(colored.stdout).toBe(plain.stdout);
+ });
+
+ test.each([
+ ["a .prettierrc", { ".prettierrc": "{}\n" }, []],
+ ["prettier in package.json", { "package.json": `{ "prettier": {} }` }, []],
+ ["--config", { "mine.json": "{}\n" }, ["--config", "mine.json"]],
+ ["--flavor prettier", {}, ["--flavor", "prettier"]],
+ ])("with %s the output is worded like Prettier's", async (_, configuration, flags) => {
+ const [different, same] = await Promise.all([
+ format({ ...configuration, "a.js": ugly, "b.js": ugly }, [...flags, "--check", "a.js", "b.js"]),
+ format({ ...configuration, "a.js": formatted }, [...flags, "--check", "a.js"]),
+ ]);
+ expect(different).toMatchObject({
+ stdout: "Checking formatting...\n",
+ stderr: "[warn] a.js\n[warn] b.js\n[warn] Code style issues found in 2 files. Run bun fmt to fix.\n",
+ exitCode: 1,
+ });
+ expect(same).toMatchObject({
+ stdout: "Checking formatting...\nAll matched files use Prettier code style!\n",
+ stderr: "",
+ exitCode: 0,
+ });
+ });
+});
+
+describe.concurrent("bun fmt", () => {
+ test("errors start with Bun's `error:`, or Prettier's `[error]` with a .prettierrc", async () => {
+ const [missing, ofPrettier] = await Promise.all([
+ format({ "a.js": formatted }, ["nothing.js"]),
+ format({ "a.js": formatted, ".prettierrc": "{}\n" }, ["nothing.js"]),
+ ]);
+ expect(missing.stderr).toStartWith('error: No files matching the pattern were found: "nothing.js".\n');
+ expect(missing.exitCode).toBe(2);
+ expect(ofPrettier.stderr).toStartWith('[error] No files matching the pattern were found: "nothing.js".\n');
+ expect(ofPrettier.exitCode).toBe(2);
+ });
+
+ test("errors and warnings about flags get the same prefixes", async () => {
+ const flags = ["--plugin", "prettier-plugin-x"];
+ const [refused, allowed, ofPrettier] = await Promise.all([
+ format({ "a.js": formatted }, flags),
+ format({ "a.js": formatted }, [...flags, "--allow-unsupported"]),
+ format({ "a.js": formatted, ".prettierrc": "{}\n" }, flags),
+ ]);
+ expect(refused.stderr).toStartWith("error: bun fmt does not include the plugin prettier-plugin-x\n");
+ expect(allowed.stderr).toStartWith("warn: --plugin has no effect ");
+ expect(ofPrettier.stderr).toStartWith("[error] bun fmt does not include the plugin prettier-plugin-x\n");
+ expect([refused.exitCode, allowed.exitCode, ofPrettier.exitCode]).toEqual([2, 0, 2]);
+ });
+
+ test("lists the files it writes and counts them", async () => {
+ const { stdout, stderr, exitCode, files } = await format({ "a.js": ugly, "b.js": formatted, "c.js": ugly }, []);
+ expect(stdout).toBe("a.js\nc.js\n");
+ expect(stderr).toBe("Formatted 2 files, 1 unchanged\n");
+ expect(files).toEqual({ "a.js": formatted, "b.js": formatted, "c.js": formatted });
+ expect(exitCode).toBe(0);
+ });
+
+ test("--check --write writes files like a plain run", async () => {
+ const { stdout, stderr, exitCode, files } = await format({ "a.js": ugly, "b.js": formatted }, [
+ "--check",
+ "--write",
+ ]);
+ expect(stdout).toBe("a.js\n");
+ expect(stderr).toBe("Formatted 1 file, 1 unchanged\n");
+ expect(files).toEqual({ "a.js": formatted, "b.js": formatted });
+ expect(exitCode).toBe(0);
+ });
+});
diff --git a/test/cli/init/init.test.ts b/test/cli/init/init.test.ts
index 2170dda67685..113be9d6abcc 100644
--- a/test/cli/init/init.test.ts
+++ b/test/cli/init/init.test.ts
@@ -60,6 +60,8 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
expect(readme).toInclude("v" + Bun.version.replaceAll("-debug", ""));
expect(readme).toInclude("index.ts");
expect(readme).toInclude("bun check");
+ expect(readme).toInclude("`bun lint`");
+ expect(readme).toInclude("`bun fmt`");
expect(fs.existsSync(path.join(temp, "index.ts"))).toBe(true);
expect(fs.existsSync(path.join(temp, ".gitignore"))).toBe(true);
@@ -414,6 +416,34 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
expect(fs.existsSync(path.join(temp, "src/components/ui"))).toBe(true);
}, 30_000);
+ test.each(["--react", "--react=tailwind", "--react=shadcn"])(
+ "bun init %s writes the same [lint] section to bunfig.toml as bun lint --init",
+ async flag => {
+ await using temp = tempDir("bun-init-lint-section", { "alone/a.js": "" });
+ const run = async (cwd: string, ...args: string[]) => {
+ await using proc = Bun.spawn({
+ cmd: [bunExe(), ...args],
+ cwd,
+ stdio: ["ignore", "pipe", "inherit"],
+ env: initEnv,
+ });
+ const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+ return { stdout, exitCode };
+ };
+ expect((await run(path.join(temp, "alone"), "lint", "--init")).exitCode).toBe(0);
+ expect((await run(String(temp), "init", flag, "app")).exitCode).toBe(0);
+ expect(fs.readFileSync(path.join(temp, "app/bunfig.toml"), "utf8")).toEndWith(
+ 'env = "BUN_PUBLIC_*"\n\n' + fs.readFileSync(path.join(temp, "alone/bunfig.toml"), "utf8"),
+ );
+ expect(await run(path.join(temp, "app"), "lint", "--init")).toEqual({
+ stdout: "bunfig.toml already has a [lint] section\n",
+ exitCode: 0,
+ });
+ expect(fs.readFileSync(path.join(temp, "app/README.md"), "utf8")).toInclude("`bun lint`");
+ },
+ 30_000,
+ );
+
// Every template declares `typescript: "^7"`, so the `bun install` that
// `bun init` runs installs TypeScript 7. Typecheck and build with that
// exact install. https://github.com/oven-sh/bun/issues/33050
@@ -467,6 +497,34 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
]);
expect({ checkStdout, checkStderr, checkExited }).toMatchObject({ checkStdout: "", checkExited: 0 });
+ // `bun lint` reports nothing, not even a warning, and `bun fmt` has nothing to change.
+ await using lint = Bun.spawn({
+ cmd: [bunExe(), "lint", "-f", "json"],
+ cwd: temp,
+ stdio: ["ignore", "pipe", "pipe"],
+ env: bunEnv,
+ });
+ const [lintStdout, lintStderr, lintExited] = await Promise.all([
+ lint.stdout.text(),
+ lint.stderr.text(),
+ lint.exited,
+ ]);
+ const problems = JSON.parse(lintStdout).flatMap((file: { messages: unknown[] }) => file.messages);
+ expect({ problems, lintStderr, lintExited }).toMatchObject({ problems: [], lintExited: 0 });
+
+ await using format = Bun.spawn({
+ cmd: [bunExe(), "fmt", "--check"],
+ cwd: temp,
+ stdio: ["ignore", "pipe", "pipe"],
+ env: bunEnv,
+ });
+ const [formatStdout, formatStderr, formatExited] = await Promise.all([
+ format.stdout.text(),
+ format.stderr.text(),
+ format.exited,
+ ]);
+ expect({ formatStdout, formatStderr, formatExited }).toMatchObject({ formatExited: 0 });
+
// The blank template has no `build` script; the react templates do.
// --bun for the same reason: the script is `bun run build.ts`.
const pkg = JSON.parse(fs.readFileSync(path.join(temp, "package.json"), "utf8"));
@@ -488,6 +546,32 @@ const initEnv = { ...bunEnv, BUN_AGENT_RULE_DISABLED: "1" };
180_000,
);
+ test.skipIf(isWindows)(
+ "`bun fmt --check` passes on the generated CLAUDE.md",
+ async () => {
+ await using temp = tempDir("bun-init-claude-md", { "bin/claude": "#!/bin/sh\n" });
+ fs.chmodSync(path.join(temp, "bin/claude"), 0o755);
+ await using init = Bun.spawn({
+ cmd: [bunExe(), "init", "-y", "app"],
+ cwd: temp,
+ stdio: ["ignore", "ignore", "inherit"],
+ env: { ...bunEnv, PATH: `${path.join(temp, "bin")}:${bunEnv.PATH}`, CURSOR_AGENT_RULE_DISABLED: "1" },
+ });
+ expect(await init.exited).toBe(0);
+ expect(fs.readFileSync(path.join(temp, "app/CLAUDE.md"), "utf8")).toStartWith("Default to using Bun");
+
+ await using format = Bun.spawn({
+ cmd: [bunExe(), "fmt", "--check", "CLAUDE.md"],
+ cwd: path.join(temp, "app"),
+ stdio: ["ignore", "pipe", "pipe"],
+ env: bunEnv,
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([format.stdout.text(), format.stderr.text(), format.exited]);
+ expect({ stdout, stderr, exitCode }).toMatchObject({ exitCode: 0 });
+ },
+ 30_000,
+ );
+
test("nested `bun install` output is inherited", async () => {
// `bun init` spawns `bun install` via spawn_sync_inherit. The child must
// inherit stdout/stderr so its output reaches the parent's pipe — a
diff --git a/test/cli/install/bun-workspaces.test.ts b/test/cli/install/bun-workspaces.test.ts
index 7a7604ff674d..a055c8d2822f 100644
--- a/test/cli/install/bun-workspaces.test.ts
+++ b/test/cli/install/bun-workspaces.test.ts
@@ -235,6 +235,36 @@ test.concurrent("allowing negative workspace patterns", async () => {
});
});
+test.concurrent("extglob and brace sequence workspace patterns", async () => {
+ using ctx = await setupTest();
+ const { packageDir, env } = ctx;
+ const good = ["packages/pkg1", "packages/pkg2", "apps/web", "apps/api", "libs/lib1", "libs/lib2"];
+ // Installing any of these would fail.
+ const excluded = ["packages/internal", "apps/other", "libs/lib3"];
+ await Promise.all([
+ write(
+ join(packageDir, "package.json"),
+ JSON.stringify({
+ name: "root",
+ workspaces: ["packages/!(internal)", "apps/@(web|api)", "libs/lib{1..2}"],
+ }),
+ ),
+ ...good.map(dir => write(join(packageDir, dir, "package.json"), JSON.stringify({ name: dir.split("/")[1] }))),
+ ...excluded.map(dir =>
+ write(
+ join(packageDir, dir, "package.json"),
+ JSON.stringify({ name: dir.split("/")[1], dependencies: { "doesnt-exist-oops": "1.2.3" } }),
+ ),
+ ),
+ ]);
+
+ const { exited } = await runBunInstall(env, packageDir);
+ expect(await exited).toBe(0);
+
+ const lockfile = Bun.JSONC.parse(await file(join(packageDir, "bun.lock")).text()) as { workspaces: object };
+ expect(Object.keys(lockfile.workspaces).sort()).toEqual(["", ...good].sort());
+});
+
test("dependency on same name as workspace and dist-tag", async () => {
using ctx = await setupTest();
const { packageDir, env } = ctx;
diff --git a/test/cli/lint/bun-rules.test.ts b/test/cli/lint/bun-rules.test.ts
index 3947d9563dd5..60651d450a44 100644
--- a/test/cli/lint/bun-rules.test.ts
+++ b/test/cli/lint/bun-rules.test.ts
@@ -760,6 +760,11 @@ const rules: Record = {
{ code: `const A = z.string();`, options: [{ roots: ["v"] }] },
`const A = userSchema();`,
`const B = A.extend({ b: 1 });`,
+ // `lazySchema` itself ends with the factory suffix.
+ {
+ code: `${zod}const A = lazySchema(() => z.object({ a: userSchema() }));`,
+ options: [{ factorySuffix: "Schema", lazyWrapper: "lazySchema" }],
+ },
],
"no-side-effects-on-import": [
@@ -1411,6 +1416,8 @@ const rules: Record = {
`${processes}const child = spawn("a");\nconst other = child;`,
`${processes}const child = spawn("a");\nthis.child = child;`,
`${processes}const child = spawn("a");\nexport { child };`,
+ `${processes}export const child = spawn("a");`,
+ `${processes}export let child;\nchild = spawn("a");`,
`${files}await pipeline(createReadStream("a"), createWriteStream("b"));`,
`${files}const source = createReadStream("a");\nfinished(source, done);`,
`${files}const source = createReadStream("a");\nfor await (const piece of source) use(piece);`,
@@ -1717,7 +1724,12 @@ const testRules: Record = {
`test(«" a"», () => {\n expect(1).toMatchSnapshot();\n});`,
`test(«a», () => {});`,
{ code: `describe(«add», () => {});`, options: [{ ignoreTypeOfDescribeName: false }] },
+ { code: `test(«"adds"», () => {});`, options: [{ mustMatch: "/^ADDS/" }] },
+ { code: `test(«"Adds"», () => {});`, options: [{ mustNotMatch: "/^adds/i" }] },
+ { code: `it(«"adds"», () => {});\ntest("adds", () => {});`, options: [{ mustMatch: { it: "^should " } }] },
+ { code: `test("adds", () => {});`, options: [{ mustMatch: "/^ADDS/i" }] },
+ { code: `it("should add", () => {});`, options: [{ mustMatch: { it: "^should " } }] },
`test("a", () => {});`,
`test(() => {});`,
`test(callback);`,
@@ -1741,6 +1753,33 @@ const testRules: Record = {
`test.skip("a", () => {});`,
`test.todo("a", () => {});`,
`test.todoIf(a)("b");`,
+ `own("a", () => {});`,
+ // `**` also matches zero segments, and `*` matches any character of a name.
+ ...[
+ `test("a", () => {\n request(b).expect(200);\n});`,
+ `test("a", () => {\n request(b).get("/").set("c").expect(200);\n});`,
+ `test("a", () => {\n check_all$(b);\n});`,
+ `test("a", () => {\n b.c.verify();\n});`,
+ `test("a", () => {\n verify();\n});`,
+ `test("a", () => {\n $assert(b);\n});`,
+ `«test»("a", () => {\n request(b).get("/");\n});`,
+ `«test»("a", () => {\n requests.expect(200);\n});`,
+ `«test»("a", () => {\n recheck(b);\n});`,
+ `«test»("a", () => {\n assert(b);\n});`,
+ ].map(code => ({
+ code,
+ options: [{ assertFunctionNames: ["request.**.expect", "check*", "**.verify", "$ass*"] }],
+ })),
+ // A custom wrapper, a method and a hook.
+ ...[
+ `«own»("a", () => {});`,
+ `«helpers.own»("a", () => {});`,
+ `«beforeAll»(() => {});`,
+ `own("a", () => {\n expect(1).toBe(1);\n});`,
+ `other("a", () => {});`,
+ `own.skip("a", () => {});`,
+ `own;`,
+ ].map(code => ({ code, options: [{ additionalTestBlockFunctions: ["own", "helpers.own", "beforeAll"] }] })),
].map(inBunTest),
"no-done-callback": [
@@ -1764,6 +1803,13 @@ const testRules: Record = {
"prefer-ending-with-an-expect": [
`«test»(() => {\n expect(1).toBe(1);\n a();\n});`,
+ `own("a", () => {\n b();\n});`,
+ ...[
+ `«own»("a", () => {\n expect(1).toBe(1);\n b();\n});`,
+ `«beforeAll»(() => {\n b();\n});`,
+ `own("a", () => {\n b();\n expect(1).toBe(1);\n});`,
+ `other("a", () => {\n b();\n});`,
+ ].map(code => ({ code, options: [{ additionalTestBlockFunctions: ["own", "beforeAll"] }] })),
`«test»("a", { retry: 1 }, () => {\n expect(1).toBe(1);\n a();\n});`,
`test(() => {\n a();\n expect(1).toBe(1);\n});`,
].map(inBunTest),
@@ -1798,6 +1844,66 @@ const testRules: Record = {
.map(it => (it.code.includes("«") ? it : it.code))
.map(inBunTest),
+ // A test's count includes its nested blocks and the callbacks it passes to other functions.
+ "max-expects": [
+ `test("a", () => {\n expect(1).toBe(1);\n «expect»(2).toBe(2);\n});`,
+ `test("a", () => {\n expect(1).toBe(1);\n for (const b of c) {\n «expect»(b).toBe(2);\n }\n});`,
+ `test("a", () => {\n expect(1).toBe(1);\n c.forEach(b => {\n «expect»(b).toBe(2);\n });\n});`,
+ `test("a", () => {\n if (b) expect(1).toBe(1);\n else «expect»(2).toBe(2);\n});`,
+ `function check() {\n expect(1).toBe(1);\n «expect»(2).toBe(2);\n}`,
+
+ `test("a", () => {\n expect(1).toBe(1);\n});\ntest("b", () => {\n expect(2).toBe(2);\n});`,
+ `describe("a", () => {\n test("b", () => {\n expect(1).toBe(1);\n });\n test("c", () => {\n expect(2).toBe(2);\n });\n});`,
+ `test("a", () => {\n expect(1).toBe(1);\n function check() {\n expect(2).toBe(2);\n }\n});`,
+ `test("a", () => {\n expect.assertions(1);\n expect.hasAssertions();\n expect(1).toBe(1);\n});`,
+ ]
+ .map(code => ({ code, options: [{ max: 1 }] }))
+ .map(inBunTest),
+
+ "no-conditional-expect": [
+ `test("a", () => {\n if (b) «expect»(1).toBe(1);\n});`,
+ `test("a", function () {\n if (b) «expect»(1).toBe(1);\n});`,
+ `test("a", function named() {\n if (b) «expect»(1).toBe(1);\n});`,
+ `test("a", () => {\n each(function () {\n if (b) «expect»(1).toBe(1);\n });\n});`,
+ // Functions that a test calls, or that are passed as the test itself.
+ `function check() {\n if (b) «expect»(1).toBe(1);\n}\ntest("a", () => check());`,
+ `function check() {\n if (b) «expect»(1).toBe(1);\n}\ntest("a", check);`,
+ `const check = () => {\n if (b) «expect»(1).toBe(1);\n};\ntest("a", () => check());`,
+ `const check = function () {\n if (b) «expect»(1).toBe(1);\n};\ntest("a", check);`,
+
+ `if (b) {\n test("a", function () {\n expect(1).toBe(1);\n });\n}`,
+ `test("a", () => {\n if (b) {\n const check = () => expect(1).toBe(1);\n }\n});`,
+ `function check() {\n if (b) expect(1).toBe(1);\n}`,
+ `const check = () => {\n if (b) expect(1).toBe(1);\n};\ncheck();`,
+ `const checks = {\n check() {\n if (b) expect(1).toBe(1);\n },\n};\ntest("a", () => checks.check());`,
+ ].map(inBunTest),
+
+ // The condition for running a test, its title and its timeout aren't part of the test body.
+ "no-conditional-in-test": [
+ `test("a", () => {\n «if (a) b();»\n});`,
+ `test.skipIf(a)("b", () => {\n const c = «d || e»;\n});`,
+ `test("a", { timeout: 1000 }, function () {\n return «b ? c : d»;\n});`,
+ `test(() => {\n «a ?? b»;\n}, 1000);`,
+
+ `test.skipIf(a || b)("c", () => {});`,
+ `test.if(a && b)("c", () => {});`,
+ `test.todoIf(a ? b : c)("d", () => {});`,
+ `test.each(a ?? b)("c", () => {});`,
+ `test(a || "b", () => {});`,
+ `test("a", () => {}, b ? 1000 : 5000);`,
+ `test("a", { timeout: b ?? 1000 }, () => {});`,
+ ].map(inBunTest),
+
+ "no-large-snapshots": [
+ inTest("expect(a).«toMatchInlineSnapshot»(`\n1\n2\n3\n`);"),
+ inTest("expect(a).«toMatchInlineSnapshot»({ b: expect.any(Number) }, `\n1\n2\n3\n`);"),
+ inTest("expect(a).toMatchInlineSnapshot({\n b: expect.any(Number),\n c: expect.any(Number),\n}, `1`);"),
+ inTest("expect(a).toMatchInlineSnapshot(`1`);"),
+ inTest("expect(a).toMatchInlineSnapshot();"),
+ ]
+ .map(code => ({ code, options: [{ inlineMaxSize: 2 }] }))
+ .map(inBunTest),
+
"no-identical-title": [
`test("a", () => {});\ntest(«"a"», () => {});`,
`test.failing("a", () => {});\ntest.serial(«"a"», () => {});`,
@@ -1899,6 +2005,13 @@ const testRules: Record = {
},
].map(inBunTest),
+ "prefer-to-be": [
+ { code: inTest(`expect(a).«toEqual»(1);`), output: inTest(`expect(a).toBe(1);`) },
+ { code: inTest(`expect(a).«toEqual»(-1);`), output: inTest(`expect(a).toBe(-1);`) },
+ inTest(`expect(a).toEqual(0.5);`),
+ inTest(`expect(a).toEqual(-0.5);`),
+ ].map(inBunTest),
+
"prefer-to-contain": [
{
code: inTest(`expect(a.includes(1), "why").«toBe»(true);`),
@@ -1920,11 +2033,53 @@ const testRules: Record = {
},
].map(inBunTest),
+ "prefer-mock-return-shorthand": [
+ { code: `a.«mockImplementation»(() => 1);`, output: `a.mockReturnValue(1);` },
+ { code: `a.«mockImplementationOnce»(() => ({ b: [c] }));`, output: `a.mockReturnValueOnce({ b: [c] });` },
+ { code: `a.«mockImplementation»(function () {\n return 1;\n});`, output: `a.mockReturnValue(1);` },
+ // These run each time the mock is called.
+ `a.mockImplementation(() => create());`,
+ `a.mockImplementation(() => new User());`,
+ `a.mockImplementation(() => ({ id: next() }));`,
+ "a.mockImplementation(() => sql`b`);",
+ `a.mockImplementation(() => import("b"));`,
+ // It returns nothing.
+ `a.mockImplementation(function () {\n b;\n});`,
+ ].map(inBunTest),
+
+ "prefer-spy-on": [
+ ...[
+ { code: `a.b = «jest.fn»();`, suggestions: [`jest.spyOn(a, 'b').mockImplementation();`] },
+ // No suggestion, because `spyOn` isn't imported.
+ `a.b = «mock»();`,
+ `a.b = other();`,
+ `const a = mock();`,
+ `const a = { b: mock() };`,
+ `function f(mock) {\n a.b = mock();\n}`,
+ ].map(inBunTest),
+ ...[
+ { code: `a.b = «mock»();`, suggestions: [`spyOn(a, 'b').mockImplementation();`] },
+ { code: `a.b = «mock»(() => 1);`, suggestions: [`spyOn(a, 'b').mockImplementation(() => 1);`] },
+ { code: `a[b] = «mock»(c);`, suggestions: [`spyOn(a, b).mockImplementation(c);`] },
+ ].map(({ code, suggestions }) => {
+ const head = `import { mock, spyOn } from "bun:test";\n`;
+ return { code: head + code, suggestions: suggestions.map(it => head + it) };
+ }),
+ {
+ code: `import { mock as fake, spyOn } from "bun:test";\na.b = «fake»();`,
+ suggestions: [`import { mock as fake, spyOn } from "bun:test";\nspyOn(a, 'b').mockImplementation();`],
+ },
+ `import { test } from "bun:test";\nimport { mock } from "./mock";\na.b = mock();`,
+ ],
+
"prefer-describe-function-title": [
{
code: `import { add } from "./add";\ndescribe(«"add"», () => {});`,
suggestions: [`import { add } from "./add";\ndescribe(add, () => {});`],
},
+ // A type can't be passed as a value.
+ `import type { Add } from "./add";\ndescribe("Add", () => {});`,
+ `import { type Add } from "./add";\ndescribe("Add", () => {});`,
].map(inBunTest),
// oxlint applies these, and the fixes above of what is awaited, included and compared. A test that passes can fail afterwards.
@@ -1935,6 +2090,14 @@ const testRules: Record = {
"prefer-strict-boolean-matchers": [
{ code: inTest(`expect(1).«toBeTruthy()»;`), suggestions: [inTest(`expect(1).toBe(true);`)] },
{ code: inTest(`expect(0, "why").«toBeFalsy()»;`), suggestions: [inTest(`expect(0, "why").toBe(false);`)] },
+ // `.not.toBe(true)` passes for everything but `true`.
+ { code: inTest(`expect(a).not.«toBeTruthy()»;`), suggestions: [inTest(`expect(a).toBe(false);`)] },
+ { code: inTest(`expect(a).not.«toBeFalsy()»;`), suggestions: [inTest(`expect(a).toBe(true);`)] },
+ {
+ code: inTest(`await expect(a).resolves.not.«toBeTruthy()»;`),
+ suggestions: [inTest(`await expect(a).resolves.toBe(false);`)],
+ },
+ inTest(`expect(a)["not"].«toBeTruthy()»;`),
].map(inBunTest),
"require-hook": [
@@ -2260,14 +2423,13 @@ describe.concurrent("the plugin bun", () => {
expect(exitCode).toBe(1);
});
- test("--rules lists them, without a category and without a page", async () => {
+ test("--rules lists them, without a category", async () => {
const { stdout } = await lint({ ".oxlintrc.json": "{}" }, ["--rules", "-f", "json"]);
const listed = (JSON.parse(stdout) as Record[]).filter(it => it.scope === "bun");
// `bun/format` is tested with `prettier/prettier`: prettier-rule.test.ts.
expect(listed.map(it => it.value)).toEqual([...Object.keys(rules), "format"].toSorted());
- expect([...new Set(listed.map(it => JSON.stringify([it.category, it.default, it.docs_url])))]).toEqual([
- "[null,false,null]",
- ]);
+ expect([...new Set(listed.map(it => JSON.stringify([it.category, it.default])))]).toEqual(["[null,false]"]);
+ expect(listed.map(it => it.docs_url)).toEqual(listed.map(it => `https://bun.com/docs/lint/rules/bun/${it.value}`));
});
test("options that a rule does not have are refused", async () => {
@@ -2291,10 +2453,152 @@ describe.concurrent("the plugin bun", () => {
const options = { patterns: [{ pattern: "(" }] };
const files = { "eslint.config.mjs": flat({ "bun/no-restricted-text": ["error", options] }), "a.js": eager };
const { stderr, exitCode } = await lint(files, ["a.js"]);
- expect(stderr).toContain(`The pattern "(" is not a regular expression`);
+ expect(stderr).toContain(`Invalid pattern "(": Invalid regular expression: `);
expect(exitCode).toBe(2);
});
+ test("each rule's message", async () => {
+ const files = {
+ "bunfig.toml": `[lint.rules]
+"bun/no-eager-dynamic-import" = "error"
+"bun/no-eager-native-addon" = "error"
+"bun/no-env-at-module-scope" = "error"
+"bun/no-literal-temp-dir" = "error"
+"bun/no-negative-repeat-count" = "error"
+"bun/no-redundant-catch-type" = "error"
+"bun/no-useless-spread-fallback" = "error"
+"bun/no-array-just-to-count" = "error"
+"bun/prefer-builtin-sleep" = "error"
+"bun/react-prefer-updater-function" = "error"
+"bun/no-console-window-flash" = "error"
+"bun/no-unportable-commands" = "error"
+"bun/no-cwd-dependent-path" = "error"
+"bun/prefer-lazy-schema" = "error"
+"bun/no-side-effects-on-import" = "error"
+"bun/no-unseeded-random-in-property-test" = "error"
+"bun/react-no-namespace-hooks" = "error"
+"bun/react-no-latest-value-ref" = "error"
+"bun/jsx-no-forbidden-nesting" = "error"
+"bun/consistent-directive-prefix" = "error"
+"bun/no-restricted-text" = ["error", { patterns = [{ pattern = "foo" }] }]
+"bun/prefer-timeout-signal" = "error"
+"bun/prefer-url-for-sibling-files" = "error"
+"bun/react-no-local-render-helpers" = "error"
+"bun/prefer-local-module" = ["error", { modules = [{ package = "axios", use = "@/http" }] }]
+"bun/no-unbounded-requests" = "error"
+"bun/no-unhandled-emitter-errors" = "error"
+"bun/no-cast-to-brand" = ["error", { branded = [{ module = "src/ids", type = "UserId", mint = ["toUserId"], mintedIn = ["src/session.ts"] }] }]
+`,
+ "tsconfig.json": `{ "compilerOptions": { "strict": true, "jsx": "preserve" } }\n`,
+ "a.tsx": `import { exec, spawn } from "node:child_process";
+import fs from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import fc from "fast-check";
+import React, { useRef, useEffect, useState } from "react";
+import axios from "axios";
+const a1 = import("a");
+const addon = require("./addon.node");
+const port = process.env.PORT;
+const env = { ...process.env };
+const t = "/tmp/a.txt";
+const r = " ".repeat(width - text.length);
+try {} catch (error: unknown) {}
+const s = { ...(b ? { c: 1 } : {}) };
+const n = b.split(",").length;
+await new Promise(done => setTimeout(done, 250));
+spawn("npm", ["install"]);
+spawn("ls", ["-l"]);
+exec("a && b");
+exec("ps -ef");
+fs.readFileSync("a.txt");
+const A = z.string();
+start();
+a.b = 1;
+fc.property(fc.integer(), a => fc.sample(fc.integer(), 1));
+fc.property(fc.integer(), a => a > Math.random());
+React.useState(0);
+function C({ count }) {
+ const saved = useRef(count);
+ saved.current = count;
+ useEffect(() => {
+ saved.current = count;
+ });
+ const [rows, setRows] = useState([]);
+ setRows([...rows, 1]);
+}
+const x = ;
+// oxlint-disable-next-line no-debugger
+debugger;
+const f = "a foo b";
+const controller = new AbortController();
+setTimeout(() => controller.abort(), 2000);
+await fetch(address, { signal: controller.signal });
+const j = join(import.meta.dirname, "a.txt");
+function Table({ rows }) {
+ const renderCell = row => {rows.map(renderCell)}
;
+}
+axios.get("/a");
+axios.get("/a", { timeout: 0 });
+const ps = "ps -ef";
+`,
+ "src/ids.ts": `export type UserId = string & { brand: 1 };
+export const toUserId = (a: string) => a as UserId;
+`,
+ "src/views/page.ts": `import type { UserId } from "../ids";
+import { toUserId } from "../ids";
+const a = text as UserId;
+const b = toUserId(text);
+`,
+ };
+ const { stdout, exitCode } = await lint(files, ["-f", "json"]);
+ const messages = (JSON.parse(stdout) as { messages: { ruleId: string | null; message: string }[] }[])
+ .flatMap(it => it.messages)
+ .filter(it => it.ruleId?.startsWith("bun/"));
+ expect([...new Set(messages.map(it => `${it.ruleId}: ${it.message}`))].sort()).toEqual([
+ "bun/consistent-directive-prefix: Use `eslint` instead of `oxlint`.",
+ "bun/jsx-no-forbidden-nesting: `` cannot be inside ``.",
+ "bun/no-array-just-to-count: `split()` builds an array only to read its length. Count the separators instead.",
+ "bun/no-cast-to-brand: This cast creates a `UserId` from an unchecked value. Only `src/ids` should create one.",
+ "bun/no-cast-to-brand: `toUserId` turns any value into a `UserId`, and this file is not allowed to import it.",
+ "bun/no-console-window-flash: On Windows, this process briefly opens a console window. Set `windowsHide: true`.",
+ 'bun/no-cwd-dependent-path: "a.txt" is relative to the working directory of the process. Resolve it from `import.meta.dirname`.',
+ "bun/no-eager-dynamic-import: This `import()` runs as soon as the module is imported. Call it where it is needed, or use an `import` statement.",
+ "bun/no-eager-native-addon: The native addon `./addon.node` loads as soon as the module is imported. Load it inside the function that needs it.",
+ "bun/no-env-at-module-scope: The environment is read as soon as the module is imported. Read it inside the function that needs it.",
+ "bun/no-env-at-module-scope: `process.env.PORT` is read as soon as the module is imported. Read it inside the function that needs it.",
+ "bun/no-literal-temp-dir: `/tmp` is not the temporary directory on every system. Use `os.tmpdir()`.",
+ "bun/no-negative-repeat-count: `repeat()` throws a `RangeError` if this count is negative. Give it a lower bound.",
+ "bun/no-redundant-catch-type: With `strict` or `useUnknownInCatchVariables`, a `catch` variable is already `unknown`. Remove the annotation.",
+ "bun/no-restricted-text: `foo` matches the restricted pattern `foo`.",
+ "bun/no-side-effects-on-import: This changes an object as soon as the module is imported. Move it into an exported function.",
+ "bun/no-side-effects-on-import: This runs as soon as the module is imported. Move it into an exported function.",
+ "bun/no-unbounded-requests: This axios request has no time limit. Set `timeout` or pass a `signal`.",
+ "bun/no-unbounded-requests: `timeout: 0` means no time limit.",
+ "bun/no-unhandled-emitter-errors: `spawn()` emits `error` when it fails, which crashes the process if nothing listens. Add an `error` listener.",
+ "bun/no-unportable-commands: On Windows, `npm` is the script `npm.cmd`, which cannot run without a shell.",
+ "bun/no-unportable-commands: `&&` is shell syntax, and the shell differs between systems.",
+ "bun/no-unportable-commands: `ls` does not exist on Windows.",
+ "bun/no-unportable-commands: `ps` does not exist on Windows.",
+ "bun/no-unportable-commands: `ps` options differ between systems, and `ps` does not exist on Windows.",
+ "bun/no-unseeded-random-in-property-test: `Math.random()` ignores the seed of the run, so a failure cannot be replayed or shrunk. Make the value a parameter of the property.",
+ "bun/no-unseeded-random-in-property-test: `sample()` ignores the seed of the run, so a failure cannot be replayed or shrunk. Make the value a parameter of the property.",
+ "bun/no-useless-spread-fallback: This empty object is not needed. Spreading `false`, `null` or `undefined` into an object does nothing.",
+ "bun/prefer-builtin-sleep: This promise only waits. Use `Bun.sleep(ms)` or `setTimeout(ms)` from `node:timers/promises`.",
+ "bun/prefer-lazy-schema: This schema is built as soon as the module is imported. Build it when it is first used.",
+ "bun/prefer-local-module: Import from `@/http` instead of `axios`.",
+ "bun/prefer-timeout-signal: Only a timer aborts this controller. Use `AbortSignal.timeout(ms)` instead.",
+ 'bun/prefer-url-for-sibling-files: Bundlers cannot follow this path. Use `new URL("./file", import.meta.url)`.',
+ "bun/react-no-latest-value-ref: This effect only copies a value into `saved.current`. Use `useEffectEvent()` to read the latest values without a ref.",
+ "bun/react-no-latest-value-ref: `saved.current` is set during render. React may render more than once, or throw the result away.",
+ "bun/react-no-local-render-helpers: `renderCell` is created again on every render, and React does not see it as a component. Move it out and make it a component.",
+ 'bun/react-no-namespace-hooks: Import `useState` by name from "react".',
+ "bun/react-prefer-updater-function: `rows` may be out of date when `setRows` is called. Pass a function: `setRows(previous => ..)`.",
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
test("bun/prefer-local-module leaves the files in exemptFiles alone", async () => {
const options = { modules: [{ package: "axios", use: "@/http" }], exemptFiles: ["src/http.js"] };
const code = `import axios from "axios";\n`;
@@ -2593,10 +2897,13 @@ expect(1).toBe(1);
"8 bun:test/valid-expect-in-promise",
]);
expect(own(reported(stdout, "quiet.test.js"))).toEqual([]);
- // Errors, as what else is on, but for one.
+ // Skipping a test and exporting from a test file are often done on purpose. The rest are errors.
const files = JSON.parse(stdout) as { messages: { ruleId: string; severity: number }[] }[];
- const warnings = files.flatMap(it => it.messages).filter(it => it.severity !== 2);
- expect(warnings.map(it => it.ruleId)).toEqual(["bun:test/no-disabled-tests"]);
+ const ofBunTest = files.flatMap(it => it.messages).filter(it => it.ruleId.startsWith("bun:test/"));
+ expect(ofBunTest.filter(it => it.severity !== 2).map(it => it.ruleId)).toEqual([
+ "bun:test/no-disabled-tests",
+ "bun:test/no-export",
+ ]);
}
// A test that is skipped on purpose does not fail the run.
expect(unix(skipped.stdout)).toEqual(["2 Warning/bun:test/no-disabled-tests"]);
@@ -2703,6 +3010,24 @@ expect(1).toBe(1);
expect(named.exitCode).toBe(1);
});
+ test("`settings.vitest` doesn't apply to it", async () => {
+ const code = `import { describe } from "bun:test";\nimport { add } from "./add";\ndescribe("add", () => {});\ndescribe("", () => {});\n`;
+ const config = {
+ settings: { vitest: { typecheck: true } },
+ rules: { "bun:test/prefer-describe-function-title": 2, "bun:test/valid-title": 2 },
+ };
+ const { stdout } = await lint({ ".oxlintrc.json": JSON.stringify(config), "a.test.ts": code }, ["-f", "unix", "."]);
+ expect(unix(stdout)).toEqual(["3 Error/bun:test(prefer-describe-function-title)", "4 Error/bun:test(valid-title)"]);
+ });
+
+ test("valid-title prints the pattern exactly as the option spells it", async () => {
+ const code = `import { it, test } from "bun:test";\nit("a", () => {});\ntest("b", () => {});\n`;
+ const rules = { "bun:test/valid-title": ["error", { mustMatch: { it: "^should ", test: "/^ADDS /i" } }] };
+ const { stdout } = await lint({ "eslint.config.mjs": flat(rules), "a.test.js": code }, ["-f", "unix", "."]);
+ expect(stdout).toContain(":2:4: it should match ^should [");
+ expect(stdout).toContain(":3:6: test should match /^ADDS /i [");
+ });
+
test("comments turn a rule off", async () => {
const code = (prefix: string) => `import { test } from "bun:test";
// ${prefix}-disable-next-line ${name}
@@ -2863,7 +3188,7 @@ var a = b;
]);
expect(Object.entries(JSON.parse(plain.stdout).rules).filter(it => it[0].startsWith("bun:test/"))).toEqual([
["bun:test/no-disabled-tests", [1]],
- ["bun:test/no-export", [2]],
+ ["bun:test/no-export", [1]],
["bun:test/no-focused-tests", [2]],
["bun:test/valid-describe-callback", [2]],
["bun:test/valid-expect", [2]],
@@ -2875,7 +3200,7 @@ var a = b;
expect(JSON.parse(oxlint.stdout).plugins).toEqual([]);
});
- test("--rules lists them, without a category and without a page", async () => {
+ test("--rules lists them, without a category", async () => {
const [json, lines, alone] = await Promise.all([
lint({ ".oxlintrc.json": "{}" }, ["--rules", "-f", "json"]),
lint({}, ["--rules"]),
@@ -2885,9 +3210,10 @@ var a = b;
expect(alone.stdout).toBe(json.stdout);
const listed = (JSON.parse(json.stdout) as Record[]).filter(it => it.scope === "bun:test");
expect(listed.map(it => it.value)).toEqual(Object.keys(twins));
- expect([...new Set(listed.map(it => JSON.stringify([it.category, it.default, it.docs_url])))]).toEqual([
- "[null,false,null]",
- ]);
+ expect([...new Set(listed.map(it => JSON.stringify([it.category, it.default])))]).toEqual(["[null,false]"]);
+ expect(listed.map(it => it.docs_url)).toEqual(
+ listed.map(it => `https://bun.com/docs/lint/rules/bun-test/${it.value}`),
+ );
expect(lines.stdout.split("\n").filter(it => it.startsWith("bun:test/"))).toEqual(
Object.keys(twins).map(it => `bun:test/${it}`),
);
@@ -2937,7 +3263,7 @@ var a = b;
expect(taken.stderr).not.toContain("Key");
expect(taken.exitCode).toBe(0);
const missing = await check({ "bun:test/no-mocks-import": "error" });
- expect(missing.stderr).toContain(`1 rule of the plugin "bun:test" did not run: bun:test/no-mocks-import`);
+ expect(missing.stderr).toContain("1 rule in eslint.config.mjs is not supported: bun:test/no-mocks-import");
expect(missing.exitCode).toBe(2);
});
diff --git a/test/cli/lint/bunfig.test.ts b/test/cli/lint/bunfig.test.ts
new file mode 100644
index 000000000000..7a24d93489ec
--- /dev/null
+++ b/test/cli/lint/bunfig.test.ts
@@ -0,0 +1,956 @@
+// Tests for the `[lint]` section of bunfig.toml.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+// Disable AI agent and CI detection regardless of the environment the tests run in.
+const env = {
+ ...bunEnv,
+ AGENT: "0",
+ CLAUDECODE: undefined,
+ REPL_ID: undefined,
+ GITHUB_ACTIONS: undefined,
+ GITHUB_WORKSPACE: undefined,
+ NO_COLOR: undefined,
+ FORCE_COLOR: undefined,
+};
+
+const config = (rules: Record) => `export default [{ rules: ${JSON.stringify(rules)} }];\n`;
+const basic = config({
+ "no-debugger": "error",
+ "no-unused-vars": "warn",
+ eqeqeq: "error",
+ yoda: ["error", "always"],
+ "no-var": "warn",
+});
+const bad = "var a = 1\nif (a == 2) { debugger; }\n";
+
+/** Runs `bun lint ...args` in a temp directory containing `files`. `reads` lists the files to read back afterwards. */
+async function lint(files: Record, args: string[], reads: string[] = []) {
+ using dir = tempDir("bun-lint", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", ...args],
+ env,
+ cwd: String(dir),
+ stdin: "ignore",
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ const read = (name: string) =>
+ existsSync(join(String(dir), name)) ? readFileSync(join(String(dir), name), "utf8") : null;
+ type Result = { filePath: string; messages: { ruleId: string | null; severity: number }[] };
+ const results: Result[] = stdout.startsWith('{"results":') ? JSON.parse(stdout).results : [];
+ const problems = results.flatMap(({ filePath, messages }) => {
+ const file = normalizeBunSnapshot(filePath, String(dir)).replace("/", "");
+ return messages.map(it => `${file} ${it.ruleId ?? "-"} ${it.severity === 2 ? "error" : "warn"}`);
+ });
+ return {
+ /** One `file rule severity` string per problem. Empty unless the run used `-f json-with-metadata`. */
+ problems: problems.sort(),
+ stdout: normalizeBunSnapshot(stdout, String(dir)),
+ stderr: normalizeBunSnapshot(stderr, String(dir)),
+ exitCode,
+ files: Object.fromEntries(reads.map(name => [name, read(name)])),
+ };
+}
+
+// Each `[lint]` key sets the default for the flag of the same name.
+describe.concurrent("[lint] in bunfig.toml", () => {
+ /** Returns everything a run leaves behind: its output with timings masked, its exit code and the files. */
+ async function run(files: Record, args: string[]) {
+ const reads = Object.keys(files).filter(name => name !== "bunfig.toml");
+ const result = await lint(files, args, reads);
+ // JSON doubles the backslashes in Windows paths, so `normalizeBunSnapshot` misses the temp directory there.
+ // Mask its random suffix here.
+ const text = (printed: string) => printed.replace(/\d+(\.\d+)?m?s\b/g, "0ms").replace(/\bbun-lint_\w+/g, "");
+ return { stdout: text(result.stdout), stderr: text(result.stderr), exitCode: result.exitCode, files: result.files };
+ }
+
+ const eslint = { "eslint.config.js": basic, "a.js": bad };
+ const oxlint = { ".oxlintrc.json": `{ "rules": { "no-debugger": "error", "no-var": "warn" } }`, "a.js": bad };
+ const typed = {
+ ".oxlintrc.json": `{ "rules": { "typescript/no-floating-promises": "error" } }`,
+ "tsconfig.json": `{ "compilerOptions": { "strict": true }, "include": ["*.ts"] }`,
+ "a.ts": "async function f() {}\nf();\nconst a: string = 1;\n",
+ };
+ const many = Array.from({ length: 60 }, () => "debugger;\n").join("");
+ const suppressions = JSON.stringify({
+ "a.js": { "no-debugger": { count: 1 }, eqeqeq: { count: 1 }, yoda: { count: 1 } },
+ });
+
+ // Each case: the bunfig.toml lines, the equivalent flags, flags that override them, the files, and the other args.
+ const keys: [lines: string, flags: string[], opposite: string[], files: Record, args: string[]][] = [
+ [
+ `config = "other.config.js"`,
+ ["--config", "other.config.js"],
+ ["-c", "eslint.config.js"],
+ { ...eslint, "other.config.js": config({ "no-var": "error" }) },
+ ["a.js"],
+ ],
+ [`configLookup = false`, ["--no-config-lookup"], ["--config-lookup"], eslint, ["a.js"]],
+ [`flavor = "oxlint"`, ["--flavor=oxlint"], ["--flavor=eslint"], { ...eslint, ...oxlint }, ["a.js"]],
+ [`flavor = "eslint"`, ["--flavor=eslint"], ["--flavor=oxlint"], { ...eslint, ...oxlint }, ["a.js"]],
+ [`ext = [".foo"]`, ["--ext", ".foo"], [], { ...eslint, "b.foo": bad }, ["."]],
+ [`ext = ".foo"`, ["--ext", ".foo"], [], { ...eslint, "b.foo": bad }, ["."]],
+ [
+ `ignorePatterns = ["b.js", "sub/"]`,
+ ["--ignore-pattern", "b.js", "--ignore-pattern=sub/"],
+ [],
+ { ...eslint, "b.js": bad, "sub/c.js": bad },
+ ["."],
+ ],
+ [`ignorePath = "mine"`, ["--ignore-path", "mine"], [], { ...oxlint, "b.js": bad, mine: "b.js\n" }, ["."]],
+ [
+ `ignore = false`,
+ ["--no-ignore"],
+ ["--ignore"],
+ {
+ "eslint.config.js": `export default [{ ignores: ["a.js"] }, { rules: { "no-debugger": "error" } }];`,
+ "a.js": bad,
+ },
+ ["a.js"],
+ ],
+ [
+ `warnIgnored = false`,
+ ["--no-warn-ignored"],
+ ["--warn-ignored"],
+ { "eslint.config.js": `export default [{ ignores: ["a.js"] }];`, "a.js": bad, "b.js": "" },
+ ["a.js", "b.js"],
+ ],
+ [`quiet = true`, ["--quiet"], ["--no-quiet"], eslint, ["a.js"]],
+ [`silent = true`, ["--silent"], ["--no-silent"], oxlint, ["a.js"]],
+ [
+ `maxWarnings = 0`,
+ ["--max-warnings", "0"],
+ ["--max-warnings=10"],
+ { ...eslint, "a.js": "var a = 1;\na;\n" },
+ ["a.js"],
+ ],
+ [
+ `denyWarnings = true`,
+ ["--deny-warnings"],
+ ["--no-deny-warnings"],
+ { ...oxlint, "a.js": "var a = 1;\na;\n" },
+ ["a.js"],
+ ],
+ [`format = "unix"`, ["-f", "unix"], ["--format=json"], eslint, ["a.js"]],
+ [`all = true`, ["--all"], ["--no-all"], { ...eslint, "a.js": many }, ["-f", "pretty", "a.js"]],
+ [
+ `inlineConfig = false`,
+ ["--no-inline-config"],
+ ["--inline-config"],
+ { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\ndebugger;\n" },
+ ["a.js"],
+ ],
+ [
+ `reportUnusedDisableDirectives = true`,
+ ["--report-unused-disable-directives"],
+ ["--report-unused-disable-directives-severity=off"],
+ { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\na;\n" },
+ ["a.js"],
+ ],
+ [
+ `reportUnusedDisableDirectives = "off"`,
+ ["--report-unused-disable-directives-severity", "off"],
+ ["--report-unused-disable-directives"],
+ { ...eslint, "a.js": "// eslint-disable-next-line no-debugger\na;\n" },
+ ["a.js"],
+ ],
+ [
+ `reportUnusedInlineConfigs = "error"`,
+ ["--report-unused-inline-configs=error"],
+ ["--report-unused-inline-configs=off"],
+ { ...eslint, "a.js": "/* eslint no-debugger: error */\na;\n" },
+ ["a.js"],
+ ],
+ [
+ `suppressionsLocation = "known.json"`,
+ ["--suppressions-location", "known.json"],
+ ["--suppressions-location=none.json"],
+ { ...eslint, "known.json": suppressions },
+ ["a.js"],
+ ],
+ [
+ `passOnUnprunedSuppressions = true`,
+ ["--pass-on-unpruned-suppressions"],
+ ["--no-pass-on-unpruned-suppressions"],
+ { ...eslint, "a.js": "a;\n", "eslint-suppressions.json": suppressions },
+ ["a.js"],
+ ],
+ [
+ `errorOnUnmatchedPattern = false`,
+ ["--no-error-on-unmatched-pattern"],
+ ["--error-on-unmatched-pattern"],
+ eslint,
+ ["none.js"],
+ ],
+ [`passOnNoPatterns = true`, ["--pass-on-no-patterns"], ["--no-pass-on-no-patterns"], eslint, []],
+ [
+ `exitOnFatalError = true`,
+ ["--exit-on-fatal-error"],
+ ["--no-exit-on-fatal-error"],
+ { ...eslint, "a.js": "a(" },
+ ["a.js"],
+ ],
+ [
+ `allowUnsupported = true`,
+ ["--allow-unsupported"],
+ ["--no-allow-unsupported"],
+ { ".eslintrc.json": `{ "rules": { "no-debugger": "error", "require-jsdoc": "warn" } }`, "a.js": bad },
+ ["a.js"],
+ ],
+ [
+ `inferGlobals = true`,
+ ["--infer-globals"],
+ ["--no-infer-globals"],
+ {
+ "eslint.config.js": config({ "no-undef": "error" }),
+ "tsconfig.json": `{ "compilerOptions": { "allowJs": true }, "include": ["*.ts", "*.js"] }`,
+ "globals.d.ts": "declare const mine: number;\n",
+ "a.js": "mine;\nother;\n",
+ },
+ ["a.js"],
+ ],
+ [`typeAware = true`, ["--type-aware"], ["--no-type-aware"], typed, ["a.ts"]],
+ [
+ `typeAware = false`,
+ ["--no-type-aware"],
+ ["--type-aware"],
+ {
+ ...typed,
+ ".oxlintrc.json": `{ "options": { "typeAware": true }, "rules": { "typescript/no-floating-promises": "error" } }`,
+ },
+ ["a.ts"],
+ ],
+ [`typeCheck = true`, ["--type-check"], ["--no-type-check"], typed, ["--type-aware", "a.ts"]],
+ [
+ `tsconfig = "none.json"`,
+ ["--tsconfig", "none.json"],
+ ["--tsconfig", "tsconfig.json"],
+ typed,
+ ["--type-aware", "a.ts"],
+ ],
+ [`project = "none.json"`, ["--project", "none.json"], ["-p", "tsconfig.json"], typed, ["--type-aware", "a.ts"]],
+ [
+ `disableNestedConfig = true`,
+ ["--disable-nested-config"],
+ ["--no-disable-nested-config"],
+ { ...oxlint, "sub/.oxlintrc.json": `{ "rules": { "no-debugger": "off" } }`, "sub/a.js": bad },
+ ["sub/a.js"],
+ ],
+ [
+ `fixType = ["suggestion"]`,
+ ["--fix-type", "suggestion"],
+ [],
+ { "eslint.config.js": config({ "unicode-bom": ["error", "always"], "no-var": "error" }), "a.js": bad },
+ ["--fix", "a.js"],
+ ],
+ [
+ `[lint.rules]\n"no-debugger" = "off"\neqeqeq = ["error", "smart"]\n"no-eval" = 2`,
+ ["--rule", `{"no-debugger": "off", "eqeqeq": ["error", "smart"], "no-eval": 2}`],
+ ["--rule", "no-debugger: warn"],
+ { ...eslint, "a.js": `${bad}eval(a == null);\n` },
+ ["a.js"],
+ ],
+ [
+ `[lint.rules]\n"no-debugger" = "off"\n"no-eval" = "error"`,
+ ["--rule", `{"no-debugger": "off", "no-eval": "error"}`, "--flavor=oxlint"],
+ ["--rule", "no-debugger: warn"],
+ { ...oxlint, "a.js": `${bad}eval(a);\n` },
+ ["a.js"],
+ ],
+ [
+ `[lint.rules]\n"no-restricted-imports" = ["error", { paths = ["lodash"], patterns = [{ group = ["a\\nb*"], message = "it's \\"so\\"" }] }]`,
+ ["--rule", `{"no-restricted-imports": ["error", { "paths": ["lodash"] }]}`],
+ [],
+ { ...eslint, "a.js": `import "lodash";\n` },
+ ["a.js"],
+ ],
+ [
+ `[lint.globals]\nmine = "readonly"\nyours = true\ntheirs = false\nours = "writable"`,
+ ["--global", "mine,yours:true", "--global", "theirs,ours:true"],
+ [],
+ {
+ "eslint.config.js": config({ "no-undef": "error", "no-global-assign": "error" }),
+ "a.js": "mine = yours = theirs = ours = other;\n",
+ },
+ ["a.js"],
+ ],
+ [
+ `[lint.parserOptions]\necmaFeatures = { jsx = true }`,
+ ["--parser-options", "ecmaFeatures: { jsx: true }"],
+ ["--parser-options", "ecmaFeatures: { jsx: false }"],
+ { ...eslint, "a.js": ";\n" },
+ ["a.js"],
+ ],
+ [
+ `[lint.categories]\nstyle = "warn"\nall = "off"\ncorrectness = "error"`,
+ ["-A", "all", "-W", "style", "-D", "correctness"],
+ [],
+ { ".oxlintrc.json": "{}", "a.js": `${bad}for (;;) {}\n` },
+ ["a.js"],
+ ],
+ ];
+
+ test.each(keys)("%s", async (lines, flags, opposite, files, args) => {
+ const bunfig = { "bunfig.toml": lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n` };
+ const [plain, byKey, byFlag, underFlag, byOtherFlag] = await Promise.all([
+ run(files, args),
+ run({ ...files, ...bunfig }, args),
+ run(files, [...flags, ...args]),
+ run({ ...files, ...bunfig }, [...opposite, ...args]),
+ // Flags add to list and table keys instead of replacing them.
+ run(files, [...(opposite.length === 0 || /^\[|= \[/.test(lines) ? flags : []), ...opposite, ...args]),
+ ]);
+ expect(byKey).toEqual(byFlag);
+ expect(byKey).not.toEqual(plain);
+ expect(underFlag).toEqual(byOtherFlag);
+ });
+
+ test("threads works like --threads and rejects a negative number", async () => {
+ const [byKey, byFlag, wrong] = await Promise.all([
+ run({ ...eslint, "bunfig.toml": "[lint]\nthreads = 1\n" }, ["a.js"]),
+ run(eslint, ["--threads=1", "a.js"]),
+ run({ ...eslint, "bunfig.toml": "[lint]\nthreads = -1\n" }, ["a.js"]),
+ ]);
+ expect(byKey).toEqual(byFlag);
+ expect(wrong.stderr).toContain(`--threads takes a number, not "-1"`);
+ expect(wrong.exitCode).toBe(2);
+ });
+
+ // At 288 bytes per thread, these would take 19 GB, or more than the address space.
+ test.each(["67108864", "9007199254740991", "9223372036854775808"])(
+ "%s threads is capped at the maximum",
+ async count => {
+ const [byKey, byFlag, few] = await Promise.all([
+ run({ ...eslint, "bunfig.toml": `[lint]\nthreads = ${count}\n` }, ["a.js"]),
+ run(eslint, [`--threads=${count}`, "a.js"]),
+ run(eslint, ["--threads=1", "a.js"]),
+ ]);
+ // Above 2^53 - 1, bunfig.toml fails to load before the key is read.
+ if (Number.isSafeInteger(Number(count))) expect(byKey).toEqual(few);
+ expect(byFlag).toEqual(few);
+ },
+ );
+
+ // ESLint rejects --fix-type in a run that doesn't fix anything.
+ test("fixType is ignored unless the run fixes", async () => {
+ const files = { ...eslint, "bunfig.toml": `[lint]\nfixType = ["layout"]\n` };
+ const [without, plain, dry, dryByFlag] = await Promise.all([
+ run(files, ["a.js"]),
+ run(eslint, ["a.js"]),
+ run(files, ["--fix-dry-run", "-f", "json", "a.js"]),
+ run(eslint, ["--fix-dry-run", "--fix-type=layout", "-f", "json", "a.js"]),
+ ]);
+ expect(without).toEqual(plain);
+ expect(dry).toEqual(dryByFlag);
+ });
+
+ test("a key doesn't pick between an ESLint and an oxlint config", async () => {
+ const both = { ...eslint, ...oxlint };
+ const undecided = "note: Using .oxlintrc.json. eslint.config.js is ignored. Use --config to pick it.";
+ const results = await Promise.all(
+ [
+ `denyWarnings = true`,
+ `typeAware = true`,
+ `ext = [".js"]`,
+ `[lint.rules]\n"no-var" = "off"`,
+ `[lint.categories]\nstyle = "warn"`,
+ ].map(lines =>
+ run({ ...both, "bunfig.toml": lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n` }, ["a.js"]),
+ ),
+ );
+ for (const result of results) {
+ expect(result.stderr).toContain(undecided);
+ expect(result.exitCode).toBe(1);
+ }
+ // With only an ESLint config, neither the key nor the flag switches the run to oxlint.
+ const [byKey, byFlag, plain] = await Promise.all([
+ run({ ...eslint, "bunfig.toml": "[lint]\ndenyWarnings = true\n" }, ["-f", "unix", "a.js"]),
+ run(eslint, ["--deny-warnings", "-f", "unix", "a.js"]),
+ run(eslint, ["-f", "unix", "a.js"]),
+ ]);
+ expect(byKey.stdout).toBe(plain.stdout);
+ expect(byFlag.stdout).toBe(plain.stdout);
+ });
+
+ test("bun/format compares a file with bun fmt's output, including [fmt] options", async () => {
+ const files = { "a.js": "a('b')\n", "bunfig.toml": "[fmt]\nsemi = false\nsingleQuote = true\n" };
+ const rule = (...options: unknown[]) => ({
+ ".oxlintrc.json": JSON.stringify({ rules: { "bun/format": ["error", ...options] } }),
+ });
+ const [withSection, without, overridden] = await Promise.all([
+ run({ ...files, ...rule() }, ["-f", "unix", "a.js"]),
+ run({ "a.js": files["a.js"], ...rule() }, ["-f", "unix", "a.js"]),
+ run({ ...files, ...rule({ semi: true }) }, ["-f", "unix", "a.js"]),
+ ]);
+ expect(withSection.stdout).toBe("");
+ expect(withSection.exitCode).toBe(0);
+ expect(without.stdout).toContain(`Replace \`'b')\` with \`"b");\``);
+ expect(overridden.stdout).toContain("Insert `;`");
+ expect(overridden.stdout).not.toContain("Replace");
+ });
+
+ test("bunfig.toml is read from the working directory, after --cwd is applied", async () => {
+ const files = {
+ ...eslint,
+ "sub/a.js": bad,
+ "bunfig.toml": `[lint]\nformat = "unix"\n`,
+ "sub/bunfig.toml": `[lint]\nquiet = true\nformat = "json"\n`,
+ };
+ const [above, below] = await Promise.all([run(files, ["sub/a.js"]), run(files, ["--cwd=sub", "a.js"])]);
+ expect(above.stdout).toContain("[Warning/no-var]");
+ expect(JSON.parse(below.stdout)[0].warningCount).toBe(0);
+ });
+
+ /** Runs `bun ...args` in a temp directory containing `files`. */
+ async function bun(files: Record, args: string[]) {
+ using dir = tempDir("bun-lint-bunfig", files);
+ const stdio = { stdin: "ignore", stdout: "pipe", stderr: "pipe" } as const;
+ await using proc = spawn({ cmd: [bunExe(), ...args], env, cwd: String(dir), ...stdio });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+ }
+
+ test("--config= before `lint` picks a file other than bunfig.toml", async () => {
+ const files = {
+ ...eslint,
+ "bunfig.toml": `[lint]\nformat = "unix"\n`,
+ "other.toml": `[lint]\nformat = "json"\n`,
+ };
+ const results = await Promise.all([
+ bun(files, ["lint", "a.js"]),
+ bun(files, ["--config=other.toml", "lint", "a.js"]),
+ bun(files, ["-c=other.toml", "lint", "a.js"]),
+ // Flags after `lint` belong to the linter.
+ bun(files, ["--config=other.toml", "lint", "-c", "eslint.config.js", "a.js"]),
+ bun(files, ["--config=none.toml", "lint", "a.js"]),
+ ]);
+ expect(results.map(it => [it.stdout.startsWith("[{"), it.exitCode])).toEqual([
+ [false, 1],
+ [true, 1],
+ [true, 1],
+ [true, 1],
+ [false, 2],
+ ]);
+ expect(results[4].stderr).toContain(`while reading config "`);
+ });
+
+ test("errors in [lint] point at the line in bunfig.toml, like errors in other sections", async () => {
+ const bunfig = `[lint]\nquiet = true\n\n[lint.rules]\neqeqeq = ["error", "smart"]\n"no-var" = "always"\n`;
+ const result = await bun({ ...eslint, "bunfig.toml": bunfig }, ["lint", "a.js"]);
+ expect(result.stderr).toContain(`6 | "no-var" = "always"\n`);
+ expect(result.stderr).toMatch(
+ /error: "always" is not a valid severity for no-var\n Expected "off", "warn", or "error"\n\s+at bunfig\.toml:6:12\n$/,
+ );
+ expect(result.stdout).toBe("");
+ expect(result.exitCode).toBe(2);
+ });
+
+ test.each(["--config=", "-c="])(
+ "a mistake in the rules of bun %sother.toml lint is shown in that file",
+ async flag => {
+ const files = {
+ "a.js": "foo;\n",
+ "bunfig.toml": `# Not read.\n[lint.rules]\n"no-var" = "error"\n`,
+ "config/other.toml": `[lint.rules]\n"no-vra" = "error"\n`,
+ };
+ const result = await bun(files, [flag + "config/other.toml", "lint", "a.js"]);
+ expect(result.stderr).toContain(`2 | "no-vra" = "error"\n`);
+ expect(result.stderr).toMatch(
+ /error: Unknown rule "no-vra"\n Did you mean "no-var"\?\n\s+at config\/other\.toml:2:1\n$/,
+ );
+ expect(result.exitCode).toBe(2);
+ },
+ );
+
+ // These flags describe a single run, not the project.
+ test.each([
+ ["fix = true", "--fix"],
+ ["fixDryRun = true", "--fix-dry-run"],
+ ["fixSuggestions = true", "--fix-suggestions"],
+ ["fixDangerously = true", "--fix-dangerously"],
+ ["init = true", "--init"],
+ ["stdin = true", "--stdin"],
+ [`stdinFilename = "a.js"`, "--stdin-filename"],
+ [`printConfig = "a.js"`, "--print-config"],
+ ["suppressAll = true", "--suppress-all"],
+ [`suppressRule = ["no-var"]`, "--suppress-rule"],
+ ["pruneSuppressions = true", "--prune-suppressions"],
+ [`outputFile = "report.txt"`, "--output-file"],
+ ["color = true", "--color"],
+ ["timing = true", "--timing"],
+ [`cwd = "sub"`, "--cwd"],
+ ])("%s is rejected and nothing is written", async (line, flag) => {
+ const key = line.split(" ")[0];
+ const result = await run({ ...eslint, "bunfig.toml": `[lint]\n${line}\n` }, ["a.js"]);
+ expect(result.stderr).toContain(
+ `error: "${key}" cannot be set in bunfig.toml\n Use ${flag} on the command line\n`,
+ );
+ expect(result.stdout).toBe("");
+ expect(result.files["a.js"]).toBe(bad);
+ expect(result.exitCode).toBe(2);
+ });
+
+ test.each([
+ ["quiet = 1", "expected boolean but received number"],
+ [`maxWarnings = "0"`, "expected number but received string"],
+ ["maxWarnings = 1.5", "maxWarnings must be a whole number"],
+ ["config = false", "expected string but received boolean"],
+ ["ignorePatterns = true", "expected array but received boolean"],
+ ["ignorePatterns = [1]", "expected string but received number"],
+ [`flavor = "biome"`, '--flavor must be eslint or oxlint, not "biome"'],
+ [`format = "fancy"`, `Unknown format "fancy"\n Available formats: stylish, pretty, json,`],
+ [`fixType = ["all"]`, `Unknown fix type\n Expected "directive", "problem", "suggestion", or "layout"`],
+ ["fixType = true", "expected array but received boolean"],
+ [
+ `reportUnusedDisableDirectives = "loud"`,
+ `"loud" is not a valid severity for reportUnusedDisableDirectives\n Expected "off", "warn", or "error"`,
+ ],
+ ["reportUnusedDisableDirectives = 3", "3 is not a valid severity for reportUnusedDisableDirectives"],
+ [`reportUnusedInlineConfigs = true`, "true is not a valid severity for reportUnusedInlineConfigs"],
+ ["rules = true", "expected object but received boolean"],
+ [
+ `[lint.rules]\neqeqeq = "always"`,
+ `"always" is not a valid severity for eqeqeq\n Expected "off", "warn", or "error"`,
+ ],
+ [`[lint.rules]\neqeqeq = ["smart"]`, `"smart" is not a valid severity for eqeqeq`],
+ [`[lint.rules]\neqeqeq = []`, "[] is not a valid severity for eqeqeq"],
+ [`[lint.rules]\neqeqeq = true`, "true is not a valid severity for eqeqeq"],
+ [
+ `[lint.globals]\na = "on"`,
+ `"on" is not a valid value for the global a\n Expected "readonly", "writable", or "off"`,
+ ],
+ [`[lint.globals]\na = 1`, "1 is not a valid value for the global a"],
+ [`[lint.categories]\nstyles = "warn"`, `Unknown key "styles" in [lint.categories]\n Did you mean "style"?`],
+ [`[lint.categories]\nsecurity = "warn"`, `Unknown key "security" in [lint.categories]\n at`],
+ [`[lint.categories]\nstyle = "deny"`, `"deny" is not a valid severity for style`],
+ ["maxWarning = 0", `Unknown key "maxWarning" in [lint]\n Did you mean "maxWarnings"?`],
+ ["max-warnings = 0", `Unknown key "max-warnings" in [lint]\n Did you mean "maxWarnings"?`],
+ // Flag names whose key is spelled differently.
+ [`ignorePattern = ["a"]`, `Unknown key "ignorePattern" in [lint]\n Did you mean "ignorePatterns"?`],
+ [`rule = "a"`, `Unknown key "rule" in [lint]\n Did you mean "rules"?`],
+ [`global = "a"`, `Unknown key "global" in [lint]\n Did you mean "globals"?`],
+ [`deny = "style"`, `Unknown key "deny" in [lint]\n Did you mean "categories"?`],
+ // No similar key, so no suggestion.
+ [`plugins = ["import"]`, `Unknown key "plugins" in [lint]\n at`],
+ [`extends = ["a"]`, `Unknown key "extends" in [lint]\n at`],
+ ["cache = true", `Unknown key "cache" in [lint]\n at`],
+ [`env = ["node"]`, `Unknown key "env" in [lint]\n at`],
+ ])("%s is rejected: %s", async (lines, message) => {
+ const bunfig = lines.startsWith("[") ? `${lines}\n` : `[lint]\n${lines}\n`;
+ const result = await run({ ...eslint, "bunfig.toml": bunfig }, ["a.js"]);
+ expect(result.stderr).toContain(message);
+ expect(result.stdout).toBe("");
+ expect(result.exitCode).toBe(2);
+ });
+
+ test("every flag in --help has a key, or an error that names the flag to use instead", async () => {
+ const help = await lint({}, ["--help", "--all"]);
+ const flags = [...help.stdout.matchAll(/^\s+(?:-\w, )?--([a-z0-9-]+)/gm)].map(it => it[1]);
+ expect(flags.length).toBeGreaterThan(90);
+ const renamed: Record = {
+ "ignore-pattern": "ignorePatterns",
+ "report-unused-disable-directives-severity": "reportUnusedDisableDirectives",
+ rule: "rules",
+ global: "globals",
+ allow: "categories",
+ warn: "categories",
+ deny: "categories",
+ };
+ const answers = await Promise.all(
+ flags.map(async flag => {
+ const positive = flag.replace(/^no-/, "");
+ const key = renamed[positive] ?? positive.replace(/-(\w)/g, (_, it) => it.toUpperCase());
+ // No key takes a nested array, so a key that exists complains about the type.
+ const { stderr } = await run({ "bunfig.toml": `[lint]\n${key} = [[1]]\n` }, ["--list-files"]);
+ return [flag, /expected .+ but received|is not a valid severity|cannot be set in bunfig\.toml/.test(stderr)];
+ }),
+ );
+ // ESLint and oxlint flags that aren't project settings, or that do nothing.
+ expect(
+ answers
+ .filter(it => !it[1])
+ .map(it => it[0])
+ .sort(),
+ ).toEqual([
+ "cache",
+ "cache-file",
+ "cache-location",
+ "cache-strategy",
+ "concurrency",
+ "disable-oxc-plugin",
+ "disable-typescript-plugin",
+ "disable-unicorn-plugin",
+ "env",
+ "flag",
+ "import-plugin",
+ "jest-plugin",
+ "jsdoc-plugin",
+ "jsx-a11y-plugin",
+ "lsp",
+ "mcp",
+ "nextjs-plugin",
+ "no-eslintrc",
+ "node-plugin",
+ "parser",
+ "plugin",
+ "promise-plugin",
+ "react-perf-plugin",
+ "react-plugin",
+ "resolve-plugins-relative-to",
+ "rulesdir",
+ "vitest-plugin",
+ "vue-plugin",
+ ]);
+ });
+});
+
+describe.concurrent("[[lint.overrides]]", () => {
+ /** Returns the problems as `file rule severity`. This output format is the same for every kind of config. */
+ async function problems(files: Record, args: string[] = []) {
+ return (await lint(files, ["-f", "json-with-metadata", ...args])).problems;
+ }
+
+ const log = "console.log(1);\n";
+ const tree = {
+ "a.test.js": log,
+ "sub/b.test.js": log,
+ "sub/c.js": log,
+ "scripts/d.js": log,
+ "scripts/vendor/e.js": log,
+ "README.md": "# Not JavaScript\n",
+ };
+ const bunfig = `
+[lint.rules]
+"no-console" = "error"
+
+[[lint.overrides]]
+files = ["*.test.js", "scripts/**"]
+excludeFiles = ["scripts/vendor/**"]
+rules = { "no-console" = "off" }
+
+[[lint.overrides]]
+files = "*.md"
+rules = { "no-var" = "error" }
+`;
+ const left = ["scripts/vendor/e.js no-console error", "sub/c.js no-console error"];
+ const flat = `module.exports = [{ rules: { "no-console": "warn" } }];\n`;
+ const oxlintrc = JSON.stringify({ categories: { correctness: "off" }, rules: { "no-console": "warn" } });
+ const configs: Record> = {
+ "no config file": {},
+ "eslint.config.js": { "eslint.config.js": flat },
+ ".oxlintrc.json": { ".oxlintrc.json": oxlintrc },
+ ".eslintrc.json": { ".eslintrc.json": JSON.stringify({ root: true, rules: { "no-console": "warn" } }) },
+ };
+
+ describe.each(Object.keys(configs))("with %s", name => {
+ const files = { ...tree, ...configs[name], "bunfig.toml": bunfig };
+
+ // A pattern without a slash matches a file name in any directory. Others match the path relative to bunfig.toml.
+ test("an override applies to files that match `files` but not `excludeFiles`", async () => {
+ expect(await problems(files)).toEqual(left);
+ });
+
+ test("`files` doesn't add files to the run", async () => {
+ const { stdout, exitCode } = await lint(files, ["--list-files"]);
+ expect(stdout).toContain("c.js");
+ expect(stdout).not.toContain("README.md");
+ expect(exitCode).toBe(0);
+ });
+
+ test("--rule wins over an override, even when it repeats [lint.rules]", async () => {
+ const all = Object.keys(tree).filter(it => it.endsWith(".js"));
+ expect(await problems(files, ["--rule", "no-console: error"])).toEqual(
+ all.map(it => `${it} no-console error`).sort(),
+ );
+ expect(await problems(files, ["--rule", "no-console: warn", "sub"])).toEqual([
+ "sub/b.test.js no-console warn",
+ "sub/c.js no-console warn",
+ ]);
+ });
+
+ test("a later override wins over an earlier one", async () => {
+ const later = `${bunfig}\n[[lint.overrides]]\nfiles = "sub/**"\nrules = { "no-console" = "warn" }\n`;
+ expect(await problems({ ...files, "bunfig.toml": later })).toEqual([
+ "scripts/vendor/e.js no-console error",
+ "sub/b.test.js no-console warn",
+ "sub/c.js no-console warn",
+ ]);
+ });
+
+ test("patterns use Bun.Glob syntax, including extglobs and brace ranges", async () => {
+ const names = ["a/x.js", "ab/x.js", "c/x.js", "f1.js", "f3.js", "f4.js"];
+ const files = { ...configs[name], ...Object.fromEntries(names.map(it => [it, log])) };
+ const override = (patterns: string) =>
+ `[lint.rules]\n"no-console" = "error"\n[[lint.overrides]]\n${patterns}\nrules = { "no-console" = "off" }\n`;
+ const globs = `["+(a|b)/**", "f{1..3}.js"]`;
+ const reported = async (patterns: string) =>
+ (await problems({ ...files, "bunfig.toml": override(patterns) })).map(it => it.split(" ")[0]);
+ expect(await reported(`files = ${globs}`)).toEqual(["c/x.js", "f4.js"]);
+ expect(await reported(`files = "**/*.js"\nexcludeFiles = ${globs}`)).toEqual([
+ "a/x.js",
+ "ab/x.js",
+ "f1.js",
+ "f3.js",
+ ]);
+ });
+
+ test("a leading ! negates a pattern, with or without a slash", async () => {
+ const [a, aTest, b, bTest] = ["a.js", "a.test.js", "src/b.js", "src/b.test.js"];
+ const files = { ...configs[name], ...Object.fromEntries([a, aTest, b, bTest].map(it => [it, log])) };
+ // The patterns, and the files that still get reported because the override doesn't apply to them.
+ const rows: Record = {
+ 'files = ["*.test.js"]': [a, b],
+ 'files = ["!**/*.test.js"]': [aTest, bTest],
+ 'files = ["!*.test.js"]': [aTest, bTest],
+ 'files = ["!!*.test.js"]': [a, b],
+ 'files = ["!./a.js"]': [a],
+ 'files = ["!src/"]': [],
+ 'files = ["!src/**"]': [b, bTest],
+ // `!(` starts an extglob group. It isn't a negation.
+ 'files = ["!(a|b).js"]': [a, b],
+ 'files = ["!!(a|b).js"]': [aTest, bTest],
+ 'files = ["**/*.js"]\nexcludeFiles = ["!*.test.js"]': [a, b],
+ 'files = ["**/*.js"]\nexcludeFiles = ["!**/*.test.js"]': [a, b],
+ 'files = ["**/*.js"]\nexcludeFiles = ["!(a|b).js"]': [aTest, bTest],
+ };
+ const reported = async (patterns: string) => {
+ const bunfig = `[lint.rules]\n"no-console" = "error"\n[[lint.overrides]]\n${patterns}\nrules = { "no-console" = "off" }\n`;
+ return (await problems({ ...files, "bunfig.toml": bunfig })).map(it => it.split(" ")[0]);
+ };
+ const results = await Promise.all(Object.keys(rows).map(reported));
+ expect(Object.fromEntries(Object.keys(rows).map((patterns, at) => [patterns, results[at]]))).toEqual(rows);
+ });
+
+ test("an override can set globals, and --global wins over it", async () => {
+ const files = {
+ ...configs[name],
+ "a.js": "mine;\n",
+ "a.test.js": "mine;\n",
+ "bunfig.toml": `
+[lint.rules]
+"no-undef" = "error"
+[lint.globals]
+mine = "readonly"
+[[lint.overrides]]
+files = "*.test.js"
+globals = { mine = "off" }
+`,
+ };
+ expect(await problems(files, ["a.js", "a.test.js"])).toEqual(["a.test.js no-undef error"]);
+ expect(await problems(files, ["--global", "mine", "a.js", "a.test.js"])).toEqual([]);
+ });
+ });
+
+ // oxlint has no extglobs or brace ranges. It reads `{1..3}` as a group with one alternative, `1..3`.
+ // Checked against oxlint 1.87.
+ test("overrides in an .oxlintrc.json keep oxlint's glob syntax", async () => {
+ const overrides = [{ files: ["f{1..3}.js", "@(a|b)/**"], rules: { "no-console": "off" } }];
+ const files = {
+ ".oxlintrc.json": JSON.stringify({ ...JSON.parse(oxlintrc), rules: { "no-console": "error" }, overrides }),
+ "f1.js": log,
+ "f1..3.js": log,
+ "a/x.js": log,
+ };
+ expect(await problems(files)).toEqual(["a/x.js no-console error", "f1.js no-console error"]);
+ });
+
+ // oxlint puts `**/` in front of a pattern without a slash, even in front of a `!`, which then is a literal. Checked against
+ // oxlint 1.87.
+ test("a negated pattern without a slash in an .oxlintrc.json matches nothing, like in oxlint", async () => {
+ const config = (override: object) =>
+ JSON.stringify({
+ ...JSON.parse(oxlintrc),
+ rules: { "no-console": "error" },
+ overrides: [{ ...override, rules: { "no-console": "off" } }],
+ });
+ const files = { "a.js": log, "a.test.js": log };
+ const reported = async (override: object) =>
+ (await problems({ ...files, ".oxlintrc.json": config(override) })).map(it => it.split(" ")[0]);
+ expect(await reported({ files: ["!*.test.js"] })).toEqual(["a.js", "a.test.js"]);
+ expect(await reported({ files: ["!**/*.test.js"] })).toEqual(["a.test.js"]);
+ expect(await reported({ files: ["**/*.js"], excludeFiles: ["!*.test.js"] })).toEqual([]);
+ });
+
+ test("patterns are relative to bunfig.toml's directory, wherever the config file is", async () => {
+ const files = { ...tree, "bunfig.toml": bunfig, "config/mine.json": oxlintrc, "config/mine.js": flat };
+ expect(await problems(files, ["--config", "config/mine.json"])).toEqual(left);
+ expect(await problems(files, ["--config", "config/mine.js"])).toEqual(left);
+ const nested = { ...tree, "bunfig.toml": bunfig, ".oxlintrc.json": "{}", "scripts/.oxlintrc.json": oxlintrc };
+ expect(await problems(nested)).toEqual(left);
+ // That's the bunfig.toml in the working directory.
+ const below = { ...tree, "bunfig.toml": "", "scripts/bunfig.toml": bunfig.replaceAll("scripts/", "") };
+ expect(await problems(below, ["--cwd", "scripts"])).toEqual(["scripts/vendor/e.js no-console error"]);
+ });
+
+ test("a severity on its own keeps the options from [lint.rules]", async () => {
+ const files = {
+ "a.js": "export const f = a => [a == null, a == 1];\n",
+ "bunfig.toml": `[lint.rules]\neqeqeq = ["error", "smart"]\n[[lint.overrides]]\nfiles = "*.js"\nrules = { eqeqeq = "warn" }\n`,
+ };
+ expect(await problems(files)).toEqual(["a.js eqeqeq warn"]);
+ });
+
+ test("a core rule set for *.test.ts runs as its typescript-eslint version in every directory", async () => {
+ const files = {
+ "a.test.ts": "const unused = 1;\nexport {};\n",
+ "sub/b.test.ts": "const unused = 1;\nexport {};\n",
+ "bunfig.toml": `[[lint.overrides]]\nfiles = "*.test.ts"\nrules = { "no-unused-vars" = "error" }\n`,
+ };
+ expect(await problems(files)).toEqual([
+ "a.test.ts @typescript-eslint/no-unused-vars error",
+ "sub/b.test.ts @typescript-eslint/no-unused-vars error",
+ ]);
+ });
+
+ test("an override can set settings", async () => {
+ const files = {
+ "a.jsx": "export default a)(?b)"], " regex parse error:\n (?a)(?b)\n ^ ^\nerror: duplicate capture group name, received `[ \"(?a)(?b)\" ]`"],
+ ["id-match", ["a{2,1}"], " regex parse error:\n a{2,1}\n ^^^^^\nerror: invalid repetition count range, the start must be <= the end, received `[ \"a{2,1}\" ]`"],
+ ["id-match", ["\\1"], " regex parse error:\n \\1\n ^^\nerror: backreferences are not supported, received `[ \"\\\\1\" ]`"],
+ ["id-match", ["[z-a]"], " regex parse error:\n [z-a]\n ^^^\nerror: invalid character class range, the start must be <= the end, received `[ \"[z-a]\" ]`"],
+ ["id-match", ["(?i-i)"], " regex parse error:\n (?i-i)\n ^ ^\nerror: duplicate flag, received `[ \"(?i-i)\" ]`"],
+ ["id-match", ["a\nb("], " regex parse error:\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n1: a\n2: b(\n ^\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nerror: unclosed group, received `[ \"a\\nb(\" ]`"],
+ ["id-match", ["\\x{110000}"], " regex parse error:\n \\x{110000}\n ^^^^^^\nerror: hexadecimal literal is not a Unicode scalar value, received `[ \"\\\\x{110000}\" ]`"],
+ ["id-match", ["\u65e5\u672c("], " regex parse error:\n \u65e5\u672c(\n ^\nerror: unclosed group, received `[ \"\u65e5\u672c(\" ]`"],
+ ["id-denylist", ["a", 1], " invalid type: integer `1`, expected a string, received `[ \"a\", 1 ]`"],
+ ["func-names", ["always", {"generators": "x"}], " unknown variant `x`, expected one of `always`, `as-needed`, `never`, received `[ \"always\", { \"generators\": \"x\" } ]`"],
+ ["func-name-matching", ["x"], " Expected configuration to match either the first or second tuple type"],
+ ["func-name-matching", ["always", {"zz": 1}], " Error deserializing second tuple element: unknown field `zz`, expected `considerPropertyDescriptor` or `includeCommonJSModuleExports`"],
+ ["func-name-matching", ["always", {}, 1], " Expected at most 2 elements in the configuration array"],
+ ["func-name-matching", [{}, {}], " Error deserializing first tuple element: invalid value: map, expected map with a single key"],
+ ["logical-assignment-operators", ["never", {}], " options object is only valid with \"always\", received `[ \"never\", {} ]`"],
+ ["logical-assignment-operators", ["x"], " unknown variant `x`, expected `always` or `never`, received `[ \"x\" ]`"],
+ ["logical-assignment-operators", [1], " expected [], [\"always\"], [\"never\"], or [\"always\", options], received `[ 1 ]`"],
+ ["logical-assignment-operators", ["always", {"enforceForIfStatements": 1}], " invalid type: integer `1`, expected a boolean, received `[ \"always\", { \"enforceForIfStatements\": 1 } ]`"],
+ ["no-restricted-properties", [{}], " expected either `object` or `property`"],
+ ["no-restricted-properties", [{"object": "a", "allowObjects": ["b"]}], " `allowObjects` requires `property`"],
+ ["no-restricted-properties", [{"object": 1}], " invalid type: integer `1`, expected a string"],
+ ["no-restricted-properties", [{"object": "a"}, {"object": "a", "property": "b", "allowProperties": ["c"]}], " `allowProperties` cannot be used with `property`"],
+ ["sort-imports", [{"memberSyntaxSortOrder": ["none", "all"]}], " memberSyntaxSortOrder must contain exactly 4 kinds, got 2\n received config: `{ \"memberSyntaxSortOrder\": [ \"none\", \"all\" ] }`"],
+ ["sort-imports", [{"memberSyntaxSortOrder": ["none", "all", "multiple", "multiple"]}], " memberSyntaxSortOrder must contain 4 unique kinds, but duplicates were found\n received config: `{ \"memberSyntaxSortOrder\": [ \"none\", \"all\", \"multiple\", \"multiple\" ] }`"],
+ ["no-implicit-coercion", [{"allow": ["x"]}], " Invalid operator 'x' in allow list. Valid values are: \"!!\", \"~\", \"+\", \"- -\", \"-\", \"*\"\n received config: `{ \"allow\": [ \"x\" ] }`"],
+ ["no-implicit-coercion", [{"allow": "!!"}], " invalid type: string \"!!\", expected a sequence of operator strings\n received config: `{ \"allow\": \"!!\" }`"],
+ ["typescript/ban-ts-comment", [{"ts-check": "x"}], " expected a boolean, `allow-with-description`, or a descriptionFormat object\n received config: `{ \"ts-check\": \"x\" }`"],
+ ["typescript/ban-ts-comment", [{"ts-check": {"descriptionFormat": "("}}], " regex parse error:\n (\n ^\nerror: unclosed group\n received config: `{ \"ts-check\": { \"descriptionFormat\": \"(\" } }`"],
+ ["typescript/ban-ts-comment", [{"minimumDescriptionLength": -1}], " invalid value: integer `-1`, expected u64\n received config: `{ \"minimumDescriptionLength\": -1 }`"],
+ ["typescript/ban-ts-comment", [{"ts-ignore": {"zz": 1}}], " unknown field `zz`, expected `descriptionFormat`\n received config: `{ \"ts-ignore\": { \"zz\": 1 } }`"],
+ ["typescript/no-floating-promises", [{"allowForKnownSafeCalls": [{"from": "package", "name": "a"}]}], " data did not match any variant of untagged enum TypeOrValueSpecifier\n received config: `{ \"allowForKnownSafeCalls\": [ { \"from\": \"package\", \"name\": \"a\" } ] }`"],
+ ["typescript/no-restricted-types", [{"types": {"k": false}}], " data did not match any variant of untagged enum BanConfigValue\n received config: `{ \"types\": { \"k\": false } }`"],
+ ["typescript/array-type", [{"default": "x"}], " unknown variant `x`, expected one of `array`, `array-simple`, `generic`\n received config: `{ \"default\": \"x\" }`"],
+ ["typescript/no-this-alias", [{"allowNames": [], "allowedNames": []}], " duplicate field `allowedNames`\n received config: `{ \"allowNames\": [], \"allowedNames\": [] }`"],
+ ["unicorn/filename-case", [{"case": "x"}], " unknown variant `x`, expected one of `kebabCase`, `camelCase`, `snakeCase`, `pascalCase`, `lowercase`, `screamingSnakeCase`\n received config: `{ \"case\": \"x\" }`"],
+ ["unicorn/import-style", [{"styles": {"k": true}}], " module style override boolean must be `false`\n received config: `{ \"styles\": { \"k\": true } }`"],
+ ["react/jsx-no-literals", [{"zz": 1}], " unknown field `zz`\n received config: `{ \"zz\": 1 }`"],
+ ["react/jsx-no-literals", [{"noStrings": 1, "elementOverrides": 1}], " invalid type: integer `1`, expected a map\n received config: `{ \"noStrings\": 1, \"elementOverrides\": 1 }`"],
+ ["react/jsx-no-literals", [[]], " invalid type: sequence, expected struct JsxNoLiteralsConfig\n received config: `[]`"],
+ ["react/jsx-no-script-url", [{"zz": 1}], " Expected configuration to match either the first or second tuple type"],
+ ["react/jsx-no-script-url", [[], null], " Error deserializing second tuple element: invalid type: null, expected struct JsxNoScriptUrlOptions"],
+ ["react/forbid-component-props", [{"forbid": [{"message": "a"}]}], " data did not match any variant of untagged enum ForbidItem\n received config: `{ \"forbid\": [ { \"message\": \"a\" } ] }`"],
+ ["jsx-a11y/aria-role", [{"ignoreNonDOM": 1}], " invalid type: integer `1`, expected a boolean\n received config: `{ \"ignoreNonDOM\": 1 }`"],
+ ["react-perf/jsx-no-new-object-as-prop", [{"nativeAllowList": "x"}], " data did not match any variant of untagged enum NativeAllowList\n received config: `{ \"nativeAllowList\": \"x\" }`"],
+ ["jest/no-restricted-matchers", [{"toBe": 1}], " invalid type: integer `1`, expected a string\n received config: `{ \"toBe\": 1 }`"],
+ ["jest/no-restricted-matchers", [[]], " invalid type: sequence, expected struct NoRestrictedMatchersConfig\n received config: `[]`"],
+ ["jest/max-expects", [{"max": "x"}], " invalid type: string \"x\", expected u32\n received config: `{ \"max\": \"x\" }`"],
+ ["vitest/max-expects", [{"max": -1}], " invalid value: integer `-1`, expected u32\n received config: `{ \"max\": -1 }`"],
+ ["import/no-cycle", [{"maxDepth": -1}], " invalid value: integer `-1`, expected u32\n received config: `{ \"maxDepth\": -1 }`"],
+ ["import/first", ["x"], " unknown variant `x`, expected `absolute-first` or `disable-absolute-first`\n received config: `\"x\"`"],
+ ["import/no-nodejs-modules", [{}], " missing field `allow`\n received config: `{}`"],
+ ["import/no-nodejs-modules", [[]], " invalid length 0, expected struct NoNodejsModulesConfig with 1 element\n received config: `[]`"],
+ ["no-invalid-regexp", [{"allowConstructorFlags": ["ab"]}], " invalid value: string \"ab\", expected a character\n received config: `{ \"allowConstructorFlags\": [ \"ab\" ] }`"],
+ ["no-invalid-regexp", [{"allowConstructorFlags": [1]}], " invalid type: integer `1`, expected a character\n received config: `{ \"allowConstructorFlags\": [ 1 ] }`"],
+ ["no-fallthrough", [{"commentPattern": "("}], " regex parse error:\n (?iu)(\n ^\nerror: unclosed group\n received config: `{ \"commentPattern\": \"(\" }`"],
+ ["capitalized-comments", ["always", {"ignorePattern": "("}], " regex parse error:\n ^\\s*(?:()\n ^\nerror: unclosed group"],
+ ["capitalized-comments", ["always", 1], " invalid type: integer `1`, expected struct OptionsJson"],
+ ["capitalized-comments", ["always", {"line": {"zz": 1}}], " unknown field `zz`, expected one of `ignorePattern`, `ignoreInlineComments`, `ignoreConsecutiveComments`"],
+ ["promise/param-names", [{"resolvePattern": "["}], " regex parse error:\n [\n ^\nerror: unclosed character class\n received config: `{ \"resolvePattern\": \"[\" }`"],
+ ["one-var", [1], " data did not match any variant of untagged enum OneVarConfig\n received config: `1`"],
+ ["prefer-destructuring", [{"zz": 1}], " data did not match any variant of untagged enum PreferDestructuringOption, received `[ { \"zz\": 1 } ]`"],
+ ["complexity", [{"max": 1, "maximum": 2}], " duplicate field `max`\n received config: `{ \"max\": 1, \"maximum\": 2 }`"],
+ ["complexity", ["x"], " invalid type: string \"x\", expected struct ComplexityConfig\n received config: `\"x\"`"],
+ ["jsdoc/require-param", [1], " invalid type: integer `1`, expected struct RequireParamConfig"],
+ ["vue/max-props", [{"maxProps": -1}], " invalid value: integer `-1`, expected u32\n received config: `{ \"maxProps\": -1 }`"],
+ ["jsdoc/require-param-name", [1], " This rule does not accept configuration options."],
+ ["no-empty-function", [{"allow": ["x"]}], " unknown variant `x`, expected one of `function`, `functions`, `arrow-functions`, `arrowFunctions`, `generator-functions`, `generatorFunctions`, `method`, `methods`, `generator-methods`, `generatorMethods`, `getter`, `getters`, `setter`, `setters`, `constructor`, `constructors`, `async-functions`, `asyncFunctions`, `async-methods`, `asyncMethods`, `private-constructors`, `privateConstructors`, `protected-constructors`, `protectedConstructors`, `decorated-functions`, `decoratedFunctions`, `override-methods`, `overrideMethods`\n received config: `{ \"allow\": [ \"x\" ] }`"],
+ ["node/no-new-require", [1], " This rule does not accept configuration options."],
+ ["nextjs/no-img-element", [null], " This rule does not accept configuration options."],
+ ["oxc/no-barrel-file", [{"threshold": "x"}], " invalid type: string \"x\", expected u32\n received config: `{ \"threshold\": \"x\" }`"],
+ ["vue/no-reserved-props", [{"vueVersion": 4}], " vueVersion must be either 2 or 3\n received config: `{ \"vueVersion\": 4 }`"],
+ ["vue/no-reserved-props", [{"vueVersion": 256}], " invalid value: integer `256`, expected u8\n received config: `{ \"vueVersion\": 256 }`"],
+ ["vue/no-reserved-props", [[1, 1]], " vueVersion must be either 2 or 3\n received config: `[ 1, 1 ]`"],
+ ["jsx-a11y/control-has-associated-label", [{"depth": 26, "labelAttributes": 1}], " depth must be less than or equal to 25\n received config: `{ \"depth\": 26, \"labelAttributes\": 1 }`"],
+ ["jsx-a11y/control-has-associated-label", [{"labelAttributes": 1, "depth": 26}], " invalid type: integer `1`, expected a sequence\n received config: `{ \"labelAttributes\": 1, \"depth\": 26 }`"],
+ ["jest/expect-expect", [{"assertFunctionNames": [1, "a.(.b"]}], " invalid assert function pattern `a.(.b`: regex parse error:\n (?ui)^a\\.(\\.b(\\.|$)\n ^\nerror: unclosed group"],
+ ["jest/expect-expect", [{"assertFunctionNames": ["**("]}], " invalid assert function pattern `**(`: regex parse error:\n (?ui)^[a-z\\d]*[a-z\\d]*((\\.|$)\n ^\nerror: unclosed group"],
+ ["vitest/expect-expect", [{"assertFunctionNames": ["["]}], " invalid assert function pattern `[`: regex parse error:\n (?ui)^[(\\.|$)\n ^\nerror: unclosed character class"],
+ ["jest/prefer-ending-with-an-expect", [{"assertFunctionNames": ["a", "["]}], " regex parse error:\n (?ui)^[(\\.|$)\n ^\nerror: unclosed character class\n received config: `{ \"assertFunctionNames\": [ \"a\", \"[\" ] }`"],
+ ["jest/prefer-ending-with-an-expect", [{"assertFunctionNames": ["(", 1]}], " invalid type: integer `1`, expected a string\n received config: `{ \"assertFunctionNames\": [ \"(\", 1 ] }`"],
+ ["jest/prefer-ending-with-an-expect", [{"assertFunctionNames": ["("], "zz": 1}], " regex parse error:\n (?ui)^((\\.|$)\n ^\nerror: unclosed group\n received config: `{ \"assertFunctionNames\": [ \"(\" ], \"zz\": 1 }`"],
+ ["no-restricted-globals", ["a", {"globals": 1}], " Expected 'object' property to be an array"],
+ ["no-restricted-globals", [{"globals": ["a", 1]}], " Expected 'globals' array to contain either strings or objects"],
+ ["one-var", [[null, null]], " data did not match any variant of untagged enum OneVarConfig\n received config: `[ null, null ]`"],
+ ["react/forbid-elements", [{"forbid": [["x", null]]}], " data did not match any variant of untagged enum ForbidItem\n received config: `{ \"forbid\": [ [ \"x\", null ] ] }`"],
+ ["react/forbid-dom-props", [{"forbid": [[null, null, null, "x"]]}], " data did not match any variant of untagged enum ForbidDomPropsItem\n received config: `{ \"forbid\": [ [ null, null, null, \"x\" ] ] }`"],
+ ["typescript/no-restricted-types", [{"types": {"k": [null, null, null]}}], " data did not match any variant of untagged enum BanConfigValue\n received config: `{ \"types\": { \"k\": [ null, null, null ] } }`"],
+ ["capitalized-comments", ["always", {"line": []}], " invalid length 1, expected struct CommentConfigJson with 3 elements"],
+ ["capitalized-comments", ["always", {"block": ["a", true]}], " invalid length 2, expected struct CommentConfigJson with 3 elements"],
+ ["react/jsx-fragments", [{"mode": "x"}], " data did not match any variant of untagged enum JsxFragments\n received config: `{ \"mode\": \"x\" }`"],
+ ["react/jsx-fragments", [["syntax"]], " data did not match any variant of untagged enum JsxFragments\n received config: `[ \"syntax\" ]`"],
+ ["id-match", ["(?-u)\\xFF"], " regex parse error:\n (?-u)\\xFF\n ^^^^\nerror: pattern can match invalid UTF-8, received `[ \"(?-u)\\\\xFF\" ]`"],
+ ["id-match", ["(?-u:[^a])"], " regex parse error:\n (?-u:[^a])\n ^^^^\nerror: pattern can match invalid UTF-8, received `[ \"(?-u:[^a])\" ]`"],
+ ["id-match", ["(?-u)[\u00e9]"], " regex parse error:\n (?-u)[\u00e9]\n ^\nerror: Unicode not allowed here, received `[ \"(?-u)[\u00e9]\" ]`"],
+ ["id-match", ["a\\pXb"], " regex parse error:\n a\\pXb\n ^^^\nerror: Unicode property not found, received `[ \"a\\\\pXb\" ]`"],
+ ["vue/no-reserved-props", [{"vueVersion": 2}], null],
+ ["jsx-a11y/control-has-associated-label", [{"depth": 25}], null],
+ ["jest/expect-expect", [{"assertFunctionNames": ["a.*.b", "**", "x*", "+"], "additionalTestBlockFunctions": ["("]}], null],
+ ["jest/expect-expect", ["("], null],
+ ["jest/expect-expect", [{"assertFunctionNames": "("}], null],
+ ["jest/prefer-ending-with-an-expect", [{"assertFunctionNames": ["a.*.b", "**"], "additionalTestBlockFunctions": ["("]}], null],
+ ["no-restricted-globals", ["a", {"name": "b", "message": "m"}, 1], null],
+ ["no-restricted-globals", [{"globals": ["a", {"name": 1}], "checkGlobalObject": 1}], null],
+ ["one-var", [[null, true]], null],
+ ["react/forbid-dom-props", [{"forbid": [["x", null, null, null]]}], null],
+ ["capitalized-comments", ["always", {"line": [null, null, null]}], null],
+ ["react/jsx-fragments", [{"mode": "element", "zz": 1}], null],
+ ["id-match", ["(?-u)\u00e9\\x{FF}\\B((?u).)"], null],
+ ["id-match", ["\\pl\\p{Greek}"], null],
+ ["no-use-before-define", ["x"], " invalid type: string \"x\", expected struct NoUseBeforeDefineConfig\n received config: `\"x\"`"],
+ ["no-use-before-define", ["nofunc"], null],
+ ["eqeqeq", ["always", {"null": "ignore"}], null],
+ ["eqeqeq", ["smart"], null],
+ ["eqeqeq", [{"always": null}], null],
+ ["eqeqeq", [], null],
+ ["max-lines", [300], null],
+ ["max-lines", [{"max": 300, "skipComments": true}], null],
+ ["max-lines", [0], null],
+ ["max-lines", [1, 2], null],
+ ["max-lines", [[1, true]], null],
+ ["curly", ["multi", "consistent"], null],
+ ["curly", ["all", null], null],
+ ["getter-return", [{}], null],
+ ["getter-return", [{}, {"zz": 1}], null],
+ ["getter-return", [[]], null],
+ ["getter-return", [[true]], null],
+ ["no-unused-vars", [{"zz": 1}], null],
+ ["no-unused-vars", [null], null],
+ ["no-unused-vars", [{"varsIgnorePattern": "^_"}], null],
+ ["no-unused-vars", [{"caughtErrors": true}], null],
+ ["no-unused-vars", [{"varsIgnorePattern": 1}], null],
+ ["no-unused-vars", ["local"], null],
+ ["id-match", ["^[a-z]+$", {"properties": true}], null],
+ ["id-match", ["(?x) a # c"], null],
+ ["id-match", ["[[:alpha:]&&[^a]]\\b{start}\\p{Greek}\\x{41}"], null],
+ ["func-name-matching", [{}], null],
+ ["func-name-matching", ["never"], null],
+ ["func-name-matching", ["always", {}], null],
+ ["logical-assignment-operators", ["always", {"enforceForIfStatements": true}], null],
+ ["logical-assignment-operators", ["never"], null],
+ ["no-restricted-properties", [{"object": "a"}, {"property": "b", "allowObjects": ["c"]}], null],
+ ["typescript/ban-ts-comment", [{"ts-check": {"descriptionFormat": "^: .+$"}, "ts-ignore": "allow-with-description", "ts-nocheck": true}], null],
+ ["typescript/no-floating-promises", [{"allowForKnownSafeCalls": ["a", {"from": "file", "name": ["a"], "path": null}, {"from": "package", "name": "a", "package": "p"}]}], null],
+ ["typescript/no-restricted-types", [{"types": {"a": true, "b": "m", "c": {"message": null, "fixWith": "d"}}}], null],
+ ["radix", ["x"], null],
+ ["max-statements", ["x"], null],
+ ["no-restricted-imports", [{"paths": 1}], null],
+ ["react/jsx-no-literals", [{"elementOverrides": {"a": {"allowElement": true, "noStrings": true}}, "noStrings": true}], null],
+ ["react/forbid-component-props", [{"forbid": ["a", {"propName": "b", "message": null}, {"propNamePattern": "c"}]}], null],
+ ["sort-imports", [{"memberSyntaxSortOrder": ["single", "multiple", "all", "none"]}], null],
+ ["unicorn/import-style", [{"styles": {"k": false, "l": {"named": true}}}], null],
+ ["jest/no-restricted-matchers", [{"toBe": "m", "toEqual": null}], null],
+ ["capitalized-comments", ["x", {"zz": 1, "ignorePattern": "a", "line": {"ignoreInlineComments": true}}, 1], null],
+ ["complexity", [20], null],
+ ["complexity", [{"maximum": 2, "variant": "modified"}], null],
+ ["no-invalid-regexp", [{"allowConstructorFlags": ["a", "\u00e9"]}], null],
+ ];
+ const plugins = [...new Set(rows.flatMap(([rule]) => (rule.includes("/") ? [rule.split("/")[0]] : [])))];
+ // A rule is once in a file.
+ const rounds: (typeof rows)[] = [];
+ for (const row of rows) {
+ const round = rounds.find(it => it.every(other => other[0] !== row[0]));
+ if (round) round.push(row);
+ else rounds.push([row]);
+ }
+
+ test.each(rounds.map((round, at) => [at, round] as const))("file %i", async (_, round) => {
+ const rules = Object.fromEntries(round.map(([rule, options]) => [rule, ["off", ...options]]));
+ const files = {
+ ".oxlintrc.json": JSON.stringify({ plugins, categories: { correctness: "off" }, rules }),
+ "a.js": "export {};\n",
+ };
+ const { raw, exitCode } = await lint(files, ["a.js"]);
+ const expected = round
+ .filter(it => it[2] !== null)
+ .map(([rule, , refusal]) => {
+ const name = rule.replace(/^(jsx|react)-(a11y|perf)\//, "$1_$2/");
+ return `Invalid configuration for rule \`${name}\`:\n${refusal}`;
+ })
+ .sort();
+ const at = raw.indexOf("Invalid configuration");
+ expect(at < 0 ? "" : raw.slice(at).trimEnd()).toBe(expected.join("\n\n"));
+ expect(exitCode).toBe(expected.length > 0 ? 1 : 0);
+ });
+
+ const bad = (word: string) => ["error", word];
+ const said = async (config: object, extended: object = {}, flags: string[] = []) => {
+ const files = {
+ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, ...config }),
+ "extended.json": JSON.stringify(extended),
+ "a.js": "export {};\n",
+ };
+ const { raw, exitCode } = await lint(files, [...flags, "a.js"]);
+ return [[...raw.matchAll(/Invalid configuration for rule `([^`]+)`/g)].map(it => it[1]), exitCode];
+ };
+ const forJs = (rules: object, more: object = {}) => ({ files: ["*.js"], rules, ...more });
+ const key = { "react/jsx-key": ["error", 1] };
+ const extending = { extends: ["./extended.json"] };
+
+ const looks: [name: string, rules: string[], config: object, extended?: object, flags?: string[]][] = [
+ [
+ "the file before its overrides",
+ ["eqeqeq"],
+ { rules: { eqeqeq: bad("x") }, overrides: [forJs({ curly: bad("x") })] },
+ ],
+ [
+ "one override after the other",
+ ["curly", "yoda"],
+ { overrides: [forJs({ yoda: bad("x"), curly: bad("x") }), forJs({ eqeqeq: bad("x") })] },
+ ],
+ [
+ "with what it extends",
+ ["curly", "yoda"],
+ { ...extending, rules: { yoda: bad("x") } },
+ { rules: { curly: bad("x") } },
+ ],
+ ["not what it says otherwise", [], { ...extending, rules: { curly: "off" } }, { rules: { curly: bad("x") } }],
+ [
+ "the overrides of what it extends first",
+ ["curly"],
+ { ...extending, overrides: [forJs({ yoda: bad("x") })] },
+ { overrides: [forJs({ curly: bad("x") })] },
+ ],
+ ["a plugin of what it extends", ["react/jsx-key"], extending, { plugins: ["react"], rules: key }],
+ [
+ "a plugin of what it extends, for its own rules",
+ ["react/jsx-key"],
+ { ...extending, rules: key },
+ { plugins: ["react"] },
+ ],
+ ["its plugin, for what it extends", ["react/jsx-key"], { ...extending, plugins: ["react"] }, { rules: key }],
+ ["both have plugins", ["react/jsx-key"], { ...extending, plugins: [] }, { plugins: ["react"], rules: key }],
+ ["a plugin of a flag, for what it extends", ["react/jsx-key"], extending, { rules: key }, ["--react-plugin"]],
+ [
+ "a plugin of an override that it extends",
+ ["react/jsx-key"],
+ extending,
+ { overrides: [forJs(key, { plugins: ["react"] })] },
+ ],
+ ["an override that it extends, without the plugin", [], extending, { overrides: [forJs(key)] }],
+ [
+ "an override that it extends, with the plugin of that file",
+ ["react/jsx-key"],
+ extending,
+ { plugins: ["react"], overrides: [forJs(key)] },
+ ],
+ ];
+ test.each(looks.map(it => [it[0], it] as const))("what is looked at: %s", async (_, row) => {
+ const [, rules, config, extended, flags] = row;
+ expect(await said(config, extended, flags)).toEqual([rules, rules.length > 0 ? 1 : 0]);
+ });
+ });
+
// oxlint 1.87 takes each, and each is valid by its own configuration_schema.json. The schemas of ESLint's rules refuse them.
test("options that oxlint takes and the schema of ESLint's rule does not", async () => {
const sets: [rule: string, options: unknown[]][] = [
@@ -2085,11 +2429,123 @@ describe.concurrent("an .oxlintrc.json", () => {
[{ rules: [] }, "invalid type: sequence, expected Record {
- const { problems, stdout, exitCode } = await lint({ ".oxlintrc.json": JSON.stringify(config), "a.js": code });
+ const files = { ".oxlintrc.json": JSON.stringify(config), "a.js": code };
+ const { problems, raw, stdout, exitCode } = await lint(files);
expect(problems).toEqual([]);
expect(stdout).toContain("Cannot use the configuration file /.oxlintrc.json:\n");
- expect(stdout).toContain(why);
+ // As it was printed: it has backslashes.
+ expect(raw).toContain(why);
expect(exitCode).toBe(1);
});
@@ -2116,6 +2572,37 @@ describe.concurrent("an .oxlintrc.json", () => {
expect(byAlias.exitCode).toBe(1);
});
+ // `plugins` refuses "bun", so the note must not ask for it. oxlint 1.87 takes a `name` in `jsPlugins`.
+ test("the note about a plugin in JavaScript that is called like Bun's own gives advice that the config takes", async () => {
+ const rule = `{ create: () => ({}) }`;
+ const files = {
+ "bun.js": `export default { meta: { name: "bun" }, rules: { "no-array-just-to-count": ${rule}, own: ${rule}, other: ${rule} } };`,
+ "a.js": "export {};\n",
+ };
+ const advice = async (config: object) => {
+ const all = { categories: { correctness: "off" }, ...config };
+ const result = await lint({ ...files, ".oxlintrc.json": JSON.stringify(all) }, ["-f", "stylish", "a.js"]);
+ expect(result.exitCode).toBe(0);
+ return result.stderr.split("\n").filter(it => it.startsWith(" To use "));
+ };
+ const builtIn = { "bun/no-array-just-to-count": "error" };
+ expect(await advice({ jsPlugins: ["./bun.js"], rules: builtIn })).toEqual([
+ ` To use the built-in rule, remove ./bun.js from "jsPlugins".`,
+ ]);
+ expect(await advice({ jsPlugins: ["./bun.js"], rules: { ...builtIn, "bun/own": "error" } })).toEqual([
+ ` To use the built-in rule, give the plugin another name: "jsPlugins": [{ "name": "bun-js", "specifier": "./bun.js" }]. Then rename the other rule to "bun-js/..".`,
+ ]);
+ expect(
+ await advice({ jsPlugins: ["./bun.js"], rules: { ...builtIn, "bun/own": "error", "bun/other": "warn" } }),
+ ).toEqual([
+ ` To use the built-in rule, give the plugin another name: "jsPlugins": [{ "name": "bun-js", "specifier": "./bun.js" }]. Then rename the other rules to "bun-js/..".`,
+ ]);
+ // What the notes ask for.
+ expect(await advice({ rules: builtIn })).toEqual([]);
+ const jsPlugins = [{ name: "bun-js", specifier: "./bun.js" }];
+ expect(await advice({ jsPlugins, rules: { ...builtIn, "bun-js/own": "error" } })).toEqual([]);
+ });
+
test("oxlint.config.mts is read, and two files of oxlint in one directory are refused", async () => {
const program = `export default { categories: { correctness: "off" }, rules: { "no-var": "error" } };`;
expect((await lint({ "oxlint.config.mts": program, "a.js": code }, ["a.js"])).problems).toEqual([
@@ -2520,6 +3007,785 @@ describe.concurrent("an .oxlintrc.json", () => {
expect((await lint(enables, [".", "--report-unused-disable-directives"])).problems).toEqual(["a.js:2:3 -"]);
});
+ // Every row was run on oxlint 1.87. It matches one of its own rules by the text after the last `/` of the name, and reports
+ // every comment that silenced nothing, whatever the name is.
+ test("which names in a disable comment silence a built-in rule, and which comments are unused", async () => {
+ // `$` is the number of the line, to keep the names apart.
+ const rows: { file: string; bad: string; good: string; silence: string[]; nothing: string[] }[] = [
+ {
+ file: "debugger.js",
+ bad: "debugger;",
+ good: "f();",
+ silence: [
+ "no-debugger",
+ "eslint/no-debugger",
+ "typescript/no-debugger",
+ "@typescript-eslint/no-debugger",
+ "react/no-debugger",
+ "vitest/no-debugger",
+ "@stylistic/no-debugger",
+ "foo/no-debugger",
+ "a/b/no-debugger",
+ "foo/eslint/no-debugger",
+ "/no-debugger",
+ ],
+ nothing: ["eslint(no-debugger)", "xno-debugger", "no-debugger-x", "x-no-debugger", "NO-DEBUGGER", "no-debugge"],
+ },
+ {
+ file: "any.ts",
+ bad: "export let a$: any;",
+ good: "export let a$: number;",
+ silence: [
+ "no-explicit-any",
+ "typescript/no-explicit-any",
+ "@typescript-eslint/no-explicit-any",
+ "typescript-eslint/no-explicit-any",
+ "eslint/no-explicit-any",
+ "ts/no-explicit-any",
+ "react/no-explicit-any",
+ ],
+ nothing: [],
+ },
+ {
+ file: "hooks.jsx",
+ bad: "function f$() { useState(); } f$();",
+ good: "function f$() { g(); } f$();",
+ silence: [
+ "rules-of-hooks",
+ "react/rules-of-hooks",
+ "react-hooks/rules-of-hooks",
+ "react_hooks/rules-of-hooks",
+ "eslint/rules-of-hooks",
+ "foo/rules-of-hooks",
+ ],
+ nothing: [],
+ },
+ {
+ file: "focused.test.js",
+ bad: "it.only('a', () => {});",
+ good: "it('a', () => {});",
+ silence: ["no-focused-tests", "jest/no-focused-tests", "vitest/no-focused-tests", "foo/no-focused-tests"],
+ nothing: [],
+ },
+ {
+ file: "alt.jsx",
+ bad: "x = ;",
+ good: "x = ;",
+ silence: ["alt-text", "jsx-a11y/alt-text", "jsx_a11y/alt-text", "a11y/alt-text"],
+ nothing: [],
+ },
+ {
+ file: "img.jsx",
+ bad: "x = ![a]()
;",
+ good: "x = ;",
+ silence: [
+ "no-img-element",
+ "nextjs/no-img-element",
+ "@next/next/no-img-element",
+ "next/no-img-element",
+ "@next/no-img-element",
+ ],
+ nothing: [],
+ },
+ {
+ file: "require.js",
+ bad: "x = new require('a');",
+ good: "x = require('a');",
+ silence: ["no-new-require", "node/no-new-require", "n/no-new-require", "eslint/no-new-require"],
+ nothing: [],
+ },
+ // Two rules have this name. Either prefix silences both.
+ {
+ file: "import-namespace.ts",
+ bad: "import * as a$ from 'a'; a$();",
+ good: "import a$ from 'a'; a$();",
+ silence: ["no-namespace", "import/no-namespace", "typescript/no-namespace", "foo/no-namespace"],
+ nothing: [],
+ },
+ {
+ file: "namespace.ts",
+ bad: "export namespace N$ {}",
+ good: "export const N$ = 1;",
+ silence: ["no-namespace", "import/no-namespace", "@typescript-eslint/no-namespace", "foo/no-namespace"],
+ nothing: [],
+ },
+ // Rules that are off, rules of plugins that are off, and names that are no rule's.
+ {
+ file: "off.js",
+ bad: "",
+ good: "console.log(1);",
+ silence: [],
+ nothing: [
+ "no-console",
+ "eslint/no-console",
+ "foo/no-console",
+ "typescript/no-console",
+ "oxc/no-barrel-file",
+ "no-barrel-file",
+ "vitest/no-import-node-test",
+ "check-access",
+ "foo/check-access",
+ "jsdoc/check-access",
+ "jsdoc/require-param",
+ "vue/max-props",
+ "vue/no-export-in-script-setup",
+ "foo/no-alert",
+ "typescript/no-floating-promises",
+ "nope",
+ "foo/nope",
+ "eslint/nope",
+ "no-multiple-empty-lines",
+ "@stylistic/semi",
+ "prettier/prettier",
+ ],
+ },
+ ];
+ const comments = [
+ (name: string) => `// oxlint-disable-next-line ${name}\n`,
+ (name: string) => `/* eslint-disable-next-line ${name} */\n`,
+ ];
+ const files: Record = {};
+ const expected: string[] = [];
+ for (const { file, bad, good, silence, nothing } of rows) {
+ let [text, line] = ["", 1];
+ const add = (name: string, code: string, outcome: "silenced" | "unused" | "reported") => {
+ for (const comment of comments) {
+ text += comment(name) + code.replaceAll("$", String(line)) + "\n";
+ if (outcome !== "silenced") expected.push(`${file}:${line} unused`);
+ if (outcome === "reported") expected.push(`${file}:${line + 1} reported`);
+ line += 2;
+ }
+ };
+ for (const name of silence) {
+ add(name, bad, "silenced");
+ add(name, good, "unused");
+ }
+ for (const name of nothing) {
+ if (bad) add(name, bad, "reported");
+ add(name, good, "unused");
+ }
+ files[file] = text;
+ }
+ const config = {
+ categories: { correctness: "off" },
+ plugins: ["typescript", "react", "import", "jest", "jsx-a11y", "nextjs", "node"],
+ rules: {
+ "no-debugger": "error",
+ "no-console": "off",
+ "typescript/no-explicit-any": "error",
+ "react/rules-of-hooks": "error",
+ "jest/no-focused-tests": "error",
+ "jsx-a11y/alt-text": "error",
+ "nextjs/no-img-element": "error",
+ "node/no-new-require": "error",
+ "import/no-namespace": "error",
+ "typescript/no-namespace": "error",
+ },
+ };
+ const { problems } = await lint({ ".oxlintrc.json": JSON.stringify(config), ...files }, [
+ ".",
+ "--report-unused-disable-directives",
+ ]);
+ const found = problems.map(it => it.replace(/:\d+ (.*)$/, (_, rule) => (rule === "-" ? " unused" : " reported")));
+ expect(found.sort()).toEqual(expected.sort());
+ });
+
+ // oxlint 1.87 rejects this config: "Rule 'no-debuger' not found in plugin 'eslint'", "Plugin 'foo' not found". The rules here are
+ // those of one oxlint version, and a config for a later one can name a rule that is new, so it's a warning.
+ test("an unknown rule that an .oxlintrc.json turns off is a warning, once for each name", async () => {
+ const config = {
+ categories: { correctness: "off" },
+ rules: {
+ "no-debugger": "error",
+ "no-debuger": "off",
+ "foo/bar": "off",
+ "unicorn/no-nul": "allow",
+ "typescript/no-explicit-an": 0,
+ // There is no list of the rules of this plugin.
+ "jsdoc/whatever": "off",
+ },
+ overrides: [{ files: ["*.ts"], rules: { "no-debuger": "off", "react/jsx-kye": "off" } }],
+ };
+ const files = { ".oxlintrc.json": JSON.stringify(config), "a.js": "debugger;\n", "b.js": "debugger;\n" };
+ const { problems, stderr, exitCode } = await lint(files);
+ expect(problems).toEqual(["a.js:1:1 no-debugger", "b.js:1:1 no-debugger"]);
+ expect(stderr.trim().split("\n")).toEqual([
+ 'warn: Unknown rule "no-debuger" is turned off in the oxlint config',
+ ' Did you mean "no-debugger"?',
+ 'warn: Unknown rule "foo/bar" is turned off in the oxlint config',
+ " It has no effect. Fix the name or remove it.",
+ 'warn: Unknown rule "unicorn/no-nul" is turned off in the oxlint config',
+ ' Did you mean "unicorn/no-null"?',
+ 'warn: Unknown rule "typescript/no-explicit-an" is turned off in the oxlint config',
+ ' Did you mean "typescript/no-explicit-any"?',
+ 'warn: Unknown rule "react/jsx-kye" is turned off in the oxlint config',
+ ' Did you mean "react/jsx-key"?',
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
+ // oxlint 1.87 fails with this text for each of the first three, before it lints.
+ test("the options of a JS plugin's rule are checked for every entry of an .oxlintrc.json", async () => {
+ const plugin = `export default { meta: { name: "pl" }, rules: { opt: { meta: { schema: [{ enum: ["a", "b"] }] }, create: () => ({}) } } };\n`;
+ const run = async (config: object) => {
+ const oxlintrc = JSON.stringify({ categories: { correctness: "off" }, jsPlugins: ["./plugin.js"], ...config });
+ const { stdout, stderr, exitCode } = await lint(
+ { ".oxlintrc.json": oxlintrc, "plugin.js": plugin, "a.js": "a;\n" },
+ ["a.js"],
+ );
+ const said = (stdout + stderr).includes(
+ `Failed to setup JS plugin options:\nError: Options validation failed for rule 'pl/opt':\nOptions:\n[\n "zzz"\n]\nErrors:\n\tValue "zzz" should be equal to one of the allowed values.`,
+ );
+ return [said, exitCode];
+ };
+ expect(
+ await Promise.all([
+ run({ rules: { "pl/opt": ["error", "zzz"] } }),
+ run({ rules: { "pl/opt": ["off", "zzz"] } }),
+ run({ overrides: [{ files: ["*.nothing"], rules: { "pl/opt": ["error", "zzz"] } }] }),
+ run({ rules: { "pl/opt": ["off", "a"] } }),
+ ]),
+ ).toEqual([
+ [true, 1],
+ [true, 1],
+ [true, 1],
+ [false, 0],
+ ]);
+ });
+
+ // oxlint 1.87 says so for each of the first five, before it lints.
+ test("options for a JS plugin's rule that takes none are refused, also where the rule is off", async () => {
+ const plugin = `const create = () => ({});
+ export default { meta: { name: "pl" }, rules: { none: { create }, meta: { meta: { type: "problem" }, create }, empty: { meta: { schema: [] }, create }, any: { meta: { schema: false }, create } } };\n`;
+ const run = async (rule: string, entry: unknown) => {
+ const config = {
+ categories: { correctness: "off" },
+ jsPlugins: ["./plugin.js"],
+ rules: { [`pl/${rule}`]: entry },
+ };
+ const files = { ".oxlintrc.json": JSON.stringify(config), "plugin.js": plugin, "a.js": "a;\n" };
+ const { stdout, stderr, exitCode } = await lint(files, ["a.js"]);
+ const text = `Failed to setup JS plugin options:\nError: Rule 'pl/${rule}' does not accept options`;
+ return [(stdout + stderr).includes(text), exitCode];
+ };
+ expect(
+ await Promise.all([
+ run("none", ["off", {}]),
+ run("none", ["error", {}]),
+ run("none", ["off", null]),
+ run("meta", ["off", {}]),
+ run("empty", ["off", {}]),
+ run("any", ["off", {}]),
+ run("none", ["off"]),
+ run("none", "off"),
+ ]),
+ ).toEqual([
+ [true, 1],
+ [true, 1],
+ [true, 1],
+ [true, 1],
+ [true, 1],
+ [false, 0],
+ [false, 0],
+ [false, 0],
+ ]);
+ });
+
+ // What oxlint 1.87 and ESLint 10.12 do. oxlint goes by `char::is_whitespace` of Rust, ESLint by `\s`.
+ test("white space beside the label of a disable comment: U+0085 for oxlint, U+FEFF for ESLint", async () => {
+ const codes = [0x20, 0x85, 0xa0, 0x1680, 0x2003, 0x3000, 0xfeff, 0x180e, 0x200b];
+ const files = (tool: string) =>
+ Object.fromEntries(
+ codes.flatMap(code => [
+ [`a${code.toString(16)}.js`, `debugger; //${String.fromCodePoint(code)}${tool}-disable-line no-debugger\n`],
+ [`b${code.toString(16)}.js`, `debugger; // ${tool}-disable-line${String.fromCodePoint(code)}no-debugger\n`],
+ ]),
+ );
+ const rules = { "no-debugger": "error" };
+ const [oxlint, eslint] = await Promise.all([
+ lint({ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, rules }), ...files("oxlint") }),
+ lint({ "eslint.config.mjs": `export default [{ rules: ${JSON.stringify(rules)} }];\n`, ...files("eslint") }),
+ ]);
+ const notSilenced = (...names: string[]) =>
+ names.flatMap(it => [`a${it}.js:1:1 no-debugger`, `b${it}.js:1:1 no-debugger`]).sort();
+ expect(oxlint.problems).toEqual(notSilenced("feff", "180e", "200b"));
+ expect(eslint.problems).toEqual(notSilenced("85", "180e", "200b"));
+ });
+
+ // What oxlint 1.87 and ESLint 10.12 report.
+ test("no-irregular-whitespace: oxlint lets a line separator pass that ends a // comment", async () => {
+ const files = {
+ "a.js": "a; // c\u2028b;\n",
+ "b.js": "a; // c\u2029b;\n",
+ "c.js": "a; // c\u2028\u2028b;\n",
+ "d.js": "a;\u2028b;\n",
+ "e.js": "a; /* c\u2028d */ b;\n",
+ "f.js": "// c\u2028",
+ };
+ const rules = { "no-irregular-whitespace": "error" };
+ const [oxlint, eslint] = await Promise.all([
+ lint({ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, rules }), ...files }),
+ lint({ "eslint.config.mjs": `export default [{ rules: ${JSON.stringify(rules)} }];\n`, ...files }),
+ ]);
+ const places = (problems: string[]) => problems.map(it => it.replace(" no-irregular-whitespace", ""));
+ // The second separator of c.js. This format counts lines like ESLint. oxlint's own formats say 1:11.
+ expect(places(oxlint.problems)).toEqual(["c.js:2:1", "d.js:1:3", "e.js:1:8"]);
+ expect(places(eslint.problems)).toEqual([
+ "a.js:1:8",
+ "b.js:1:8",
+ "c.js:1:8",
+ "c.js:2:1",
+ "d.js:1:3",
+ "e.js:1:8",
+ "f.js:1:5",
+ ]);
+ });
+
+ // The lines of oxlint 1.87, in its order.
+ test("the findings about a file: of the built-in rules by place, of JS plugins as they report, about comments last", async () => {
+ const plugin = `export default { meta: { name: "pl" }, rules: {
+ back: { create(c) { const all = []; return { Identifier(n) { all.push(n); }, "Program:exit"() { for (const n of all.reverse()) c.report({ node: n, message: "back " + n.name }); } }; } },
+ fwd: { create(c) { return { Identifier(n) { c.report({ node: n, message: "fwd " + n.name }); } }; } },
+ } };\n`;
+ const rules = { "pl/fwd": "error", "pl/back": "error", "no-var": "warn", "no-debugger": "error" };
+ const code = [
+ "// oxlint-disable-next-line no-alert",
+ "debugger;",
+ "a; b;",
+ "// oxlint-disable-next-line pl/back",
+ "debugger;",
+ "var c = 1; // oxlint-disable-line no-var",
+ "d; // oxlint-disable-line pl/fwd",
+ "// oxlint-disable-next-line no-eval",
+ "debugger;",
+ ];
+ const files = {
+ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, jsPlugins: ["./plugin.js"], rules }),
+ "plugin.js": plugin,
+ "c.js": code.join("\n") + "\n",
+ };
+ const { stdout } = await lint(files, ["-f", "unix", "--report-unused-disable-directives", "c.js"]);
+ const lines = stdout.split("\n").filter(it => it.startsWith("c.js:"));
+ expect(lines.map(it => it.replace(/^c\.js:(\d+:\d+): .*?(\w+\([\w-]+\))?\]$/, "$1 $2").trim())).toEqual([
+ "2:1 eslint(no-debugger)",
+ "5:1 eslint(no-debugger)",
+ "9:1 eslint(no-debugger)",
+ "3:1 pl(fwd)",
+ "3:4 pl(fwd)",
+ "6:5 pl(fwd)",
+ "7:1 pl(back)",
+ "6:5 pl(back)",
+ "3:4 pl(back)",
+ "3:1 pl(back)",
+ "1:1",
+ "4:1",
+ "8:1",
+ ]);
+ });
+
+ // Each count is what oxlint 1.87 prints.
+ test("number_of_rules is there for a file outside the working directory, unless it has another configuration", async () => {
+ const rc = (rules: object) => JSON.stringify({ categories: { correctness: "off" }, rules });
+ const files = {
+ ".oxlintrc.json": rc({ "no-debugger": "error", "no-var": "error", "no-eval": "error" }),
+ "a.js": "debugger;\n",
+ "other/b.js": "debugger;\n",
+ "sub/.oxlintrc.json": rc({ "no-debugger": "error" }),
+ "sub/c.js": "debugger;\n",
+ "sub/in/d.js": "debugger;\n",
+ };
+ const count = async (cwd: string, args: (dir: string) => string[]) =>
+ JSON.parse((await lint(files, ["-f", "json"], { cwd, args })).raw).number_of_rules;
+ expect(
+ await Promise.all([
+ count("sub/in", dir => [join(dir, "sub", "c.js")]),
+ count("sub/in", dir => [join(dir, "sub")]),
+ count("sub/in", dir => ["d.js", join(dir, "sub", "c.js")]),
+ count("other", dir => [join(dir, "a.js"), "b.js"]),
+ count("other", dir => ["-c", join(dir, "sub", ".oxlintrc.json"), join(dir, "sub", "c.js")]),
+ count("sub/in", dir => ["-c", join(dir, ".oxlintrc.json"), join(dir, "other", "b.js")]),
+ count("other", dir => ["--disable-nested-config", join(dir, "sub", "c.js")]),
+ // These have two configuration files.
+ count("sub/in", dir => [join(dir, "other", "b.js")]),
+ count("other", dir => [join(dir, "a.js"), join(dir, "sub", "c.js")]),
+ ]),
+ ).toEqual([1, 1, 1, 3, 1, 3, 3, null, null]);
+ });
+
+ // Each count is what oxlint 1.87 prints. The rules run on the files of the override in both tools: only the count leaves them out.
+ test("number_of_rules leaves out what categories turn on for a plugin that only an override has", async () => {
+ const base = {
+ plugins: ["unicorn", "typescript", "import"],
+ categories: { correctness: "warn", suspicious: "warn" },
+ };
+ const count = async (config: object) => {
+ const files = { ".oxlintrc.json": JSON.stringify(config), "a.ts": "debugger;\n", "a.test.ts": "debugger;\n" };
+ return JSON.parse((await lint(files, ["-f", "json"])).raw).number_of_rules;
+ };
+ const named = { "jest/no-focused-tests": "error" };
+ expect(
+ await Promise.all([
+ count(base),
+ count({ ...base, overrides: [{ files: ["*.test.ts"], plugins: ["jest"] }] }),
+ count({ ...base, overrides: [{ files: ["*.test.ts"], plugins: ["jest"], rules: named }] }),
+ count({ ...base, overrides: [{ files: ["*.nothing"], plugins: ["jest"], rules: named }] }),
+ count({ ...base, overrides: [{ files: ["*.ts"], plugins: ["jest", "react"] }] }),
+ count({ overrides: [{ files: ["*.test.ts"], plugins: ["jest"] }] }),
+ ]),
+ ).toEqual([116, 116, 117, 117, 116, 96]);
+ });
+
+ // Each config is accepted or rejected as oxlint 1.87 does it. It takes out the comments, has serde_json read the rest, and
+ // fills its structs from that: `null` is only good for an `Option`, and a list of nothing is as good as an empty struct.
+ test("an .oxlintrc.json is read as strictly as oxlint reads it, and no more strictly", async () => {
+ const rejected = [
+ '{"rules":null}',
+ '{"categories":null}',
+ '{"settings":null}',
+ '{"options":null}',
+ '{"env":null}',
+ '{"globals":null}',
+ '{"overrides":null}',
+ '{"extends":null}',
+ '{"ignorePatterns":null}',
+ '{"overrides":[{"files":["*.js"],"rules":null}]}',
+ '{"overrides":[{"files":null}]}',
+ '{"globals":{"a":null}}',
+ '{"settings":[1]}',
+ '{"settings":[{},{},{},{},{},{},{},{}]}',
+ '{"options":[1]}',
+ '{"rules":{"eqeqeq":"off","eqeqeq":["error","x"]}}',
+ "{'rules':{}}",
+ '{"rules":{"no-debugger":\'error\'}}',
+ '\ufeff{"rules":{"no-debugger":"error"}}',
+ '{"rules":{"max-lines":["error",{"max":0x10}]}}',
+ '{"rules":{"max-lines":["error",{"max":1.}]}}',
+ '{"rules":{"max-lines":["error",{"max":.5}]}}',
+ '{"rules":{"max-lines":["error",{"max":01}]}}',
+ '{"rules":{"no-debugger":"err\\x6fr"}}',
+ '{"$schema":"\\ud800"}',
+ '\u00a0{"rules":{"no-debugger":"error"}}',
+ '\u000b{"rules":{"no-debugger":"error"}}',
+ ];
+ const accepted = [
+ '{"plugins":null}',
+ '{"jsPlugins":null}',
+ '{"$schema":null}',
+ '{"overrides":[{"files":["*.js"],"env":null}]}',
+ '{"overrides":[{"files":["*.js"],"globals":null}]}',
+ '{"overrides":[{"files":["*.js"],"plugins":null}]}',
+ '{"settings":[]}',
+ '{"settings":[{},{}]}',
+ '{"options":[]}',
+ '{"options":[null]}',
+ '{"options":{"typeAware":null}}',
+ '{"options":[false]}',
+ '{"options":[null,null,null,1]}',
+ '{"settings":[{},{},{},{},{},{}]}',
+ '{"settings":{"zz":1}}',
+ '{"settings":{"react":[]}}',
+ '{"settings":{"react":{"zz":1,"version":null}}}',
+ '{"settings":{"react":{"formComponents":["a",{"name":"a","attribute":"b","zz":1}]}}}',
+ '{"settings":{"jsx-a11y":[null,{},{}]}}',
+ '{"settings":{"next":{"rootDir":["a"]}}}',
+ '{"settings":{"jsdoc":{"tagNamePreference":{"a":false,"b":"c","d":{"message":"m"}}}}}',
+ '{"settings":{"jest":[1]}}',
+ '{"settings":{"jsx-a11y":[null]}}',
+ '{"settings":{"jest":{"version":"v29.7.0-beta.1"}}}',
+ '{"settings":{"jest":{"version":"29.x"}}}',
+ '{"settings":{"jest":{"version":29}}}',
+ '{"settings":{"jest":{"version":null}}}',
+ '{"settings":{"react":{"linkComponents":[{"name":"a","linkAttribute":"to"},{"name":"b","linkAttribute":["to"]}]}}}',
+ '{"settings":{"react":{"formComponents":[{"name":"a","formAttribute":"to"},{"name":"b","linkAttribute":"to"}]}}}',
+ '{"settings":{"react":{"linkComponents":[{"name":"a","attribute":"x","linkAttribute":["to"]}]}}}',
+ '{"overrides":[[["*.js"],[],null,null]]}',
+ "{,}",
+ "{}/",
+ "/**/{}",
+ "{}#x",
+ '{"rules":{"eqeqeq":["error","x"],"eqeqeq":"off"}}',
+ '{"rules":{"no-var":"nonsense","no-var":"off"}}',
+ '{"categories":{"correctness":"x","correctness":"warn"}}',
+ '#!x\n{"rules":{"no-debugger":"error"}}',
+ '{"rules":{"no-debugger":"error"}} # c',
+ '{"rules":{"no-debugger":"error"}} // c',
+ '// c\n{"rules":{"no-debugger":"error"}}',
+ '{"rules":{"no-debugger":"error"},}',
+ '{"rules":{"no-debugger":"err\\u006fr"}}',
+ '{"$schema":"\\/"}',
+ ];
+ const run = async (config: string) => {
+ const { problems, exitCode } = await lint({ ".oxlintrc.json": config, "a.js": "debugger;\n" });
+ return [config, problems.length === 0 && exitCode === 1 ? "rejected" : problems.join()];
+ };
+ expect(await Promise.all([...rejected, ...accepted].map(run))).toEqual([
+ ...rejected.map(config => [config, "rejected"]),
+ ...accepted.map(config => [config, "a.js:1:1 no-debugger"]),
+ ]);
+ });
+
+ // What oxlint 1.87 prints below "Failed to parse oxlint config .", or in place of that. It makes blanks of the comments, of
+ // the line breaks in `/* */` too, and of a comma before a `}` or `]`, and has serde_json read the rest. Columns are in bytes.
+ test("an .oxlintrc.json that is no JSON is refused in the words of oxlint", async () => {
+ // prettier-ignore
+ const rows: [text: string, why: string][] = [
+ ["{\n \"rules\": {\n \"no-debugger\": \"error\"\n \"no-var\": \"off\"\n }\n}\n", "expected `,` or `}` at line 4 column 5"],
+ ["{\n // c\n \"rules\": { /* a\n b */ no-debugger: 1 }\n}\n", "key must be a string at line 3 column 25"],
+ ["", "EOF while parsing a value at line 1 column 0"],
+ ["\n", "EOF while parsing a value at line 2 column 0"],
+ ["{", "EOF while parsing an object at line 1 column 1"],
+ ["[1,", "EOF while parsing a value at line 1 column 3"],
+ ["{\"a\"", "EOF while parsing an object at line 1 column 4"],
+ ["{\"a\":", "EOF while parsing a value at line 1 column 5"],
+ ["{\"a\":1", "EOF while parsing an object at line 1 column 6"],
+ ["{\"a\" 1}", "expected `:` at line 1 column 6"],
+ ["{\"a\":}", "expected value at line 1 column 6"],
+ ["{\"a\":1 \"b\":2}", "expected `,` or `}` at line 1 column 8"],
+ ["[1 2]", "expected `,` or `]` at line 1 column 4"],
+ ["{a:1}", "key must be a string at line 1 column 2"],
+ ["{\"a\":1,,}", "key must be a string at line 1 column 8"],
+ ["[1, ,]", "expected value at line 1 column 5"],
+ ["{\"a\":1,]", "expected `,` or `}` at line 1 column 8"],
+ ["[1,]]", "trailing characters at line 1 column 5"],
+ ["tru", "EOF while parsing a value at line 1 column 3"],
+ ["truex", "trailing characters at line 1 column 5"],
+ ["-", "EOF while parsing a value at line 1 column 1"],
+ ["-a", "invalid number at line 1 column 2"],
+ ["01", "invalid number at line 1 column 2"],
+ ["1.", "EOF while parsing a value at line 1 column 2"],
+ ["1.a", "invalid number at line 1 column 3"],
+ ["1e+", "EOF while parsing a value at line 1 column 3"],
+ ["1ea", "invalid number at line 1 column 3"],
+ ["0x10", "trailing characters at line 1 column 2"],
+ ["+1", "expected value at line 1 column 1"],
+ [".5", "expected value at line 1 column 1"],
+ ["1e400", "number out of range at line 1 column 5"],
+ ["NaN", "expected value at line 1 column 1"],
+ ["\"a", "EOF while parsing a string at line 1 column 2"],
+ ["\"\\x\"", "invalid escape at line 1 column 3"],
+ ["\"\\u12\"", "EOF while parsing a string at line 1 column 6"],
+ ["\"\\uzzzz\"", "invalid escape at line 1 column 7"],
+ ["\"\\ud800\"", "unexpected end of hex escape at line 1 column 8"],
+ ["\"\\ud800\\n\"", "unexpected end of hex escape at line 1 column 9"],
+ ["\"\\ud800\\u0041\"", "lone leading surrogate in hex escape at line 1 column 13"],
+ ["\"\\udc00\"", "lone leading surrogate in hex escape at line 1 column 7"],
+ ["\"a\tb\"", "control character (\\u0000-\\u001F) found while parsing a string at line 1 column 3"],
+ ["\"a\nb\"", "control character (\\u0000-\\u001F) found while parsing a string at line 2 column 0"],
+ ["{}\n\n x", "trailing characters at line 3 column 3"],
+ ["{},", "trailing characters at line 1 column 3"],
+ ["/* a", "EOF while parsing a value at line 1 column 4"],
+ ["/*\n\n*/x", "expected value at line 1 column 7"],
+ ["/*\n\n*/{\n x}", "key must be a string at line 2 column 2"],
+ ["// a\nx", "expected value at line 2 column 1"],
+ ["# a\nx", "expected value at line 2 column 1"],
+ ["{\"a\": /* c\n */ x}", "expected value at line 1 column 16"],
+ ["{\"//\": x}", "expected value at line 1 column 8"],
+ ["{'a':1}", "key must be a string at line 1 column 2"],
+ ["\ufeff{}", "expected value at line 1 column 1"],
+ ["\u00a0{}", "expected value at line 1 column 1"],
+ ["\r\n{\r\n x}", "key must be a string at line 3 column 2"],
+ ["\r{\r x}", "key must be a string at line 1 column 5"],
+ ["{\"\u65e5\u672c\": x}", "expected value at line 1 column 12"],
+ ["[1,2,3\n,4\n,x]", "expected value at line 3 column 2"],
+ ["{} / x", "Failed to parse jsonc file /.oxlintrc.json: Kind(InvalidData)"],
+ ["/x", "Failed to parse jsonc file /.oxlintrc.json: Kind(InvalidData)"],
+ ["[]", "Expected a JSON object."],
+ ["null", "Expected a JSON object."],
+ ["[1,]", "Expected a JSON object."],
+ ["[,]", "Expected a JSON object."],
+ [Buffer.alloc(127, "[").toString() + "x", "expected value at line 1 column 128"],
+ [Buffer.alloc(128, "[").toString() + "x", "recursion limit exceeded at line 1 column 128"],
+ ];
+ const run = async ([text]: [string, string]) => {
+ const { stdout, exitCode } = await lint({ ".oxlintrc.json": text, "a.js": "debugger;\n" }, ["a.js"]);
+ const start = "error: Cannot use the configuration file /.oxlintrc.json:\n";
+ const said = stdout.startsWith(start) ? stdout.slice(start.length).trimEnd() : stdout;
+ return [text, said.replace("Failed to parse oxlint config /.oxlintrc.json.\n", ""), exitCode];
+ };
+ // `stdout` has a slash for every backslash.
+ expect(await Promise.all(rows.map(run))).toEqual(rows.map(([text, why]) => [text, why.replaceAll("\\", "/"), 1]));
+ });
+
+ // What oxlint 1.87 reports.
+ test("an override of an .oxlintrc.json that is a list has the fields in their order", async () => {
+ const found = async (...fields: unknown[]) => {
+ const config = { categories: { correctness: "off" }, overrides: [fields] };
+ return (await lint({ ".oxlintrc.json": JSON.stringify(config), "a.js": "debugger;\n" }, ["a.js"])).problems;
+ };
+ const rules = { "no-debugger": "error" };
+ expect(await found(["*.js"], [], null, null, null, null, rules)).toEqual(["a.js:1:1 no-debugger"]);
+ expect(await found(["*.ts"], [], null, null, null, null, rules)).toEqual([]);
+ expect(await found(["*.js"], ["a.js"], null, null, null, null, rules)).toEqual([]);
+ });
+
+ // Each row is what oxlint 1.87 reports. As for `JSON.parse`, the last of two values with one key counts.
+ test("of two entries with one key in an .oxlintrc.json the last counts", async () => {
+ const rows: [config: string, found: string[]][] = [
+ [
+ '{"rules":{"no-debugger":"error"},"rules":{"no-debugger":"off"}}',
+ ["2:5 no-unused-vars warning", "3:1 no-unused-expressions warning", "3:4 no-unused-expressions warning"],
+ ],
+ [
+ '{"rules":{"no-debugger":"off"},"rules":{"no-debugger":"error"}}',
+ [
+ "1:1 no-debugger error",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"rules":{"no-debugger":"error","no-debugger":"off"}}',
+ ["2:5 no-unused-vars warning", "3:1 no-unused-expressions warning", "3:4 no-unused-expressions warning"],
+ ],
+ [
+ '{"rules":{"no-debugger":"off","no-debugger":"error"}}',
+ [
+ "1:1 no-debugger error",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"rules":{"no-debugger":"error"},"rules":{"no-var":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:1 no-var error",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"categories":{"correctness":"off"},"categories":{"correctness":"error"}}',
+ [
+ "1:1 no-debugger error",
+ "2:5 no-unused-vars error",
+ "3:1 no-unused-expressions error",
+ "3:4 no-unused-expressions error",
+ ],
+ ],
+ ['{"categories":{"correctness":"error","correctness":"off"}}', []],
+ [
+ '{"plugins":["unicorn"],"plugins":[],"rules":{"unicorn/no-null":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"plugins":[],"plugins":["unicorn"],"rules":{"unicorn/no-null":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "2:9 no-null error",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"overrides":[{"files":["*.js"],"rules":{"no-debugger":"off"}}],"overrides":[]}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"overrides":[],"overrides":[{"files":["*.js"],"rules":{"no-debugger":"off"}}]}',
+ ["2:5 no-unused-vars warning", "3:1 no-unused-expressions warning", "3:4 no-unused-expressions warning"],
+ ],
+ [
+ '{"overrides":[{"files":["*.ts"],"files":["*.js"],"rules":{"no-debugger":"off"}}]}',
+ ["2:5 no-unused-vars warning", "3:1 no-unused-expressions warning", "3:4 no-unused-expressions warning"],
+ ],
+ [
+ '{"globals":{"a":"off","a":"readonly"},"rules":{"no-undef":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-undef error",
+ "3:4 no-unused-expressions warning",
+ "4:1 no-undef error",
+ "4:17 no-undef error",
+ ],
+ ],
+ [
+ '{"globals":{"a":"readonly"},"globals":{},"rules":{"no-undef":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-undef error",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-undef error",
+ "3:4 no-unused-expressions warning",
+ "4:1 no-undef error",
+ "4:17 no-undef error",
+ ],
+ ],
+ [
+ '{"env":{"browser":true,"browser":false},"rules":{"no-undef":"error"}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-undef error",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-undef error",
+ "3:4 no-unused-expressions warning",
+ "4:1 no-undef error",
+ "4:17 no-undef error",
+ ],
+ ],
+ [
+ '{"rules":{"no-console":["error",{"allow":["log"],"allow":["warn"]}]}}',
+ [
+ "1:1 no-debugger warning",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ "4:1 no-console error",
+ ],
+ ],
+ [
+ '{"rules":{"eslint/no-debugger":"off","no-debugger":"error"}}',
+ [
+ "1:1 no-debugger error",
+ "2:5 no-unused-vars warning",
+ "3:1 no-unused-expressions warning",
+ "3:4 no-unused-expressions warning",
+ ],
+ ],
+ [
+ '{"rules":{"no-debugger":"error","eslint/no-debugger":"off"}}',
+ ["2:5 no-unused-vars warning", "3:1 no-unused-expressions warning", "3:4 no-unused-expressions warning"],
+ ],
+ ];
+ const text = "debugger;\nvar v = null;\na; window;\nconsole.log(1); console.warn(2);\n";
+ const nested = rows.flatMap(([config], i) => [
+ [`d${i}/.oxlintrc.json`, config],
+ [`d${i}/a.js`, text],
+ ]);
+ const { raw } = await lint({ ".oxlintrc.json": "{}", ...Object.fromEntries(nested) });
+ type Message = { ruleId: string; line: number; column: number; severity: number };
+ const results: { filePath: string; messages: Message[] }[] = JSON.parse(raw).results;
+ const found = Object.fromEntries(
+ results.map(({ filePath, messages }) => [
+ filePath.split(/[\\/]/).at(-2),
+ messages
+ .map(
+ it => `${it.line}:${it.column} ${it.ruleId.split("/").at(-1)} ${["off", "warning", "error"][it.severity]}`,
+ )
+ .sort(),
+ ]),
+ );
+ expect(found).toEqual(Object.fromEntries(rows.map(([, expected], i) => [`d${i}`, [...expected].sort()])));
+ });
+
test("a comment that disables a rule which does not run on the file is unused, as for oxlint", async () => {
const { problems } = await lint(
{
@@ -2532,14 +3798,98 @@ describe.concurrent("an .oxlintrc.json", () => {
expect(problems).toEqual(["a.vue:2:1 -"]);
});
+ // Every row is what oxlint 1.87 prints. Without --type-aware it acts as if the rules that need types didn't exist.
+ test("disable comments are unused under .oxlintrc.json when the only rules left are ones that need types", async () => {
+ const text = [
+ "declare function g(): void;",
+ "export async function f() {",
+ " // oxlint-disable-next-line",
+ " g();",
+ " g(); // eslint-disable-line",
+ " // oxlint-disable-next-line typescript/await-thenable",
+ " g();",
+ " // eslint-disable-next-line @typescript-eslint/await-thenable",
+ " g();",
+ " g(); // oxlint-disable-line await-thenable",
+ " // oxlint-disable-next-line typescript/await-thenable, no-debugger",
+ " g();",
+ " // oxlint-disable-next-line typescript/await-thenable, no-debugger",
+ " debugger;",
+ " // oxlint-disable-next-line typescript/await-thenable",
+ " await 1;",
+ " // oxlint-disable-next-line",
+ " await 2;",
+ " /* oxlint-disable typescript/await-thenable */",
+ " await 3;",
+ " /* oxlint-enable typescript/await-thenable */",
+ " await 4;",
+ " /* oxlint-disable */",
+ " g();",
+ " /* oxlint-enable */",
+ "}",
+ "",
+ ].join("\n");
+ const run = async (config: object, ...flags: string[]) => {
+ const files = {
+ ".oxlintrc.json": JSON.stringify(config),
+ "tsconfig.json": JSON.stringify({
+ compilerOptions: { strict: true, noEmit: true, lib: ["es2022"], types: [] },
+ }),
+ "a.ts": text,
+ };
+ const { problems } = await lint(files, ["a.ts", "--report-unused-disable-directives", ...flags]);
+ const place = (it: string) => it.split(/[: ]/).slice(1, 3).map(Number);
+ return problems
+ .sort((a, b) => place(a)[0] - place(b)[0] || place(a)[1] - place(b)[1])
+ .map(it => it.replace("a.ts:", "").replace(" -", " unused").replace(/ .*\//, " "));
+ };
+ const only = (severity: string) => ({
+ categories: { correctness: "off" },
+ rules: { "no-debugger": "error", "typescript/await-thenable": severity },
+ });
+ // These silence nothing, whether or not the rule runs.
+ const always = ["3:3", "5:8", "6:3", "8:3", "10:8", "11:3", "13:31"].map(it => `${it} unused`);
+ const withoutTheRule = [...always, "15:3 unused", "17:3 unused", "21:3 unused", "25:3 unused"];
+ const results = await Promise.all([
+ run({}),
+ run({}, "--type-aware"),
+ run(only("error")),
+ run(only("error"), "--type-aware"),
+ run(only("off")),
+ run(only("off"), "--type-aware"),
+ ]);
+ expect(results).toEqual([
+ [
+ ...always,
+ "15:3 unused",
+ "16:3 no-unnecessary-await",
+ "20:3 no-unnecessary-await",
+ "21:3 unused",
+ "22:3 no-unnecessary-await",
+ "25:3 unused",
+ ],
+ [
+ ...always,
+ "16:3 no-unnecessary-await",
+ "20:3 no-unnecessary-await",
+ "22:3 no-unnecessary-await",
+ "22:9 await-thenable",
+ "25:3 unused",
+ ],
+ withoutTheRule,
+ [...always, "22:9 await-thenable", "25:3 unused"],
+ withoutTheRule,
+ withoutTheRule,
+ ]);
+ });
+
test("the rules that a category turns on and that do not exist here are named, in a warning", async () => {
const config = {
plugins: ["unicorn", "oxc", "react", "jsx-a11y", "jest"],
categories: { correctness: "warn" },
};
const named = (stderr: string) =>
- /rules that the categories turn on do not exist here yet and did not run: (.*)/.exec(stderr)?.[1].split(", ") ??
- [];
+ /rules enabled by "categories" are not supported yet and did not run: (.*)/.exec(stderr)?.[1].split(", ") ?? [];
const { stderr, exitCode } = await lint({ ".oxlintrc.json": JSON.stringify(config), "a.js": "export {};\n" });
expect(exitCode).toBe(0);
const lacking = named(stderr);
@@ -2582,6 +3932,173 @@ test("--print-config of oxlint: what each plugin is called in the name of a rule
expect(Object.keys(JSON.parse(stdout).rules).sort()).toEqual(names);
});
+// A rule is handed such a key once, at its first place and with its last value, as `JSON.parse` makes it. So it sees the same
+// whether it asks for the key or walks the entries.
+describe.concurrent("a key that is written more than once in what a rule is handed", () => {
+ const plugin = `
+ const show = (name, value) => console.log(name + " " + JSON.stringify(value) + " " + JSON.stringify(Object.keys(value)));
+ const create = context => (show("options", context.options[0]), show("settings", context.settings.mine ?? {}), {});
+ module.exports = { meta: { name: "mine" }, rules: { show: { meta: { schema: false }, create } } };\n`;
+ const printed = (result: { raw: string; stderr: string }, name: string) =>
+ (result.raw + result.stderr).split("\n").filter(it => it.startsWith(name + " "));
+
+ // What oxlint 1.87 prints.
+ test.each([
+ [
+ '{"size": 1, "color": "red", "size": 3, "shape": null, "size": 5}',
+ '{"size":5,"color":"red","shape":null} ["size","color","shape"]',
+ ],
+ // The whole of the last one: nothing is merged.
+ ['{"box": {"w": 1, "h": 2}, "n": 0, "box": {"h": 3}}', '{"box":{"h":3},"n":0} ["box","n"]'],
+ [
+ '{"deep": {"list": [{"k": 1, "k": 2}], "list": [{"k": 3, "j": 4, "k": 5}]}}',
+ '{"deep":{"list":[{"k":5,"j":4}]}} ["deep"]',
+ ],
+ ['{"size": "big", "size": ["small"]}', '{"size":["small"]} ["size"]'],
+ ['{"size": 1, "\\u0073ize": 2}', '{"size":2} ["size"]'],
+ // A property like any other.
+ [
+ '{"__proto__": {"size": 1}, "color": "red", "__proto__": {"size": 2}}',
+ '{"__proto__":{"size":2},"color":"red"} ["__proto__","color"]',
+ ],
+ ])("a rule in JavaScript, from an .oxlintrc.json: %s", async (written, handed) => {
+ const config = `{ "jsPlugins": ["./plugin.cjs"], "settings": { "mine": ${written} }, "rules": { "mine/show": ["error", ${written}] } }`;
+ const result = await lint({ ".oxlintrc.json": config, "plugin.cjs": plugin, "a.js": "export {};\n" }, ["a.js"]);
+ expect(printed(result, "options")).toEqual([`options ${handed}`]);
+ expect(printed(result, "settings")).toEqual([`settings ${handed}`]);
+ expect(result.exitCode).toBe(0);
+ });
+
+ // What oxlint 1.87 reports. The rule walks its one option, a map from the name of a matcher to what is said about it.
+ test.each([
+ ['{"toBe": "first", "toEqual": "other", "toBe": "last"}', ["2 toBe last", "3 toEqual other"]],
+ ['{"toBe": "first", "toBe": null}', ["2 toBe undefined"]],
+ // The first value, which no map of the rule can have, is not looked at.
+ ['{"toBe": 1, "toBe": "last"}', ["2 toBe last"]],
+ ])("a built-in rule that walks the entries, from an .oxlintrc.json: %s", async (written, found) => {
+ const files = {
+ ".oxlintrc.json": `{ "plugins": ["jest"], "categories": { "correctness": "off" }, "rules": { "jest/no-restricted-matchers": ["error", ${written}] } }`,
+ "a.test.js": 'test("t", () => {\n expect(a).toBe(1);\n expect(a).toEqual(1);\n});\n',
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.test.js"]);
+ type Diagnostic = { message: string; help?: string; labels: { span: { line: number } }[] };
+ const diagnostics: Diagnostic[] = JSON.parse(raw).diagnostics;
+ const shown = diagnostics.map(it => `${it.labels[0].span.line} ${it.message.split("`")[1]} ${it.help}`);
+ expect(shown).toEqual(found);
+ expect(exitCode).toBe(1);
+ });
+
+ // What oxlint 1.87 and ESLint 10.12 do: `true` if the file, which has three lines, has too many, a text if the options are refused.
+ describe.each<[written: string, outcome: boolean | string]>([
+ ['{"max": 1, "max": 100}', false],
+ ['{"max": 100, "max": 1}', true],
+ ['{"max": "many", "max": 100}', false],
+ ['{"max": 100, "max": "many"}', "many"],
+ ])("a built-in rule that asks for the key: %s", (written, outcome) => {
+ const found = outcome === true ? ["max-lines"] : [];
+ const rulesOf = (problems: string[]) => problems.map(it => it.split(" ")[1]);
+
+ test("from an .oxlintrc.json", async () => {
+ const config = `{ "categories": { "correctness": "off" }, "rules": { "max-lines": ["error", ${written}] } }`;
+ const { problems, raw, exitCode } = await lint({ ".oxlintrc.json": config, "a.js": "a;\nb;\nc;\n" }, ["a.js"]);
+ expect(rulesOf(problems)).toEqual(found);
+ if (typeof outcome === "string") expect(raw).toContain(`invalid type: string "${outcome}", expected u32`);
+ expect(exitCode).toBe(outcome === false ? 0 : 1);
+ });
+
+ test("from a comment", async () => {
+ const files = {
+ "eslint.config.mjs": "export default [{ rules: {} }];\n",
+ "a.js": `/* eslint max-lines: ["error", ${written}] */\na;\nb;\n`,
+ };
+ const { problems, raw, exitCode } = await lint(files, ["a.js"]);
+ expect(rulesOf(problems)).toEqual(outcome === false ? [] : ["max-lines"]);
+ if (typeof outcome === "string") expect(raw).toContain(`Value \\"${outcome}\\" should be integer.`);
+ expect(exitCode).toBe(outcome === false ? 0 : 1);
+ });
+
+ test("from --rule", async () => {
+ const files = { "eslint.config.mjs": "export default [{ rules: {} }];\n", "a.js": "a;\nb;\nc;\n" };
+ const { problems, stderr, exitCode } = await lint(files, ["--rule", `max-lines: ["error", ${written}]`, "a.js"]);
+ expect(rulesOf(problems)).toEqual(found);
+ if (typeof outcome === "string") expect(stderr).toContain(`Value "${outcome}" should be integer.`);
+ expect(exitCode).toBe(typeof outcome === "string" ? 2 : Number(outcome));
+ });
+ });
+
+ // What ESLint 10.12 prints. It reads both with levn, which assigns each entry to an object: `__proto__` is no property then.
+ describe.each([
+ [
+ '{"size": 1, "color": "red", "size": 3, "shape": null, "size": 5}',
+ '{"size":5,"color":"red","shape":null} ["size","color","shape"]',
+ ],
+ ['{"box": {"w": 1, "h": 2}, "n": 0, "box": {"h": 3}}', '{"box":{"h":3},"n":0} ["box","n"]'],
+ [
+ '{"deep": {"list": [{"k": 1, "k": 2}], "list": [{"k": 3, "j": 4, "k": 5}]}}',
+ '{"deep":{"list":[{"k":5,"j":4}]}} ["deep"]',
+ ],
+ [`{size: 1, "size": 2, 'size': 3}`, '{"size":3} ["size"]'],
+ ['{"__proto__": {"size": 1}, "color": "red"}', '{"color":"red"} ["color"]'],
+ ])("a rule in JavaScript, with an eslint.config.mjs: %s", (written, handed) => {
+ const files = {
+ "eslint.config.mjs": `import mine from "./plugin.cjs";\nexport default [{ plugins: { mine } }];\n`,
+ "plugin.cjs": plugin,
+ };
+
+ test("from a comment", async () => {
+ const code = `/* eslint mine/show: ["error", ${written}] */\nexport {};\n`;
+ expect(printed(await lint({ ...files, "a.js": code }, ["a.js"]), "options")).toEqual([`options ${handed}`]);
+ });
+
+ test("from --rule", async () => {
+ const result = await lint({ ...files, "a.js": "export {};\n" }, [
+ "--rule",
+ `mine/show: ["error", ${written}]`,
+ "a.js",
+ ]);
+ expect(printed(result, "options")).toEqual([`options ${handed}`]);
+ });
+ });
+
+ // TOML has no such thing.
+ test.each([
+ 'max-lines = ["error", { max = 100, max = 1 }]\n',
+ 'max-lines = "off"\nmax-lines = ["error", { max = 1 }]\n',
+ '"max-lines" = "off"\nmax-lines = ["error", { max = 1 }]\n',
+ ])("a bunfig.toml is refused: %j", async rules => {
+ const { problems, stderr, exitCode } = await lint({ "bunfig.toml": `[lint.rules]\n${rules}`, "a.js": "a;\nb;\n" }, [
+ "a.js",
+ ]);
+ expect(problems).toEqual([]);
+ expect(stderr).toContain("error: Cannot redefine key");
+ expect(exitCode).toBe(2);
+ });
+
+ // The words of js-yaml 4, which reads these files for ESLint 8 and throws. It reads an `.eslintrc` too, which can be JSON.
+ test.each([
+ [
+ ".eslintrc.yaml",
+ "root: true\nrules:\n max-lines: [error, {max: 100, max: 1}]\n",
+ "duplicated mapping key (3:33)\n\n 1 | root: true\n 2 | rules:\n 3 | max-lines: [error, {max: 100, max: 1}]\n-------------------------------------^",
+ ],
+ [
+ ".eslintrc.yml",
+ 'root: true\nrules:\n "no-var": off\n eqeqeq: off\n no-var: error\nenv: {}\nglobals: {}\nsettings: {}\n',
+ 'duplicated mapping key (5:3)\n\n 2 | rules:\n 3 | "no-var": off\n 4 | eqeqeq: off\n 5 | no-var: error\n-------^\n 6 | env: {}\n 7 | globals: {}',
+ ],
+ [
+ ".eslintrc",
+ '{ "root": true, "rules": { "no-var": "off", "no-var": "error" } }\n',
+ 'duplicated mapping key (1:45)\n\n 1 | ... e, "rules": { "no-var": "off", "no-var": "error" } }\n-----------------------------------------^',
+ ],
+ ])("a %s is refused", async (name, text, why) => {
+ const { problems, stderr, exitCode } = await lint({ [name]: text, "a.js": "var a;\n" }, ["a.js"]);
+ expect(problems).toEqual([]);
+ expect(stderr).toContain(`Cannot read config file: /${name}\nError: ${why}`);
+ expect(exitCode).toBe(2);
+ });
+});
+
describe.concurrent("the configuration files of ESLint 8", () => {
test.each([
[".eslintrc.json", rc(eqeqeq)],
@@ -3256,80 +4773,187 @@ describe.concurrent("whose configuration files count", () => {
"sub/b.js": "var y = 1;\nif (y == 2) {}\n",
};
- // `oxlint --fix && eslint --fix .`, each replaced by `bun lint`: one of the two tools would be left out, in silence.
- test("where files of both tools count and nothing decides, nothing is linted", async () => {
- const say = "Say which one this run is for: --flavor=oxlint or --flavor=eslint.";
- const { problems, stdout, stderr, exitCode } = await lint(both, ["--fix", "a.js", "sub/b.js"]);
- expect([problems, stdout]).toEqual([[], ""]);
- expect(stderr).toBe(`error: Both /eslint.config.js and /.oxlintrc.json are here. ${say}`);
- expect(exitCode).toBe(2);
+ const ignores = (ignored: string, used = ".oxlintrc.json") =>
+ `note: Using ${used}. ${ignored} is ignored. Use --config to pick it.`;
+
+ // A project with both configs is moving to oxlint.
+ test("the oxlint config wins over an ESLint config, and one note says so", async () => {
+ const { problems, stderr, exitCode } = await lint(both, ["a.js", "sub/b.js"]);
+ expect(problems).toEqual(["a.js:2:7 eqeqeq"]);
+ expect(stderr).toBe(ignores("eslint.config.js"));
+ expect(exitCode).toBe(1);
// Also where one is further up than the other.
const { "sub/.oxlintrc.json": _, ...above } = both;
- const below = await lint(above, ["."], { cwd: "sub" });
- expect(below.stderr).toBe(`error: Both /sub/eslint.config.js and /.oxlintrc.json are here. ${say}`);
- expect(below.exitCode).toBe(2);
+ const below = await lint(above, ["b.js"], { cwd: "sub" });
+ expect(below.problems).toEqual(["sub/b.js:2:7 eqeqeq"]);
+ expect(below.stderr).toBe(ignores("eslint.config.js", "../.oxlintrc.json"));
+ expect(below.exitCode).toBe(1);
+ expect((await lint(both, ["--silent", "a.js"])).stderr).toBe("");
expect((await lint(both, ["--nonsense"])).exitCode).toBe(1);
});
- test("oxlint needs no file: an eslint.config.js and the dependency", async () => {
+ const [ofESLint, ofOxlint, legacy] = [both["eslint.config.js"], oxlintrc({ "no-debugger": "error" }), rc(noVar)];
+ const asModule = ofESLint.replace("module.exports =", "export default");
+ test.each([
+ ["eslint.config.js", ofESLint, "no-var"],
+ ["eslint.config.mjs", asModule, "no-var"],
+ ["eslint.config.cjs", ofESLint, "no-var"],
+ ["eslint.config.ts", asModule, "no-var"],
+ ["eslint.config.mts", asModule, "no-var"],
+ ["eslint.config.cts", ofESLint, "no-var"],
+ ["mine.js", ofESLint, "no-var"],
+ [".oxlintrc.json", ofOxlint, "no-debugger"],
+ [".oxlintrc.jsonc", `// Mine.\n${ofOxlint}`, "no-debugger"],
+ ["oxlint.config.ts", `export default ${ofOxlint};`, "no-debugger"],
+ ["oxlint.config.mts", `export default ${ofOxlint};`, "no-debugger"],
+ ["vite.config.ts", `export default { lint: ${ofOxlint} };`, "no-debugger"],
+ ["mine.json", ofOxlint, "no-debugger"],
+ [".eslintrc.json", legacy, "no-var"],
+ [".eslintrc", legacy, "no-var"],
+ [".eslintrc.js", `module.exports = ${legacy};`, "no-var"],
+ [".eslintrc.cjs", `module.exports = ${legacy};`, "no-var"],
+ [".eslintrc.yaml", yaml("no-var"), "no-var"],
+ [".eslintrc.yml", yaml("no-var"), "no-var"],
+ ["legacy.json", legacy, "no-var"],
+ ])("with both kinds of config file, --config picks %s and prints no note", async (name, text, rule) => {
+ const files = { ...both, [`picked/${name}`]: text };
+ const [byFlag, byKey] = await Promise.all([
+ lint(files, ["--config", `picked/${name}`, "a.js"]),
+ lint({ ...files, "bunfig.toml": `[lint]\nconfig = "picked/${name}"\n` }, ["a.js"]),
+ ]);
+ for (const { problems, stderr } of [byFlag, byKey]) {
+ expect(problems.map(it => it.split(" ")[1])).toEqual([rule]);
+ expect(stderr).not.toContain("is ignored");
+ }
+ });
+
+ test("an eslint.config.js wins over a dependency on oxlint", async () => {
const files = {
"eslint.config.js": both["eslint.config.js"],
"package.json": JSON.stringify({ devDependencies: { eslint: "*", oxlint: "*" } }),
"a.js": code,
};
- const { stderr, exitCode } = await lint(files, ["a.js"]);
- expect(stderr).toStartWith(
- "error: Both /eslint.config.js and the dependency on oxlint in /package.json are here. Say which one",
- );
- expect(exitCode).toBe(2);
+ const { problems, stderr } = await lint(files, ["a.js"]);
+ expect(problems).toEqual(["a.js:1:1 no-var"]);
+ expect(stderr).not.toContain("is ignored");
expect((await lint(files, ["--flavor=eslint", "a.js"])).problems).toEqual(["a.js:1:1 no-var"]);
// Its defaults.
expect((await lint(files, ["--flavor=oxlint", "a.js"])).problems).toEqual(["a.js:2:13 no-debugger"]);
- expect((await lint(files, ["--type-aware", "a.js"])).exitCode).toBe(2);
- const { "package.json": _, ...alone } = files;
- expect((await lint(alone, ["a.js"])).problems).toEqual(["a.js:1:1 no-var"]);
- expect((await lint(alone, ["--type-aware", "a.js"])).problems).toEqual(["a.js:1:1 no-var"]);
+ expect((await lint(files, ["--type-aware", "a.js"])).problems).toEqual(["a.js:1:1 no-var"]);
});
- test("--type-aware, which ESLint does not have, is for oxlint where there are files of both", async () => {
- const { problems, stderr } = await lint(both, ["--type-aware", "a.js"]);
- expect(problems).toEqual(["a.js:2:7 eqeqeq"]);
- expect(stderr).not.toContain("Both ");
- expect((await lint(both, ["--type-aware", "--cache", "a.js"])).problems).toEqual(["a.js:1:1 no-var"]);
+ test.each([
+ [["--type-aware"], ["a.js:2:7 eqeqeq"]],
+ [["--cache"], ["a.js:2:7 eqeqeq"]],
+ [["--no-warn-ignored"], ["a.js:2:7 eqeqeq"]],
+ [
+ ["--rule", "no-var: error"],
+ ["a.js:1:1 no-var", "a.js:2:7 eqeqeq"],
+ ],
+ [
+ ["-D", "no-debugger"],
+ ["a.js:2:13 no-debugger", "a.js:2:7 eqeqeq"],
+ ],
+ ])("%j doesn't pick between an ESLint and an oxlint config", async (flags, expected) => {
+ const { problems, stderr } = await lint(both, [...flags, "a.js"]);
+ expect(problems).toEqual(expected);
+ expect(stderr).toBe(ignores("eslint.config.js"));
});
- test.each([["--cache"], ["--no-warn-ignored"], ["--ext", ".js"], ["--rule", "no-var: error"]])(
- "%s is a flag that only ESLint has, so the run is for ESLint",
- async (...flags) => {
- const { problems, stderr } = await lint(both, [...flags, "a.js"]);
- expect(problems).toEqual(["a.js:1:1 no-var"]);
- expect(stderr).not.toContain("Both ");
- },
- );
-
test.each([
["eslint", ["a.js:1:1 no-var"]],
["oxlint", ["a.js:2:7 eqeqeq"]],
])("--flavor=%s", async (flavor, expected) => {
const { problems, stderr } = await lint(both, [`--flavor=${flavor}`, "a.js", "sub/b.js"]);
expect(problems).toEqual(expected);
- expect(stderr).not.toContain("Both ");
+ expect(stderr).not.toContain("is ignored");
});
test("--flavor takes two values", async () => {
const { stderr, exitCode } = await lint(both, ["--flavor=biome", "."]);
- expect(stderr).toContain("Option flavor: 'biome' not one of eslint or oxlint.");
+ expect(stderr).toContain('--flavor must be eslint or oxlint, not "biome"');
expect(exitCode).toBe(1);
});
- test("flags that only oxlint has, without a configuration file, are for oxlint", async () => {
- // Its defaults warn about what is surely wrong.
- const { problems, exitCode } = await lint({ "a.js": code }, ["-D", "no-var", "a.js"]);
- expect(problems).toEqual(["a.js:1:1 no-var", "a.js:2:13 no-debugger"]);
- expect(exitCode).toBe(1);
- const allowed = await lint({ "a.js": code }, ["-A", "no-debugger", "a.js"]);
- expect(allowed.problems).toEqual([]);
- expect(allowed.exitCode).toBe(0);
+ // Covers every flag in the "Compatibility with oxlint" group of --help --all.
+ test("oxlint flags keep Bun's default rules and output without a config file", async () => {
+ const run = async (...args: string[]) => {
+ using dir = tempDir("bun-lint-oxlint-flags", { "a.js": "export function f(a) {\n if (a) {\n }\n}\n" });
+ const stdio = { stdin: "ignore", stdout: "pipe", stderr: "pipe" } as const;
+ await using proc = spawn({ cmd: [...command, ...args], env, cwd: String(dir), ...stdio });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr: stderr.replace(/ \[[\d.]+m?s\]/, ""), exitCode };
+ };
+ const [help, plain, limited] = await Promise.all([run("--help", "--all"), run(), run("--max-warnings", "0")]);
+ expect(plain.stdout).toContain("warn: Empty block statement. no-empty\n");
+ expect(plain.stdout).toEndWith("\n1 problem (0 errors, 1 warning)\n");
+ expect([plain.stderr, plain.exitCode]).toEqual(["Linted 1 file\n", 0]);
+ expect(limited).toEqual({
+ stdout: plain.stdout,
+ stderr: "error: Found too many warnings (maximum: 0).\nLinted 1 file\n",
+ exitCode: 1,
+ });
+
+ const error = (text: string) => ({ stdout: "", stderr: `error: ${text}\n`, exitCode: 2 });
+ const expected: Record = {
+ allow: [["-A", "no-var"], plain],
+ warn: [["-W", "no-empty"], plain],
+ deny: [["-D", "no-var"], plain],
+ "deny-warnings": [["--deny-warnings"], limited],
+ silent: [["--silent"], { stdout: "", stderr: "", exitCode: 0 }],
+ "disable-nested-config": [["--disable-nested-config"], plain],
+ lsp: [["--lsp"], error("bun lint does not support --lsp")],
+ };
+ const group = help.stdout.slice(help.stdout.indexOf("Compatibility with oxlint"));
+ const flags = [...group.matchAll(/^ +(?:-\w, )?--([a-z0-9-]+)/gm)].map(it => it[1]);
+ // Every built-in rule is available without a config file, so there are no plugins to turn on or off.
+ for (const flag of flags.filter(it => it.endsWith("-plugin"))) {
+ const why = `--${flag} is an oxlint flag and has no effect here\n This run uses Bun's defaults.`;
+ expected[flag] = [[`--${flag}`], error(why)];
+ }
+ expect(Object.keys(expected).sort()).toEqual(flags.sort());
+ const results = await Promise.all(Object.values(expected).map(([args]) => run(...args)));
+ expect(Object.fromEntries(Object.keys(expected).map((flag, at) => [flag, results[at]]))).toEqual(
+ Object.fromEntries(Object.entries(expected).map(([flag, [, result]]) => [flag, result])),
+ );
+ expect(await run("--deny-warnings", "--silent")).toEqual({ stdout: "", stderr: "", exitCode: 1 });
+ });
+
+ test("-A, -W and -D add to Bun's defaults without a config file", async () => {
+ const files = { "a.js": "var x = 1;\nexport function f(a) {\n if (a) {\n }\n return x;\n}\n" };
+ const run = async (...flags: string[]) => {
+ const { problems, exitCode } = await lint(files, [...flags, "a.js"]);
+ return [problems, exitCode];
+ };
+ const [noVar, noEmpty] = ["a.js:1:1 no-var", "a.js:3:10 no-empty"];
+ expect(await run()).toEqual([[noEmpty], 0]);
+ expect(await run("-D", "no-var")).toEqual([[noVar, noEmpty], 1]);
+ expect(await run("-W", "no-var")).toEqual([[noVar, noEmpty], 0]);
+ expect(await run("-D", "eslint/no-var")).toEqual([[noVar, noEmpty], 1]);
+ expect(await run("-D", "no-var", "-A", "no-var")).toEqual([[noEmpty], 0]);
+ expect(await run("-A", "no-empty")).toEqual([[], 0]);
+ // A category works like [lint.categories].
+ const byKey = await lint({ ...files, "bunfig.toml": `[lint.categories]\nrestriction = "error"\n` }, ["a.js"]);
+ expect(byKey.problems).toContain(noVar);
+ expect(await run("-D", "restriction")).toEqual([byKey.problems, 1]);
+ });
+
+ test.each([
+ [["-D", "no-vra"], `Unknown rule "no-vra"\n Did you mean "no-var"?`],
+ [["-A", "no-vra"], `Unknown rule "no-vra"\n Did you mean "no-var"?`],
+ [["-W", "indent"], `"indent" is a formatting rule\n bun fmt does that`],
+ ])("%j is rejected without a config file", async (flags, why) => {
+ const { problems, stderr, exitCode } = await lint({ "a.js": code }, [...flags, "a.js"]);
+ expect({ problems, stderr, exitCode }).toEqual({ problems: [], stderr: `error: ${why}`, exitCode: 2 });
+ });
+
+ test("without a root config file, --disable-nested-config skips config files in subdirectories", async () => {
+ const files = { "a.js": code, "sub/.oxlintrc.json": oxlintrc({ eqeqeq: "error" }), "sub/b.js": code };
+ expect((await lint(files)).problems).toEqual(["a.js:2:13 no-debugger", "sub/b.js:2:7 eqeqeq"]);
+ expect((await lint(files, ["--disable-nested-config", "."])).problems).toEqual([
+ "a.js:2:13 no-debugger",
+ "sub/b.js:2:13 no-debugger",
+ ]);
});
test("without a configuration file, the package.json tells", async () => {
@@ -3347,11 +4971,11 @@ describe.concurrent("whose configuration files count", () => {
expect(eslint.exitCode).toBe(1);
const both = await lint({ ...files, "package.json": dependsOn("eslint", "oxlint") });
expect(both.stderr).toContain(
- "No configuration file found, and /package.json has both eslint and oxlint: using the defaults of oxlint. Use --flavor=eslint for the other.",
+ "No config file found, and package.json depends on both eslint and oxlint\n Using oxlint's defaults. Add a config file to change that.",
);
expect(both.exitCode).toBe(0);
const chosen = await lint({ ...files, "package.json": dependsOn("eslint", "oxlint") }, ["--flavor=eslint", "."]);
- expect(chosen.stderr).not.toContain("No configuration file found");
+ expect(chosen.stderr).not.toContain("No config file found");
expect(chosen.exitCode).toBe(1);
expect((await lint(files)).exitCode).toBe(1);
});
@@ -3410,12 +5034,6 @@ describe.concurrent("whose configuration files count", () => {
expect(withFile.problems).toEqual(["a.js:2:13 no-debugger", "packages/own/b.js:2:13 no-debugger"]);
});
- test("flags that only oxlint has, where there are both, are for oxlint", async () => {
- const { problems, stderr } = await lint(both, ["-D", "no-debugger", "a.js"]);
- expect(problems).toEqual(["a.js:2:13 no-debugger", "a.js:2:7 eqeqeq"]);
- expect(stderr).not.toContain("Both ");
- });
-
describe("the file that is found decides, whatever flags there are", () => {
const flat = { "eslint.config.js": both["eslint.config.js"] };
const oxlint = { ".oxlintrc.json": both[".oxlintrc.json"] };
@@ -3425,6 +5043,7 @@ describe.concurrent("whose configuration files count", () => {
".eslintrc.json": { ".eslintrc.json": rc(noVar) },
".oxlintrc.json": oxlint,
"both": { ...flat, ...oxlint },
+ ".eslintrc.json and .oxlintrc.json": { ".eslintrc.json": rc(noVar), ...oxlint },
"eslint.config.js and the dependency": { ...flat, "package.json": `{ "devDependencies": { "oxlint": "*" } }` },
"the dependency": { "package.json": `{ "devDependencies": { "oxlint": "*" } }` },
"files by other names": { "mine.js": both["eslint.config.js"], "mine.json": both[".oxlintrc.json"] },
@@ -3438,12 +5057,11 @@ describe.concurrent("whose configuration files count", () => {
const [ofESLint, ofOxlint] = [[["a.js:1:1 no-var"], 1] as const, [["a.js:2:7 eqeqeq"], 1] as const];
const [defaults, builtIn] = [[["a.js:2:13 no-debugger"], 0] as const, [["a.js:2:13 no-debugger"], 1] as const];
const [nothing, failsInSilence] = [[[], 0] as const, [[], 1] as const];
- const asks = [[], 2, "Say which one this run is for: --flavor=oxlint or --flavor=eslint."] as const;
const refused = (flag: string, whose: string, where: string) =>
- [[], 2, `error: ${flag} is a flag of ${whose}. It means nothing ${where}.`] as const;
- const withFlat = "with /eslint.config.js, a configuration file of ESLint";
- const withLegacy = "with /.eslintrc.json, a configuration file of ESLint 8";
- const withOxlint = "with /.oxlintrc.json, a configuration file of oxlint";
+ [[], 2, `error: ${flag} is an ${whose} flag and has no effect here\n This run uses ${where}.`] as const;
+ const withFlat = "eslint.config.js, an ESLint config";
+ const withLegacy = ".eslintrc.json, an ESLint 8 config";
+ const withOxlint = ".oxlintrc.json, an oxlint config";
test.each<[keyof typeof projects, string[], readonly [readonly string[], number, string?]]>([
["eslint.config.js", [], ofESLint],
@@ -3498,39 +5116,37 @@ describe.concurrent("whose configuration files count", () => {
[".oxlintrc.json", ["--flavor=eslint"], builtIn],
[".oxlintrc.json and [lint] ext", [], ofOxlint],
- // Nothing else decides.
["no file", [], builtIn],
- ["no file", ["--silent"], nothing],
- ["no file", ["--deny-warnings"], [["a.js:2:13 no-debugger"], 1]],
- ["no file", ["--import-plugin"], defaults],
+ ["no file", ["--silent"], failsInSilence],
+ ["no file", ["--deny-warnings"], builtIn],
+ ["no file", ["--disable-nested-config"], builtIn],
+ ["no file", ["-D", "correctness"], builtIn],
+ ["no file", ["--import-plugin"], refused("--import-plugin", "oxlint", "Bun's defaults")],
+ ["no file", ["--fix-suggestions"], builtIn],
+ ["no file", ["--fix-dangerously"], builtIn],
+ ["no file", ["--type-check"], builtIn],
+ // Only ESLint 8 has --env, so this is an ESLint 8 run, which has no rules on.
["no file", ["--env", "browser"], nothing],
- [
- "no file",
- ["--flavor=eslint", "--import-plugin"],
- refused("--import-plugin", "oxlint", "in a run that stands in for ESLint"),
- ],
- [
- "no file",
- ["--flavor=oxlint", "--env", "browser"],
- refused("--env browser", "ESLint 8", "in a run that stands in for oxlint"),
- ],
+ ["no file", ["--flavor=eslint", "--import-plugin"], refused("--import-plugin", "oxlint", "Bun's defaults")],
+ ["no file", ["--flavor=oxlint", "--env", "browser"], refused("--env browser", "ESLint 8", "oxlint's defaults")],
["the dependency", [], defaults],
["the dependency", ["--cache"], defaults],
- [
- "the dependency",
- ["--parser", "espree"],
- refused("--parser espree", "ESLint", "in a run that stands in for oxlint"),
- ],
- ["both", [], asks],
+ ["the dependency", ["--parser", "espree"], refused("--parser espree", "ESLint", "oxlint's defaults")],
+ ["both", [], [...ofOxlint, ignores("eslint.config.js")]],
+ [".eslintrc.json and .oxlintrc.json", [], [...ofOxlint, ignores(".eslintrc.json")]],
["both", ["--silent"], failsInSilence],
["both", ["--deny-warnings"], ofOxlint],
- ["both", ["--cache"], ofESLint],
- ["both", ["--env", "browser"], refused("--env browser", "ESLint 8", withFlat)],
+ ["both", ["--cache"], ofOxlint],
+ ["both", ["--ext", ".js"], refused("--ext .js", "ESLint", withOxlint)],
+ ["both", ["--env", "browser"], refused("--env browser", "ESLint 8", withOxlint)],
- // The command without the flag does not guess, and most flags of oxlint mean something to both.
- ["eslint.config.js and the dependency", [], asks],
- ["eslint.config.js and the dependency", ["--silent"], asks],
- ["eslint.config.js and the dependency", ["--deny-warnings", "-D", "correctness"], asks],
+ ["eslint.config.js and the dependency", [], ofESLint],
+ ["eslint.config.js and the dependency", ["--silent"], failsInSilence],
+ [
+ "eslint.config.js and the dependency",
+ ["--deny-warnings", "-D", "correctness"],
+ refused("-D correctness", "oxlint", withFlat),
+ ],
["eslint.config.js and the dependency", ["--cache"], ofESLint],
["eslint.config.js and the dependency", ["--rules"], nothing],
@@ -3543,12 +5159,12 @@ describe.concurrent("whose configuration files count", () => {
[
"files by other names",
["-c", "mine.js", "--import-plugin"],
- refused("--import-plugin", "oxlint", "with /mine.js, a configuration file of ESLint"),
+ refused("--import-plugin", "oxlint", "mine.js, an ESLint config"),
],
[
"files by other names",
["-c", "mine.json", "--ext", ".js"],
- refused("--ext .js", "ESLint", "with /mine.json, a configuration file of oxlint"),
+ refused("--ext .js", "ESLint", "mine.json, an oxlint config"),
],
])("%s, %j", async (project, flags, [problems, exitCode, said]) => {
const run = await lint({ ...projects[project], "a.js": code }, [...flags, "a.js"]);
@@ -3581,24 +5197,24 @@ describe.concurrent("whose configuration files count", () => {
]);
}
expect((await lint(files, ["--silent", "one"])).exitCode).toBe(1);
- const withFile = "It means nothing with /one/eslint.config.js, a configuration file of ESLint.";
- for (const [flags, said] of [
- [["--env", "browser"], "--env browser is a flag of ESLint 8"],
- [["--no-eslintrc"], "--no-eslintrc is a flag of ESLint 8"],
- [["--import-plugin"], "--import-plugin is a flag of oxlint"],
+ const withFile = "one/eslint.config.js, an ESLint config.";
+ for (const [flags, said, uses] of [
+ [["--env", "browser"], "--env browser is an ESLint 8 flag and has no effect here", withFile],
+ [["--no-eslintrc"], "--no-eslintrc is an ESLint 8 flag and has no effect here", withFile],
+ [["--import-plugin"], "--import-plugin is an oxlint flag and has no effect here", "Bun's defaults."],
] as const) {
for (const args of [["."], ["one/a.js"]]) {
const { problems, stderr, exitCode } = await lint(one, [...flags, ...args]);
expect({ problems, stderr, exitCode }).toEqual({
problems: [],
- stderr: `error: ${said}. ${withFile}`,
+ stderr: `error: ${said}\n This run uses ${uses}`,
exitCode: 2,
});
}
}
});
- test("--silent says nothing, and --deny-warnings fails a run that only has warnings", async () => {
+ test("--silent prints nothing, and --deny-warnings fails on a warning like --max-warnings 0", async () => {
const files = {
"eslint.config.js": `module.exports = [{ rules: { "no-var": "warn" } }];`,
"a.js": "var x = 1;\n",
@@ -3606,6 +5222,7 @@ describe.concurrent("whose configuration files count", () => {
expect((await lint(files, ["a.js"])).exitCode).toBe(0);
const denied = await lint(files, ["--deny-warnings", "a.js"]);
expect([denied.problems, denied.exitCode]).toEqual([["a.js:1:1 no-var"], 1]);
+ expect(denied.stderr).toStartWith("error: Found too many warnings (maximum: 0).\n");
const { stdout, stderr, exitCode } = await lint(files, ["--deny-warnings", "--silent", "a.js"]);
expect({ stdout, stderr, exitCode }).toEqual({ stdout: "", stderr: "", exitCode: 1 });
});
@@ -3636,11 +5253,11 @@ describe.concurrent("the command line of oxlint", () => {
test.each([
[["--nonsense"], "Invalid option '--nonsense'"],
- [["--threads=x"], '--threads takes a number, not "x".'],
+ [["--threads=x"], '--threads takes a number, not "x"'],
[["--max-warnings=x"], "Invalid value for option 'max-warnings'"],
[["--debug=nonsense"], "couldn't parse `nonsense`: 'nonsense' is not a known debug option"],
[["--debug=files,timings"], "debug option 'files' cannot be combined with other debug options"],
- [["-f", "nonsense"], 'There is no formatter "nonsense".'],
+ [["-f", "nonsense"], 'Unknown format "nonsense"\n Available formats: stylish, '],
[["-c", "nowhere.json"], "nowhere.json"],
[["--tsconfig", "nowhere.json"], 'nowhere.json" does not exist, Please provide a valid tsconfig file.'],
[
@@ -3658,15 +5275,13 @@ describe.concurrent("the command line of oxlint", () => {
expect(forEslint.exitCode).toBe(2);
});
- test("so does a run that is oxlint's by --config, by the package.json or by a flag", async () => {
+ test("a run that uses oxlint because of --config or package.json also exits with 1", async () => {
const broken = { "broken.json": "{", "a.js": code };
expect((await lint(broken, ["-c", "broken.json"])).exitCode).toBe(1);
const files = { "package.json": JSON.stringify({ devDependencies: { oxlint: "*" } }), "a.js": code };
expect((await lint(files, ["--type-check"])).exitCode).toBe(1);
- expect((await lint({ "a.js": code }, ["-D", "no-var", "--type-check"])).exitCode).toBe(1);
- // Only oxlint has the flag.
- expect((await lint({ "a.js": code }, ["--type-check"])).exitCode).toBe(1);
- expect((await lint({ "a.js": code }, ["--flavor=eslint", "--type-check"])).exitCode).toBe(2);
+ // --type-check works on its own without a config file.
+ expect((await lint({ "a.js": code }, ["--type-check"])).problems).toEqual(["a.js:2:13 no-debugger"]);
});
test("a configuration that cannot be used ends the run with 1", async () => {
@@ -3712,6 +5327,84 @@ describe.concurrent("the command line of oxlint", () => {
expect(alone.exitCode).toBe(1);
});
+ // The texts are those of oxlint 1.87.0.
+ test.each([
+ [
+ { settings: { react: { version: 1 } } },
+ 'invalid type: integer `1`, expected a version string like \\"18.2.0\\" or \\"17.0\\"',
+ ],
+ [{ settings: { react: { version: "detect" } } }, "invalid major version in settings.react.version"],
+ [{ settings: { react: { version: "18.x" } } }, "invalid minor version in settings.react.version"],
+ [{ settings: { react: { version: "18.2.0-rc.1" } } }, "invalid patch version in settings.react.version"],
+ [{ settings: { react: { version: "18.2.0.1" } } }, "has too many components, expected major.minor.patch"],
+ [{ settings: { react: { version: "" } } }, "version string cannot be empty for settings.react.version"],
+ [
+ { rules: { "no-unused-vars": ["error", { vars: "nope" }] } },
+ "Invalid 'vars' option for no-unused-vars: Expected or all or local, got nope",
+ ],
+ [
+ { rules: { "no-unused-vars": ["off", "nope"] } },
+ "Invalid 'vars' option for no-unused-vars: Expected or all or local, got nope",
+ ],
+ [
+ { rules: { "no-unused-vars": ["error", { args: 1 }] } },
+ "Invalid 'args' option for no-unused-vars: Expected a string, got 1",
+ ],
+ [{ rules: { "no-unused-vars": ["error", { args: "some" }] } }, "Expected or after-used or all or none, got some"],
+ [
+ { rules: { "no-unused-vars": ["error", { caughtErrors: "some" }] } },
+ "Invalid 'caughtErrors' option for no-unused-vars: Expected or all or none, got some",
+ ],
+ [
+ { rules: { "no-unused-vars": ["error", 1] } },
+ "Invalid 'vars' option for no-unused-vars: Expected a string or an object, got 1",
+ ],
+ ])("an option value that oxlint rejects is a config error: %j", async (config, why) => {
+ // `stdout` has its backslashes normalized, and one of these texts has some.
+ const { raw, exitCode } = await lint({ ".oxlintrc.json": JSON.stringify(config), "a.js": code });
+ expect(raw).toContain(why);
+ expect(exitCode).toBe(1);
+ });
+
+ test.each([
+ { settings: { react: { version: "18" } } },
+ { settings: { react: { version: "18.2" } } },
+ { settings: { react: { version: null } } },
+ { rules: { "no-unused-vars": ["error", "local"] } },
+ { rules: { "no-unused-vars": ["error", { vars: "all", args: "after-used", caughtErrors: "none" }] } },
+ { rules: { "no-unused-vars": ["error", { caughtErrors: false }] } },
+ ])("an option value that oxlint accepts is not: %j", async config => {
+ const { stdout } = await lint({ ".oxlintrc.json": JSON.stringify(config), "a.js": code });
+ expect(stdout).toStartWith('{"results":');
+ });
+
+ // Rules that look at several files lint a file a second time, without types.
+ test("--type-check still reports type errors when import rules are on", async () => {
+ const files = {
+ "tsconfig.json": JSON.stringify({ compilerOptions: { strict: true, noEmit: true, types: [] } }),
+ "q.ts": "export const q = 1;\n",
+ "b.ts": [
+ 'import { q } from "./q";',
+ 'import { q as r } from "./q";',
+ "// oxlint-disable-next-line",
+ 'const n: number = "x";',
+ "var old = await 1;",
+ "export default [n, q, r, old];",
+ "",
+ ].join("\n"),
+ };
+ const rules = { "no-var": "error", "import/no-duplicates": "error", "typescript/await-thenable": "error" };
+ const config = JSON.stringify({ plugins: ["import", "typescript"], categories: { correctness: "off" }, rules });
+ const { problems, exitCode } = await lint({ ...files, ".oxlintrc.json": config }, ["--type-aware", "--type-check"]);
+ expect(problems).toEqual([
+ "b.ts:1:19 import/no-duplicates",
+ "b.ts:4:7 typescript/TS2322",
+ "b.ts:5:1 no-var",
+ "b.ts:5:17 @typescript-eslint/await-thenable",
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
test("--print-config prints what oxlint prints", async () => {
using dir = tempDir("bun-lint-print-config", {
".oxlintrc.json": JSON.stringify({
@@ -3866,60 +5559,6 @@ describe.concurrent("the command line of oxlint", () => {
});
});
- test("--init writes the defaults of oxlint, and not over a file", async () => {
- using dir = tempDir("bun-lint-init", { "a.js": "debugger;\n" });
- const run = async (...args: string[]) => {
- await using proc = spawn({
- cmd: [...command, ...args],
- env,
- cwd: String(dir),
- stdout: "pipe",
- stderr: "pipe",
- });
- const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
- return { stdout, stderr: normalizeBunSnapshot(stderr, String(dir)), exitCode };
- };
- expect(await run("--init")).toEqual({ stdout: "Configuration file created\n", stderr: "", exitCode: 0 });
- expect(JSON.parse(readFileSync(join(String(dir), ".oxlintrc.json"), "utf8"))).toEqual({
- $schema: "./node_modules/oxlint/configuration_schema.json",
- plugins: ["typescript", "unicorn", "oxc"],
- categories: { correctness: "error" },
- rules: {},
- env: { builtin: true },
- });
- const again = await run("--init");
- expect(normalizeBunSnapshot(again.stdout, String(dir))).toContain("/.oxlintrc.json exists already.");
- expect(again.exitCode).toBe(1);
- // It is one that can be used.
- expect((await run("--allow-unsupported", "a.js")).exitCode).toBe(1);
- });
-
- test.each(["eslint.config.mjs", ".eslintrc.json"])(
- "--init beside %s writes nothing unless --flavor=oxlint",
- async name => {
- using dir = tempDir("bun-lint-init", {
- [name]: name.endsWith(".json") ? rc(noVar) : "export default [];",
- "sub/a.js": code,
- });
- const run = async (...args: string[]) => {
- await using proc = spawn({
- cmd: [...command, ...args],
- env,
- cwd: join(String(dir), "sub"),
- stderr: "pipe",
- });
- const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
- return { stderr: normalizeBunSnapshot(stderr, String(dir)), exitCode };
- };
- const refused = await run("--init");
- expect(refused.stderr).toContain(`which would count in place of /${name}. Use --flavor=oxlint to write it.`);
- expect(refused.exitCode).toBe(2);
- expect(existsSync(join(String(dir), "sub", ".oxlintrc.json"))).toBe(false);
- expect((await run("--init", "--flavor=oxlint")).exitCode).toBe(0);
- expect(existsSync(join(String(dir), "sub", ".oxlintrc.json"))).toBe(true);
- },
- );
-
test("node_modules is a directory like any other, which a .gitignore has", async () => {
const files = {
".oxlintrc.json": oxlintrc,
@@ -3950,9 +5589,9 @@ describe.concurrent("what the configuration asks for and cannot be done", () =>
test("a rule that does not exist: the rest is linted, and the run fails", async () => {
const { problems, stderr, exitCode } = await lint(files);
expect(problems).toEqual(["a.js:1:1 no-var"]);
- expect(stderr).toContain("2 rules of ESLint did not run: require-jsdoc, valid-jsdoc");
+ expect(stderr).toContain("2 rules in your .eslintrc config are not supported: require-jsdoc, valid-jsdoc");
expect(stderr).not.toContain("no-rule-that-is-off");
- expect(stderr).toContain("--allow-unsupported makes this a warning.");
+ expect(stderr).toContain("\n Everything else was linted. Use --allow-unsupported to make this a warning.");
expect(exitCode).toBe(2);
});
@@ -3965,11 +5604,19 @@ describe.concurrent("what the configuration asks for and cannot be done", () =>
test("--allow-unsupported makes it a warning", async () => {
const { problems, stderr, exitCode } = await lint(files, ["--allow-unsupported", "."]);
expect(problems).toEqual(["a.js:1:1 no-var"]);
- expect(stderr).toContain("warn: 2 rules of ESLint did not run: require-jsdoc, valid-jsdoc");
+ expect(stderr).toContain("warn: 2 rules in your .eslintrc config are not supported: require-jsdoc, valid-jsdoc");
expect(exitCode).toBe(1);
expect((await lint({ ...files, "a.js": "let x = 1;\nx;\n" }, ["--allow-unsupported", "."])).exitCode).toBe(0);
});
+ test("without a config file, a comment that turns on a rule that isn't built in is reported as a problem", async () => {
+ const files = { "a.js": "/* eslint promise/not-there: error, jest/nope: error */\nexport {};\n" };
+ const { problems, stderr, exitCode } = await lint(files);
+ expect(problems).toEqual(["a.js:1:1 jest/nope", "a.js:1:1 promise/not-there"]);
+ expect(stderr).not.toContain("did not run");
+ expect(exitCode).toBe(1);
+ });
+
test("files in a language that is not read here", async () => {
const files = {
"eslint.config.mjs": `export default [
@@ -3985,14 +5632,14 @@ describe.concurrent("what the configuration asks for and cannot be done", () =>
const { problems, stderr, exitCode } = await lint(files);
expect(problems).toEqual(["a.js:1:1 no-var"]);
expect(stderr).toContain(
- "4 files were not linted, only JavaScript and TypeScript can be (3 *.one, 1 *.two): b.one, c.one, d.one, ..",
+ "4 files were not linted because bun lint only supports JavaScript and TypeScript (3 *.one, 1 *.two): b.one, c.one, d.one, ..",
);
expect(exitCode).toBe(2);
expect((await lint(files, ["--allow-unsupported", "."])).exitCode).toBe(1);
});
});
-// ESLint has deprecated its rules about layout, and eslint-plugin-react its `jsx-space-before-closing`. They are not built in: `bun format`
+// ESLint has deprecated its rules about layout, and eslint-plugin-react its `jsx-space-before-closing`. They are not built in: `bun fmt`
// does their work. The configurations that people share still turn them on.
describe.concurrent("the deprecated rules about layout", () => {
const rules = {
@@ -4010,8 +5657,7 @@ describe.concurrent("the deprecated rules about layout", () => {
];
const forPeople = ["-f", "stylish", "."];
const notes = (stderr: string) => stderr.split("\n").filter(it => it.startsWith("note: "));
- const note = (count: number, names: string) =>
- `note: ${count} formatting rules that are deprecated did not run, bun format does their work: ${names}`;
+ const note = (count: number, names: string) => `note: ${count} deprecated formatting rules did not run: ${names}`;
test.each(flavors)("%s: they do not run, which is a note and no error", async (name, config) => {
const files = { [name]: config(rules), "a.js": untidy };
@@ -4045,9 +5691,7 @@ describe.concurrent("the deprecated rules about layout", () => {
test("one alone", async () => {
const { stderr } = await lint({ "eslint.config.mjs": flavors[0][1]({ semi: 2 }), "a.js": "a" }, forPeople);
- expect(notes(stderr)).toEqual([
- "note: 1 formatting rule that is deprecated did not run, bun format does its work: semi",
- ]);
+ expect(notes(stderr)).toEqual(["note: 1 deprecated formatting rule did not run: semi"]);
});
// As after eslint-config-prettier.
@@ -4256,7 +5900,7 @@ describe.concurrent("the deprecated rules about layout", () => {
expect(builtIn.problems).toEqual([]);
expect(builtIn.exitCode).toBe(0);
expect(notes(shown.stderr)).toEqual([
- "note: 1 formatting rule that is deprecated did not run, bun format does its work: react/jsx-space-before-closing",
+ "note: 1 deprecated formatting rule did not run: react/jsx-space-before-closing",
]);
expect(ofThePackage.problems).toEqual(["a.js:1:1 react/jsx-space-before-closing"]);
});
@@ -4271,7 +5915,7 @@ describe.concurrent("the deprecated rules about layout", () => {
};
const { problems, stderr, exitCode } = await lint(files, ["a.js"]);
expect(problems).toEqual(["a.js:1:1 no-debugger"]);
- expect(stderr).toContain("2 rules of ESLint did not run: semi, quotes");
+ expect(stderr).toContain("2 rules in .oxlintrc.json are not supported: semi, quotes");
expect(stderr).not.toContain("formatting");
expect(exitCode).toBe(2);
});
@@ -4288,16 +5932,16 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
const clean = { "a.js": "export {};\n", "b.vue": "\n" };
const quiet = { categories: { correctness: "off" }, rules: { "no-debugger": "warn" } };
const named = (plugin: string, ...rules: string[]) =>
- `${rules.length} rule${rules.length > 1 ? "s" : ""} of the plugin "${plugin}" did not run: ${rules.join(", ")}. None is built in: turn them off, or take them out of the configuration`;
+ `${rules.length} ${rules.length > 1 ? "rules" : "rule"} in .oxlintrc.json ${rules.length > 1 ? "are" : "is"} not supported: ${rules.join(", ")}`;
const ofCategories = (...plugins: string[]) =>
- `note: The rules of the plugin${plugins.length > 1 ? "s" : ""} "${plugins.join('" and "')}" that the categories turn on did not run. None is built in: take ${plugins.length > 1 ? "them" : "it"} out of "plugins"`;
+ `note: bun lint has no "${plugins.join('" or "')}" rules, so none of them ran`;
const silent = { problems: found, exitCode: 0, said: [], notes: [] };
/** What is reported, the exit code, what is said about what cannot be done, and the notes. */
async function run(config: object, flags: string[] = [], more: Record = {}) {
const all = { ...files, ...more, ".oxlintrc.json": JSON.stringify(config) };
const { problems, stderr, exitCode } = await lint(all, [...flags, "."]);
const lines = stderr.split("\n");
- const said = lines.slice(lines.findIndex(it => it.includes("cannot be done yet")) + 1 || lines.length, -1);
+ const said = lines.filter(it => it.startsWith("error: ")).map(it => it.slice("error: ".length));
const notes = lines.filter(it => it.startsWith("note: "));
return { problems, exitCode, said: said.map(it => it.trim()), notes };
}
@@ -4306,8 +5950,7 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
const rules = {
...quiet.rules,
"jsdoc/require-param": "error",
- // Nothing looks at the options.
- "vue/no-dupe-keys": ["warn", { nothing: 1 }],
+ "vue/no-dupe-keys": ["warn", { groups: ["a"] }],
"vue/max-props": "deny",
};
expect(await run({ ...quiet, plugins: ["jsdoc", "vue"], rules })).toEqual({
@@ -4320,7 +5963,9 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
{ ...files, ".oxlintrc.json": JSON.stringify({ ...quiet, plugins: ["jsdoc", "vue"], rules }) },
["--allow-unsupported", "."],
);
- expect(allowed.stderr).toContain(`warn: ${named("jsdoc", "jsdoc/require-param")}`);
+ expect(allowed.stderr).toContain(
+ `warn: ${named("jsdoc", "jsdoc/require-param")}\n bun lint has no "jsdoc" rules. Turn it off or remove it.\n`,
+ );
expect(allowed.exitCode).toBe(0);
});
@@ -4438,8 +6083,10 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
expect(exitCode).toBe(1);
});
- test("a comment that disables one of their rules is neither wrong nor unused, and stays", async () => {
+ test("a comment that disables one of their rules is neither wrong nor unused, and stays, if such a rule is on", async () => {
const text = [
+ // oxlint's jsdoc rules look at comments like this one. Without any, none of them could have reported anything.
+ "/** A function. */",
"// oxlint-disable-next-line jsdoc/require-param",
"a;",
"// eslint-disable-next-line vue/no-dupe-keys, no-debugger",
@@ -4447,9 +6094,10 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
"/* oxlint-disable vue/max-props */",
"",
].join("\n");
- const all = { "a.js": text, "b.vue": `\n`, ".oxlintrc.json": JSON.stringify(quiet) };
+ const on = { ...quiet, plugins: ["jsdoc", "vue"], rules: { ...quiet.rules, "jsdoc/require-param": "warn" } };
+ const all = { "a.js": text, "b.vue": `\n`, ".oxlintrc.json": JSON.stringify(on) };
const { problems, raw } = await lint(all, ["--report-unused-disable-directives", "."]);
- expect(problems).toEqual(["a.js:3:47 -", "b.vue:4:47 -"]);
+ expect(problems).toEqual(["a.js:4:47 -", "b.vue:5:47 -"]);
expect(JSON.parse(raw).results[0].messages[0].message).toBe(
"Unused eslint-disable directive (no problems were reported from no-debugger).",
);
@@ -4458,6 +6106,40 @@ describe.concurrent("the plugins jsdoc and vue of oxlint, of which no rule is bu
expect(JSON.parse(fixed.raw).results[0].output).toBe(`\n`);
});
+ // What oxlint 1.87 reports: each of these comments, whole. Its jsdoc rules only look at `/**` comments, so in a file without one
+ // none of them was skipped, and a comment that silences nothing here silences nothing there.
+ test("without a /** comment, comments are unused as for oxlint although rules of jsdoc are on", async () => {
+ const text = [
+ "// oxlint-disable-next-line jsdoc/require-param",
+ "a;",
+ "// eslint-disable-next-line vue/no-dupe-keys, no-debugger",
+ "a;",
+ "// oxlint-disable-next-line",
+ "a;",
+ "// oxlint-disable-next-line foo/no-debugger, no-dupe-keys",
+ "a;",
+ "/* oxlint-disable vue/max-props */",
+ "",
+ ].join("\n");
+ const on = { ...quiet, plugins: ["jsdoc", "vue"], rules: { ...quiet.rules, "jsdoc/require-param": "warn" } };
+ const all = { "a.js": text, "b.vue": `\n`, ".oxlintrc.json": JSON.stringify(on) };
+ const { problems } = await lint(all, ["--report-unused-disable-directives", "."]);
+ expect(problems).toEqual([1, 3, 5, 7, 9].flatMap(line => [`a.js:${line}:1 -`, `b.vue:${line + 1}:1 -`]).sort());
+ // oxlint reports the same with these. Here nobody knows what their rules would have reported, and a comment that is called
+ // unused is one that --fix-suggestions removes. So only a name that none of their rules has is reported.
+ const withBlock = { ...all, "a.js": `/** A function. */\n${text}`, "b.vue": "" };
+ const withVue = {
+ ...all,
+ "b.vue": "",
+ ".oxlintrc.json": JSON.stringify({ ...on, rules: { "vue/max-props": "warn" } }),
+ };
+ const [block, vue] = await Promise.all(
+ [withBlock, withVue].map(files => lint(files, ["--report-unused-disable-directives", "a.js"])),
+ );
+ expect(block.problems).toEqual(["a.js:4:47 -", "a.js:8:29 -"]);
+ expect(vue.problems).toEqual(["a.js:3:47 -", "a.js:7:29 -"]);
+ });
+
test("--rules does not list them", async () => {
const { raw } = await lint({ ".oxlintrc.json": "{}" }, ["--rules", "-f", "json"]);
const scopes = new Set(JSON.parse(raw).map((it: { scope: string }) => it.scope));
@@ -4919,7 +6601,7 @@ describe.concurrent("a search that leaves the project of an eslint.config.js", (
["..", { links: { "linked": "theirs" } }, "linked"],
])("a file without a configuration file ends the run: %s %j", async (argument, more, file) => {
const { ran, files, stderr, exitCode } = await run("mine", [argument], more);
- expect(stderr).toContain(`Could not find config file. /w/${file} has no eslint.config.* `);
+ expect(stderr).toContain(`Could not find config file.\n No eslint.config.* was found next to /w/${file} or`);
expect(ran.filter(it => !it.startsWith("mine"))).toEqual([]);
expect({ files, exitCode }).toEqual({ files: [], exitCode: 2 });
});
@@ -5211,7 +6893,7 @@ describe("an infinite number in an eslint.config.mjs", () => {
};
const { raw, stderr, exitCode } = await lint(files, ["a.js"]);
if (typeof expected === "string") {
- expect(stderr).toBe(`error: ${expected}`);
+ expect(stderr).toBe(`error: Invalid config in eslint.config.mjs\n${expected}`);
expect(exitCode).toBe(2);
return;
}
@@ -5273,7 +6955,7 @@ describe("an infinite number in an eslint.config.mjs", () => {
};
const { raw, stderr, exitCode } = await lint(files, ["a.js"]);
if (typeof expected === "string") {
- expect(stderr).toBe(`error: ${expected}`);
+ expect(stderr).toBe(`error: Invalid config in eslint.config.mjs\n${expected}`);
expect(exitCode).toBe(2);
return;
}
diff --git a/test/cli/lint/defaults.test.ts b/test/cli/lint/defaults.test.ts
new file mode 100644
index 000000000000..f8c2a585449c
--- /dev/null
+++ b/test/cli/lint/defaults.test.ts
@@ -0,0 +1,1558 @@
+// Tests for what `bun lint` does in a project without an ESLint or oxlint config.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, normalizeBunSnapshot, tempDir } from "harness";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+const env = {
+ ...bunEnv,
+ AGENT: "0",
+ CLAUDECODE: undefined,
+ REPL_ID: undefined,
+ GITHUB_ACTIONS: undefined,
+ NO_COLOR: "1",
+};
+
+type Result = { filePath: string; messages: { line: number; column: number; severity: number; ruleId: string }[] };
+
+/** `reports` has one `a.js:1:1 error no-debugger` string per problem. `texts` has the files' contents after the run. */
+async function lint(files: Record, args: string[], stdin?: string, cwd = ".") {
+ using dir = tempDir("bun-lint-defaults", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", ...args],
+ env,
+ cwd: join(String(dir), cwd),
+ stdin: stdin === undefined ? "ignore" : Buffer.from(stdin),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ const json = JSON.parse(stdout || "null");
+ const nameOf = (path: string) => normalizeBunSnapshot(path, String(dir)).slice("/".length);
+ const reports = (Array.isArray(json) ? (json as Result[]) : []).flatMap(({ filePath, messages }) =>
+ messages.map(
+ it => `${nameOf(filePath)}:${it.line}:${it.column} ${it.severity === 2 ? "error" : "warning"} ${it.ruleId}`,
+ ),
+ );
+ const texts = Object.fromEntries(
+ Object.keys(files).map(name => [name, readFileSync(join(String(dir), name), "utf8")]),
+ );
+ return { json, reports, texts, stderr, exitCode };
+}
+
+describe.concurrent("globals", () => {
+ test("every global that Bun has is defined", async () => {
+ // `bun -e` also makes `fs`, `path` and other built-in modules global, so ask a file.
+ using dir = tempDir("bun-lint-defaults-globals", {
+ "names.js": "console.log(JSON.stringify(Object.getOwnPropertyNames(globalThis)));",
+ });
+ await using proc = spawn({ cmd: [bunExe(), "names.js"], env, cwd: String(dir), stdout: "pipe", stderr: "inherit" });
+ const names = (JSON.parse(await proc.stdout.text()) as string[]).filter(name => /^[A-Za-z_$][\w$]*$/.test(name));
+ expect(names).toContain("HTMLRewriter");
+ const { reports } = await lint({ "a.js": `console.log(\n${names.join(",\n")},\n);\n` }, []);
+ expect(reports).toEqual([]);
+ });
+
+ const tests = `
+ describe("a", () => {
+ before(() => {});
+ beforeAll(() => {});
+ beforeEach(() => {});
+ it("b", () => expect(1).toBe(1));
+ test("c", () => expectTypeOf(jest.fn()).toBeFunction());
+ fit("d", () => vi.fn());
+ xit("e", () => {});
+ afterEach(() => {});
+ afterAll(() => {});
+ after(() => {});
+ });
+ fdescribe("f", () => {});
+ xdescribe("g", () => {});
+ `;
+
+ test.each([
+ "a.test.js",
+ "a.spec.mjs",
+ "a_test.cjs",
+ "a_spec.jsx",
+ "__tests__/a.js",
+ "src/__tests__/deep/a.js",
+ "test/a.js",
+ "packages/x/test/a.mjs",
+ "tests/a.js",
+ "spec/a.js",
+ "a-test.js",
+ "a.e2e.js",
+ "e2e/a.js",
+ "__mocks__/fs.js",
+ "jest.setup.js",
+ "jest-setup.cjs",
+ "vitest.setup.mjs",
+ "src/setupTests.js",
+ "config/setup-jest.js",
+ "testSetup.js",
+ ])("the test runners' globals are defined in %s", async name => {
+ const { reports, exitCode } = await lint({ [name]: tests }, []);
+ expect(reports).toEqual([]);
+ expect(exitCode).toBe(0);
+ });
+
+ test.each(["cypress/e2e/login.cy.js", "cypress/support/commands.js", "src/login.cy.js"])(
+ "Cypress's globals are defined in %s",
+ async name => {
+ const code = 'describe("a", () => it("b", () => cy.get("a").then(() => assert.ok(expect(Cypress.env("c"))))));\n';
+ const { reports, exitCode } = await lint({ [name]: code }, []);
+ expect(reports).toEqual([]);
+ expect(exitCode).toBe(0);
+ },
+ );
+
+ test.each([
+ "a.js",
+ "src/a.js",
+ "testing/a.js",
+ "latest/a.js",
+ "src/test.js",
+ "setup.js",
+ "src/contest.js",
+ "src/cy.js",
+ ])("the test runners' globals are not defined in %s", async name => {
+ const { reports, exitCode } = await lint({ [name]: 'describe("a", () => {});\n' }, []);
+ expect(reports).toEqual([`${name}:1:1 error no-undef`]);
+ expect(exitCode).toBe(1);
+ });
+
+ // Which names `**/*{.,_,-}{test,spec,e2e,cy}.{js,mjs,cjs,jsx,ts,mts,cts,tsx}` is for. A global of a test runner can't be
+ // assigned to. In another file nothing defines it, which is only reported in JavaScript.
+ test("a file is a test by what its name ends with", async () => {
+ const [stems, separators] = [
+ ["a", "", "a.b", "test"],
+ [".", "_", "-", "", "+"],
+ ];
+ const words = ["test", "spec", "e2e", "cy", "tes", "tests", "Test", "atest"];
+ const extensions = ["js", "mjs", "cjs", "jsx", "ts", "mts", "cts", "tsx"];
+ // To Windows and macOS `a.Test.js` is the file `a.test.js`.
+ const folderOf = (word: string) => (word === "Test" ? "cased/" : "");
+ const names = stems.flatMap(stem =>
+ separators.flatMap(separator =>
+ words.flatMap(word => extensions.map(extension => `${folderOf(word)}${stem}${separator}${word}.${extension}`)),
+ ),
+ );
+ names.push("a.test.js.js", "a.test.jsx.ts", "a.test.d.ts", "a.test..js", "a.spec.ts.mts");
+ names.push("src/deep/a_e2e.cts", "src/a.cy/b.js", "src/a.test.js/b.ts");
+ const expected = [...new Set(names)].flatMap(name => {
+ if (/[._-](test|spec|e2e|cy)\.(js|mjs|cjs|jsx|ts|mts|cts|tsx)$/.test(name)) return [`${name} no-global-assign`];
+ return /\.[mc]?jsx?$/.test(name) ? [`${name} no-undef`] : [];
+ });
+ const { reports } = await lint(Object.fromEntries(names.map(name => [name, "describe = 1;\n"])), []);
+ expect(reports.map(it => it.replace(/:1:1 \w+ /, " ")).sort()).toEqual(expected.sort());
+ });
+
+ test("an eslint-env comment defines its globals, and is only an error with an ESLint config", async () => {
+ const files = { "a.js": '/* eslint-env mocha, nonsense */\ndescribe("a", () => {});\njQuery("a");\n' };
+ const config = { "eslint.config.mjs": `export default [{ rules: { "no-undef": "error" } }];\n` };
+ const [native, eslint] = await Promise.all([lint(files, []), lint({ ...files, ...config }, ["a.js"])]);
+ expect(native.reports).toEqual(["a.js:3:1 error no-undef"]);
+ expect(eslint.reports).toEqual(["a.js:1:1 error null", "a.js:2:1 error no-undef", "a.js:3:1 error no-undef"]);
+ });
+
+ test("a service worker's globals are defined", async () => {
+ const code = `self.addEventListener("install", event => event.waitUntil(skipWaiting()));
+self.addEventListener("activate", () => clients.claim());
+self.addEventListener("push", event => registration.showNotification(event.data.text()));
+importScripts("./lib.js");
+skipWaitng();
+`;
+ const { reports } = await lint({ "public/sw.js": code }, []);
+ expect(reports).toEqual(["public/sw.js:5:1 error no-undef"]);
+ });
+
+ test.each(["test", "tests", "spec", "__tests__"])(
+ "a project inside a folder named %s isn't all tests",
+ async folder => {
+ const files = {
+ [`${folder}/app/package.json`]: "{}",
+ [`${folder}/app/src/a.js`]: 'describe("a", () => {});\n',
+ [`${folder}/app/test/b.js`]: 'describe("b", () => {});\n',
+ };
+ for (const cwd of [`${folder}/app`, `${folder}/app/src`]) {
+ const { reports } = await lint(files, [], undefined, cwd);
+ expect({ cwd, reports }).toEqual({ cwd, reports: [`${folder}/app/src/a.js:1:1 error no-undef`] });
+ }
+ },
+ );
+
+ test("in a repository, a test folder with its own package.json gives the same result from every directory", async () => {
+ const files = {
+ ".git/HEAD": "ref: refs/heads/main\n",
+ "package.json": "{}",
+ "src/a.js": 'describe("a", () => {});\n',
+ "test/package.json": "{}",
+ "test/b.js": 'describe("b", () => {});\n',
+ "test/unit/c.js": 'describe("c", () => {});\n',
+ };
+ for (const cwd of ["test", "test/unit"]) {
+ const { reports, exitCode } = await lint(files, [], undefined, cwd);
+ expect({ cwd, reports, exitCode }).toEqual({ cwd, reports: [], exitCode: 0 });
+ }
+ expect((await lint(files, [])).reports).toEqual(["src/a.js:1:1 error no-undef"]);
+ });
+
+ test("a repository inside a folder named test isn't all tests, with or without a package.json", async () => {
+ for (const extra of [{}, { "test/app/package.json": "{}" }]) {
+ const files = {
+ "test/app/.git/HEAD": "ref: refs/heads/main\n",
+ "test/app/src/a.js": 'describe("a", () => {});\n',
+ "test/app/test/b.js": 'describe("b", () => {});\n',
+ ...extra,
+ };
+ for (const cwd of ["test/app", "test/app/src"]) {
+ const { reports } = await lint(files, [], undefined, cwd);
+ expect({ cwd, reports }).toEqual({ cwd, reports: ["test/app/src/a.js:1:1 error no-undef"] });
+ }
+ }
+ });
+
+ test("the test folders count from the closest package.json, also when run from inside one", async () => {
+ const files = {
+ "package.json": "{}",
+ "test/a.js": 'describe("a", () => {});\n',
+ "test/unit/b.js": 'describe("b", () => {});\n',
+ "packages/x/package.json": "{}",
+ "packages/x/test/c.js": 'describe("c", () => {});\n',
+ };
+ for (const cwd of [".", "test", "test/unit", "packages/x", "packages/x/test"]) {
+ const { reports, exitCode } = await lint(files, [], undefined, cwd);
+ expect({ cwd, reports, exitCode }).toEqual({ cwd, reports: [], exitCode: 0 });
+ }
+ });
+});
+
+describe.concurrent("severities", () => {
+ test("code that's often written on purpose is a warning, not an error", async () => {
+ const { reports, exitCode } = await lint(
+ {
+ "a.js": `export const strip = text => text.replace(/\\x1b\\[[0-9;]*m/g, "");
+export function words(text, re, object) {
+ let match;
+ while (match = re.exec(text)) console.log(match[0]);
+ try {
+ return object.hasOwnProperty(text);
+ } catch (error) {
+ error = new Error(String(error));
+ throw error;
+ }
+}
+`,
+ "b.ts": `export type Keep = T extends Function ? T : never;
+// @ts-ignore
+export const name: String = "a";
+export enum Level { Off = 0, None = 0 }
+export interface Emitter { on(): void }
+export class Emitter {}
+export const text = document.querySelector("h1")?.textContent!;
+`,
+ "c.test.ts": `import { expect, test } from "bun:test";
+export const fixture = 1;
+test("a", () => {
+ expect(fixture).toBe(1);
+});
+`,
+ },
+ [],
+ );
+ expect(reports).toEqual([
+ "a.js:1:43 warning no-control-regex",
+ "a.js:4:10 warning no-cond-assign",
+ "a.js:6:19 warning no-prototype-builtins",
+ "a.js:8:5 warning no-ex-assign",
+ "b.ts:1:33 warning @typescript-eslint/no-unsafe-function-type",
+ "b.ts:2:1 warning @typescript-eslint/ban-ts-comment",
+ "b.ts:3:20 warning @typescript-eslint/no-wrapper-object-types",
+ "b.ts:4:30 warning @typescript-eslint/no-duplicate-enum-values",
+ "b.ts:5:18 warning @typescript-eslint/no-unsafe-declaration-merging",
+ "b.ts:6:14 warning @typescript-eslint/no-unsafe-declaration-merging",
+ "b.ts:7:21 warning @typescript-eslint/no-non-null-asserted-optional-chain",
+ "c.test.ts:2:14 warning bun:test/no-export",
+ ]);
+ expect(exitCode).toBe(0);
+ });
+
+ test("require() in a TypeScript file isn't reported", async () => {
+ const code = `import path = require("node:path");
+export default { path, plugins: [require("tailwindcss-animate")] };
+`;
+ const on = `[lint.rules]\n"@typescript-eslint/no-require-imports" = "error"\n`;
+ const [plain, turnedOn] = await Promise.all([
+ lint({ "tailwind.config.ts": code }, []),
+ lint({ "tailwind.config.ts": code, "bunfig.toml": on }, []),
+ ]);
+ expect(plain.reports).toEqual([]);
+ expect(turnedOn.reports).toEqual([
+ "tailwind.config.ts:1:15 error @typescript-eslint/no-require-imports",
+ "tailwind.config.ts:2:34 error @typescript-eslint/no-require-imports",
+ ]);
+ });
+
+ const files = {
+ "a.js": "debugger;\nif (Bun) {\n}\nlet unused;\n",
+ "b.ts": "export let a: any = 1;\nexport interface B {\n constructor(): void;\n}\n",
+ };
+
+ test("default rules that catch bugs are errors, and the rest are warnings", async () => {
+ const { reports, exitCode } = await lint(files, []);
+ expect(reports).toEqual([
+ "a.js:1:1 error no-debugger",
+ "a.js:2:10 warning no-empty",
+ "a.js:4:5 warning no-unused-vars",
+ "b.ts:1:12 warning prefer-const",
+ "b.ts:1:15 warning @typescript-eslint/no-explicit-any",
+ "b.ts:3:3 error @typescript-eslint/no-misused-new",
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
+ test("the rules that --type-aware adds are split the same way", async () => {
+ const { reports, exitCode } = await lint(
+ {
+ "tsconfig.json": "{}",
+ "a.ts": "export async function f() {\n return 1;\n}\nf();\nawait 1;\n",
+ },
+ ["--type-aware"],
+ );
+ expect(reports).toEqual([
+ "a.ts:1:8 warning @typescript-eslint/require-await",
+ "a.ts:4:1 error @typescript-eslint/no-floating-promises",
+ "a.ts:5:1 warning @typescript-eslint/await-thenable",
+ ]);
+ expect(exitCode).toBe(1);
+ });
+
+ test("with --type-aware, using a value of type any is a warning", async () => {
+ const { reports, exitCode } = await lint(
+ {
+ "tsconfig.json": `{ "compilerOptions": { "strict": true, "lib": ["esnext", "dom"], "types": [] } }`,
+ "a.ts": `export async function load(url: string, log: (text: string) => void) {
+ const body = await (await fetch(url)).json();
+ log(body);
+ body.run();
+ return body;
+}
+`,
+ },
+ ["--type-aware"],
+ );
+ expect(reports).toEqual([
+ "a.ts:2:9 warning @typescript-eslint/no-unsafe-assignment",
+ "a.ts:3:7 warning @typescript-eslint/no-unsafe-argument",
+ "a.ts:4:3 warning @typescript-eslint/no-unsafe-call",
+ "a.ts:4:8 warning @typescript-eslint/no-unsafe-member-access",
+ "a.ts:5:3 warning @typescript-eslint/no-unsafe-return",
+ ]);
+ expect(exitCode).toBe(0);
+ });
+
+ test("warnings don't fail the run unless --max-warnings is exceeded, and --quiet hides them", async () => {
+ const warned = { "a.js": files["a.js"].replace("debugger;", "") };
+ const [plain, limited, quiet] = await Promise.all([
+ lint(warned, []),
+ lint(warned, ["--max-warnings", "0"]),
+ lint(files, ["--quiet"]),
+ ]);
+ expect(plain.reports).toEqual(["a.js:2:10 warning no-empty", "a.js:4:5 warning no-unused-vars"]);
+ expect(limited.reports).toEqual(plain.reports);
+ expect(limited.stderr).toContain("Found too many warnings (maximum: 0).");
+ expect(quiet.reports).toEqual(["a.js:1:1 error no-debugger", "b.ts:3:3 error @typescript-eslint/no-misused-new"]);
+ expect([plain.exitCode, limited.exitCode, quiet.exitCode]).toEqual([0, 1, 1]);
+ });
+
+ test("severities from bunfig.toml and --rule are kept as written", async () => {
+ const bunfig = `[lint.rules]\n"no-empty" = "error"\n"no-debugger" = "warn"\n"no-var" = "error"\n`;
+ const [byFile, byFlag] = await Promise.all([
+ lint({ ...files, "bunfig.toml": bunfig, "c.js": "var c = 1;\nexport { c };\n" }, []),
+ lint(files, ["--rule", "prefer-const: error", "--rule", "no-debugger: off"]),
+ ]);
+ expect(byFile.reports).toEqual([
+ "a.js:1:1 warning no-debugger",
+ "a.js:2:10 error no-empty",
+ "a.js:4:5 warning no-unused-vars",
+ "b.ts:1:12 warning prefer-const",
+ "b.ts:1:15 warning @typescript-eslint/no-explicit-any",
+ "b.ts:3:3 error @typescript-eslint/no-misused-new",
+ "c.js:1:1 error no-var",
+ ]);
+ expect(byFlag.reports).toEqual([
+ "a.js:2:10 warning no-empty",
+ "a.js:4:5 warning no-unused-vars",
+ "b.ts:1:12 error prefer-const",
+ "b.ts:1:15 warning @typescript-eslint/no-explicit-any",
+ "b.ts:3:3 error @typescript-eslint/no-misused-new",
+ ]);
+ });
+
+ test("the same presets are all errors in an eslint.config.js", async () => {
+ const config = `export default [
+ { files: ["**/*.{js,ts}"], extends: ["eslint:recommended"], languageOptions: { globals: { Bun: "readonly" } } },
+ { files: ["**/*.ts"], extends: ["typescript-eslint/recommended"] },
+ ];\n`;
+ const { reports } = await lint({ ...files, "eslint.config.js": config }, ["a.js", "b.ts"]);
+ expect(reports).toEqual([
+ "a.js:1:1 error no-debugger",
+ "a.js:2:10 error no-empty",
+ "a.js:4:5 error no-unused-vars",
+ "b.ts:1:12 error prefer-const",
+ "b.ts:1:15 error @typescript-eslint/no-explicit-any",
+ "b.ts:3:3 error @typescript-eslint/no-misused-new",
+ ]);
+ });
+
+ test("bun:test rules that catch a broken test are errors", async () => {
+ const code = `import { expect, test } from "bun:test";\ntest.skip("a", () => {});\ntest.only("b", () => {\n expect(1);\n});\n`;
+ const { reports } = await lint({ "a.test.ts": code }, []);
+ expect(reports).toEqual([
+ "a.test.ts:2:1 warning bun:test/no-disabled-tests",
+ "a.test.ts:3:6 error bun:test/no-focused-tests",
+ "a.test.ts:4:3 error bun:test/valid-expect",
+ ]);
+ });
+
+ test("--print-config shows the default severities and options", async () => {
+ const { json } = await lint(files, ["--print-config", "b.ts"]);
+ const { rules } = json;
+ const unusedOnPurpose = {
+ argsIgnorePattern: "^_",
+ varsIgnorePattern: "^_",
+ caughtErrorsIgnorePattern: "^_",
+ destructuredArrayIgnorePattern: "^_",
+ ignoreRestSiblings: true,
+ };
+ expect({
+ "no-debugger": rules["no-debugger"],
+ "no-empty": rules["no-empty"],
+ "prefer-const": rules["prefer-const"],
+ "@typescript-eslint/no-explicit-any": rules["@typescript-eslint/no-explicit-any"],
+ "@typescript-eslint/no-unused-vars": rules["@typescript-eslint/no-unused-vars"],
+ "no-unused-vars": rules["no-unused-vars"],
+ }).toEqual({
+ "no-debugger": [2],
+ "no-empty": [1],
+ "prefer-const": [1],
+ "@typescript-eslint/no-explicit-any": [1],
+ "@typescript-eslint/no-unused-vars": [1, unusedOnPurpose],
+ "no-unused-vars": [0, unusedOnPurpose],
+ });
+ });
+});
+
+describe.concurrent("defaults that differ from ESLint's", () => {
+ /** Returns the reports of `rules`, with no config and with the same rules turned on in an eslint.config.mjs. */
+ async function inBothModes(files: Record, rules: string[], args: string[] = []) {
+ const on = JSON.stringify(Object.fromEntries(rules.map(rule => [rule, "error"])));
+ const config = `const plugin = name => ({ meta: { name: "eslint-plugin-" + name }, rules: {} });
+export default [
+ { plugins: { "react-hooks": plugin("react-hooks"), react: plugin("react") } },
+ { files: ["**/*.{js,jsx}"], languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } } },
+ {
+ files: ["**/*.{ts,tsx}"],
+ extends: ["typescript-eslint/base"],
+ languageOptions: { parserOptions: { projectService: true } },
+ },
+ { rules: ${on} },
+];
+`;
+ const names = Object.keys(files).filter(name => /\.[jt]sx?$/.test(name));
+ const [native, eslint] = await Promise.all([
+ lint(files, args),
+ lint({ ...files, "eslint.config.mjs": config }, names),
+ ]);
+ const own = (reports: string[]) => reports.filter(it => rules.some(rule => it.endsWith(` ${rule}`)));
+ return { native: own(native.reports), eslint: own(eslint.reports) };
+ }
+
+ test("no-irregular-whitespace checks code, not text", async () => {
+ const files = {
+ "a.jsx": `// At most 10\u00a0kg, コメント\u3000全角
+export const price = ;
+export const form = ;
+[1].forEach(save);
+if (save()) save().catch(console.error);
+`,
+ };
+ const rule = "@typescript-eslint/no-misused-promises";
+ const { native, eslint } = await inBothModes(files, [rule], ["--type-aware"]);
+ expect(native).toEqual([`a.tsx:10:13 error ${rule}`, `a.tsx:11:5 error ${rule}`]);
+ expect(eslint).toEqual([`a.tsx:9:36 error ${rule}`, `a.tsx:10:13 error ${rule}`, `a.tsx:11:5 error ${rule}`]);
+ });
+
+ test("no-fallthrough accepts the usual ways to write the comment", async () => {
+ const comments = [
+ "// falls through",
+ "/* intentional fall-through */",
+ "// FALLTHROUGH",
+ "// no break",
+ "// and the next",
+ ];
+ const cases = comments.map((comment, i) => ` case ${i}:\n console.log(${i});\n ${comment}\n`);
+ const files = { "a.js": `export function f(a) {\n switch (a) {\n${cases.join("")} default:\n }\n}\n` };
+ const { native, eslint } = await inBothModes(files, ["no-fallthrough"]);
+ expect(native).toEqual(["a.js:18:5 error no-fallthrough"]);
+ expect(eslint).toEqual([9, 15, 18].map(line => `a.js:${line}:5 error no-fallthrough`));
+ });
+
+ test("a namespace inside declare global is allowed", async () => {
+ const files = {
+ "a.ts": `declare global {
+ namespace NodeJS {
+ interface ProcessEnv {
+ API_URL: string;
+ }
+ }
+}
+export namespace Shapes {
+ export const unit = 1;
+}
+`,
+ };
+ const rule = "@typescript-eslint/no-namespace";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ expect(native).toEqual([`a.ts:8:8 warning ${rule}`]);
+ expect(eslint).toEqual([`a.ts:2:3 error ${rule}`, `a.ts:8:8 error ${rule}`]);
+ });
+
+ const react = { "package.json": JSON.stringify({ dependencies: { react: "^19.0.0" } }) };
+
+ test("a parameter named use isn't React's hook", async () => {
+ const files = {
+ ...react,
+ "e2e/fixtures.ts": `import { test as base } from "@playwright/test";
+export const test = base.extend<{ user: string }>({
+ user: async ({}, use) => {
+ await use("alice");
+ },
+});
+`,
+ "src/imported.ts": `import { use } from "react";
+export function load(promise: Promise) {
+ return use(promise);
+}
+`,
+ "src/global.js": `export function load(promise) {
+ return use(promise);
+}
+`,
+ };
+ const rule = "react-hooks/rules-of-hooks";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ const real = [`src/global.js:2:10 error ${rule}`, `src/imported.ts:3:10 error ${rule}`];
+ expect(native).toEqual(real);
+ expect(eslint).toEqual([`e2e/fixtures.ts:4:11 error ${rule}`, ...real]);
+ });
+
+ test("a story's render function can call hooks", async () => {
+ const files = {
+ ...react,
+ "src/Button.stories.tsx": `import { useState } from "react";
+export const Controlled = {
+ render: (args: object) => {
+ const [on] = useState(false);
+ return ;
+ },
+};
+export const Broken = {
+ render(args: { on: boolean }) {
+ if (args.on) useState(false);
+ return ;
+ },
+};
+`,
+ "src/Button.tsx": `import { useState } from "react";
+export const story = {
+ render: () => {
+ const [on] = useState(false);
+ return ;
+ },
+};
+`,
+ };
+ const rule = "react-hooks/rules-of-hooks";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ const real = [`src/Button.stories.tsx:10:18 error ${rule}`, `src/Button.tsx:4:18 error ${rule}`];
+ expect(native).toEqual(real);
+ expect(eslint).toEqual([`src/Button.stories.tsx:4:18 error ${rule}`, ...real]);
+ });
+
+ test("process.exit() ends a case", async () => {
+ const files = {
+ "a.js": `export function run(command, usage, fail) {
+ switch (command) {
+ case "help":
+ usage();
+ process.exit(0);
+ case "crash":
+ process.abort();
+ case "check":
+ if (usage) {
+ process.exit(1);
+ } else {
+ return 1;
+ }
+ case "maybe":
+ if (usage) process.exit(1);
+ case "fail":
+ fail("never returns");
+ default:
+ return 0;
+ }
+}
+`,
+ };
+ const { native, eslint } = await inBothModes(files, ["no-fallthrough"]);
+ expect(native).toEqual([16, 18].map(line => `a.js:${line}:5 error no-fallthrough`));
+ expect(eslint).toEqual([6, 8, 14, 16, 18].map(line => `a.js:${line}:5 error no-fallthrough`));
+ });
+
+ test("with --type-aware, a call that returns never ends a case", async () => {
+ const files = {
+ "tsconfig.json": `{ "compilerOptions": { "strict": true, "types": [] } }`,
+ "a.ts": `declare function fail(message: string): never;
+export function run(command: string) {
+ switch (command) {
+ case "fail":
+ fail("stop");
+ case "log":
+ console.log(command);
+ default:
+ return 0;
+ }
+}
+`,
+ };
+ const { native, eslint } = await inBothModes(files, ["no-fallthrough"], ["--type-aware"]);
+ expect(native).toEqual(["a.ts:8:5 error no-fallthrough"]);
+ expect(eslint).toEqual(["a.ts:6:5 error no-fallthrough", "a.ts:8:5 error no-fallthrough"]);
+ });
+
+ test("an array of elements needs keys only where React renders it as a list", async () => {
+ const files = {
+ ...react,
+ "a.jsx": `export function Wizard({ step }) {
+ const steps = [edit , more]} />;
+export const List = () => a , b ];
+}
+export const Arrow = () => [a ];
+export const Mapped = ({ items }) => items.map(item => {item} );
+`,
+ };
+ const rule = "react/jsx-key";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ const at = (places: string[]) => places.map(place => `a.jsx:${place} error ${rule}`);
+ const rendered = ["7:33", "7:45", "8:46", "10:11", "10:23", "12:29", "13:56"];
+ expect(native).toEqual(at(rendered));
+ expect(eslint).toEqual(at(["2:18", "2:31", "5:23", "5:33", "6:46", "6:69", ...rendered]));
+ const all = { "bunfig.toml": `[lint.rules]\n"${rule}" = ["error", { checkArraysOutsideJSX = true }]\n` };
+ expect((await inBothModes({ ...files, ...all }, [rule])).native).toEqual(eslint);
+ });
+
+ test("true, false, 0 and 1 can switch code off and on", async () => {
+ const files = {
+ "a.jsx": `export const Flags = ({ a }) => (
+ ) => map.get("a")?.v!;
+export async function later(list: number[]) {
+ await null;
+ delete list[0];
+}
+export async function one() {
+ return 1;
+}
+export function start() {
+ one();
+}
+`,
+ "b.js": `export function f(a, b) {
+ switch (a) {
+ case 1:
+ let x = b;
+ return x;
+ }
+}
+export class C {
+ #sent = sendEmail();
+ #plain = 1;
+ #method() {}
+}
+`,
+ };
+ const { texts } = await lint(files, ["--fix-suggestions", "--type-aware"]);
+ expect(texts["a.ts"]).toBe(files["a.ts"]);
+ expect(texts["b.js"]).toBe(files["b.js"].replace(" #plain = 1;\n #method() {}\n", ""));
+ });
+
+ test("adding await and removing async don't collide", async () => {
+ const files = {
+ "tsconfig.json": `{ "compilerOptions": { "strict": true, "types": [] } }`,
+ "a.test.ts": `import { expect, test } from "bun:test";
+test("a", async () => {
+ expect(Promise.resolve(1)).resolves.toBe(1);
+});
+`,
+ };
+ const { texts } = await lint(files, ["--fix-suggestions", "--type-aware"]);
+ expect(texts["a.test.ts"]).toBe(files["a.test.ts"].replace(" expect(", " await expect("));
+ });
+
+ // Not `Object.hasOwn`, which is ES2022: it's a type error with an older `target`, and it throws in older browsers.
+ test("the fix for hasOwnProperty works everywhere", async () => {
+ const files = { "a.mjs": "export const has = (o, k) => [o.hasOwnProperty(k), o.isPrototypeOf(k)];\n" };
+ const { texts } = await lint(files, ["--fix-suggestions"]);
+ expect(texts["a.mjs"]).toBe(
+ "export const has = (o, k) => [Object.prototype.hasOwnProperty.call(o, k), Object.prototype.isPrototypeOf.call(o, k)];\n",
+ );
+ });
+
+ test("with an ESLint config the suggestion is ESLint's", async () => {
+ const files = {
+ "a.mjs": "const sent = sendEmail();\n",
+ "eslint.config.mjs": `export default [{ rules: { "no-unused-vars": "error" } }];\n`,
+ };
+ const { json } = await lint(files, ["a.mjs"]);
+ expect(json[0].messages[0].suggestions).toEqual([
+ {
+ messageId: "removeVar",
+ data: { varName: "sent" },
+ fix: { range: [0, 25], text: "" },
+ desc: "Remove unused variable 'sent'.",
+ },
+ ]);
+ });
+});
+
+describe.concurrent("declaration files", () => {
+ const code = `declare var a: any;
+declare class B { new(): B; }
+declare const d: {};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare const c: any;
+`;
+
+ test.each(["types.d.ts", "types.d.mts", "types.d.cts", "types.d.css.ts"])(
+ "%s: default rules run if they're errors, and are skipped if they're warnings",
+ async name => {
+ const { reports, exitCode } = await lint({ [name]: code }, []);
+ expect(reports).toEqual([`${name}:2:19 error @typescript-eslint/no-misused-new`]);
+ expect(exitCode).toBe(1);
+ },
+ );
+
+ test("files with similar names still get the warnings", async () => {
+ const { reports } = await lint({ "d.ts": "export const a: any = 1;\n", "a.d.js": "let a;\n" }, []);
+ expect(reports).toEqual([
+ "a.d.js:1:5 warning no-unused-vars",
+ "d.ts:1:17 warning @typescript-eslint/no-explicit-any",
+ ]);
+ });
+
+ test("rules set in bunfig.toml or with --rule apply to them too", async () => {
+ const bunfig = `[lint.rules]\n"@typescript-eslint/no-explicit-any" = "warn"\n"no-var" = "error"\n`;
+ const expected = [
+ "types.d.ts:1:1 error no-var",
+ "types.d.ts:1:16 warning @typescript-eslint/no-explicit-any",
+ "types.d.ts:2:19 error @typescript-eslint/no-misused-new",
+ ];
+ const [byFile, byFlag] = await Promise.all([
+ lint({ "types.d.ts": code, "bunfig.toml": bunfig }, []),
+ lint({ "types.d.ts": code }, ["--rule", "@typescript-eslint/no-explicit-any: warn", "--rule", "no-var: error"]),
+ ]);
+ expect(byFile.reports).toEqual(expected);
+ expect(byFlag.reports).toEqual(expected);
+ });
+
+ test("with an eslint.config.js they're linted like any other file", async () => {
+ const config = `export default [{ files: ["**/*.ts"], extends: ["typescript-eslint/recommended"] }];\n`;
+ const { reports } = await lint({ "types.d.ts": code, "eslint.config.js": config }, ["types.d.ts"]);
+ expect(reports).toEqual([
+ "types.d.ts:1:1 error no-var",
+ "types.d.ts:1:16 error @typescript-eslint/no-explicit-any",
+ "types.d.ts:2:19 error @typescript-eslint/no-misused-new",
+ "types.d.ts:3:18 error @typescript-eslint/no-empty-object-type",
+ ]);
+ });
+});
+
+describe.concurrent("names that start with _ are allowed to be unused", () => {
+ const code = `const _a = 1;
+export function f(_b, c) {}
+try {
+ f();
+} catch (_e) {
+ f();
+}
+const [_d, e] = [1, 2];
+const { g, ...rest } = Bun;
+console.log(e, rest);
+const h = 1;
+`;
+ const all = ["1:7", "2:19", "2:23", "5:10", "8:8", "9:9", "11:7"];
+
+ test.each([
+ ["a.js", "no-unused-vars"],
+ ["a.ts", "@typescript-eslint/no-unused-vars"],
+ ])("%s", async (name, rule) => {
+ const set = (setting: string) => ({ [name]: code, "bunfig.toml": `[lint.rules]\n"${rule}" = ${setting}\n` });
+ const [plain, severity, options] = await Promise.all([
+ lint({ [name]: code }, []),
+ lint(set(`"error"`), []),
+ lint(set(`["warn", { varsIgnorePattern = "^x" }]`), []),
+ ]);
+ expect(plain.reports).toEqual([`${name}:2:23 warning ${rule}`, `${name}:11:7 warning ${rule}`]);
+ expect(plain.json[0].messages.map((it: { message: string }) => it.message)).toEqual([
+ "'c' is defined but never used.",
+ "'h' is assigned a value but never used.",
+ ]);
+ // A severity on its own keeps the default options. An option that's set only changes that option.
+ expect(severity.reports).toEqual([`${name}:2:23 error ${rule}`, `${name}:11:7 error ${rule}`]);
+ expect(options.reports).toEqual(["1:7", "2:23", "11:7"].map(at => `${name}:${at} warning ${rule}`));
+ });
+
+ test("doesn't apply with an eslint.config.js", async () => {
+ const config = `export default [{ rules: { "no-unused-vars": "error" } }];\n`;
+ const { reports } = await lint({ "eslint.config.js": config, "a.js": code }, ["a.js"]);
+ expect(reports).toEqual(all.map(at => `a.js:${at} error no-unused-vars`));
+ });
+});
+
+describe.concurrent("comments that disable rules", () => {
+ const code = `// eslint-disable-next-line no-console
+console.log(1);
+// eslint-disable-next-line no-debugger
+console.log(2);
+// eslint-disable-next-line some-plugin/some-rule, not-a-rule
+console.log(3);
+// eslint-disable-next-line
+console.log(4);
+/* eslint-disable unicorn/no-null, no-empty */
+console.log(5);
+`;
+ const unused = (line: number) => `a.js:${line}:1 warning null`;
+
+ test("a comment for a rule that's off or doesn't exist isn't reported as unused", async () => {
+ const [reported, fixed] = await Promise.all([lint({ "a.js": code }, []), lint({ "a.js": code }, ["--fix"])]);
+ expect(reported.reports).toEqual([unused(3), unused(7), unused(9)]);
+ expect(reported.json[0].messages.map((it: { message: string }) => it.message)).toEqual([
+ "Unused eslint-disable directive (no problems were reported from 'no-debugger').",
+ "Unused eslint-disable directive (no problems were reported).",
+ "Unused eslint-disable directive (no problems were reported from 'no-empty').",
+ ]);
+ expect(reported.exitCode).toBe(0);
+ expect(fixed.texts["a.js"]).toBe(
+ code
+ .replace("// eslint-disable-next-line no-debugger\n", "")
+ .replace("// eslint-disable-next-line\n", "")
+ .replace("unicorn/no-null, no-empty", "unicorn/no-null"),
+ );
+ });
+
+ test("--fix removes an unused comment without leaving spaces behind", async () => {
+ const text = `function f() {
+ // eslint-disable-next-line no-debugger
+ g();
+ g(); // eslint-disable-line no-debugger
+ g(/* eslint-disable-line no-debugger */ 1);
+\t/* eslint-disable-next-line no-debugger */\t\r
+ g();
+}
+f();
+// eslint-disable-line no-debugger`;
+ const config = { "eslint.config.mjs": `export default [{ rules: { "no-debugger": "error" } }];\n` };
+ const [native, eslint] = await Promise.all([
+ lint({ "a.cjs": text }, ["--fix"]),
+ lint({ "a.cjs": text, ...config }, ["--fix", "a.cjs"]),
+ ]);
+ expect(native.texts["a.cjs"]).toBe("function f() {\n g();\n g();\n g( 1);\n g();\n}\nf();\n");
+ // ESLint puts a space where the comment was.
+ expect(eslint.texts["a.cjs"]).toBe("function f() {\n \n g();\n g(); \n g( 1);\n\t \t\r\n g();\n}\nf();\n ");
+ });
+
+ test("a rule turned on by bunfig.toml or a comment counts as on", async () => {
+ const bunfig = `[lint.rules]\n"no-alert" = "warn"\n`;
+ const text = `/* eslint no-eval: error */\n// eslint-disable-next-line no-alert, no-eval, no-console\nconsole.log(1);\n`;
+ const { json } = await lint({ "bunfig.toml": bunfig, "a.js": text }, []);
+ expect(json[0].messages.map((it: { message: string }) => it.message)).toEqual([
+ "Unused eslint-disable directive (no problems were reported from 'no-alert').",
+ "Unused eslint-disable directive (no problems were reported from 'no-eval').",
+ ]);
+ });
+
+ test("with an eslint.config.js they're reported, like in ESLint", async () => {
+ const config = `export default [{ rules: { "no-debugger": "error" } }];\n`;
+ const { reports } = await lint({ "eslint.config.js": config, "a.js": code }, ["a.js"]);
+ expect(reports).toEqual([
+ unused(1),
+ unused(3),
+ "a.js:5:1 error some-plugin/some-rule",
+ "a.js:5:1 error not-a-rule",
+ unused(7),
+ "a.js:9:1 error unicorn/no-null",
+ unused(9),
+ ]);
+ });
+});
+
+describe.concurrent("React", () => {
+ const component = `import { useEffect, useState } from "react";
+export function App({ items, on }) {
+ if (on) {
+ useState(0);
+ }
+ useEffect(() => {
+ console.log(items);
+ }, []);
+ return (
+ ", " // eslint-disable-next-line react/jsx-key\n "),
+ };
+ const { reports, exitCode } = await lint(files, []);
+ expect(reports).toEqual([]);
+ expect(exitCode).toBe(0);
+ });
+
+ test("--print-config lists them only if package.json has react", async () => {
+ const files = {
+ "package.json": dependingOn("dependencies"),
+ "mail/package.json": dependingOn("dependencies", "preact"),
+ };
+ const [withReact, without] = await Promise.all([
+ lint(files, ["--print-config", "App.jsx"]),
+ lint(files, ["--print-config", "mail/App.jsx"]),
+ ]);
+ const ofReact = (printed: { rules: object }) =>
+ Object.fromEntries(Object.entries(printed.rules).filter(([name]) => name.startsWith("react")));
+ expect(ofReact(withReact.json)).toEqual({
+ "react-hooks/rules-of-hooks": [2],
+ "react-hooks/exhaustive-deps": [1],
+ "react/jsx-key": [2, { checkArraysOutsideJSX: false }],
+ "react/jsx-uses-react": [2],
+ });
+ // `react/jsx-uses-react` reports nothing. It's also for Preact's `h`, so it doesn't depend on React.
+ expect(ofReact(without.json)).toEqual({
+ "react/jsx-key": [0, { checkArraysOutsideJSX: false }],
+ "react/jsx-uses-react": [2],
+ });
+ });
+
+ test("they stay off with an ESLint or oxlint config", async () => {
+ const files = { "package.json": dependingOn("dependencies"), "App.jsx": component };
+ const ofEslint = `export default [{ files: ["**/*.jsx"], languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } } }];\n`;
+ const [eslint, oxlint] = await Promise.all([
+ lint({ ...files, "eslint.config.js": ofEslint }, ["App.jsx"]),
+ lint({ ...files, ".oxlintrc.json": "{}" }, ["App.jsx"]),
+ ]);
+ expect(eslint.json).toEqual([expect.objectContaining({ messages: [] })]);
+ expect(oxlint.json.diagnostics).toEqual([]);
+ expect([eslint.exitCode, oxlint.exitCode]).toEqual([0, 0]);
+ });
+});
diff --git a/test/cli/lint/doctor.test.ts b/test/cli/lint/doctor.test.ts
new file mode 100644
index 000000000000..46c92ed2ceeb
--- /dev/null
+++ b/test/cli/lint/doctor.test.ts
@@ -0,0 +1,645 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isASAN, isDebug, tempDir } from "harness";
+import { readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+// Disable AI agent and CI detection regardless of the environment the tests run in.
+const env = {
+ ...bunEnv,
+ AGENT: "0",
+ CLAUDECODE: undefined,
+ REPL_ID: undefined,
+ GITHUB_ACTIONS: undefined,
+ GITHUB_WORKSPACE: undefined,
+ NO_COLOR: undefined,
+ FORCE_COLOR: undefined,
+};
+
+async function doctor(files: Record, args: string[] = []) {
+ using dir = tempDir("bun-lint-doctor", files);
+ const list = () => (readdirSync(String(dir), { recursive: true }) as string[]).sort();
+ const before = list();
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "--threads", "2", "--doctor", ...args],
+ env,
+ cwd: String(dir),
+ stdin: "ignore",
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ const isUntouched =
+ Bun.deepEquals(list(), before) &&
+ Object.entries(files).every(([name, text]) => readFileSync(join(String(dir), name), "utf8") === text);
+ return { stdout, stderr, exitCode, isUntouched };
+}
+
+/** Files for an installed ESLint plugin with the given `rules`. None of them reports anything. */
+function plugin(name: string, rules: string[], { isModule = false, version = "99.0.0" } = {}) {
+ const object = `{ meta: { name: ${JSON.stringify(name)}, version: ${JSON.stringify(version)} }, rules: { ${rules
+ .map(rule => `${JSON.stringify(rule)}: { create: () => ({}) }`)
+ .join(", ")} } }`;
+ return {
+ [`node_modules/${name}/package.json`]: JSON.stringify({
+ name,
+ version,
+ main: "index.js",
+ type: isModule ? "module" : "commonjs",
+ }),
+ [`node_modules/${name}/index.js`]: isModule ? `export default ${object};` : `module.exports = ${object};`,
+ };
+}
+
+const dependencies = (...names: string[]) =>
+ JSON.stringify({ name: "app", type: "module", devDependencies: Object.fromEntries(names.map(name => [name, "*"])) });
+
+// Plugins that aren't built in get loaded in a JavaScript VM, and starting one takes seconds in a debug build.
+const timeout = isDebug || isASAN ? 120_000 : 10_000;
+
+const flat = {
+ ...plugin("eslint-plugin-first", ["a", "b"]),
+ ...plugin("eslint-plugin-second", ["c"], { isModule: true }),
+ ...plugin("eslint-plugin-react-hooks", ["rules-of-hooks", "exhaustive-deps"]),
+ "package.json": dependencies(
+ "eslint",
+ "eslint-plugin-first",
+ "eslint-plugin-second",
+ "eslint-plugin-react-hooks",
+ "eslint-plugin-never-imported",
+ "typescript",
+ ),
+ "eslint.config.js": `
+ import first from "eslint-plugin-first";
+ import second from "eslint-plugin-second";
+ import hooks from "eslint-plugin-react-hooks";
+ const local = { rules: { x: { create: () => ({}) } } };
+ export default [
+ {
+ plugins: { first, second, "react-hooks": hooks, local },
+ rules: {
+ "no-var": "error",
+ eqeqeq: "warn",
+ "no-console": "off",
+ "first/a": "error",
+ "second/c": "error",
+ "local/x": "warn",
+ "react-hooks/rules-of-hooks": "error",
+ indent: "error",
+ "no-such-rule": "error",
+ },
+ },
+ { files: ["**/*.ts"], rules: { "first/b": "error", "no-undef": "error", eqeqeq: "off" } },
+ ];`,
+ "src/a.js": "var a = 1;\n",
+ "src/b.ts": "var b = 1;\n",
+};
+
+describe.concurrent("bun lint --doctor", () => {
+ test(
+ "with an eslint.config.js",
+ async () => {
+ const { stdout, stderr, exitCode, isUntouched } = await doctor(flat);
+ expect(stderr).toBe("");
+ expect(stdout).toBe(`Using eslint.config.js (ESLint flat config)
+
+ 3 files to lint
+
+ 4 rules run natively
+ 4 rules run in JavaScript
+ eslint-plugin-first 2
+ eslint-plugin-second 1
+ eslint.config.js 1
+ 2 rules do not run
+ 1 is not supported: no-such-rule
+ 1 is a formatting rule, use bun fmt: indent
+
+You can remove: eslint, eslint-plugin-never-imported
+Still needed: eslint-plugin-first, eslint-plugin-second (their rules run in JavaScript)
+ eslint-plugin-react-hooks (eslint.config.js loads it)
+Not checked: other tools' configs, CI files, Git hooks
+`);
+ expect(isUntouched).toBe(true);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "-f json prints the same report as JSON",
+ async () => {
+ const { stdout, exitCode } = await doctor(flat, ["-f", "json"]);
+ expect(JSON.parse(stdout)).toEqual({
+ config: { path: "eslint.config.js", kind: "eslint", nested: [], ignored: null },
+ files: { linted: 3, by_eslint: {}, not_linted: {} },
+ rules: {
+ native: ["eqeqeq", "no-undef", "no-var", "react-hooks/rules-of-hooks"],
+ javascript: {
+ "eslint-plugin-first": ["first/a", "first/b"],
+ "eslint-plugin-second": ["second/c"],
+ "eslint.config.js": ["local/x"],
+ },
+ not_run: [
+ { rule: "no-such-rule", reason: "not_supported" },
+ { rule: "indent", reason: "formatting" },
+ ],
+ },
+ packages: {
+ removable: ["eslint", "eslint-plugin-never-imported"],
+ needed: [
+ { name: "eslint-plugin-first", reason: "rules", by: null },
+ { name: "eslint-plugin-react-hooks", reason: "config", by: "eslint.config.js" },
+ { name: "eslint-plugin-second", reason: "rules", by: null },
+ ],
+ not_checked: ["other tools' configs", "CI files", "Git hooks"],
+ },
+ notes: [],
+ });
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "only counts rules for the files that the arguments select",
+ async () => {
+ const { stdout, exitCode } = await doctor(flat, ["-f", "json", "src/a.js"]);
+ const { files, rules } = JSON.parse(stdout);
+ expect(files.linted).toBe(1);
+ expect(rules.native).toEqual(["eqeqeq", "no-var", "react-hooks/rules-of-hooks"]);
+ expect(rules.javascript["eslint-plugin-first"]).toEqual(["first/a"]);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "--no-native-plugin-rules runs a plugin's rules from its package",
+ async () => {
+ const { stdout, exitCode } = await doctor(flat, ["-f", "json", "--no-native-plugin-rules"]);
+ const { rules, packages } = JSON.parse(stdout);
+ expect(rules.native).toEqual(["eqeqeq", "no-undef", "no-var"]);
+ expect(rules.javascript["eslint-plugin-react-hooks"]).toEqual(["react-hooks/rules-of-hooks"]);
+ expect(packages.needed).toContainEqual({ name: "eslint-plugin-react-hooks", reason: "rules", by: null });
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "with an .oxlintrc.json",
+ async () => {
+ const { stdout, stderr, exitCode, isUntouched } = await doctor({
+ ...plugin("eslint-plugin-first", ["a", "b"]),
+ "package.json": dependencies("oxlint", "oxlint-tsgolint", "eslint-plugin-first"),
+ ".oxlintrc.json": JSON.stringify({
+ categories: { correctness: "off" },
+ ignorePatterns: ["node_modules"],
+ plugins: ["typescript", "unicorn", "vue"],
+ jsPlugins: ["eslint-plugin-first"],
+ rules: {
+ "no-var": "error",
+ "unicorn/no-null": "warn",
+ "first/a": "error",
+ "typescript/no-floating-promises": "error",
+ "vue/no-arrow-functions-in-watch": "error",
+ },
+ }),
+ "a.ts": "var a = null;\n",
+ });
+ expect(stderr).toBe("");
+ expect(stdout).toBe(`Using .oxlintrc.json (oxlint config)
+
+ 1 file to lint
+
+ 2 rules run natively
+ 1 rule runs in JavaScript
+ eslint-plugin-first 1
+ 2 rules do not run
+ 1 is not supported: vue/no-arrow-functions-in-watch
+ 1 needs types, use --type-aware: @typescript-eslint/no-floating-promises
+
+You can remove: oxlint, oxlint-tsgolint
+Still needed: eslint-plugin-first (its rules run in JavaScript)
+Not checked: other tools' configs, CI files, Git hooks
+`);
+ expect(isUntouched).toBe(true);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test("lists every unsupported rule, but only the first few formatting rules", async () => {
+ const files = {
+ "eslint.config.js": `export default [{ rules: { indent: 2, semi: 2, quotes: 2, "comma-dangle": 2, "no-such-rule": 2, "nor-this": 2, "nor-that": 2, "nor-any": 2 } }];`,
+ };
+ const [text, json] = await Promise.all([doctor(files), doctor(files, ["-f", "json"])]);
+ expect(text.stdout).toContain(`
+ 8 rules do not run
+ 4 are not supported: no-such-rule, nor-any, nor-that, nor-this
+ 4 are formatting rules, use bun fmt: comma-dangle, indent, quotes, ..
+`);
+ expect(JSON.parse(json.stdout).rules.not_run).toContainEqual({ rule: "semi", reason: "formatting" });
+ expect(text.exitCode).toBe(0);
+ });
+
+ test("the React rules are on in a project that depends on react", async () => {
+ const native = async (dependency: string) => {
+ const files = { "package.json": dependencies(dependency), "a.jsx": "" };
+ return JSON.parse((await doctor(files, ["-f", "json"])).stdout).rules.native;
+ };
+ const [withReact, without] = await Promise.all([native("react"), native("preact")]);
+ expect(withReact).toContain("react-hooks/rules-of-hooks");
+ expect(without).not.toContain("react-hooks/rules-of-hooks");
+ expect(withReact.length).toBeGreaterThan(without.length);
+ });
+
+ test("--type-aware runs the rules that need types", async () => {
+ const { stdout, exitCode } = await doctor(
+ {
+ ".oxlintrc.json": JSON.stringify({
+ categories: { correctness: "off" },
+ rules: { "typescript/no-floating-promises": "error" },
+ }),
+ "tsconfig.json": "{}",
+ "a.ts": "export {};\n",
+ },
+ ["-f", "json", "--type-aware"],
+ );
+ const { rules } = JSON.parse(stdout);
+ expect(rules).toEqual({ native: ["@typescript-eslint/no-floating-promises"], javascript: {}, not_run: [] });
+ expect(exitCode).toBe(0);
+ });
+
+ test(
+ "with an .eslintrc.json",
+ async () => {
+ const { stdout, exitCode } = await doctor(
+ {
+ ...plugin("eslint-plugin-first", ["a", "b"]),
+ "package.json": dependencies("eslint", "eslint-plugin-first"),
+ ".eslintrc.json": JSON.stringify({
+ root: true,
+ plugins: ["first"],
+ rules: { "no-var": "error", "first/a": "error", semi: "error" },
+ }),
+ "a.js": "var a = 1;\n",
+ },
+ ["-f", "json"],
+ );
+ const { config, rules, packages } = JSON.parse(stdout);
+ expect(config).toEqual({ path: ".eslintrc.json", kind: "eslintrc", nested: [], ignored: null });
+ expect(rules).toEqual({
+ native: ["no-var"],
+ javascript: { "eslint-plugin-first": ["first/a"] },
+ not_run: [{ rule: "semi", reason: "formatting" }],
+ });
+ expect(packages.removable).toEqual(["eslint"]);
+ expect(packages.needed).toEqual([{ name: "eslint-plugin-first", reason: "rules", by: null }]);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "repeats the note that a normal run prints about plugin versions",
+ async () => {
+ const files = { ...flat, ...plugin("eslint-plugin-react-hooks", ["rules-of-hooks"], { version: "1.0.0" }) };
+ const [text, json] = await Promise.all([doctor(files), doctor(files, ["-f", "json"])]);
+ const note = /^eslint-plugin-react-hooks 1\.0\.0 is installed/;
+ expect(JSON.parse(json.stdout).notes).toEqual([expect.stringMatching(note)]);
+ expect(text.stdout).toEndWith(`\n\nnote: ${JSON.parse(json.stdout).notes[0]}\n`);
+ expect(text.exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test("files that need the config's custom parser go to the installed ESLint", async () => {
+ const files = {
+ "package.json": dependencies("eslint"),
+ "eslint.config.js": `
+ const parser = { meta: { name: "my-parser" }, parse() {} };
+ export default [{ rules: { "no-var": "error" } }, { files: ["**/*.foo"], languageOptions: { parser } }];`,
+ "a.js": "",
+ "b.foo": "",
+ "c.foo": "",
+ };
+ const eslint = { "node_modules/eslint/package.json": JSON.stringify({ name: "eslint", version: "10.0.0" }) };
+ const [installed, missing] = await Promise.all([doctor({ ...files, ...eslint }), doctor(files)]);
+ expect(installed.stdout).toBe(`Using eslint.config.js (ESLint flat config)
+
+ 4 files to lint
+ 2 of them go to your installed ESLint: 2 *.foo
+
+ 1 rule runs natively
+ 0 rules run in JavaScript
+
+Still needed: eslint (some files go to it)
+`);
+ expect(missing.stdout).toBe(`Using eslint.config.js (ESLint flat config)
+
+ 2 files to lint
+ 2 files cannot be linted: 2 *.foo
+ Install eslint to lint them
+
+ 1 rule runs natively
+ 0 rules run in JavaScript
+
+Still needed: eslint (some files go to it)
+`);
+ expect(installed.exitCode).toBe(0);
+ expect(missing.exitCode).toBe(0);
+ });
+
+ test("with both an ESLint and an oxlint config, says which one is used and why", async () => {
+ const files = {
+ "eslint.config.js": `export default [{ rules: { "no-var": "error", eqeqeq: "error" } }];`,
+ ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, rules: { "no-debugger": "error" } }),
+ "a.js": "",
+ };
+ const [text, json, picked] = await Promise.all([
+ doctor(files),
+ doctor(files, ["-f", "json"]),
+ doctor(files, ["--config", "eslint.config.js"]),
+ ]);
+ expect(text.stderr).toBe("");
+ expect(text.stdout).toStartWith(`Using .oxlintrc.json (oxlint config)
+eslint.config.js is ignored because the project also has an oxlint config. Use --config to pick it.
+
+ 2 files to lint
+
+ 1 rule runs natively
+`);
+ expect(JSON.parse(json.stdout).config).toEqual({
+ path: ".oxlintrc.json",
+ kind: "oxlint",
+ nested: [],
+ ignored: "eslint.config.js",
+ });
+ expect(picked.stdout).toStartWith(`Using eslint.config.js (ESLint flat config)
+
+ 2 files to lint
+
+ 2 rules run natively
+`);
+ expect(text.exitCode).toBe(0);
+ expect(picked.exitCode).toBe(0);
+ });
+
+ test("only packages named like linter tooling are removable", async () => {
+ const names = [
+ "eslint",
+ "oxlint",
+ "oxlint-tsgolint",
+ "typescript-eslint",
+ "@eslint/js",
+ "@typescript-eslint/parser",
+ "eslint-plugin-a",
+ "@scope/eslint-plugin",
+ "@scope/eslint-plugin-a",
+ "eslint-config-a",
+ "@scope/eslint-config",
+ "@scope/eslint-config-a",
+ "eslint-import-resolver-typescript",
+ ];
+ const others = [
+ "vite-plugin-eslint",
+ "eslint-webpack-plugin",
+ "@nuxt/eslint",
+ "@rollup/plugin-eslint",
+ "eslint-pluginish",
+ "eslint-plugin",
+ "prettier-eslint",
+ "globals",
+ ];
+ const { stdout, exitCode } = await doctor(
+ {
+ "package.json": dependencies(...names, ...others),
+ "eslint.config.js": `export default [{ rules: { "no-var": "error" } }];`,
+ },
+ ["-f", "json"],
+ );
+ expect(JSON.parse(stdout).packages).toEqual({
+ removable: names.toSorted(),
+ needed: [],
+ not_checked: ["other tools' configs", "CI files", "Git hooks"],
+ });
+ expect(exitCode).toBe(0);
+ });
+
+ test("a package used by a script, lint-staged or another dependency is still needed", async () => {
+ const installed = (name: string, fields: object) => ({
+ [`node_modules/${name}/package.json`]: JSON.stringify({ name, version: "1.0.0", ...fields }),
+ });
+ const files = {
+ "package.json": JSON.stringify({
+ type: "module",
+ scripts: {
+ build: "vite build",
+ lint: "cross-env CI=1 eslint . && echo done",
+ "lint:ox": "node_modules/.bin/oxlint",
+ },
+ "lint-staged": { "*.ts": ["@scope/eslint-config-cli --fix", "git add"] },
+ devDependencies: Object.fromEntries(
+ [
+ "eslint",
+ "oxlint",
+ "@scope/eslint-config-cli",
+ "vite-plugin-eslint",
+ "eslint-plugin-of-vite",
+ "eslint-config-of-the-plugin",
+ "eslint-plugin-free",
+ ].map(name => [name, "*"]),
+ ),
+ }),
+ ...installed("vite-plugin-eslint", { peerDependencies: { eslint: "*", "eslint-plugin-of-vite": "*" } }),
+ ...installed("eslint-plugin-of-vite", { dependencies: { "eslint-config-of-the-plugin": "*" } }),
+ "eslint.config.js": `export default [{ rules: { "no-var": "error" } }];`,
+ };
+ const [text, json] = await Promise.all([doctor(files), doctor(files, ["-f", "json"])]);
+ expect(text.stdout).toEndWith(`
+You can remove: eslint-plugin-free
+Still needed: @scope/eslint-config-cli (lint-staged runs it)
+ eslint (the "lint" script runs it)
+ eslint-config-of-the-plugin (eslint-plugin-of-vite needs it)
+ eslint-plugin-of-vite (vite-plugin-eslint needs it)
+ oxlint (the "lint:ox" script runs it)
+Not checked: other tools' configs, CI files, Git hooks
+`);
+ expect(JSON.parse(json.stdout).packages).toEqual({
+ removable: ["eslint-plugin-free"],
+ needed: [
+ { name: "@scope/eslint-config-cli", reason: "lint_staged", by: null },
+ { name: "eslint", reason: "script", by: "lint" },
+ { name: "eslint-config-of-the-plugin", reason: "dependent", by: "eslint-plugin-of-vite" },
+ { name: "eslint-plugin-of-vite", reason: "dependent", by: "vite-plugin-eslint" },
+ { name: "oxlint", reason: "script", by: "lint:ox" },
+ ],
+ not_checked: ["other tools' configs", "CI files", "Git hooks"],
+ });
+ expect(text.exitCode).toBe(0);
+ });
+
+ test("eslint is still needed if a plugin that runs in JavaScript depends on it", async () => {
+ const files = {
+ ...plugin("eslint-plugin-first", ["a"]),
+ "package.json": dependencies("eslint", "eslint-plugin-first"),
+ "eslint.config.js": `import first from "eslint-plugin-first";
+ export default [{ plugins: { first }, rules: { "first/a": "error" } }];`,
+ };
+ const manifest = JSON.parse(files["node_modules/eslint-plugin-first/package.json"]);
+ files["node_modules/eslint-plugin-first/package.json"] = JSON.stringify({
+ ...manifest,
+ peerDependencies: { eslint: ">=9" },
+ });
+ const { stdout, exitCode } = await doctor(files);
+ expect(stdout).toEndWith(`
+Still needed: eslint (eslint-plugin-first needs it)
+ eslint-plugin-first (its rules run in JavaScript)
+`);
+ expect(exitCode).toBe(0);
+ });
+
+ // eslint-plugin-unicorn does this.
+ test(
+ "rules are attributed to the package even if it doesn't export the plugin object its configs use",
+ async () => {
+ const { stdout, exitCode } = await doctor({
+ "node_modules/eslint-plugin-inner/package.json": JSON.stringify({
+ name: "eslint-plugin-inner",
+ version: "1.0.0",
+ main: "index.js",
+ type: "module",
+ }),
+ "node_modules/eslint-plugin-inner/index.js": `const inner = { rules: { a: { create: () => ({}) } } };
+ export default { ...inner, configs: { recommended: { plugins: { inner }, rules: { "inner/a": "error" } } } };`,
+ "package.json": dependencies("eslint-plugin-inner"),
+ "eslint.config.js": `import inner from "eslint-plugin-inner";\nexport default [inner.configs.recommended];\n`,
+ "a.js": "var a = 1;\n",
+ });
+ expect(stdout).toEndWith(`
+ 1 rule runs in JavaScript
+ eslint-plugin-inner 1
+
+Still needed: eslint-plugin-inner (its rules run in JavaScript)
+`);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test(
+ "rules from --rulesdir are listed under --rulesdir",
+ async () => {
+ const { stdout, exitCode } = await doctor(
+ {
+ ".eslintrc.json": JSON.stringify({ root: true, rules: { "my-rule": "error", "no-var": "error" } }),
+ "rules/my-rule.js": "module.exports = { create: () => ({}) };\n",
+ "a.js": "var a = 1;\n",
+ },
+ ["--rulesdir", "rules"],
+ );
+ expect(stdout).toEndWith(`
+ 1 rule runs natively
+ 1 rule runs in JavaScript
+ --rulesdir 1
+`);
+ expect(exitCode).toBe(0);
+ },
+ timeout,
+ );
+
+ test("lists the config files in subdirectories", async () => {
+ const { stdout, exitCode } = await doctor({
+ "eslint.config.js": `export default [{ rules: { "no-var": "error" } }];`,
+ "packages/a/eslint.config.js": `export default [{ rules: { eqeqeq: "error" } }];`,
+ "a.js": "",
+ "packages/a/b.js": "",
+ });
+ expect(stdout).toStartWith(`Using eslint.config.js (ESLint flat config)
+Also packages/a/eslint.config.js
+
+ 4 files to lint
+
+ 2 rules run natively
+ 0 rules run in JavaScript
+`);
+ expect(exitCode).toBe(0);
+ });
+
+ test("without a config file", async () => {
+ const { stdout, stderr, exitCode, isUntouched } = await doctor({
+ "package.json": dependencies("typescript"),
+ "a.ts": "var a = 1;\n",
+ });
+ expect(stderr).toBe("");
+ expect(stdout).toStartWith("No ESLint or oxlint config found. Using Bun's defaults.\n\n 1 file to lint\n\n");
+ expect(stdout).toMatch(/^ +\d+ rules are on\n( {8}\S+ +\d+\n)*? {8}eslint +\d+\n/m);
+ expect(stdout).toMatch(/^ {8}@typescript-eslint +\d+$/m);
+ expect(stdout).toMatch(/^ {8}bun:test +\d+$/m);
+ expect(stdout).not.toContain("JavaScript");
+ expect(stdout).toEndWith("\nRun bun lint --init to add a [lint] section to bunfig.toml\n");
+ expect(isUntouched).toBe(true);
+ expect(exitCode).toBe(0);
+ });
+
+ test("without a config file, [lint.rules] in bunfig.toml still counts", async () => {
+ const files = { "a.js": "" };
+ const [plain, configured] = await Promise.all([
+ doctor(files, ["-f", "json"]),
+ doctor({ ...files, "bunfig.toml": `[lint.rules]\n"no-console" = "warn"\n"no-debugger" = "off"\n` }, [
+ "-f",
+ "json",
+ ]),
+ ]);
+ const [before, after] = [JSON.parse(plain.stdout), JSON.parse(configured.stdout)];
+ expect(before.config).toEqual({ path: null, kind: "none", nested: [], ignored: null });
+ expect(after.config).toEqual(before.config);
+ expect(before.rules.native).toContain("no-debugger");
+ expect(before.rules.native).not.toContain("no-console");
+ expect(after.rules.native).toEqual(
+ [...before.rules.native.filter((it: string) => it !== "no-debugger"), "no-console"].sort(),
+ );
+ expect(configured.exitCode).toBe(0);
+ });
+
+ test("with no files to lint, lists the rules a file would get", async () => {
+ const { stdout, exitCode } = await doctor({ "README.md": "" }, ["-f", "json"]);
+ const { files, rules } = JSON.parse(stdout);
+ expect(files.linted).toBe(0);
+ expect(rules.native).toContain("no-debugger");
+ expect(rules.native).toContain("@typescript-eslint/no-explicit-any");
+ expect(exitCode).toBe(0);
+ });
+
+ test("a config file that throws is an error", async () => {
+ const { stdout, stderr, exitCode } = await doctor({
+ "eslint.config.js": `throw new Error("broken on purpose");`,
+ "a.js": "",
+ });
+ expect(stdout).toBe("");
+ expect(stderr).toContain("broken on purpose");
+ expect(exitCode).toBe(2);
+ });
+
+ test("a config that ESLint would reject is an error", async () => {
+ const { stdout, stderr, exitCode } = await doctor({
+ "eslint.config.js": `export default [{ rules: { eqeqeq: ["error", "sometimes"] } }];`,
+ "a.js": "",
+ });
+ expect(stdout).toBe("");
+ expect(stderr).toContain(`Key "rules": Key "eqeqeq"`);
+ expect(exitCode).toBe(2);
+ });
+
+ test("runs even if package.json has a `lint` script", async () => {
+ const { stdout, exitCode } = await doctor({
+ "package.json": JSON.stringify({ scripts: { lint: "echo the script" } }),
+ "a.js": "",
+ });
+ expect(stdout).toStartWith("No ESLint or oxlint config found.");
+ expect(exitCode).toBe(0);
+ });
+});
diff --git a/test/cli/lint/explain.test.ts b/test/cli/lint/explain.test.ts
new file mode 100644
index 000000000000..bef518b1824b
--- /dev/null
+++ b/test/cli/lint/explain.test.ts
@@ -0,0 +1,362 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "fs";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { join } from "path";
+
+const pagesDir = join(import.meta.dir, "../../../docs/lint/rules");
+
+type Env = Record;
+
+async function lint(files: Record, args: string[], env: Env = {}) {
+ using dir = tempDir("bun-lint-explain", files);
+ await using proc = Bun.spawn({
+ cmd: [bunExe(), "lint", ...args],
+ env: { ...bunEnv, COLUMNS: "80", ...env },
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+/** Like `lint`, but stdout is a terminal. */
+async function lintInTerminal(args: string[], env: Env = {}) {
+ using dir = tempDir("bun-lint-explain", {});
+ let output = "";
+ const decoder = new TextDecoder();
+ await using proc = Bun.spawn({
+ cmd: [bunExe(), "lint", ...args],
+ env: { ...bunEnv, ...env },
+ cwd: String(dir),
+ terminal: { cols: 200, rows: 50, data: (_, chunk) => void (output += decoder.decode(chunk, { stream: true })) },
+ });
+ const exitCode = await proc.exited;
+ return { output: output.replaceAll("\r\n", "\n"), exitCode };
+}
+
+interface Listed {
+ scope: string;
+ value: string;
+ category: string | null;
+ type_aware: boolean;
+ fix: string;
+ default: boolean;
+ docs_url: string;
+ id: string;
+ aliases: string[];
+ description: string;
+ kind: "problem" | "suggestion" | "layout" | null;
+ deprecated: boolean;
+ on_by_default: "error" | "warn" | false;
+ modes: ("native" | "eslint" | "oxlint")[];
+ schema: unknown[] | Record | null;
+ default_options: unknown[] | null;
+}
+
+const listRules = async () => JSON.parse((await lint({}, ["--rules", "-f", "json"])).stdout) as Listed[];
+
+/** Returns every docs page as `/`. */
+const pages = () => [...new Bun.Glob("*/**/*.mdx").scanSync(pagesDir)].map(it => it.replaceAll("\\", "/").slice(0, -4));
+
+function frontmatter(page: string) {
+ const text = readFileSync(join(pagesDir, page + ".mdx"), "utf8");
+ const field = (key: string) => JSON.parse(new RegExp(`^${key}: (".*")$`, "m").exec(text.split("\n---\n")[0])![1]);
+ return { description: field("description") as string };
+}
+
+const base = "https://bun.com/docs/lint/rules/";
+
+describe.concurrent("--rules -f json", () => {
+ test("has oxlint's keys first, then Bun's", async () => {
+ const rules = await listRules();
+ expect(rules.length).toBeGreaterThan(1000);
+ expect([...new Set(rules.map(it => Object.keys(it).join()))]).toEqual([
+ "scope,value,category,type_aware,fix,default,docs_url,id,aliases,description,kind,deprecated,on_by_default,modes,schema,default_options",
+ ]);
+ expect(rules.find(it => it.id === "@typescript-eslint/no-floating-promises")).toEqual({
+ scope: "typescript",
+ value: "no-floating-promises",
+ category: "correctness",
+ type_aware: true,
+ fix: "fixable_suggestion",
+ default: true,
+ docs_url: base + "typescript/no-floating-promises",
+ id: "@typescript-eslint/no-floating-promises",
+ aliases: ["typescript-eslint/no-floating-promises", "typescript/no-floating-promises"],
+ description: frontmatter("typescript/no-floating-promises").description,
+ kind: "problem",
+ deprecated: false,
+ on_by_default: false,
+ modes: ["native", "eslint", "oxlint"],
+ schema: [expect.objectContaining({ type: "object", additionalProperties: false })],
+ default_options: [expect.objectContaining({ ignoreVoid: true, ignoreIIFE: false })],
+ });
+ });
+
+ test("schema and default_options describe a rule's options", async () => {
+ const rules = new Map((await listRules()).map(it => [it.id, it]));
+ const options = (id: string) => ({
+ schema: rules.get(id)!.schema,
+ default_options: rules.get(id)!.default_options,
+ });
+ expect(options("no-console")).toEqual({
+ schema: [
+ {
+ type: "object",
+ properties: { allow: { type: "array", items: { type: "string" }, minItems: 1, uniqueItems: true } },
+ additionalProperties: false,
+ },
+ ],
+ default_options: [{}],
+ });
+ expect(options("eqeqeq").default_options).toEqual(["always"]);
+ expect(options("@typescript-eslint/array-type").default_options).toEqual([{ default: "array" }]);
+ // No options.
+ expect(options("no-debugger")).toEqual({ schema: null, default_options: null });
+ // Rules ported from oxlint take options but have no schema.
+ expect(options("unicorn/filename-case")).toEqual({ schema: null, default_options: null });
+ // Includes the options that Bun's built-in config sets.
+ for (const id of ["no-unused-vars", "@typescript-eslint/no-unused-vars"])
+ expect(options(id).default_options).toEqual([expect.objectContaining({ argsIgnorePattern: "^_" })]);
+ // It also sets options for rules that are off by default.
+ for (const id of ["no-unused-expressions", "@typescript-eslint/no-unused-expressions"])
+ expect(options(id).default_options).toEqual([expect.objectContaining({ allowShortCircuit: true })]);
+ expect([...rules.values()].filter(it => (it.schema === null) !== (it.default_options === null))).toEqual([]);
+ });
+
+ test("is the same no matter what config the project has", async () => {
+ const [alone, eslint, oxlint] = await Promise.all([
+ lint({}, ["--rules", "-f", "json"]),
+ lint({ "eslint.config.mjs": "export default [];" }, ["--rules", "-f", "json"]),
+ lint({ ".oxlintrc.json": "{}", "bunfig.toml": '[lint.rules]\n"no-var" = "off"\n' }, ["--rules", "-f", "json"]),
+ ]);
+ expect(eslint.stdout).toBe(alone.stdout);
+ expect(oxlint.stdout).toBe(alone.stdout);
+ });
+
+ test("no ID or alias refers to more than one rule", async () => {
+ const rules = await listRules();
+ const names = rules.flatMap(it => [it.id, ...it.aliases]);
+ expect(names.filter((name, at) => names.indexOf(name) !== at)).toEqual([]);
+ expect(rules.filter(it => !it.modes.includes("native")).map(it => it.id)).toEqual([]);
+ expect([...new Set(rules.map(it => it.kind))].sort()).toEqual(["layout", "problem", "suggestion", null].sort());
+ });
+
+ test("docs_url points to the rule's page in its plugin's directory", async () => {
+ const rules = await listRules();
+ const directories = Object.fromEntries(rules.map(it => [it.scope, it.docs_url.slice(base.length).split("/")[0]]));
+ expect(directories).toEqual({
+ "bun": "bun",
+ "bun:test": "bun-test",
+ "eslint": "eslint",
+ "import": "import",
+ "jest": "jest",
+ "jsx_a11y": "jsx-a11y",
+ "nextjs": "nextjs",
+ "node": "node",
+ "oxc": "oxc",
+ "prettier": "prettier",
+ "promise": "promise",
+ "react": "react",
+ "react_perf": "react-perf",
+ "typescript": "typescript",
+ "unicorn": "unicorn",
+ "vitest": "vitest",
+ });
+ expect(rules.filter(it => it.docs_url !== `${base}${directories[it.scope]}/${it.value}`)).toEqual([]);
+ });
+
+ test("description matches the docs page's description", async () => {
+ const rules = new Map((await listRules()).map(it => [it.docs_url.slice(base.length), it]));
+ const written = pages().map(page => ({ page, description: frontmatter(page).description }));
+ expect(written.length).toBeGreaterThan(1000);
+ expect(written.map(({ page }) => ({ page, description: rules.get(page)?.description }))).toEqual(written);
+ });
+
+ test("on_by_default matches --print-config in a project without a config", async () => {
+ const react = { "package.json": JSON.stringify({ dependencies: { react: "^19.0.0" } }) };
+ const [rules, ...printed] = await Promise.all([
+ listRules(),
+ ...["a.js", "a.jsx", "a.ts", "a.tsx"].map(file => lint(react, ["--print-config", file])),
+ ]);
+ const strongest: Record = {};
+ for (const { stdout } of printed) {
+ for (const [id, [severity]] of Object.entries(JSON.parse(stdout).rules as Record)) {
+ strongest[id] = Math.max(strongest[id] ?? 0, severity);
+ }
+ }
+ const on = Object.entries(strongest).filter(it => it[1] > 0);
+ expect(on.length).toBeGreaterThan(70);
+ expect(Object.fromEntries(rules.filter(it => it.on_by_default).map(it => [it.id, it.on_by_default]))).toEqual(
+ Object.fromEntries(on.map(([id, severity]) => [id, severity === 2 ? "error" : "warn"])),
+ );
+ expect(strongest).toMatchObject({
+ "no-debugger": 2,
+ "react-hooks/rules-of-hooks": 2,
+ "react-hooks/exhaustive-deps": 1,
+ });
+ });
+});
+
+describe.concurrent("--rules", () => {
+ test("prints one rule per line into a pipe", async () => {
+ const [{ stdout, stderr, exitCode }, rules] = await Promise.all([lint({}, ["--rules"]), listRules()]);
+ expect(stdout).toBe(rules.map(it => `${it.scope}/${it.value}\n`).join(""));
+ expect(stderr).toBe("");
+ expect(exitCode).toBe(0);
+ });
+
+ test.skipIf(isWindows)("groups rules by plugin and adds descriptions in a terminal", async () => {
+ const [{ output, exitCode }, rules] = await Promise.all([lintInTerminal(["--rules"]), listRules()]);
+ const lines = output.split("\n");
+ const count = (scope: string) => rules.filter(it => it.scope === scope).length;
+ expect(lines.filter(line => /^\S.* rules?\)$/.test(line))).toEqual(
+ [...new Set(rules.map(it => it.scope))].map(scope => {
+ const directory = rules
+ .find(it => it.scope === scope)!
+ .docs_url.slice(base.length)
+ .split("/")[0];
+ return `${directory} (${count(scope)} ${count(scope) === 1 ? "rule" : "rules"})`;
+ }),
+ );
+ const rows = lines.filter(line => line.startsWith(" "));
+ expect(rows.map(row => row.slice(9).split(" ")[0])).toEqual(rules.map(it => it.id));
+ expect(rows.map(row => row.slice(2, 9).trim() || false)).toEqual(rules.map(it => it.on_by_default));
+ const described = (id: string) =>
+ rows
+ .find(row => row.slice(9).split(" ")[0] === id)!
+ .slice(9 + id.length)
+ .trim();
+ expect(described("no-var")).toBe(frontmatter("eslint/no-var").description.replaceAll("`", ""));
+ expect(lines.slice(-3)).toEqual([
+ `${rules.length} rules. The ones marked error or warn are on by default.`,
+ "Run bun lint --explain to read about a rule.",
+ "",
+ ]);
+ expect(exitCode).toBe(0);
+ });
+});
+
+describe.concurrent("--explain", () => {
+ test("prints the rule's docs page", async () => {
+ const { stdout, stderr, exitCode } = await lint({}, ["--explain", "eqeqeq"]);
+ const { description } = frontmatter("eslint/eqeqeq");
+ expect(stdout.split("\n").slice(0, 7)).toEqual([
+ "eqeqeq",
+ "======",
+ "",
+ description.replaceAll("`", ""),
+ "",
+ "Off by default, fixable. Also called eslint/eqeqeq.",
+ "",
+ ]);
+ expect(stdout).toContain("\nExamples\n--------\n");
+ expect(stdout).toContain(
+ '\nConfigure\n---------\n\nOff by default. To turn it on:\n\nbunfig.toml\n\n+- toml\n| [lint.rules]\n| "eqeqeq" = "error" # or "warn"\n',
+ );
+ // A code block's file name goes above it.
+ expect(stdout).toContain("\n\nbunfig.toml\n\n+- toml\n| [lint.rules]\n");
+ expect(stdout).toEndWith(`\n${base}eslint/eqeqeq\n`);
+ // Frontmatter and MDX comments are left out.
+ expect(stdout).not.toContain("title:");
+ expect(stdout).not.toContain("{/*");
+ expect(stderr).toBe("");
+ expect(exitCode).toBe(0);
+ });
+
+ test("summarizes the default severity, fixability, aliases and related rules", async () => {
+ const third = async (rule: string) =>
+ (await lint({}, ["--explain", rule], { COLUMNS: "200" })).stdout.split("\n\n")[2];
+ const rules = ["no-debugger", "prefer-const", "typescript/no-floating-promises", "no-unused-vars", "jest/no-hooks"];
+ expect(await Promise.all(rules.map(third))).toEqual([
+ "On by default as an error. Also called eslint/no-debugger.",
+ "On by default as a warning, fixable. Also called eslint/prefer-const.",
+ "Off by default, needs types. Also called typescript-eslint/no-floating-promises, typescript/no-floating-promises.",
+ "On by default as a warning. Also called eslint/no-unused-vars. See also @typescript-eslint/no-unused-vars.",
+ "Off by default. See also bun:test/no-hooks, vitest/no-hooks.",
+ ]);
+ });
+
+ test("accepts a rule's ID and all of its aliases", async () => {
+ const rules = await listRules();
+ const names = ["@typescript-eslint/no-explicit-any", "react-hooks/rules-of-hooks", "@next/next/no-img-element"];
+ for (const rule of rules.filter(it => names.includes(it.id))) {
+ const printed = await Promise.all([rule.id, ...rule.aliases].map(name => lint({}, ["--explain", name])));
+ expect(rule.aliases.length).toBeGreaterThan(0);
+ expect(printed[0].stdout).toStartWith(rule.id + "\n");
+ expect([...new Set(printed.map(it => it.stdout))]).toHaveLength(1);
+ }
+ });
+
+ test("accepts a rule name without its plugin if only one rule has that name", async () => {
+ const [short, long, several] = await Promise.all([
+ lint({}, ["--explain", "no-floating-promises"]),
+ lint({}, ["--explain", "@typescript-eslint/no-floating-promises"]),
+ lint({}, ["--explain", "no-focused-tests"]),
+ ]);
+ expect(short).toEqual(long);
+ expect(short.exitCode).toBe(0);
+ expect(several).toEqual({
+ stdout: "",
+ stderr:
+ 'error: 3 rules are called "no-focused-tests"\n' +
+ " Choose one: bun:test/no-focused-tests, jest/no-focused-tests, vitest/no-focused-tests\n",
+ exitCode: 2,
+ });
+ });
+
+ test("an unknown rule is an error, with a suggestion", async () => {
+ expect(await lint({}, ["--explain", "no-vra"])).toEqual({
+ stdout: "",
+ stderr: 'error: Unknown rule "no-vra"\n Did you mean "no-var"?\n',
+ exitCode: 2,
+ });
+ expect((await lint({}, ["--explain", "no-explicit-an"])).stderr).toMatch(
+ /\n Did you mean ".+\/no-explicit-any"\?\n$/,
+ );
+ });
+
+ test("fails without a rule name", async () => {
+ const { stdout, exitCode } = await lint({}, ["--explain"]);
+ expect(stdout).toBe("");
+ expect(exitCode).toBe(2);
+ });
+
+ test("reads no config and lints nothing", async () => {
+ const files = { "eslint.config.js": "throw new Error('read');", ".oxlintrc.json": "{", "a.js": "debugger;" };
+ const [here, alone] = await Promise.all([lint(files, ["--explain", "no-var"]), lint({}, ["--explain", "no-var"])]);
+ expect(here).toEqual(alone);
+ expect(here.exitCode).toBe(0);
+ });
+
+ test("works even if package.json has a `lint` script", async () => {
+ const files = { "package.json": JSON.stringify({ scripts: { lint: "echo the script" } }) };
+ const [one, other, alone] = await Promise.all([
+ lint(files, ["--explain", "no-var"]),
+ lint(files, ["--explain=no-var"]),
+ lint({}, ["--explain", "no-var"]),
+ ]);
+ expect(one).toEqual(alone);
+ expect(other).toEqual(alone);
+ });
+
+ test("wraps at the terminal width, and uses colors when they're on", async () => {
+ const [narrow, colored] = await Promise.all([
+ lint({}, ["--explain", "no-var"], { COLUMNS: "40" }),
+ lint({}, ["--explain", "no-var"], { NO_COLOR: undefined, FORCE_COLOR: "1" }),
+ ]);
+ const prose = narrow.stdout.split("\n").filter(line => !/^[|+]/.test(line) && !line.startsWith(base));
+ expect(Math.max(...prose.map(line => line.trimEnd().length))).toBeLessThanOrEqual(40);
+ expect(colored.stdout).toContain("\x1b[1m");
+ expect(Bun.stripANSI(colored.stdout)).toContain("no-var");
+ });
+
+ test.skipIf(isWindows)("the URL is a hyperlink in a terminal", async () => {
+ const { output, exitCode } = await lintInTerminal(["--explain", "no-var"], { NO_COLOR: undefined });
+ expect(output).toContain(`\x1b]8;;${base}eslint/no-var\x1b\\`);
+ expect(exitCode).toBe(0);
+ const listed = await lintInTerminal(["--rules"], { NO_COLOR: undefined });
+ expect(listed.output).toContain(`\x1b]8;;${base}eslint/no-var\x1b\\no-var\x1b]8;;\x1b\\`);
+ });
+});
diff --git a/test/cli/lint/git.test.ts b/test/cli/lint/git.test.ts
new file mode 100644
index 000000000000..b7dea1a2244b
--- /dev/null
+++ b/test/cli/lint/git.test.ts
@@ -0,0 +1,567 @@
+// Tests for `--staged` and `--changed` in `bun lint` and `bun fmt`.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import {
+ chmodSync,
+ existsSync,
+ mkdirSync,
+ readFileSync,
+ realpathSync,
+ renameSync,
+ rmSync,
+ symlinkSync,
+ writeFileSync,
+} from "node:fs";
+import { basename, join, relative, resolve } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+// An empty global git config, so the machine's own config doesn't affect the tests.
+const machine = tempDir("bun-lint-git-config", { "gitconfig": "" });
+afterAll(() => machine[Symbol.dispose]());
+
+const env = {
+ ...bunEnv,
+ AGENT: "0",
+ CLAUDECODE: undefined,
+ REPL_ID: undefined,
+ GITHUB_ACTIONS: undefined,
+ NO_COLOR: "1",
+ GIT_CONFIG_NOSYSTEM: "1",
+ GIT_CONFIG_GLOBAL: join(String(machine), "gitconfig"),
+ GIT_AUTHOR_NAME: "Test",
+ GIT_AUTHOR_EMAIL: "test@example.com",
+ GIT_COMMITTER_NAME: "Test",
+ GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+type Env = Record;
+
+async function run(cmd: string[], cwd: string, more: Env = {}) {
+ await using proc = spawn({ cmd, cwd, env: { ...env, ...more }, stdout: "pipe", stderr: "pipe" });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const bun = (cwd: string, args: string[], more?: Env) => run([bunExe(), ...args], cwd, more);
+
+async function git(cwd: string, ...args: string[]) {
+ const { stdout, stderr, exitCode } = await run(["git", ...args], cwd);
+ if (exitCode !== 0) throw new Error(`git ${args.join(" ")}: ${stderr}`);
+ return stdout;
+}
+
+/** Creates a repository on `main`. If there are any `files`, they go into a first commit. */
+async function repository(files: Record) {
+ const dir = tempDir("bun-lint-git", files);
+ const root = realpathSync(String(dir));
+ await git(root, "init", "-q", "-b", "main");
+ await git(root, "config", "commit.gpgsign", "false");
+ await git(root, "config", "core.autocrlf", "false");
+ if (Object.keys(files).length > 0) await commit(root);
+ return { root, [Symbol.dispose]: () => dir[Symbol.dispose]() };
+}
+
+async function commit(root: string) {
+ await git(root, "add", "-A");
+ await git(root, "commit", "-q", "-m", "a commit");
+}
+
+const write = (root: string, name: string, text: string) => {
+ mkdirSync(join(root, name, ".."), { recursive: true });
+ writeFileSync(join(root, name), text);
+};
+const read = (root: string, name: string) => readFileSync(join(root, name), "utf8");
+
+/** Returns the files a run would process, as paths relative to `root`. */
+async function selected(root: string, cwd: string, args: string[], more?: Env) {
+ const { stdout, stderr, exitCode } = await bun(cwd, [...args, "--list-files"], more);
+ expect({ exitCode, stderr: exitCode === 0 ? "" : stderr }).toEqual({ exitCode: 0, stderr: "" });
+ const names = stdout.split("\n").filter(it => it !== "");
+ return names.map(it => relative(root, resolve(cwd, it)).replaceAll("\\", "/")).sort();
+}
+
+const commands = ["lint", "fmt"] as const;
+// Code that both `--fix` and `bun fmt` change, and what each turns it into.
+const before = "let a = 1;\nexport { a };\n";
+const after = { lint: "const a = 1;\nexport { a };\n", fmt: "let a = 1;\nexport { a };\n" };
+const done = { lint: "fixed", fmt: "formatted" };
+const verb = { lint: "lint", fmt: "format" };
+const writing = { lint: ["lint", "--fix", "--rule", "prefer-const: error"], fmt: ["fmt"] };
+const tidy = "export const a = 1;\n";
+
+describe.concurrent.each(commands)("bun %s", command => {
+ test("--staged selects the files whose staged version differs from HEAD", async () => {
+ using repo = await repository({
+ "modified.js": tidy,
+ "unstaged.js": tidy,
+ "same.js": tidy,
+ "deleted.js": tidy,
+ "old-name.js": "export const renamed = 1;\n",
+ "sub/modified.js": tidy,
+ });
+ const { root } = repo;
+ const odd = isWindows ? "ünï côde.js" : 'ünï "cô\tde".js';
+ for (const name of ["modified.js", "sub/modified.js", "added.js", odd]) write(root, name, before);
+ rmSync(join(root, "deleted.js"));
+ renameSync(join(root, "old-name.js"), join(root, "new-name.js"));
+ await git(root, "add", "-A");
+ write(root, "unstaged.js", before);
+ write(root, "untracked.js", before);
+
+ const all = ["added.js", "modified.js", "new-name.js", "sub/modified.js", odd].sort();
+ expect(await selected(root, root, [command, "--staged"])).toEqual(all);
+ // In a subdirectory, arguments are relative to it, but git's paths are relative to the repository root.
+ expect(await selected(root, join(root, "sub"), [command, "--staged"])).toEqual(["sub/modified.js"]);
+ expect(await selected(root, join(root, "sub"), [command, "--staged", ".."])).toEqual(all);
+ // Config that changes how git prints paths makes no difference.
+ await git(root, "config", "diff.relative", "true");
+ await git(root, "config", "diff.renames", "copies");
+ expect(await selected(root, join(root, "sub"), [command, "--staged", ".."])).toEqual(all);
+ });
+
+ test("--changed selects files that differ from the merge base with the default branch, and untracked files", async () => {
+ using repo = await repository({
+ "a.js": tidy,
+ "b.js": tidy,
+ "c.js": tidy,
+ "d.js": tidy,
+ ".gitignore": "ignored.js\n",
+ });
+ const { root } = repo;
+ await git(root, "checkout", "-q", "-b", "feature");
+ write(root, "a.js", before);
+ await commit(root);
+ // The default branch moves on.
+ await git(root, "checkout", "-q", "main");
+ write(root, "d.js", before);
+ await commit(root);
+ await git(root, "checkout", "-q", "feature");
+ write(root, "b.js", before);
+ await git(root, "add", "b.js");
+ write(root, "c.js", before);
+ write(root, "sub/untracked.js", before);
+ write(root, "ignored.js", before);
+
+ const all = ["a.js", "b.js", "c.js", "sub/untracked.js"];
+ expect(await selected(root, root, [command, "--changed"])).toEqual(all);
+ expect(await selected(root, join(root, "sub"), [command, "--changed", ".."])).toEqual(all);
+ expect(await selected(root, root, [command, "--changed=HEAD"])).toEqual(["b.js", "c.js", "sub/untracked.js"]);
+ expect(await selected(root, root, [command, "--changed=main"])).toEqual([...all, "d.js"].sort());
+ await git(root, "tag", "-a", "-m", "a tag", "v1", "main~1");
+ expect(await selected(root, root, [command, "--changed=v1"])).toEqual(all);
+ // Without `=`, the next argument is a file, not a ref.
+ expect(await selected(root, root, [command, "--changed", "a.js", "d.js"])).toEqual(["a.js"]);
+ });
+
+ test("--changed tries origin/HEAD, then main, then master, and lists them if none exists", async () => {
+ using repo = await repository({ "a.js": tidy, "b.js": tidy, "c.js": tidy });
+ const { root } = repo;
+ const first = (await git(root, "rev-parse", "HEAD")).trim();
+ write(root, "a.js", before);
+ await commit(root);
+ await git(root, "branch", "master");
+ write(root, "b.js", before);
+ await commit(root);
+ await git(root, "checkout", "-q", "-b", "feature");
+ write(root, "c.js", before);
+ await commit(root);
+
+ expect(await selected(root, root, [command, "--changed"])).toEqual(["c.js"]);
+ await git(root, "branch", "-q", "-D", "main");
+ expect(await selected(root, root, [command, "--changed"])).toEqual(["b.js", "c.js"]);
+ await git(root, "update-ref", "refs/remotes/origin/trunk", first);
+ await git(root, "symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/trunk");
+ expect(await selected(root, root, [command, "--changed"])).toEqual(["a.js", "b.js", "c.js"]);
+
+ await git(root, "symbolic-ref", "-d", "refs/remotes/origin/HEAD");
+ await git(root, "branch", "-q", "-D", "master");
+ const { stdout, stderr, exitCode } = await bun(root, [command, "--changed"]);
+ expect(stderr).toContain("--changed cannot find the default branch");
+ expect(stderr).toContain("It tried origin/HEAD, main and master. Name a branch or a commit with --changed=");
+ expect({ stdout, exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ });
+
+ test("--changed= only accepts a single commit, not flags, ranges or paths", async () => {
+ using repo = await repository({ "a.js": tidy });
+ const { root } = repo;
+ write(root, "a.js", before);
+ for (const written of ["nothing", "--output=written.txt", "-O", "HEAD..HEAD", "HEAD HEAD", "HEAD:a.js"]) {
+ const { stdout, stderr, exitCode } = await bun(root, [command, `--changed=${written}`]);
+ expect(stderr).toContain(`"${written}" is not a branch, tag or commit in this repository`);
+ expect({ stdout, exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ }
+ expect(existsSync(join(root, "written.txt"))).toBe(false);
+ expect(read(root, "a.js")).toBe(before);
+ });
+
+ test("--staged and --changed only narrow down what the arguments and ignore files select", async () => {
+ using repo = await repository({
+ "src/a.js": tidy,
+ "lib/a.js": tidy,
+ "lib/tracked-and-ignored.js": tidy,
+ "a.txt": "a\n",
+ });
+ const { root } = repo;
+ for (const name of ["src/a.js", "lib/a.js", "lib/tracked-and-ignored.js", "a.txt", "node_modules/a/a.js"]) {
+ write(root, name, before);
+ }
+ write(root, ".gitignore", "tracked-and-ignored.js\n");
+ await git(root, "add", "-A", "-f");
+
+ const without = await selected(root, root, [command]);
+ for (const flag of ["--staged", "--changed"]) {
+ expect(await selected(root, root, [command, flag])).toEqual(without);
+ expect(await selected(root, root, [command, flag, "src"])).toEqual(["src/a.js"]);
+ expect(await selected(root, root, [command, flag, "lib/*.js"])).toEqual(["lib/a.js"]);
+ expect(await selected(root, root, [command, flag, "--ignore-pattern", "lib"])).toEqual(["src/a.js"]);
+ // A mistyped path is still an error.
+ const { exitCode } = await bun(root, [command, flag, "scr"]);
+ expect(exitCode).toBe(2);
+ }
+ expect(without).toEqual(["lib/a.js", "src/a.js"]);
+ });
+
+ test("a run with no files left says so and exits with 0", async () => {
+ using repo = await repository({ "a.js": before, "b.js": tidy });
+ const { root } = repo;
+ expect(await bun(root, [command, "--staged"])).toEqual({
+ stdout: "",
+ stderr: `No staged files to ${verb[command]}\n`,
+ exitCode: 0,
+ });
+ expect(await bun(root, [command, "--changed"])).toEqual({
+ stdout: "",
+ stderr: `No changed files to ${verb[command]}\n`,
+ exitCode: 0,
+ });
+ // A file is staged, but the argument names a different one.
+ write(root, "b.js", before);
+ await git(root, "add", "b.js");
+ const { stderr, exitCode } = await bun(root, [command, "--staged", "a.js"]);
+ expect({ stderr, exitCode }).toEqual({ stderr: `No staged files to ${verb[command]}\n`, exitCode: 0 });
+ expect(read(root, "a.js")).toBe(before);
+ });
+
+ test("in a repository without commits, --staged works and --changed is an error", async () => {
+ using repo = await repository({});
+ const { root } = repo;
+ write(root, "staged.js", before);
+ await git(root, "add", "-A");
+ write(root, "untracked.js", before);
+ expect(await selected(root, root, [command, "--staged"])).toEqual(["staged.js"]);
+ const { stdout, stderr, exitCode } = await bun(root, [command, "--changed"]);
+ expect(stderr).toContain("--changed has nothing to compare with, because this repository has no commits");
+ expect(stderr).toContain("Use --staged for the files that you have added");
+ expect({ stdout, exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ });
+
+ test.each(["--staged", "--changed"])("%s is an error outside a repository or without git", async flag => {
+ using dir = tempDir("bun-lint-git", { "a.js": before, "empty/.keep": "" });
+ const root = realpathSync(String(dir));
+ const outside = await bun(root, [command, flag], { GIT_CEILING_DIRECTORIES: join(root, "..") });
+ expect(outside.stderr).toContain(`${flag} needs a git repository`);
+ expect(outside.stderr).toMatch(/\n.* fatal: not a git repository/);
+ expect({ stdout: outside.stdout, exitCode: outside.exitCode }).toEqual({ stdout: "", exitCode: 2 });
+
+ const without = await bun(root, [command, flag], { PATH: join(root, "empty"), Path: undefined });
+ expect(without.stderr).toContain("Cannot find git in PATH");
+ expect({ stdout: without.stdout, exitCode: without.exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ expect(read(root, "a.js")).toBe(before);
+ });
+
+ test("--staged can't be combined with --changed or stdin", async () => {
+ using repo = await repository({ "a.js": tidy });
+ const together = await bun(repo.root, [command, "--staged", "--changed"]);
+ expect(together.stderr).toContain("--staged and --changed cannot be used together");
+ expect(together.exitCode).toBe(2);
+ const stdin = command === "lint" ? ["--stdin"] : ["--stdin-filepath", "a.js"];
+ const piped = await bun(repo.root, [command, "--staged", ...stdin]);
+ expect(piped.stderr).toContain(`--staged and ${stdin[0]} cannot be used together`);
+ expect(piped.exitCode).toBe(2);
+ });
+
+ test("symlinks are skipped, and a nested repository is a separate repository", async () => {
+ using repo = await repository({ "a.js": tidy });
+ const { root } = repo;
+ write(root, "inner/a.js", tidy);
+ await git(join(root, "inner"), "init", "-q", "-b", "main");
+ await commit(join(root, "inner"));
+ write(root, "inner/a.js", before);
+ await git(join(root, "inner"), "add", "-A");
+ if (!isWindows) symlinkSync("a.js", join(root, "link.js"));
+ write(root, "b.js", before);
+ await git(root, "add", "-A");
+
+ for (const flag of ["--staged", "--changed"]) {
+ expect(await selected(root, root, [command, flag])).toEqual(["b.js"]);
+ expect(await selected(root, join(root, "inner"), [command, flag])).toEqual(["inner/a.js"]);
+ }
+ });
+
+ // On macOS /tmp is such a link, and so is $PWD in a shell that got to the repository through one.
+ test.skipIf(isWindows)(
+ "files that are named through a link to the repository are selected, written and staged",
+ async () => {
+ using repo = await repository({ "src/a.js": tidy, "src/partly.js": tidy, "b.js": tidy });
+ const { root } = repo;
+ using outside = tempDir("bun-lint-git-link", {});
+ // The link is above the repository. `bun fmt` doesn't take an argument that is itself a link, like Prettier.
+ symlinkSync(join(root, ".."), join(String(outside), "link"));
+ const link = join(realpathSync(String(outside)), "link", basename(root));
+ for (const name of ["src/a.js", "src/partly.js"]) write(root, name, before);
+ await git(root, "add", "-A");
+ write(root, "src/partly.js", before + "\n");
+ write(root, "b.js", before);
+
+ // The names are printed relative to the real working directory, and go through the link.
+ const found = async (cwd: string, args: string[]) => {
+ const { stdout, stderr, exitCode } = await bun(cwd, [command, ...args, "--list-files"]);
+ expect({ exitCode, stderr: exitCode === 0 ? "" : stderr }).toEqual({ exitCode: 0, stderr: "" });
+ const names = stdout.split("\n").filter(it => it !== "");
+ return names.map(it => relative(root, realpathSync(resolve(root, it)))).sort();
+ };
+ for (const cwd of [root, link]) {
+ for (const flag of ["--staged", "--changed"]) {
+ const also = flag === "--changed" ? ["b.js"] : [];
+ expect(await found(cwd, [flag, link])).toEqual([...also, "src/a.js", "src/partly.js"]);
+ expect(await found(cwd, [flag, join(link, "src")])).toEqual(["src/a.js", "src/partly.js"]);
+ expect(await found(cwd, [flag, join(link, "src/a.js")])).toEqual(["src/a.js"]);
+ }
+ }
+
+ const { stderr, exitCode } = await bun(root, [...writing[command], "--staged", join(link, "src")]);
+ expect(stderr).toContain("src/partly.js has both staged and unstaged changes");
+ expect(exitCode).toBe(2);
+ expect(read(root, "src/a.js")).toBe(after[command]);
+ expect(read(root, "src/partly.js")).toBe(before + "\n");
+ // a.js was staged again, so only what was unstaged before still is.
+ expect(await git(root, "diff", "--name-only")).toBe("b.js\nsrc/partly.js\n");
+ },
+ );
+
+ test("a fully staged file is staged again after it's rewritten", async () => {
+ using repo = await repository({ "a.js": tidy, "sub/b.js": tidy, "c.js": tidy });
+ const { root } = repo;
+ // File names aren't passed to git as patterns. As a pattern, `*.js` would stage c.js too.
+ const names = [...(isWindows ? [] : ["*.js"]), "a.js", "new.js", "sub/b.js"];
+ for (const name of names) write(root, name, before);
+ await git(root, "add", "-A");
+ write(root, "c.js", before);
+
+ const { stderr, exitCode } = await bun(join(root, "sub"), [...writing[command], "--staged", ".."]);
+ expect({ exitCode, stderr: exitCode === 0 ? "" : stderr }).toEqual({ exitCode: 0, stderr: "" });
+ expect(await git(root, "diff", "--name-only")).toBe("c.js\n");
+ expect((await git(root, "diff", "--name-only", "--cached")).split("\n").filter(Boolean)).toEqual(names);
+ for (const name of names) expect(await git(root, "show", `:${name}`)).toBe(after[command]);
+ expect(read(root, "c.js")).toBe(before);
+ });
+
+ test("--changed stages nothing", async () => {
+ using repo = await repository({ "a.js": tidy });
+ const { root } = repo;
+ write(root, "a.js", before);
+ await git(root, "add", "-A");
+ const { exitCode } = await bun(root, [...writing[command], "--changed"]);
+ expect(read(root, "a.js")).toBe(after[command]);
+ expect(await git(root, "status", "--porcelain")).toBe("MM a.js\n");
+ expect(exitCode).toBe(0);
+ });
+
+ test("a file with both staged and unstaged changes isn't written", async () => {
+ using repo = await repository({ "partly.js": tidy, "sub/partly.js": tidy, "whole.js": tidy, "tidy.js": tidy });
+ const { root } = repo;
+ for (const name of ["partly.js", "whole.js"]) write(root, name, before);
+ write(root, "tidy.js", tidy + tidy.replace("a", "b"));
+ await git(root, "add", "-A");
+ const more = before + "export const unstaged = 1;\n";
+ write(root, "partly.js", more);
+ // tidy.js is partly staged too, but needs no rewrite, so it isn't an error.
+ write(root, "tidy.js", tidy);
+
+ const one = await bun(root, [...writing[command], "--staged"]);
+ expect(one.stderr).toContain(`partly.js has both staged and unstaged changes, so it was not ${done[command]}`);
+ expect(one.stderr).not.toContain("No problems");
+ expect(one.stderr).toContain(
+ "Stage the rest with git add, or put it away with git stash --keep-index. Then run this again.",
+ );
+ expect(one.stderr).not.toContain("tidy.js");
+ expect(one.exitCode).toBe(2);
+ expect(read(root, "partly.js")).toBe(more);
+ expect(await git(root, "status", "--porcelain")).toBe("MM partly.js\nMM tidy.js\nM whole.js\n");
+ expect(await git(root, "show", ":whole.js")).toBe(after[command]);
+
+ write(root, "sub/partly.js", before);
+ await git(root, "add", "sub");
+ write(root, "sub/partly.js", more);
+ const two = await bun(join(root, "sub"), [...writing[command], "--staged", ".."]);
+ expect(two.stderr).toMatch(
+ /2 files have both staged and unstaged changes, so they were not \w+\n.* \.\.\/partly\.js\n.* partly\.js\n/,
+ );
+ expect(two.exitCode).toBe(2);
+ expect(read(root, "sub/partly.js")).toBe(more);
+
+ // A run that doesn't write files has nothing to reject.
+ const looking = command === "lint" ? ["lint", "--rule", "prefer-const: error"] : ["fmt", "--check"];
+ const three = await bun(root, [...looking, "--staged"]);
+ expect(three.stderr).not.toContain("unstaged");
+ expect(three.exitCode).toBe(1);
+ });
+
+ test.skipIf(isWindows)("works in a pre-commit hook, on the index of that commit", async () => {
+ using repo = await repository({ "a.js": tidy, "b.js": tidy });
+ const { root } = repo;
+ const hook = join(root, ".git/hooks/pre-commit");
+ const words = [bunExe(), ...writing[command], "--staged"].map(it => `'${it}'`).join(" ");
+ writeFileSync(hook, `#!/bin/sh\nexec ${words}\n`);
+ chmodSync(hook, 0o755);
+
+ write(root, "a.js", before);
+ await git(root, "add", "a.js");
+ await git(root, "commit", "-q", "-m", "what is staged");
+ expect(await git(root, "show", "HEAD:a.js")).toBe(after[command]);
+ // `git commit -a` gives the hook a separate index file.
+ write(root, "b.js", before);
+ await git(root, "commit", "-q", "-a", "-m", "all");
+ expect(await git(root, "show", "HEAD:b.js")).toBe(after[command]);
+ expect(await git(root, "status", "--porcelain")).toBe("");
+ });
+
+ test.skipIf(isWindows)("git never runs programs named in the repository's config", async () => {
+ using repo = await repository({ "a.js": tidy, "b.js": tidy, ".gitattributes": "*.js diff=mine\n" });
+ const { root } = repo;
+ const program = join(root, "program.sh");
+ writeFileSync(program, `#!/bin/sh\necho ran >> '${join(root, "ran.txt")}'\n`);
+ chmodSync(program, 0o755);
+ for (const key of ["diff.external", "diff.mine.textconv", "diff.mine.command", "core.pager", "pager.diff"]) {
+ await git(root, "config", key, program);
+ }
+ write(root, "a.js", before);
+ await git(root, "add", "a.js");
+ write(root, "b.js", before);
+ const more = { GIT_EXTERNAL_DIFF: program, GIT_PAGER: program, PAGER: program };
+ expect(await selected(root, root, [command, "--staged"], more)).toEqual(["a.js"]);
+ expect(await selected(root, root, [command, "--changed"], more)).toEqual(["a.js", "b.js"]);
+ const { exitCode } = await bun(root, [...writing[command], "--staged"], more);
+ expect(existsSync(join(root, "ran.txt"))).toBe(false);
+ expect(exitCode).toBe(0);
+ });
+});
+
+test.concurrent("bun lint --staged -f json prints an empty result if nothing is staged", async () => {
+ using repo = await repository({ "a.js": before });
+ const { stdout, stderr, exitCode } = await bun(repo.root, ["lint", "--staged", "-f", "json"]);
+ expect({ stdout, stderr, exitCode }).toEqual({ stdout: "[]\n", stderr: "No staged files to lint\n", exitCode: 0 });
+});
+
+test.concurrent(
+ "with an oxlint config, bun lint --staged and --changed print the same messages, also on stderr",
+ async () => {
+ using repo = await repository({ ".oxlintrc.json": "{}", "a.js": before });
+ expect(await bun(repo.root, ["lint", "--staged"])).toEqual({
+ stdout: "",
+ stderr: "No staged files to lint\n",
+ exitCode: 0,
+ });
+ expect(await bun(repo.root, ["lint", "--changed=nothing"])).toEqual({
+ stdout: "",
+ stderr: 'error: "nothing" is not a branch, tag or commit in this repository\n',
+ exitCode: 2,
+ });
+ },
+);
+
+describe.concurrent("bun lint --staged --fix still reports the problems in a partly staged file", () => {
+ // One problem that can be fixed, and one that cannot.
+ const staged = "let a = 1;\nexport { a };\nif (a) {\n}\n";
+ const left = staged + "export const unstaged = 1;\n";
+ const rules = ["--rule", "prefer-const: error", "--rule", "no-empty: error"];
+ const refusal = (ext: string) => `error: partly.${ext} has both staged and unstaged changes, so it was not fixed\n`;
+
+ async function partlyStaged(ext: string, more: Record = {}) {
+ const repo = await repository({ [`partly.${ext}`]: tidy, [`whole.${ext}`]: tidy, ...more });
+ write(repo.root, `partly.${ext}`, staged);
+ write(repo.root, `whole.${ext}`, before);
+ await git(repo.root, "add", "-A");
+ write(repo.root, `partly.${ext}`, left);
+ return repo;
+ }
+
+ async function isUntouched(root: string, ext: string) {
+ expect(read(root, `partly.${ext}`)).toBe(left);
+ expect(await git(root, "show", `:partly.${ext}`)).toBe(staged);
+ expect(await git(root, "show", `:whole.${ext}`)).toBe(after.lint);
+ expect(await git(root, "status", "--porcelain")).toBe(`MM partly.${ext}\nM whole.${ext}\n`);
+ }
+
+ test("in the default format", async () => {
+ using repo = await partlyStaged("js");
+ const { stdout, stderr, exitCode } = await bun(repo.root, ["lint", "--staged", "--fix", ...rules]);
+ expect(stdout.match(/\b(prefer-const|no-empty)$|partly\.js:\d+:\d+$/gm)).toEqual([
+ "prefer-const",
+ "partly.js:1:5",
+ "no-empty",
+ "partly.js:3:8",
+ ]);
+ expect(stdout).toEndWith("\n\n2 problems (2 errors, 0 warnings)\n1 can be fixed with --fix\n");
+ // That's the problem in whole.js.
+ expect(stderr).toContain("Fixed 1 problem in 1 file\n");
+ expect(stderr).toContain("Linted 2 files ");
+ expect(stderr).toContain(refusal("js"));
+ expect(exitCode).toBe(2);
+ await isUntouched(repo.root, "js");
+ });
+
+ const typed = ["--type-aware", "--rule", "@typescript-eslint/await-thenable: error"];
+ const oxlintrc = JSON.stringify({ rules: { "prefer-const": "error", "no-empty": "error" } });
+ test.each([
+ ["without a configuration file", "js", {}, rules],
+ ["with a rule that needs types", "ts", { "tsconfig.json": "{}" }, [...rules, ...typed]],
+ ["with a configuration of oxlint", "js", { ".oxlintrc.json": oxlintrc }, []],
+ ] as const)("as JSON, %s", async (_, ext, more, flags) => {
+ using repo = await partlyStaged(ext, more);
+ const { stdout, stderr, exitCode } = await bun(repo.root, ["lint", "--staged", "--fix", "-f", "json", ...flags]);
+ const printed = JSON.parse(stdout);
+ if (Array.isArray(printed)) {
+ const of = (name: string) => printed.find(it => it.filePath.endsWith(name));
+ expect(of(`partly.${ext}`)).toMatchObject({
+ messages: [{ ruleId: "prefer-const" }, { ruleId: "no-empty" }],
+ errorCount: 2,
+ fixableErrorCount: 1,
+ });
+ expect(of(`partly.${ext}`)).not.toHaveProperty("output");
+ expect(of(`whole.${ext}`)).toMatchObject({ messages: [], output: after.lint });
+ } else {
+ expect(printed.diagnostics.map(it => `${it.filename}: ${it.code}`).sort()).toEqual([
+ "partly.js: eslint(no-empty)",
+ "partly.js: eslint(prefer-const)",
+ ]);
+ }
+ expect(stderr).toContain(refusal(ext));
+ expect(exitCode).toBe(2);
+ await isUntouched(repo.root, ext);
+ });
+
+ test("a partly staged file with nothing to fix isn't rejected", async () => {
+ using repo = await partlyStaged("js");
+ const { stderr, exitCode } = await bun(repo.root, ["lint", "--staged", "--fix", "--rule", "no-empty: error"]);
+ expect(stderr).not.toContain("unstaged");
+ expect(exitCode).toBe(1);
+ expect(read(repo.root, "partly.js")).toBe(left);
+ });
+});
+
+test.concurrent("bun fmt --staged doesn't count a file it skips", async () => {
+ using repo = await repository({ "partly.js": tidy, "whole.js": tidy, "tidy.js": tidy });
+ const { root } = repo;
+ for (const name of ["partly.js", "whole.js"]) write(root, name, before);
+ write(root, "tidy.js", tidy + "\n" + tidy.replace("a", "b"));
+ await git(root, "add", "-A");
+ write(root, "partly.js", before + tidy.replace("a", "b"));
+ const { stdout, stderr, exitCode } = await bun(root, ["fmt", "--staged"]);
+ expect(stdout).toBe("whole.js\n");
+ expect(stderr).toContain("Formatted 1 file, 1 unchanged ");
+ expect(stderr).toContain("partly.js has both staged and unstaged changes, so it was not formatted\n");
+ expect(exitCode).toBe(2);
+});
diff --git a/test/cli/lint/glob.test.ts b/test/cli/lint/glob.test.ts
new file mode 100644
index 000000000000..1b54ac076e53
--- /dev/null
+++ b/test/cli/lint/glob.test.ts
@@ -0,0 +1,459 @@
+import { afterAll, expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { relative } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+const env = { ...bunEnv, AGENT: "0", CLAUDECODE: undefined, GITHUB_ACTIONS: undefined };
+
+// Each rule reports this code exactly once, so a single run shows which of up to 16 patterns match which files.
+const rules = [
+ "no-var",
+ "eqeqeq",
+ "no-debugger",
+ "no-self-assign",
+ "no-empty",
+ "no-console",
+ "no-alert",
+ "no-eval",
+ "no-void",
+ "no-plusplus",
+ "no-ternary",
+ "no-undefined",
+ "no-bitwise",
+ "no-implicit-coercion",
+ "no-object-constructor",
+ "no-unused-expressions",
+];
+const code = `var x = 1;
+if (x == 2) debugger;
+x = x;
+if (x) {}
+console.log(x);
+alert(x);
+eval("x");
+void x;
+x++;
+x = x ? 1 : 2;
+x = undefined;
+x = x | 1;
+x = !!x;
+x = new Object();
+x;
+`;
+
+/** Uses each pattern as `files` in an `eslint.config.mjs` and returns the files it matched. */
+async function filesOf(patterns: string[], files: string[], more: object[] = []) {
+ const objects = patterns.map((pattern, index) => ({ files: [pattern], rules: { [rules[index]]: "error" } }));
+ using dir = tempDir("bun-lint-glob", {
+ ...Object.fromEntries(files.map(file => [file, code])),
+ "eslint.config.mjs": `export default ${JSON.stringify([...more, ...objects])};\n`,
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", "."],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ if (!stdout.startsWith("[")) throw new Error(`exit code ${exitCode}\n${stdout}\n${stderr}`);
+ const results: { filePath: string; messages: { ruleId: string }[] }[] = JSON.parse(stdout);
+ return patterns.map((pattern, index) => [
+ pattern,
+ results
+ .filter(it => it.messages.some(message => message.ruleId === rules[index]))
+ .map(it => relative(String(dir), it.filePath).replaceAll("\\", "/"))
+ .sort()
+ .join(" "),
+ ]);
+}
+
+const files = [
+ "a.js",
+ "a.mjs",
+ "a.cjs",
+ "a.ts",
+ "a.tsx",
+ "a.mts",
+ "a.test.ts",
+ "a.css.js",
+ "src/a.js",
+ "src/b.js",
+ "src/c.js",
+ "src/ab.js",
+ "src/aab.js",
+ "src/abc.js",
+ "src/bbc.js",
+ "src/.js",
+ "src/x/a.js",
+ "src/x/y.ts",
+ "src/a.test.ts",
+ "lib/a.js",
+ "lib/x/a.js",
+ "app/(group)/a.js",
+ "app/group/a.js",
+];
+const js =
+ "a.css.js a.js app/(group)/a.js app/group/a.js lib/a.js lib/x/a.js src/.js src/a.js src/aab.js src/ab.js src/abc.js src/b.js src/bbc.js src/c.js src/x/a.js";
+const all = [...files].sort().join(" ");
+
+// The expected files come from ESLint 10.12.
+test.concurrent("extglob patterns in `files` match the same files as ESLint", async () => {
+ const expected = [
+ ["**/*.?(c|m)js", ["a.cjs", "a.mjs", ...js.split(" ")].sort().join(" ")],
+ ["**/*.@(js|ts)", [...js.split(" "), "a.test.ts", "a.ts", "src/a.test.ts", "src/x/y.ts"].sort().join(" ")],
+ ["src/+(a|b).js", "src/a.js src/aab.js src/ab.js src/b.js"],
+ ["src/*(a|b).js", "src/.js src/a.js src/aab.js src/ab.js src/b.js"],
+ ["**/!(*.test).ts", "a.ts src/x/y.ts"],
+ ["**/*.?([cm])[jt]s?(x)", all],
+ [
+ "@(src|lib)/**/*.js",
+ js
+ .split(" ")
+ .filter(it => /^(src|lib)\//.test(it))
+ .join(" "),
+ ],
+ // Nested groups, and groups mixed with braces
+ ["src/@(a|{b,c}).js", "src/a.js src/b.js src/c.js"],
+ [
+ "**/+(a|*(b)c).js",
+ "a.js app/(group)/a.js app/group/a.js lib/a.js lib/x/a.js src/a.js src/abc.js src/bbc.js src/c.js src/x/a.js",
+ ],
+ // Parentheses without a prefix are literal.
+ ["app/(group)/*.js", "app/(group)/a.js"],
+ [
+ "**/*.{js,?(m)ts}",
+ [...js.split(" "), "a.mts", "a.test.ts", "a.ts", "src/a.test.ts", "src/x/y.ts"].sort().join(" "),
+ ],
+ // `**` at the end of an alternative that ends the pattern
+ [
+ "{lib/*.js,src/**}",
+ all
+ .split(" ")
+ .filter(it => it === "lib/a.js" || it.startsWith("src/"))
+ .join(" "),
+ ],
+ // `!(a|b)` only rejects a name if the rest of the pattern matches after `a` or `b`.
+ ["src/!(a|b)*.js", "src/.js src/c.js"],
+ // For ESLint a leading `!` always negates the pattern, even before `(`.
+ ["!(src)/**/*.js", all],
+ ["**/@(a|b).!(js)", "a.cjs a.css.js a.mjs a.mts a.test.ts a.ts a.tsx src/a.test.ts"],
+ ["src/?(a)?(b).js", "src/.js src/a.js src/ab.js src/b.js"],
+ ];
+ expect(
+ await filesOf(
+ expected.map(it => it[0]),
+ files,
+ ),
+ ).toEqual(expected);
+});
+
+test.concurrent("`ignores` handles `a`, `a/`, `a/*`, `a/**` and `!` like ESLint", async () => {
+ const files = [
+ "a.js",
+ "out/a.js",
+ "x/out/a.js",
+ "gen/a.js",
+ "gen/keep/a.js",
+ "all/a.js",
+ "all/keep/a.js",
+ "dir/a.js",
+ ];
+ const ignores = ["**/out", "gen/*", "!gen/keep", "all/**", "!all/keep", "dir/", "@(no|none)/**"];
+ // `all/**` ignores the directory `all` itself, so nothing in it can be re-included. `gen/*` doesn't ignore `gen`.
+ expect(await filesOf(["**/*.js"], files, [{ ignores }])).toEqual([["**/*.js", "a.js gen/keep/a.js"]]);
+});
+
+test.concurrent("patterns with many or deeply nested groups match quickly", async () => {
+ const name = Buffer.alloc(60, "a").toString();
+ const expected = [
+ [`${Buffer.alloc(120, "*(a|a)").toString()}b.js`, ""],
+ [`${Buffer.alloc(100, "{a,a}").toString()}*b.js`, ""],
+ [`${Buffer.alloc(40, "+(").toString()}a${Buffer.alloc(20, ")").toString()}.js`, `${name}.js`],
+ [`${Buffer.alloc(40, "!(b)").toString()}.js`, `${name}.js`],
+ ];
+ expect(
+ await filesOf(
+ expected.map(it => it[0]),
+ [`${name}.js`],
+ ),
+ ).toEqual(expected);
+});
+
+// eslint-plugin-import calls minimatch without `dot`.
+test.concurrent("wildcards in import rule options don't match a leading dot", async () => {
+ const code = 'import "./a.css";\nimport "./a.less";\nimport "./a.scss";\n';
+ const styles = { "a.css": "", "a.less": "", "a.scss": "" };
+ const inside = (directory: string) =>
+ Object.fromEntries(
+ Object.entries({ "a.js": code, ...styles }).map(([name, text]) => [`${directory}/${name}`, text]),
+ );
+ using dir = tempDir("bun-lint-glob", {
+ // `{**,}/` means `**/` or `/`.
+ "bunfig.toml": `[lint.rules]\n"import/no-unassigned-import" = ["error", { allow = ["{**,}/*.css", "**/*.less"] }]\n`,
+ ...inside("src/x"),
+ ...inside(".hidden/x"),
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", "src", ".hidden/x/a.js"],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ if (!stdout.startsWith("[")) throw new Error(`exit code ${exitCode}\n${stdout}\n${stderr}`);
+ const results: { filePath: string; messages: { line: number }[] }[] = JSON.parse(stdout);
+ const lines = results.map(it => [
+ relative(String(dir), it.filePath).replaceAll("\\", "/"),
+ it.messages.map(message => message.line),
+ ]);
+ expect(Object.fromEntries(lines)).toEqual({ "src/x/a.js": [3], ".hidden/x/a.js": [1, 2, 3] });
+ expect(exitCode).toBe(1);
+});
+
+/** Lints a project with these files and returns each report as `file:line`. */
+async function reported(files: Record, args: string[]) {
+ using dir = tempDir("bun-lint-glob", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", ...args],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ if (!stdout.startsWith("[")) throw new Error(`exit code ${exitCode}\n${stdout}\n${stderr}`);
+ const results: { filePath: string; messages: { line: number }[] }[] = JSON.parse(stdout);
+ return results
+ .flatMap(it =>
+ it.messages.map(message => `${relative(String(dir), it.filePath).replaceAll("\\", "/")}:${message.line}`),
+ )
+ .sort();
+}
+
+test.concurrent("import/no-extraneous-dependencies: `**/*.test.js` doesn't match files in .storybook", async () => {
+ const code = 'import dev from "dev";\nexport default dev;\n';
+ const files = {
+ "bunfig.toml": `[lint.rules]\n"import/no-extraneous-dependencies" = ["error", { devDependencies = ["**/*.test.js"] }]\n`,
+ "package.json": JSON.stringify({ name: "p", version: "1.0.0", devDependencies: { dev: "1.0.0" } }),
+ "node_modules/dev/package.json": JSON.stringify({ name: "dev", version: "1.0.0", main: "index.js" }),
+ "node_modules/dev/index.js": "module.exports = 1;\n",
+ "src/a.test.js": code,
+ "src/b.js": code,
+ ".storybook/a.test.js": code,
+ };
+ expect(await reported(files, ["src", ".storybook/a.test.js"])).toEqual([".storybook/a.test.js:1", "src/b.js:1"]);
+});
+
+test.concurrent.each([
+ [", patternOptions = { dot = true }", ["a.js:2"]],
+ ["", []],
+])("import/order honors patternOptions.dot%s", async (options, expected) => {
+ const group = `{ pattern = "~/**", group = "builtin", position = "before"${options} }`;
+ const files = {
+ "bunfig.toml": `[lint.rules]\n"import/order" = ["error", { pathGroups = [${group}], pathGroupsExcludedImportTypes = [] }]\n`,
+ "a.js": 'import fs from "fs";\nimport a from "~/.hidden/a";\nexport default [fs, a];\n',
+ };
+ expect(await reported(files, ["a.js"])).toEqual(expected);
+});
+
+// The answers are minimatch's. A report means that the pattern matched "~(x)/a".
+// On Windows, minimatch 3 turns every `\` of a pattern into `/`, so nothing can be escaped there.
+const escaped = isWindows ? [] : ["a.js:2"];
+test.concurrent.each([
+ ["~(x)/**", true, ["a.js:2"]],
+ ["~(x)/**", false, ["a.js:2"]],
+ ["~\\(x)/**", true, escaped],
+ ["~\\(x)/**", false, escaped],
+ ["~+(x)/**", true, []],
+ ["~?(\\(x\\))/**", true, []],
+ ["~?(\\(x\\))/**", false, escaped],
+])("import/order: the pattern %j with patternOptions.noext = %p", async (pattern, noext, expected) => {
+ const group = `{ pattern = ${JSON.stringify(pattern)}, group = "builtin", position = "before", patternOptions = { noext = ${noext} } }`;
+ const files = {
+ "bunfig.toml": `[lint.rules]\n"import/order" = ["error", { pathGroups = [${group}], pathGroupsExcludedImportTypes = [] }]\n`,
+ "a.js": 'import fs from "fs";\nimport a from "~(x)/a";\nexport default [fs, a];\n',
+ };
+ expect(await reported(files, ["a.js"])).toEqual(expected);
+});
+
+// The expected files come from ESLint 10.12.
+test.concurrent("brace sequences in `files` match the same files as ESLint", async () => {
+ // prettier-ignore
+ const names = ["0", "1", "2", "3", "4", "9", "10", "11", "01", "02", "001", "-1", "-", "a", "b", "c", "d", "{a}", "1..a"];
+ const expected = [
+ ["x{1..3}.js", "1 2 3"],
+ ["x{3..1}.js", "1 2 3"],
+ ["x{01..03}.js", "01 02"],
+ ["x{1..10}.js", "1 10 2 3 4 9"],
+ ["x{001..3}.js", "001"],
+ ["x{-1..1}.js", "-1 0 1"],
+ ["x{1..9..2}.js", "1 3 9"],
+ ["x{9..1..4}.js", "1 9"],
+ ["x{a..c}.js", "a b c"],
+ ["x{d..a..2}.js", "b d"],
+ ["x{{1..2},a}.js", "1 2 a"],
+ // Not sequences
+ ["x{1..a}.js", ""],
+ ["x{1..3,a}.js", "a"],
+ ["x{a}.js", "{a}"],
+ ["v{1..2}/**/*.js", "v1 v2"],
+ ].map(([pattern, found]) => [
+ pattern,
+ found
+ .split(" ")
+ .filter(Boolean)
+ .map(it => (it.startsWith("v") ? `${it}/x/a.js` : `x${it}.js`))
+ .sort()
+ .join(" "),
+ ]);
+ const files = [...names.map(it => `x${it}.js`), "v1/x/a.js", "v2/x/a.js", "v3/x/a.js"];
+ expect(
+ await filesOf(
+ expected.map(it => it[0]),
+ files,
+ ),
+ ).toEqual(expected);
+});
+
+// On Windows `\` is the root of the current drive, which is a directory to lint.
+const backslash = isWindows ? [] : ["\\"];
+test.concurrent.each([
+ "*[\\",
+ "*[a\\",
+ "[a-\\",
+ "[\\",
+ "{[\\}",
+ "@([\\)",
+ "[",
+ "{",
+ "@(",
+ "{1..",
+ "[!",
+ "[^\\",
+ ...backslash,
+])("an incomplete pattern matches no files: %s", async pattern => {
+ using dir = tempDir("bun-lint-glob", { "a.js": "", "eslint.config.mjs": "export default [{}];\n" });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", pattern],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ expect(stdout).toBe("");
+ expect(stderr).toContain("No files matching the pattern");
+ expect(exitCode).toBe(2);
+});
+
+const ignorable = [
+ "a.js",
+ "b.js",
+ "build/a.js",
+ "build/sub/c.js",
+ "src/b.js",
+ "src/build/d.js",
+ "a,b.js",
+ "[a].js",
+ "{a}.js",
+ "1.js",
+ "2.js",
+ "a b.js",
+];
+
+// The expected files come from oxlint 1.87.
+test.concurrent.each([
+ ["build/", "build/a.js | build/sub/c.js | src/build/d.js"],
+ ["build\\/", "build/a.js | build/sub/c.js | src/build/d.js"],
+ ["/build", "build/a.js | build/sub/c.js"],
+ ["build", "build/a.js | build/sub/c.js | src/build/d.js"],
+ ["**/build", "build/a.js | build/sub/c.js | src/build/d.js"],
+ ["src/**", "src/b.js | src/build/d.js"],
+ ["src/*/", "src/build/d.js"],
+ ["**/sub/**", "build/sub/c.js"],
+ ["/**", ignorable.join(" | ")],
+ ["{a,b}.js", "a.js | b.js | build/a.js | src/b.js"],
+ // An empty alternative is dropped.
+ ["{a,}.js", "a.js | build/a.js"],
+ ["{a\\,b,1}.js", "a,b.js | 1.js"],
+ ["{a,{b,1}}.js", "a.js | b.js | build/a.js | src/b.js | 1.js"],
+ ["a\\,b.js", "a,b.js"],
+ ["\\{a\\}.js", "{a}.js"],
+ // No sequences and no extglob
+ ["{1..2}.js", ""],
+ ["@(a|b).js", ""],
+ ["[a-b].js", "a.js | b.js | build/a.js | src/b.js"],
+ ["[!a].js", "b.js | build/sub/c.js | src/b.js | src/build/d.js | 1.js | 2.js"],
+ ["\\[a\\].js", "[a].js"],
+ // `\` doesn't escape inside a class, so the class ends at the first `]`.
+ ["[\\]a].js", ""],
+ ["a\\ b.js", "a b.js"],
+ ["a b.js ", "a b.js"],
+ ["!a.js", ""],
+])("the oxlint ignorePatterns entry %j ignores the same files as oxlint", async (line, ignored) => {
+ using dir = tempDir("bun-lint-glob", {
+ ...Object.fromEntries(ignorable.map(file => [file, "debugger;\n"])),
+ ".oxlintrc.json": JSON.stringify({ rules: { "no-debugger": "error" }, ignorePatterns: [line] }),
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", "."],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ // There's no JSON if every file is ignored.
+ const diagnostics: { filename: string }[] = stdout.startsWith("{") ? JSON.parse(stdout).diagnostics : [];
+ const linted = diagnostics.map(it => it.filename.replaceAll("\\", "/"));
+ expect(ignorable.filter(file => !linted.includes(file)).join(" | "), stderr).toBe(ignored);
+ expect(exitCode).toBe(1);
+});
+
+// The expected results come from ESLint 10.12. minimatch reads a leading `#` as a comment and a leading `!` as a negation.
+test.concurrent.each(["#*", "!*"])("the command line pattern %s matches no files, like in ESLint", async pattern => {
+ using dir = tempDir("bun-lint-glob", {
+ "a.js": "debugger;\n",
+ "#a.js": "debugger;\n",
+ "sub/b.js": "debugger;\n",
+ "eslint.config.mjs": 'export default [{ rules: { "no-debugger": "error" } }];\n',
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "--", pattern],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ expect(stdout).toBe("");
+ expect(stderr).toContain(`No files matching the pattern "${pattern}" were found.`);
+ expect(exitCode).toBe(2);
+});
+
+// The expected results come from oxlint 1.87, whose glob matcher never matches a pattern with an unclosed `{` or `[`.
+test.concurrent.each(["{a,", "a{,", "*{a,", "[*", "{*", "a\\"])(
+ "the oxlint no-restricted-imports pattern %j restricts nothing",
+ async pattern => {
+ using dir = tempDir("bun-lint-glob", {
+ "x.js": ["a", "aa", "{a}", "[a]", "{a,", "a{,"].map(source => `import "${source}";\n`).join(""),
+ ".oxlintrc.json": JSON.stringify({ rules: { "no-restricted-imports": ["error", { patterns: [pattern] }] } }),
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "-f", "json", "x.js"],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ if (!stdout.startsWith("{")) throw new Error(`exit code ${exitCode}\n${stdout}\n${stderr}`);
+ const diagnostics: { code: string }[] = JSON.parse(stdout).diagnostics;
+ expect(diagnostics.filter(it => it.code.includes("no-restricted-imports"))).toEqual([]);
+ expect(exitCode).toBe(0);
+ },
+);
diff --git a/test/cli/lint/help.test.ts b/test/cli/lint/help.test.ts
new file mode 100644
index 000000000000..16ca6353d64a
--- /dev/null
+++ b/test/cli/lint/help.test.ts
@@ -0,0 +1,245 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "fs";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { join } from "path";
+
+const root = join(import.meta.dir, "../../..");
+
+async function runIn(files: Record, ...args: string[]) {
+ using dir = tempDir("bun-lint-help", files);
+ await using proc = Bun.spawn({ cmd: [bunExe(), ...args], env: bunEnv, cwd: String(dir), stderr: "pipe" });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const run = (...args: string[]) => runIn({}, ...args);
+
+/** Maps each flag listed in a help text (by its long name) to its description. */
+const listed = (help: string): Record =>
+ Object.fromEntries([...help.matchAll(/^ {2}(?:-\w,| {3}) --([\w-]+)(?:=)? +(.+)$/gm)].map(it => [it[1], it[2]]));
+
+describe.concurrent.each([
+ {
+ command: "lint",
+ source: "src/lint/driver/cli.rs",
+ common: [
+ "fix",
+ "staged",
+ "changed",
+ "rule",
+ "rules",
+ "explain",
+ "type-aware",
+ "quiet",
+ "max-warnings",
+ "init",
+ "doctor",
+ ],
+ headings: [
+ "Rules",
+ "Files",
+ "Output",
+ "Fixing",
+ "Types",
+ "Other",
+ "Compatibility with ESLint",
+ "Compatibility with oxlint",
+ ],
+ },
+ {
+ command: "fmt",
+ source: "src/lint/driver/fmt/cli.rs",
+ common: [
+ "check",
+ "staged",
+ "changed",
+ "stdin-filepath",
+ "print-width",
+ "use-tabs",
+ "no-semi",
+ "single-quote",
+ "init",
+ "doctor",
+ ],
+ headings: ["Options", "Files", "Output", "Other", "Compatibility with Prettier", "Compatibility with oxfmt"],
+ },
+])("bun $command", ({ command, source, common, headings }) => {
+ test("--help is short", async () => {
+ const { stdout, stderr, exitCode } = await run(command, "--help");
+ const lines = stdout.trimEnd().split("\n");
+ expect(lines[0]).toBe(`Usage: bun ${command} [flags] [...files, directories or patterns]`);
+ expect(stdout.match(/^\S.*:$/gm)).toEqual(["Flags:", "Examples:"]);
+ expect(Object.keys(listed(stdout))).toEqual(common);
+ expect(lines.filter(line => line.startsWith(` bun ${command}`))).toHaveLength(3);
+ expect(lines.slice(-2)).toEqual([
+ `Full documentation is available at https://bun.com/docs/runtime/${command === "fmt" ? "format" : command}`,
+ `See every flag with bun ${command} --help --all`,
+ ]);
+ expect(lines.length).toBeLessThanOrEqual(25);
+ expect(stderr).toBe("");
+ expect(exitCode).toBe(0);
+ });
+
+ test("--help --all lists every flag the command accepts", async () => {
+ const { stdout, stderr, exitCode } = await run(command, "--help", "--all");
+ expect(stdout.match(/^\S.*:$/gm)).toEqual([...headings.map(heading => `${heading}:`), "Examples:"]);
+ const params = readFileSync(join(root, source), "utf8").matchAll(/clap::param!\(\s*"(?:-\w, )?(--[^\s"]+)/g);
+ const taken = [...params].flatMap(it => it[1].split("/"));
+ expect(taken.length).toBeGreaterThan(70);
+ const mentioned = new Set(stdout.match(/--[\w-]+/g));
+ // Listing `--no-semi` covers `--semi` too.
+ const missing = taken.filter(flag => !mentioned.has(flag) && !mentioned.has(flag.replace("--", "--no-")));
+ expect(missing).toEqual([]);
+ expect(stderr).toBe("");
+ expect(exitCode).toBe(0);
+ });
+
+ test("--help and --help --all describe a flag the same way", async () => {
+ const [short, all] = await Promise.all([run(command, "--help"), run(command, "--help", "--all")]);
+ expect(listed(all.stdout)).toMatchObject(listed(short.stdout));
+ });
+
+ test.each([["--help-all"], ["--all", "--help"], ["-h", "--all"]])("%s %s is --help --all", async (...args) => {
+ const [one, other] = await Promise.all([run(command, ...args), run(command, "--help", "--all")]);
+ expect(one).toEqual(other);
+ });
+
+ test.each(["--help", "-h", "--help-all"])("%s isn't passed to a package.json script of that name", async flag => {
+ const files = { "package.json": JSON.stringify({ scripts: { [command]: "echo the script" } }) };
+ const [here, elsewhere] = await Promise.all([runIn(files, command, flag), run(command, flag)]);
+ expect(here.stdout).toBe(
+ `${elsewhere.stdout}
+note: package.json has a "${command}" script, so bun ${command} runs that script
+ Change the script to "bun ${command}" to use the built-in command
+`,
+ );
+ expect(here.exitCode).toBe(0);
+ });
+
+ // ESLint, oxlint, Prettier and other tools behind such scripts have these flags too.
+ test.each([
+ ["--init"],
+ ["--rules"],
+ ["--print-config", "a.js"],
+ ["--print-config=a.js"],
+ ["--version"],
+ ["-v"],
+ ["-V"],
+ ["src", "-v"],
+ ...(command === "fmt" ? [["--explain", "no-var"], ["--explain=no-var"]] : []),
+ ])("%s %s is passed to a package.json script of that name, and its exit code counts", async (...args) => {
+ const files = { "package.json": JSON.stringify({ scripts: { [command]: "echo the script && exit 3 && echo" } }) };
+ const { stdout, exitCode } = await runIn(files, command, ...args);
+ expect(stdout).toBe("the script\n");
+ expect(exitCode).toBe(3);
+ });
+
+ test.each(["--help", "-h"])("bun %s prints the help and touches no file", async flag => {
+ using dir = tempDir("bun-help-before", { "a.js": "const a=1\n" });
+ await using proc = Bun.spawn({ cmd: [bunExe(), flag, command], env: bunEnv, cwd: String(dir), stderr: "pipe" });
+ const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+ expect(stdout).toBe((await run(command, "--help")).stdout);
+ expect(readFileSync(join(String(dir), "a.js"), "utf8")).toBe("const a=1\n");
+ expect(exitCode).toBe(0);
+ });
+
+ test("flags of the command that stand before it count", async () => {
+ const [flags, text, after, code] =
+ command === "fmt"
+ ? [["--check", "-c", "--list-different", "-l"], "const a=1\n", "const a=1\n", 1]
+ : [["--fix"], "let a = 1;\nexport { a };\n", "const a = 1;\nexport { a };\n", 0];
+ using dir = tempDir("bun-flags-before", { "a.ts": text });
+ for (const cmd of flags.flatMap(flag => [
+ [bunExe(), flag, command, "a.ts"],
+ [bunExe(), "--silent", flag, command, "a.ts"],
+ ])) {
+ await Bun.write(join(String(dir), "a.ts"), text);
+ await using proc = Bun.spawn({ cmd, env: bunEnv, cwd: String(dir), stdout: "pipe", stderr: "pipe" });
+ const exitCode = await proc.exited;
+ expect({ cmd: cmd.slice(1), text: readFileSync(join(String(dir), "a.ts"), "utf8"), exitCode }).toEqual({
+ cmd: cmd.slice(1),
+ text: after,
+ exitCode: code,
+ });
+ }
+ });
+
+ test("flags of bun and of BUN_OPTIONS before the command aren't passed to it", async () => {
+ using dir = tempDir("bun-flags-before", { "a.ts": "export const a = 1;\n" });
+ await using proc = Bun.spawn({
+ cmd: [bunExe(), "--smol", "--no-install", command, "a.ts"],
+ env: { ...bunEnv, BUN_OPTIONS: "--prefer-offline" },
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stderr, exitCode] = await Promise.all([proc.stderr.text(), proc.exited]);
+ expect(stderr).not.toContain("error");
+ expect(exitCode).toBe(0);
+ });
+
+ // No other tool has these flags, and the migration guides send people here who still have "lint": "eslint .".
+ test.each([["--doctor"], ...(command === "lint" ? [["--explain", "no-var"], ["--explain=no-var"]] : [])])(
+ "%s %s isn't passed to a package.json script of that name",
+ async (...args) => {
+ const scripts = (name: string) => ({
+ "package.json": JSON.stringify({ scripts: { [name]: "echo the script" } }),
+ });
+ const [here, elsewhere] = await Promise.all([
+ runIn(scripts(command), command, ...args),
+ runIn(scripts("other"), command, ...args),
+ ]);
+ expect(here.stderr).not.toContain("echo the script");
+ expect({ stdout: here.stdout, exitCode: here.exitCode }).toEqual({
+ stdout: elsewhere.stdout,
+ exitCode: elsewhere.exitCode,
+ });
+ },
+ );
+
+ test("other flags are passed to the script", async () => {
+ const files = { "package.json": JSON.stringify({ scripts: { [command]: "echo the script" } }) };
+ const { stdout, exitCode } = await runIn(files, command, "--threads=1");
+ expect(stdout).toBe("the script --threads=1\n");
+ expect(exitCode).toBe(0);
+ });
+
+ test("-- --help is passed to the script", async () => {
+ const files = { "package.json": JSON.stringify({ scripts: { [command]: "echo the script" } }) };
+ const { stdout, exitCode } = await runIn(files, command, "--", "--help");
+ expect(stdout).toBe("the script --help\n");
+ expect(exitCode).toBe(0);
+ });
+
+ test("shell completions list the same flags as --help --all", async () => {
+ const { stdout } = await run(command, "--help", "--all");
+ const flags = Object.entries(listed(stdout))
+ .filter(([, description]) => !/^(No effect|Not supported)/.test(description))
+ .map(([flag]) => flag)
+ .sort();
+ const read = (shell: string) => readFileSync(join(root, "completions", `bun.${shell}`), "utf8");
+ const bash = read("bash").match(new RegExp(`^ +${command}\\)\\n.*-W "(.+)" --`, "m"))![1];
+ const zsh = read("zsh").match(new RegExp(`^_bun_${command}_completion\\(\\) \\{\\n(.+?)^\\}`, "ms"))![1];
+ const fish = read("fish").matchAll(new RegExp(`__fish_seen_subcommand_from ${command}".* -l "([\\w-]+)"`, "g"));
+ expect({
+ bash: [...bash.matchAll(/--([\w-]+)/g)].map(it => it[1]).sort(),
+ zsh: [...zsh.matchAll(/^ +'--([\w-]+)\[/gm)].map(it => it[1]).sort(),
+ // bun.fish defines these two once, for every command.
+ fish: [...fish, ["", "help"], ["", "version"]].map(it => it[1]).sort(),
+ }).toEqual({ bash: flags, zsh: flags, fish: flags });
+ });
+});
+
+test("bun fmt --all is rejected without --help", async () => {
+ const { stdout, stderr, exitCode } = await run("fmt", "--all");
+ expect(stderr).toContain("error: --all has no effect without --help");
+ expect(stdout).toBe("");
+ expect(exitCode).toBe(2);
+});
+
+test("bun format is not a command, and says which one is", async () => {
+ const { stdout, stderr, exitCode } = await runIn({ "a.js": "a = 1\n" }, "format");
+ expect(stderr).toBe('error: Script not found "format"\nnote: The formatter is bun fmt\n');
+ expect(stdout).toBe("");
+ expect(exitCode).toBe(1);
+});
diff --git a/test/cli/lint/hints.test.ts b/test/cli/lint/hints.test.ts
new file mode 100644
index 000000000000..284c4ef47f56
--- /dev/null
+++ b/test/cli/lint/hints.test.ts
@@ -0,0 +1,358 @@
+// Tests for the hint line that `pretty` and `agent` print when a message alone doesn't explain the problem or the fix.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+async function lint(files: Record, ...args: string[]) {
+ using dir = tempDir("bun-lint-hints", files);
+ await using proc = spawn({ cmd: [bunExe(), "lint", ...args], env: bunEnv, cwd: String(dir), stderr: "pipe" });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+/** Lints `code` with `-f pretty`. Returns one string per report: the rule, the line, and the hint if there is one. */
+async function hints(code: string, file = "a.js", others: Record = {}) {
+ const { stdout } = await lint({ ...others, [file]: code }, "-f", "pretty");
+ const reports = stdout.matchAll(/^(?:error|warn): .* (\S+)\n +at [^\n]*?:(\d+):\d+\n(?:\nnote: (.*)\n)?/gm);
+ return Array.from(reports, ([, rule, line, hint]) => `${rule} ${line}${hint === undefined ? "" : ": " + hint}`);
+}
+
+describe.concurrent("no-useless-assignment", () => {
+ test("every branch assigns again", async () => {
+ const code = `
+export function rename(kind) {
+ let name = "honeypot";
+ if (kind === "a") {
+ name = "x";
+ } else {
+ name = "y";
+ }
+ return name;
+}
+`;
+ expect(await hints(code)).toEqual([
+ "no-useless-assignment 3: It is overwritten on line 5 and line 7 before it is read.",
+ ]);
+ });
+
+ test("the next statement assigns again", async () => {
+ expect(await hints(`export function f(a) {\n let b = a;\n b = 2;\n return b;\n}\n`)).toEqual([
+ "no-useless-assignment 2: It is overwritten on line 3 before it is read.",
+ ]);
+ });
+
+ test("three or more branches assign again", async () => {
+ const cases = (count: number) => Array.from({ length: count }, (_, i) => ` case ${i}: b = ${i}; break;\n`);
+ const code = (count: number) =>
+ `export function f(a) {\n let b = -1;\n switch (a) {\n${cases(count).join("")} default: b = 9;\n }\n return b;\n}\n`;
+ expect(await Promise.all([hints(code(2)), hints(code(5))])).toEqual([
+ ["no-useless-assignment 2: It is overwritten on lines 4, 5 and 6 before it is read."],
+ ["no-useless-assignment 2: It is overwritten on lines 4, 5, 6 and 3 more before it is read."],
+ ]);
+ });
+
+ test("the variable is never read again", async () => {
+ expect(await hints(`export function f(a) {\n let b = a;\n use(b);\n b = 2;\n}\n`, "a.ts")).toEqual([
+ "no-useless-assignment 4: Nothing reads it after this.",
+ ]);
+ });
+});
+
+/** Code and its expected reports. The code uses everything it declares, so nothing else gets reported. */
+const cases: [code: string, ...reports: string[]][] = [
+ [
+ `let a;\nif (a = f()) use(a);`,
+ "no-cond-assign 2: Did you mean ===? To keep the assignment, wrap it in another pair of parentheses.",
+ ],
+ [
+ `let a = 1;\nwhile (a -= 1) use(a);`,
+ "no-cond-assign 2: To keep the assignment, wrap it in another pair of parentheses.",
+ ],
+ [`let a;\nuse(a = f() ? 1 : 2, a);`],
+ [`let a;\nuse((a = f()) ? 1 : 2, a);`, "no-cond-assign 2: Did you mean ===?"],
+ [
+ `switch (f()) {\n case 1:\n const a = 1;\n use(a);\n}`,
+ "no-case-declarations 3: Every case of the switch can see it. Wrap this case in { }.",
+ ],
+ [
+ `switch (f()) {\n case 1:\n use(1);\n case 2:\n use(2);\n}`,
+ "no-fallthrough 4: Add break, or the comment // falls through if this is meant.",
+ ],
+ [`use(f() === -0);`, "no-compare-neg-zero 1: -0 and 0 compare as equal. Use Object.is(x, -0) to tell them apart."],
+ [`if (f()) {\n}`, "no-empty 1: Remove it, or put a comment in it that says why it is empty."],
+ [
+ `try {\n f();\n} catch {}`,
+ "no-empty 3: Handle the error, or put a comment in it that says why the error is ignored.",
+ ],
+ [`use(/a[]/);`, "no-empty-character-class 1: [] in a regular expression matches nothing."],
+ [
+ `export function g() {\n try {\n return f();\n } finally {\n return 2;\n }\n}`,
+ "no-unsafe-finally 5: It replaces whatever try and catch return or throw.",
+ ],
+ [`use(!f() in g());`, "no-unsafe-negation 1: !a in b means (!a) in b. Did you mean !(a in b)?"],
+ [
+ `use(!f() instanceof Map);`,
+ "no-unsafe-negation 1: !a instanceof b means (!a) instanceof b. Did you mean !(a instanceof b)?",
+ ],
+ [
+ `const a = f\n(g || h).call();\nuse(a);`,
+ "no-unexpected-multiline 2: This line continues the one before. End that one with a semicolon.",
+ ],
+ [`use(f().hasOwnProperty("a"));`, "no-prototype-builtins 1: Use Object.hasOwn(object, key) instead."],
+ [
+ `use(f().isPrototypeOf(g()));`,
+ "no-prototype-builtins 1: Use Object.prototype.isPrototypeOf.call(object, value) instead.",
+ ],
+ [
+ `use(new Promise(async resolve => resolve(await f())));`,
+ "no-async-promise-executor 1: If it throws, the promise never settles. Await outside of new Promise().",
+ ],
+ [
+ `use(typeof f() || "b");`,
+ "no-constant-binary-expression 1: The left side is always truthy or always falsy. Are parentheses missing?",
+ ],
+ [
+ `use("a" || f());`,
+ "no-constant-binary-expression 1: The left side is always truthy, so the right side is never used.",
+ ],
+ [
+ `use("" || f());`,
+ "no-constant-binary-expression 1: The left side is always falsy, so the result is always the right side.",
+ ],
+ [
+ `use({} && f());`,
+ "no-constant-binary-expression 1: The left side is always truthy, so the result is always the right side.",
+ ],
+ [
+ `use(null && f());`,
+ "no-constant-binary-expression 1: The left side is always falsy, so the right side is never used.",
+ ],
+ [
+ `use(!f() ?? "b");`,
+ "no-constant-binary-expression 1: The left side is never null or undefined, so the right side is never used.",
+ ],
+ [
+ `use(undefined ?? "b");`,
+ "no-constant-binary-expression 1: The left side is always null or undefined, so the result is always the right side.",
+ ],
+ [`use(!f() == null);`, "no-constant-binary-expression 1: The result is always the same. Are parentheses missing?"],
+ [`use({} === f());`, "no-constant-binary-expression 1"],
+ [
+ `try {\n f();\n} catch (e) {\n throw e;\n}`,
+ "no-useless-catch 1: It only throws the error again. Without try and catch, the code does the same.",
+ ],
+ [
+ `try {\n f();\n} catch (e) {\n throw e;\n} finally {\n g();\n}`,
+ "no-useless-catch 3: It only throws the error again. Without it, try and finally do the same.",
+ ],
+ [`use([1, , 2]);`, "no-sparse-arrays 1: It leaves a hole in the array. Remove the comma, or write undefined."],
+ [`const {} = f();`, "no-empty-pattern 1: It declares no variables."],
+ [
+ `const { a: {} } = f();`,
+ "no-empty-pattern 1: It declares no variables. For a default value, write = {} instead of : {}.",
+ ],
+ [
+ `const { a: [] } = f();`,
+ "no-empty-pattern 1: It declares no variables. For a default value, write = [] instead of : [].",
+ ],
+ [`class A {}\nA = f();\nuse(A);`, "no-class-assign 2: This assignment replaces the class declared on line 1."],
+ [
+ `function a() {}\n\na = f();\nuse(a);`,
+ "no-func-assign 3: This assignment replaces the function declared on line 1.",
+ ],
+ [
+ `const a = 1;\nif (f()) a = 2;\nuse(a);`,
+ "no-const-assign 2: It is declared with const on line 1. Use let if it has to change.",
+ ],
+ [`var a = 1;\nuse(a);\nvar a = 2;\nuse(a);`, "no-redeclare 3: It is first declared on line 1."],
+ [
+ `switch (f()) {\n case 1:\n break;\n case 2:\n break;\n case 1:\n break;\n}`,
+ "no-duplicate-case 6: Only the first case with this label runs. It is on line 2.",
+ ],
+ [`use({\n a: 1,\n b: 2,\n a: 3,\n});`, "no-dupe-keys 4: Only the last one counts. The first is on line 2."],
+ [`use(class {\n a() {}\n a() {}\n});`, "no-dupe-class-members 3: Only the last one counts."],
+ [`use(9007199254740993);`, "no-loss-of-precision 1: At runtime it is 9007199254740992."],
+ [`use(typeof f() === "strnig");`, 'valid-typeof 1: Did you mean "string"?'],
+ [`use(typeof f() === "array");`, "valid-typeof 1: typeof never returns this string."],
+ [
+ `use(typeof f() === null);`,
+ "no-constant-binary-expression 1: The result is always the same. Are parentheses missing?",
+ "valid-typeof 1: typeof always returns a string.",
+ ],
+ [
+ `use(typeof f() === undefined);`,
+ "no-constant-binary-expression 1: The result is always the same. Are parentheses missing?",
+ 'valid-typeof 1: typeof returns the string "undefined".',
+ ],
+ [
+ `try {\n f();\n} catch (err) {\n throw new Error("no");\n}`,
+ "no-unused-vars 3",
+ "preserve-caught-error 4: Pass { cause: err } as the last argument, so that the caught error is not lost.",
+ ],
+ [
+ String.raw`use("\d+");`,
+ String.raw`no-useless-escape 1: "\d" is the same as "d". Remove the backslash, or write \\ for a real one.`,
+ ],
+ [String.raw`use(/[\$&&a]/v);`, String.raw`no-useless-escape 1: "\$" is the same as "$" here. Remove the backslash.`],
+ [
+ `export function a() {\n return 1;\n function b() {}\n use(b);\n}`,
+ "no-unreachable 4: Nothing runs after the return on line 2.",
+ ],
+ [
+ `while (true) {\n f();\n}\nuse(1);`,
+ "no-unreachable 4: The loop on line 1 runs forever, or leaves by return or throw.",
+ ],
+ [
+ `export function a() {\n if (f()) {\n return 1;\n } else {\n throw g();\n }\n use(1);\n}`,
+ "no-unreachable 7: Every path through the if on line 2 ends in return, throw, break or continue.",
+ ],
+ [`const userName = f();\nuse(usrName, userName);`, 'no-undef 2: Did you mean "userName"?'],
+ [`consle.log(1);`, 'no-undef 1: Did you mean "console"?'],
+ [`use(new Promse(f));`, 'no-undef 1: Did you mean "Promise"?'],
+ [`describe("a", f);`, 'no-undef 1: With bun test, import it from "bun:test".'],
+ [`jQuery("a");`, "no-undef 1: If it is a global variable, declare it in [lint.globals] in bunfig.toml."],
+ [
+ `try {\n f();\n} catch (e) {\n g();\n}`,
+ "no-unused-vars 3: A catch needs no parameter. Remove it and its parentheses.",
+ ],
+ [
+ `try {\n f();\n} catch ({ a, b }) {\n g(a);\n}`,
+ "no-unused-vars 3: Remove it, or start its name with _ to keep it.",
+ ],
+ [`const a = f();`, "no-unused-vars 1: Remove it, or start its name with _ to keep it."],
+ [`export function a(b) {}`, "no-unused-vars 1: Remove it, or start its name with _ to keep it."],
+ [`import a from "a";`, "no-unused-vars 1"],
+ [
+ `use(1,\u00a02);`,
+ "no-irregular-whitespace 1: It is the character U+00A0. Replace it with a plain space or a line break.",
+ ],
+ [`use(f() === NaN);`, "use-isnan 1: Nothing is equal to NaN, not even NaN itself."],
+ [
+ `use(/[👍🏽]/u);`,
+ "no-misleading-character-class 1: What looks like one character is several, and the class matches each of them alone.",
+ ],
+];
+
+const globals = { "bunfig.toml": `[lint.globals]\nf = "readonly"\ng = "readonly"\nh = "readonly"\nuse = "readonly"\n` };
+
+test.concurrent.each(cases)("%s", async (code, ...reports) => {
+ expect(await hints(code + "\n", "a.js", globals)).toEqual(reports);
+});
+
+test.concurrent("@typescript-eslint/no-unused-vars", async () => {
+ const code = `try {\n f();\n} catch (e) {\n f();\n}\nconst { a, ...others } = f();\nconst b = f(others);\ndeclare function f(a?: unknown): any;\n`;
+ expect(await hints(code, "a.ts")).toEqual([
+ "@typescript-eslint/no-unused-vars 3: A catch needs no parameter. Remove it and its parentheses.",
+ "@typescript-eslint/no-unused-vars 7: Remove it, or start its name with _ to keep it.",
+ "@typescript-eslint/no-explicit-any 8: unknown is the safe choice where the type is not known.",
+ ]);
+});
+
+test.concurrent.each(["a.js", "a.ts"])("no-unused-vars with options from bunfig.toml, in %s", async file => {
+ const rule = file === "a.js" ? "no-unused-vars" : "@typescript-eslint/no-unused-vars";
+ const bunfig = `[lint.rules]\n"${rule}" = ["warn", { ignoreRestSiblings = false, varsIgnorePattern = "^x" }]\n`;
+ const code = `const { a, ...others } = Bun;\nconsole.log(others);\nconst _b = 1;\n`;
+ expect(await hints(code, file, { "bunfig.toml": bunfig })).toEqual([
+ `${rule} 1: To leave a property out this way, turn on the option ignoreRestSiblings.`,
+ `${rule} 3`,
+ ]);
+});
+
+test.concurrent("typescript-eslint rules", async () => {
+ const code = `
+declare const list: number[];
+list.pop;
+list.length === 0;
+list.length + 1;
+export function later(this: object) {
+ const self = this;
+ return () => self;
+}
+export class A {}
+export interface A {
+ a: number;
+}
+export let b: any;
+export const fs = require("fs");
+import path = require("path");
+export { path };
+`;
+ const bunfig = { "bunfig.toml": `[lint.rules]\n"@typescript-eslint/no-require-imports" = "warn"\n` };
+ expect(await hints(code, "a.ts", bunfig)).toEqual([
+ "@typescript-eslint/no-unused-expressions 3: Nothing uses the value. Did you mean to call it, with ()?",
+ "@typescript-eslint/no-unused-expressions 4: Nothing uses the result of the comparison. Did you mean to assign, with =?",
+ "@typescript-eslint/no-unused-expressions 5: Nothing uses the value, so the statement does nothing.",
+ "@typescript-eslint/no-this-alias 7: Use an arrow function instead. It has the this of the code around it.",
+ "@typescript-eslint/no-unsafe-declaration-merging 10: TypeScript does not check that the class sets what the interface declares.",
+ "@typescript-eslint/no-unsafe-declaration-merging 11: TypeScript does not check that the class sets what the interface declares.",
+ "@typescript-eslint/no-explicit-any 14: unknown is the safe choice where the type is not known.",
+ "@typescript-eslint/no-require-imports 15: Use an import declaration, or await import() to load it later.",
+ "@typescript-eslint/no-require-imports 16: Use an import declaration.",
+ ]);
+});
+
+test.concurrent("react-hooks/rules-of-hooks", async () => {
+ const code = `
+import { useEffect, useState } from "react";
+
+export function List({ items, open }) {
+ if (!open) {
+ return null;
+ }
+ const [count] = useState(0);
+ if (count > 1) {
+ useEffect(() => {});
+ }
+ const first = items.length > 0 && useState(items[0]);
+ return ${hint} `);
+ });
+
+ test("pretty with --all", async () => {
+ const { stdout } = await lint(files, "-f", "pretty", "--all");
+ expect(stdout).toContain(`note: ${hint}`);
+ });
+
+ test.each(["stylish", "json", "unix", "github", "junit", "checkstyle", "gitlab", "sarif"])("not %s", async format => {
+ const { stdout } = await lint(files, "-f", format);
+ expect(stdout).toContain("is not used in subsequent statements");
+ expect(stdout).not.toContain("overwritten");
+ });
+
+ test("not with an oxlint config", async () => {
+ const config = JSON.stringify({ rules: { "no-useless-assignment": "error" } });
+ const { stdout } = await lint({ ...files, ".oxlintrc.json": config }, "-f", "default");
+ expect(stdout).toContain("no-useless-assignment");
+ expect(stdout).not.toContain("overwritten");
+ });
+});
diff --git a/test/cli/lint/import-attributes.test.ts b/test/cli/lint/import-attributes.test.ts
new file mode 100644
index 000000000000..a6ca0c8f6d87
--- /dev/null
+++ b/test/cli/lint/import-attributes.test.ts
@@ -0,0 +1,627 @@
+// A `with` clause can be nested in another one: a value in the options of an import type can hold an import type that has
+// options of its own. TypeScript reports values that aren't strings, but every parser accepts them, so rules and plugins see them.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isASAN, isDebug, tempDir } from "harness";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+type Case = {
+ code: string;
+ /** Every node a plugin's listeners are called with, indented by its number of ancestors. */
+ tree: string;
+ /** The names in the options, `with` included. */
+ keys: string[];
+ /** The values in the options. */
+ values: string[];
+};
+
+// `tree` is what oxlint 1.87.0 and ESLint 10.12.0 with @typescript-eslint/parser 8.71.1 both print with the plugin below.
+// `keys` and `values` are what that ESLint reports with the rules below.
+const cases: Record = {
+ "single.ts": {
+ code: `type A = import("./a", { with: { x: "1", y: "2" } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier A
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier x
+ Literal "1"
+ Property
+ Identifier y
+ Literal "2"
+`,
+ keys: ["with", "x", "y"],
+ values: [`"1"`, `"2"`],
+ },
+ "side-by-side.ts": {
+ code: `type A = [import("./a", { with: { x: "1" } }), import("./b", { with: { y: "2" } })];`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier A
+ TSTupleType
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier x
+ Literal "1"
+ TSImportType
+ Literal "./b"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier y
+ Literal "2"
+`,
+ keys: ["with", "x", "with", "y"],
+ values: [`"1"`, `"2"`],
+ },
+ "in-type-arguments.ts": {
+ code: `type A = import("./a", { with: { outer: "1" } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier A
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier outer
+ Literal "1"
+ TSTypeParameterInstantiation
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal "2"
+`,
+ keys: ["with", "outer", "with", "inner"],
+ values: [`"1"`, `"2"`],
+ },
+ "only-in-type-arguments.ts": {
+ code: `type A = import("./a");`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier A
+ TSImportType
+ Literal "./a"
+ TSTypeParameterInstantiation
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal "2"
+`,
+ keys: ["with", "inner"],
+ values: [`"2"`],
+ },
+ "nested.ts": {
+ code: `type N = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier k
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal 1
+ Property
+ Identifier outer
+ Literal 2
+`,
+ keys: ["with", "k", "with", "inner", "outer"],
+ values: [`0 as import("./c", { with: { inner: 1 } })`, `1`, `2`],
+ },
+ "nested-last.ts": {
+ code: `type N = import("./a", { with: { outer: 2, k: 0 as import("./c", { with: { inner: 1 } }) } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier outer
+ Literal 2
+ Property
+ Identifier k
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal 1
+`,
+ keys: ["with", "outer", "k", "with", "inner"],
+ values: [`2`, `0 as import("./c", { with: { inner: 1 } })`, `1`],
+ },
+ "after-an-import-type.ts": {
+ code: `type B = import("./b", { with: { before: "0" } });
+type N = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier B
+ TSImportType
+ Literal "./b"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier before
+ Literal "0"
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier k
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal 1
+ Property
+ Identifier outer
+ Literal 2
+`,
+ keys: ["with", "before", "with", "k", "with", "inner", "outer"],
+ values: [`"0"`, `0 as import("./c", { with: { inner: 1 } })`, `1`, `2`],
+ },
+ "after-an-import.ts": {
+ code: `import data from "./d.json" with { type: "json" };
+type N = import("./a", { with: { k: 0 as import("./c", { with: { inner: 1 } }), outer: 2 } });`,
+ tree: `
+Program
+ ImportDeclaration
+ ImportDefaultSpecifier
+ Identifier data
+ Literal "./d.json"
+ ImportAttribute
+ Identifier type
+ Literal "json"
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier k
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier inner
+ Literal 1
+ Property
+ Identifier outer
+ Literal 2
+`,
+ keys: ["with", "k", "with", "inner", "outer"],
+ values: [`0 as import("./c", { with: { inner: 1 } })`, `1`, `2`],
+ },
+ "two-nested.ts": {
+ code: `const q = 1;
+type T = import("./m", { with: { a: 0 as import("./n", { with: { x: () => q } }), b: 0 as import("./o", { with: { y: () => q } }), c: () => q } });`,
+ tree: `
+Program
+ VariableDeclaration
+ VariableDeclarator
+ Identifier q
+ Literal 1
+ TSTypeAliasDeclaration
+ Identifier T
+ TSImportType
+ Literal "./m"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier a
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./n"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier x
+ ArrowFunctionExpression
+ Identifier q
+ Property
+ Identifier b
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./o"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier y
+ ArrowFunctionExpression
+ Identifier q
+ Property
+ Identifier c
+ ArrowFunctionExpression
+ Identifier q
+`,
+ keys: ["with", "a", "with", "x", "b", "with", "y", "c"],
+ values: [
+ `0 as import("./n", { with: { x: () => q } })`,
+ `() => q`,
+ `0 as import("./o", { with: { y: () => q } })`,
+ `() => q`,
+ `() => q`,
+ ],
+ },
+ "three-deep.ts": {
+ code: `const q = 1;
+type T = import("./m", { with: { a: 0 as import("./n", { with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q } }), c: () => q } });`,
+ tree: `
+Program
+ VariableDeclaration
+ VariableDeclarator
+ Identifier q
+ Literal 1
+ TSTypeAliasDeclaration
+ Identifier T
+ TSImportType
+ Literal "./m"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier a
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./n"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier x
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./o"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier y
+ ArrowFunctionExpression
+ Identifier q
+ Property
+ Identifier x2
+ ArrowFunctionExpression
+ Identifier q
+ Property
+ Identifier c
+ ArrowFunctionExpression
+ Identifier q
+`,
+ keys: ["with", "a", "with", "x", "with", "y", "x2", "c"],
+ values: [
+ `0 as import("./n", { with: { x: 0 as import("./o", { with: { y: () => q } }), x2: () => q } })`,
+ `0 as import("./o", { with: { y: () => q } })`,
+ `() => q`,
+ `() => q`,
+ `() => q`,
+ ],
+ },
+ "in-a-function.ts": {
+ code: `type T = import("./m", { with: { a: () => { let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } }); return u; } } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier T
+ TSImportType
+ Literal "./m"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier a
+ ArrowFunctionExpression
+ BlockStatement
+ VariableDeclaration
+ VariableDeclarator
+ Identifier u
+ TSTypeAnnotation
+ TSImportType
+ Literal "./n"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Identifier b
+ ObjectExpression
+ Property
+ Identifier x
+ Literal 1
+ Property
+ Identifier c
+ ArrowFunctionExpression
+ Literal 2
+ ReturnStatement
+ Identifier u
+`,
+ keys: ["with", "a", "with", "b", "x", "c"],
+ values: [`() => { let u: import("./n", { with: { b: { x: 1 }, c: () => 2 } }); return u; }`, `{ x: 1 }`, `() => 2`],
+ },
+ "quoted.ts": {
+ code: `type N = import("./a", { with: { "k": 0 as import("./c", { with: { "inner": "v1" } }), "outer": "v2" } });`,
+ tree: `
+Program
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Literal "k"
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Literal "inner"
+ Literal "v1"
+ Property
+ Literal "outer"
+ Literal "v2"
+`,
+ keys: ["with", "with"],
+ values: [`0 as import("./c", { with: { "inner": "v1" } })`, `"v1"`, `"v2"`],
+ },
+ "quoted-after-an-import.ts": {
+ code: `import data from "./d.json" with { "type": "json" };
+type N = import("./a", { with: { "k": 0 as import("./c", { with: { "inner": "v1" } }), "outer": "v2" } });`,
+ tree: `
+Program
+ ImportDeclaration
+ ImportDefaultSpecifier
+ Identifier data
+ Literal "./d.json"
+ ImportAttribute
+ Literal "type"
+ Literal "json"
+ TSTypeAliasDeclaration
+ Identifier N
+ TSImportType
+ Literal "./a"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Literal "k"
+ TSAsExpression
+ Literal 0
+ TSImportType
+ Literal "./c"
+ ObjectExpression
+ Property
+ Identifier with
+ ObjectExpression
+ Property
+ Literal "inner"
+ Literal "v1"
+ Property
+ Literal "outer"
+ Literal "v2"
+`,
+ keys: ["with", "with"],
+ values: [`0 as import("./c", { with: { "inner": "v1" } })`, `"v1"`, `"v2"`],
+ },
+};
+
+const files = Object.fromEntries(Object.entries(cases).map(([name, it]) => [name, it.code + "\n"]));
+const names = Object.keys(cases);
+
+// Each thread that runs a plugin starts a VM, which takes seconds in a debug build.
+const timeout = isDebug || isASAN ? 120_000 : 10_000;
+
+type Message = { ruleId: string; message: string; line: number; column: number; endColumn: number };
+
+/** Lints every case in a directory that also has the files in `more`. */
+async function lint(more: Record) {
+ using dir = tempDir("bun-lint-import-attributes", { ...files, ...more });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "--threads", "2", "-f", "json", ...names],
+ env: bunEnv,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "inherit",
+ });
+ const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+ return { stdout, exitCode };
+}
+
+const typescript = `files: ["**/*.ts"], languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } }`;
+
+describe.concurrent("import types with options inside the options of an import type", () => {
+ const plugin = `
+ const depth = node => (node.parent ? depth(node.parent) + 1 : 0);
+ const label = node => (node.type === "Identifier" ? " " + node.name : node.type === "Literal" ? " " + node.raw : "");
+ export default {
+ meta: { name: "tree" },
+ rules: {
+ print: {
+ create(context) {
+ const lines = [];
+ return {
+ "*": node => void lines.push(" ".repeat(depth(node)) + node.type + label(node)),
+ "Program:exit": node => context.report({ node, message: lines.join("\\n") }),
+ };
+ },
+ },
+ },
+ };`;
+ const expected = Object.fromEntries(names.map(name => [name, [cases[name].tree.trim()]]));
+
+ test(
+ "plugins get oxlint's tree with an .oxlintrc.json",
+ async () => {
+ const config = {
+ jsPlugins: ["./plugin.mjs"],
+ categories: { correctness: "off" },
+ rules: { "tree/print": "error" },
+ };
+ const { stdout, exitCode } = await lint({ "plugin.mjs": plugin, ".oxlintrc.json": JSON.stringify(config) });
+ const found: { filename: string; message: string }[] = JSON.parse(stdout).diagnostics;
+ const printed = names.map(name => [name, found.filter(it => it.filename === name).map(it => it.message)]);
+ expect(Object.fromEntries(printed)).toEqual(expected);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "plugins get typescript-eslint's tree with an eslint.config.mjs",
+ async () => {
+ const config = `import tree from "./plugin.mjs";
+ export default [{ ${typescript}, plugins: { tree }, rules: { "tree/print": "error" } }];`;
+ const { stdout, exitCode } = await lint({ "plugin.mjs": plugin, "eslint.config.mjs": config });
+ expect(byFile(stdout, it => it.message)).toEqual(expected);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ /** `show` of each message, by the name of the file. */
+ function byFile(stdout: string, show: (message: Message, name: string) => T) {
+ const results: { filePath: string; messages: Message[] }[] = JSON.parse(stdout);
+ const of = (name: string) =>
+ results.find(it => it.filePath.replaceAll("\\", "/").endsWith("/" + name))?.messages ?? [];
+ return Object.fromEntries(names.map(name => [name, of(name).map(it => show(it, name))]));
+ }
+
+ /** What each rule reports in each file: the text of the reported range. None spans lines. */
+ async function reported(rules: Record) {
+ const config = `export default [{ ${typescript}, rules: ${JSON.stringify(rules)} }];`;
+ const { stdout, exitCode } = await lint({ "eslint.config.mjs": config });
+ const text = (it: Message, name: string) =>
+ files[name].split("\n")[it.line - 1].slice(it.column - 1, it.endColumn - 1);
+ const all = byFile(stdout, (it, name) => ({ rule: it.ruleId, text: text(it, name) }));
+ const of = (rule: string) =>
+ Object.fromEntries(names.map(name => [name, all[name].filter(it => it.rule === rule).map(it => it.text)]));
+ return { of, exitCode };
+ }
+
+ test("rules that read the options of an import type get each name once", async () => {
+ const keys = [...new Set(names.flatMap(name => cases[name].keys))];
+ const { of, exitCode } = await reported({
+ "id-denylist": ["error", ...keys],
+ "id-match": ["error", `^(?!(?:${keys.join("|")})$)`, { properties: true }],
+ "id-length": ["error", { min: 20, exceptionPatterns: ["^[A-Z]$", "^(?:q|u|data)$"] }],
+ });
+ const expected = Object.fromEntries(names.map(name => [name, cases[name].keys]));
+ expect(of("id-denylist")).toEqual(expected);
+ expect(of("id-match")).toEqual(expected);
+ expect(of("id-length")).toEqual(expected);
+ expect(exitCode).toBe(1);
+ });
+
+ test("the way up from a value leads through the options of its own import type", async () => {
+ const value = "TSImportType > ObjectExpression > Property > ObjectExpression > Property > .value";
+ const { of, exitCode } = await reported({ "no-restricted-syntax": ["error", value] });
+ expect(of("no-restricted-syntax")).toEqual(Object.fromEntries(names.map(name => [name, cases[name].values])));
+ expect(exitCode).toBe(1);
+ });
+
+ test("rules that listen to string literals get each quoted string once", async () => {
+ const patterns = [{ pattern: "^.*$", message: "A string.", in: ["strings"] }];
+ const { of, exitCode } = await reported({ "bun/no-restricted-text": ["error", { patterns }] });
+ const quoted = (code: string) => Array.from(code.matchAll(/"([^"]*)"/g), it => it[1]);
+ expect(of("bun/no-restricted-text")).toEqual(Object.fromEntries(names.map(name => [name, quoted(files[name])])));
+ expect(exitCode).toBe(1);
+ });
+});
diff --git a/test/cli/lint/init.test.ts b/test/cli/lint/init.test.ts
new file mode 100644
index 000000000000..bf42d13944b2
--- /dev/null
+++ b/test/cli/lint/init.test.ts
@@ -0,0 +1,323 @@
+// Tests for `bun lint --init` and `bun fmt --init`.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
+import { chmodSync, existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+// Disable AI agent and CI detection regardless of the environment the tests run in.
+const env = {
+ ...bunEnv,
+ AGENT: "0",
+ CLAUDECODE: undefined,
+ REPL_ID: undefined,
+ GITHUB_ACTIONS: undefined,
+ NO_COLOR: "1",
+ FORCE_COLOR: undefined,
+ ESLINT_USE_FLAT_CONFIG: undefined,
+};
+
+type Command = "lint" | "fmt";
+
+async function run(cwd: string, command: Command, ...args: string[]) {
+ await using proc = spawn({ cmd: [bunExe(), command, ...args], env, cwd, stdout: "pipe", stderr: "pipe" });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const sections = {
+ lint: `[lint]
+# typeAware = true # also run the rules that need types
+
+[lint.rules]
+# "no-console" = "warn"
+# "eqeqeq" = ["error", "smart"]
+`,
+ fmt: `[fmt]
+# printWidth = 100
+# semi = false
+`,
+};
+
+const utf16 = (text: string) => Buffer.from("" + text, "utf16le").toString("latin1");
+
+describe.concurrent.each(["lint", "fmt"] as const)("bun %s --init", command => {
+ const section = sections[command];
+ const other = command === "lint" ? "fmt" : "lint";
+
+ test("creates bunfig.toml", async () => {
+ using dir = tempDir("bun-init-section", { "a.js": "a;\n" });
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: `Created bunfig.toml with a [${command}] section\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe(section);
+ expect(readdirSync(String(dir)).sort()).toEqual(["a.js", "bunfig.toml"]);
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: `bunfig.toml already has a [${command}] section\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe(section);
+ });
+
+ // File contents are written as bytes, one latin1 character per byte.
+ test.each<[string, string, string]>([
+ ["a line break at the end", '[install]\nregistry = "a"\n', "\n" + section],
+ ["none", '[install]\nregistry = "a"', "\n\n" + section],
+ ["an empty line at the end", "[install]\n\n", section],
+ ["two", "[install]\n\n\n", section],
+ ["spaces at the end", "[install]\n ", "\n" + section],
+ ["a comment at the end", "# [install]", "\n\n" + section],
+ ["nothing", "", section],
+ ["an empty line", "\n", section],
+ ["a space", " ", "\n" + section],
+ ["CRLF", "[install]\r\nauto = 'auto'\r\n", ("\n" + section).replaceAll("\n", "\r\n")],
+ ["CRLF, and none at the end", "a = 1\r\nb = 2", ("\n\n" + section).replaceAll("\n", "\r\n")],
+ ["CRLF after LF", "a = 1\nb = 2\r\n", "\n" + section],
+ ["a byte order mark", "a = 1\n", "\n" + section],
+ ["UTF-16", utf16("a = 'é'\r\n"), utf16(("\n" + section).replaceAll("\n", "\r\n")).slice(2)],
+ ["more than ASCII", Buffer.from("a = 'é→𝒳'\n").toString("latin1"), "\n" + section],
+ ["the name in a comment", `# [${command}]\n`, "\n" + section],
+ ["the name in a string", `a = """\n[${command}]\n"""\n`, "\n" + section],
+ ["the name in another table", `[install.${command}]\n`, "\n" + section],
+ ["the section of the other command", sections[other], "\n" + section],
+ ])("adds the section to a bunfig.toml with %s", async (_, before, added) => {
+ using dir = tempDir("bun-init-section", { "a.js": "a;\n" });
+ const path = join(String(dir), "bunfig.toml");
+ writeFileSync(path, before, "latin1");
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: `Added [${command}] to bunfig.toml\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(path, "latin1")).toBe(before + added);
+ // The result still parses, and the new section is found.
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: `bunfig.toml already has a [${command}] section\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ });
+
+ const key = command === "lint" ? "typeAware" : "useTabs";
+ test.each([
+ `[${command}]\n`,
+ `[ ${command} ]`,
+ `["${command}"]\n`,
+ `${command}.${key} = true\n`,
+ `${command} = { ${key} = true }\n`,
+ `a = 1\r\n\r\n[${command}] # here\r\n${key} = false`,
+ ...(command === "lint" ? ['[lint.rules]\n"no-var" = "error"\n', "[lint.globals]\n"] : []),
+ ])("leaves a bunfig.toml with %j unchanged", async before => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml": before });
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: `bunfig.toml already has a [${command}] section\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe(before);
+ });
+
+ test.each([
+ [`[${command}\n`, `bunfig.toml:1:${command.length + 2}`],
+ ["a = 1\nb = \n", "bunfig.toml:2:5"],
+ [`[${command}]\nnothing = 1\n`, "bunfig.toml:2:1"],
+ [`${command} = 1\n`, `bunfig.toml:1:${command.length + 4}`],
+ ])("an invalid bunfig.toml is an error and is left unchanged: %j", async (before, place) => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml": before });
+ const result = await run(String(dir), command, "--init");
+ expect(result.stderr).toContain("error: ");
+ expect(result.stderr).toContain(place);
+ expect({ ...result, stderr: "" }).toEqual({ stdout: "", stderr: "", exitCode: 2 });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe(before);
+ });
+
+ // `--config` makes Bun read another file, but `--init` always edits the bunfig.toml in the working directory.
+ test("an invalid bunfig.toml is also an error with `bun --config=`", async () => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml": "a = 1\nb = \n", "other.toml": "" });
+ await using proc = spawn({
+ cmd: [bunExe(), "--config=other.toml", command, "--init"],
+ env,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ expect(stderr).toStartWith("error: Cannot read bunfig.toml: ");
+ expect(stderr).toEndWith("\n at bunfig.toml:2:5\n");
+ expect({ stdout, exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe("a = 1\nb = \n");
+ });
+
+ const cannotBeKeptFromWriting = isWindows || process.getuid?.() === 0;
+
+ test.skipIf(cannotBeKeptFromWriting)("a read-only bunfig.toml is an error", async () => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml": "a = 1\n" });
+ chmodSync(join(String(dir), "bunfig.toml"), 0o444);
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: "",
+ stderr: expect.stringMatching(/^error: Cannot write bunfig\.toml: EACCES: .+\n$/),
+ exitCode: 2,
+ });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe("a = 1\n");
+ expect(readdirSync(String(dir))).toEqual(["bunfig.toml"]);
+ });
+
+ test.skipIf(cannotBeKeptFromWriting)("an unreadable bunfig.toml is an error", async () => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml": "a = 1\n" });
+ chmodSync(join(String(dir), "bunfig.toml"), 0o200);
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: "",
+ stderr: expect.stringMatching(/^error: Cannot read bunfig\.toml: EACCES: .+\n$/),
+ exitCode: 2,
+ });
+ chmodSync(join(String(dir), "bunfig.toml"), 0o644);
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe("a = 1\n");
+ });
+
+ test.skipIf(cannotBeKeptFromWriting)("in a read-only directory, only creating bunfig.toml fails", async () => {
+ using dir = tempDir("bun-init-section", { "none/a.js": "a;\n", "one/bunfig.toml": "a = 1\n" });
+ const [none, one] = [join(String(dir), "none"), join(String(dir), "one")];
+ chmodSync(none, 0o555);
+ chmodSync(one, 0o555);
+ try {
+ expect(await run(none, command, "--init")).toEqual({
+ stdout: "",
+ stderr: expect.stringMatching(/^error: Cannot write bunfig\.toml: EACCES: .+\n$/),
+ exitCode: 2,
+ });
+ // An existing bunfig.toml is still writable.
+ expect(await run(one, command, "--init")).toEqual({
+ stdout: `Added [${command}] to bunfig.toml\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(join(one, "bunfig.toml"), "utf8")).toBe("a = 1\n\n" + section);
+ } finally {
+ chmodSync(none, 0o755);
+ chmodSync(one, 0o755);
+ }
+ });
+
+ test("a directory called bunfig.toml is an error", async () => {
+ using dir = tempDir("bun-init-section", { "bunfig.toml/a.js": "a;\n" });
+ expect(await run(String(dir), command, "--init")).toEqual({
+ stdout: "",
+ stderr: expect.stringMatching(/^error: Cannot read bunfig\.toml: E[A-Z]+: .+\n$/),
+ exitCode: 2,
+ });
+ });
+
+ const flavor = command === "lint" ? "oxlint" : "oxfmt";
+ test(`--flavor=${flavor} isn't saved to bunfig.toml`, async () => {
+ using dir = tempDir("bun-init-section", { "a.js": "a;\n" });
+ expect(await run(String(dir), command, "--init", `--flavor=${flavor}`)).toEqual({
+ stdout: `Created bunfig.toml with a [${command}] section\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ expect(readFileSync(join(String(dir), "bunfig.toml"), "utf8")).toBe(section);
+ expect(readdirSync(String(dir)).sort()).toEqual(["a.js", "bunfig.toml"]);
+ });
+});
+
+describe.concurrent("writes nothing if another tool's config file is in use", () => {
+ const flat = "export default [];\n";
+ test.each<[Command, Record, string[], string]>([
+ ["lint", { "eslint.config.js": flat }, [], "eslint.config.js"],
+ ["lint", { "eslint.config.mjs": flat, "sub/a.js": "" }, ["--cwd", "sub"], "../eslint.config.mjs"],
+ ["lint", { ".eslintrc.json": "{}" }, [], ".eslintrc.json"],
+ ["lint", { "package.json": '{ "eslintConfig": {} }' }, [], "eslintConfig in package.json"],
+ ["lint", { ".oxlintrc.json": "{}" }, [], ".oxlintrc.json"],
+ ["lint", { ".oxlintrc.json": "{}", "sub/a.js": "" }, ["--cwd", "sub"], "../.oxlintrc.json"],
+ ["lint", { "config/mine.mjs": flat }, ["-c", "config/mine.mjs"], "config/mine.mjs"],
+ ["lint", { "eslint.config.js": flat, ".oxlintrc.json": "{}" }, ["--flavor=oxlint"], ".oxlintrc.json"],
+ ["lint", { "eslint.config.js": flat, ".oxlintrc.json": "{}" }, ["--flavor=eslint"], "eslint.config.js"],
+ ["fmt", { ".prettierrc": "{}" }, [], ".prettierrc"],
+ ["fmt", { ".prettierrc.toml": "semi = false\n", "sub/a.js": "" }, ["--cwd", "sub"], "../.prettierrc.toml"],
+ ["fmt", { "package.json": '{ "prettier": {} }' }, [], "prettier in package.json"],
+ ["fmt", { ".oxfmtrc.json": "{}" }, [], ".oxfmtrc.json"],
+ ["fmt", { ".oxfmtrc.jsonc": "{}", "sub/a.js": "" }, ["--cwd", "sub"], "../.oxfmtrc.jsonc"],
+ ["fmt", { "config/mine.json": "{}" }, ["--config", "config/mine.json"], "config/mine.json"],
+ ])("bun %s: %j %j", async (command, files, args, shown) => {
+ using dir = tempDir("bun-init-section", files);
+ expect(await run(String(dir), command, "--init", ...args)).toEqual({
+ stdout: `Using ${shown}. bunfig.toml is not needed.\n`,
+ stderr: "",
+ exitCode: 0,
+ });
+ const found = new Bun.Glob("**").scanSync({ cwd: String(dir), dot: true });
+ expect([...found].map(it => it.replaceAll("\\", "/")).sort()).toEqual(Object.keys(files).sort());
+ });
+
+ test.each<[Command, Record]>([
+ ["lint", { "package.json": '{ "devDependencies": { "eslint": "10.0.0" } }' }],
+ ["lint", { "package.json": '{ "devDependencies": { "oxlint": "1.0.0" } }' }],
+ ["lint", { "eslint.config.js": flat, "args": "--flavor=oxlint" }],
+ ["lint", { "eslint.config.js": flat, "args": "--no-config-lookup" }],
+ ["fmt", { "package.json": '{ "devDependencies": { "prettier": "3.0.0" } }' }],
+ ["fmt", { ".editorconfig": "root = true\n" }],
+ ["fmt", { ".prettierrc": "{}", "args": "--no-config" }],
+ ])("still writes bunfig.toml, bun %s: %j", async (command, { args, ...files }) => {
+ using dir = tempDir("bun-init-section", files);
+ const result = await run(String(dir), command, "--init", ...(args ? [args] : []));
+ expect(result.stdout).toBe(`Created bunfig.toml with a [${command}] section\n`);
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("a broken config file is an error", async () => {
+ using dir = tempDir("bun-init-section", { "eslint.config.js": "throw new Error('no');\n", ".prettierrc": "{" });
+ for (const command of ["lint", "fmt"] as const) {
+ const result = await run(String(dir), command, "--init");
+ expect(result.stderr).toContain(command === "lint" ? "eslint.config.js" : ".prettierrc");
+ expect({ stdout: result.stdout, exitCode: result.exitCode }).toEqual({ stdout: "", exitCode: 2 });
+ }
+ expect(existsSync(join(String(dir), "bunfig.toml"))).toBe(false);
+ });
+});
+
+// Uncomments each commented-out line, one at a time and then all together.
+describe.concurrent("the commented-out lines work when uncommented", () => {
+ const commented = (text: string) => text.split("\n").flatMap((line, at) => (line.startsWith("# ") ? [at] : []));
+ const variants = (text: string) =>
+ [[], ...commented(text).map(at => [at]), commented(text)].map(lines => {
+ const all = text.split("\n");
+ const keys = lines.map(at => all[at].slice(2).split(" ")[0]);
+ return [keys, all.map((line, at) => (lines.includes(at) ? line.slice(2) : line)).join("\n")] as const;
+ });
+
+ const rules: Record = {
+ typeAware: { id: "@typescript-eslint/no-floating-promises", exitCode: 1 },
+ '"no-console"': { id: "no-console", exitCode: 0 },
+ '"eqeqeq"': { id: "eqeqeq", exitCode: 1 },
+ };
+ test.each(variants(sections.lint))("bun lint: %j", async (keys, bunfig) => {
+ using dir = tempDir("bun-init-section", {
+ "a.ts": "export function f(a: number) {\n console.log(a == 1);\n return Promise.resolve();\n}\nf(1);\n",
+ "tsconfig.json": "{}",
+ "bunfig.toml": bunfig,
+ });
+ const result = await run(String(dir), "lint", "-f", "json");
+ const found = JSON.parse(result.stdout).flatMap((it: { messages: { ruleId: string }[] }) =>
+ it.messages.map(it => it.ruleId),
+ );
+ expect(found.sort()).toEqual(keys.map(key => rules[key].id).sort());
+ expect(result.exitCode).toBe(Math.max(0, ...keys.map(key => rules[key].exitCode)));
+ });
+
+ const names = Array.from({ length: 8 }, (_, at) => `argument${at}`);
+ test.each(variants(sections.fmt))("bun fmt: %j", async (keys, bunfig) => {
+ expect(["printWidth", "semi"]).toEqual(expect.arrayContaining([...keys]));
+ using dir = tempDir("bun-init-section", { "a.js": `call(${names.join(",")})\n`, "bunfig.toml": bunfig });
+ const result = await run(String(dir), "fmt", "a.js");
+ const call = keys.includes("printWidth")
+ ? `call(${names.join(", ")})`
+ : `call(\n${names.map(name => ` ${name},\n`).join("")})`;
+ expect(readFileSync(join(String(dir), "a.js"), "utf8")).toBe(call + (keys.includes("semi") ? "\n" : ";\n"));
+ expect(result.exitCode).toBe(0);
+ });
+});
diff --git a/test/cli/lint/js-parsers.test.ts b/test/cli/lint/js-parsers.test.ts
index fe2648ab3cff..9a7925f09710 100644
--- a/test/cli/lint/js-parsers.test.ts
+++ b/test/cli/lint/js-parsers.test.ts
@@ -316,7 +316,7 @@ describe.concurrent("bun lint with processors", () => {
expect(result.exitCode).toBe(1);
// What the processor gives back without a name is for the language.
const whole = await lint(files, ["b.txt"]);
- expect(whole.stderr).toContain(`b.txt returns text in the language "fenced/text".`);
+ expect(whole.stderr).toContain(`b.txt returned code in the language "fenced/text", but`);
expect(whole.exitCode).toBe(2);
},
timeout,
@@ -432,7 +432,7 @@ describe.concurrent("bun lint with languages", () => {
["-f", "json", "--timing", "c.vue"],
);
expect(summary(result.raw)).toMatchInlineSnapshot(`"c.vue: 2:1 lines/no-tabs tab p 8 v c.vue [fix 11,12 " "]"`);
- expect(result.stderr).toContain("the package eslint has linted 1 texts");
+ expect(result.stderr).toContain("the eslint package linted 1 files");
expect(result.exitCode).toBe(1);
},
timeout,
@@ -517,7 +517,7 @@ describe.concurrent("bun lint with languages", () => {
"phase.js: 2:1 lines/no-tabs tab q 2 b phase.js [fix 45,46 " "]
plain.js: 1:1 members/objects Identifier"
`);
- expect(result.stderr).toContain("the package eslint has linted 1 texts");
+ expect(result.stderr).toContain("the eslint package linted 1 files");
expect(result.exitCode).toBe(1);
},
timeout,
@@ -617,6 +617,172 @@ describe.concurrent("bun lint with languages", () => {
timeout,
);
+ describe("config objects from bunfig.toml and the command line work with ESLint 9.0", () => {
+ // A stand-in for ESLint 9.0, which rejects keys it doesn't know. `basePath` in config objects came in 9.30.
+ const strictEslint = {
+ "node_modules/eslint/package.json": JSON.stringify({ name: "eslint", version: "9.0.0", main: "index.js" }),
+ "node_modules/eslint/lib/config/flat-config-array.js": `
+ const path = require("node:path");
+ const known = ["name", "files", "ignores", "settings", "linterOptions", "languageOptions", "processor", "plugins", "rules"];
+ exports.FlatConfigArray = class {
+ #configs = [];
+ constructor(configs, { basePath }) {
+ this.basePath = basePath;
+ this.push(...configs);
+ }
+ push(...configs) {
+ this.#configs.push(...configs);
+ }
+ normalize() {
+ const unknown = this.#configs.flatMap(Object.keys).find(key => !known.includes(key));
+ if (unknown !== undefined) throw new Error(\`Unexpected key "\${unknown}" found.\`);
+ }
+ getConfig(file) {
+ const relative = path.relative(this.basePath, file).replaceAll("\\\\", "/");
+ // Like in ESLint, a negated pattern on its own ignores nothing.
+ const matches = it => (typeof it === "function" ? it(file) : !it.startsWith("!") && new Bun.Glob(it).match(relative));
+ const applies = it => (it.files?.some(matches) ?? true) && !(it.rules && it.ignores?.some(matches));
+ return { rules: Object.assign({}, ...this.#configs.filter(applies).map(it => it.rules)) };
+ }
+ };`,
+ "node_modules/eslint/index.js": `
+ exports.Linter = class {
+ verify(text, configs, { filename }) {
+ const isOn = configs.getConfig(filename).rules["no-console"] !== "off";
+ return isOn ? [{ ruleId: "no-console", severity: 2, message: "from the installed ESLint", line: 1, column: 1 }] : [];
+ }
+ getSuppressedMessages() {
+ return [];
+ }
+ };`,
+ };
+ // The parser is an inline object, so the .vue files need the whole config file plus what Bun adds to it.
+ const config = `
+ const parser = { meta: { name: "vue-eslint-parser" }, parseForESLint() {} };
+ export default [{ rules: { "no-console": "error" } }, { files: ["**/*.vue"], languageOptions: { parser } }];`;
+ // Bun lints the .js files itself and sends the .vue files to the installed ESLint.
+ const tree = Object.fromEntries(
+ ["b", "b.test", "vendor/d.test", "deep/c.test"].flatMap(name => [
+ [`tree/${name}.js`, "console.log(1);\n"],
+ [`tree/${name}.vue`, "\n"],
+ ]),
+ );
+ const bunfig = (prefix: string) => `
+[lint]
+ignorePatterns = ["${prefix}deep/"]
+[[lint.overrides]]
+files = ["*.test.*"]
+excludeFiles = ["${prefix}vendor/**"]
+rules = { "no-console" = "off" }
+`;
+ /** Returns the files under tree/ that have a problem. */
+ async function reported(files: Record, args: string[]) {
+ const { raw, stderr, exitCode } = await lint({ ...strictEslint, ...tree, ...files }, ["-f", "json", ...args]);
+ expect({ stderr: stderr.replace(/^Linted .*$/m, ""), exitCode }).toEqual({ stderr: "", exitCode: 1 });
+ const results: { filePath: string; messages: unknown[] }[] = JSON.parse(raw);
+ const names = results.filter(it => it.messages.length > 0).map(it => it.filePath.replaceAll("\\", "/"));
+ return names.map(it => it.slice(it.indexOf("/tree/") + "/tree/".length)).sort();
+ }
+ const expected = ["b.js", "b.vue", "vendor/d.test.js", "vendor/d.test.vue"];
+
+ test(
+ "from the config file's directory",
+ async () => {
+ const files = { "tree/eslint.config.mjs": config, "tree/bunfig.toml": bunfig("") };
+ expect(await reported(files, ["--cwd", "tree", "."])).toEqual(expected);
+ },
+ timeout,
+ );
+
+ test(
+ "from a subdirectory",
+ async () => {
+ const files = { "eslint.config.mjs": config, "tree/bunfig.toml": bunfig("") };
+ expect(await reported(files, ["--cwd", "tree", "."])).toEqual(expected);
+ },
+ timeout,
+ );
+
+ test(
+ "from a directory above the config file",
+ async () => {
+ const files = { "tree/eslint.config.mjs": config, "bunfig.toml": bunfig("tree/") };
+ expect(await reported(files, ["tree"])).toEqual(expected);
+ },
+ timeout,
+ );
+
+ test(
+ "with --ignore-pattern and --rule from a subdirectory",
+ async () => {
+ const files = { "eslint.config.mjs": config, "tree/bunfig.toml": bunfig("") };
+ const args = ["--cwd", "tree", "--ignore-pattern", "vendor/", "--rule", "no-console: error", "."];
+ expect(await reported(files, args)).toEqual(["b.js", "b.test.js", "b.test.vue", "b.vue"]);
+ },
+ timeout,
+ );
+
+ test(
+ "extglobs and brace ranges select the same files on both sides",
+ async () => {
+ const names = ["a/x", "ab/x", "c/x", "f1", "f3", "f4"];
+ const both = (names: string[]) => names.flatMap(name => [`globs/${name}.js`, `globs/${name}.vue`]);
+ const override = (patterns: string) => ({
+ "eslint.config.mjs": config,
+ ...Object.fromEntries(
+ both(names).map(it => [`tree/${it}`, it.endsWith(".js") ? "console.log(1);\n" : "\n"]),
+ ),
+ "tree/globs/bunfig.toml": `[[lint.overrides]]\n${patterns}\nrules = { "no-console" = "off" }\n`,
+ });
+ const globs = `["+(a|b)/**", "f{1..3}.*"]`;
+ const args = ["--cwd", "tree/globs", "."];
+ expect(await reported(override(`files = ${globs}`), args)).toEqual(both(["c/x", "f4"]));
+ expect(await reported(override(`files = "**/*"\nexcludeFiles = ${globs}`), args)).toEqual(
+ both(["a/x", "ab/x", "f1", "f3"]),
+ );
+ },
+ timeout,
+ );
+
+ test(
+ "negated patterns select the same files on both sides",
+ async () => {
+ const both = (names: string[]) => names.flatMap(name => [`negated/${name}.js`, `negated/${name}.vue`]).sort();
+ const sources = both(["a", "a.test", "src/b", "src/b.test"]).map(it => [
+ `tree/${it}`,
+ it.endsWith(".js") ? "console.log(1);\n" : "\n",
+ ]);
+ const [plain, tests] = [both(["a", "src/b"]), both(["a.test", "src/b.test"])];
+ // The patterns, and the files that still get reported because the override doesn't apply to them.
+ const rows: Record = {
+ 'files = ["*.test.*"]': plain,
+ 'files = ["!**/*.test.*"]': tests,
+ 'files = ["!*.test.*"]': tests,
+ 'files = ["!!*.test.*"]': plain,
+ 'files = ["!src/**"]': both(["src/b", "src/b.test"]),
+ // `!(` starts an extglob group. It isn't a negation.
+ 'files = ["!(a|b).{js,vue}"]': plain,
+ 'files = ["!!(a|b).{js,vue}"]': tests,
+ 'files = ["**/*"]\nexcludeFiles = ["!*.test.*"]': plain,
+ 'files = ["**/*"]\nexcludeFiles = ["!**/*.test.*"]': plain,
+ 'files = ["**/*"]\nexcludeFiles = ["!(a|b).{js,vue}"]': tests,
+ };
+ const run = (patterns: string) => {
+ const bunfig = `[[lint.overrides]]\n${patterns}\nrules = { "no-console" = "off" }\n`;
+ const files = {
+ "eslint.config.mjs": config,
+ ...Object.fromEntries(sources),
+ "tree/negated/bunfig.toml": bunfig,
+ };
+ return reported(files, ["--cwd", "tree/negated", "."]);
+ };
+ const results = await Promise.all(Object.keys(rows).map(run));
+ expect(Object.fromEntries(Object.keys(rows).map((patterns, at) => [patterns, results[at]]))).toEqual(rows);
+ },
+ timeout,
+ );
+ });
+
test(
"files for which the parser is asked for types all go to one engine",
async () => {
@@ -670,7 +836,7 @@ describe.concurrent("bun lint with languages", () => {
const result = await lint(lines, ["-f", "unix", "a.js", "b.txt"]);
expect(result.stdout).toContain("a.js:1:1: Unexpected var, use let or const instead. [Error/no-var]");
expect(result.stderr).toContain(
- `1 file was not linted, only JavaScript and TypeScript can be (1 *.txt): b.txt. The package "eslint" lints other languages, if it is installed`,
+ "1 file was not linted because bun lint only supports JavaScript and TypeScript (1 *.txt): b.txt\n To lint other languages, install eslint: bun add -d eslint",
);
expect(result.exitCode).toBe(2);
},
diff --git a/test/cli/lint/js-plugins.test.ts b/test/cli/lint/js-plugins.test.ts
index ad61394dee51..4526f4a20c3a 100644
--- a/test/cli/lint/js-plugins.test.ts
+++ b/test/cli/lint/js-plugins.test.ts
@@ -4,6 +4,16 @@ import { readFileSync } from "node:fs";
import { availableParallelism } from "node:os";
import { join } from "node:path";
import { endChildren, spawn } from "../children";
+import { cases as callCases } from "./oracle/jsplugins/calls/cases.mjs";
+import { cases as codePathCases, fileOf, isTypeScript } from "./oracle/jsplugins/code-paths/cases.mjs";
+import { cases as oxlintCases } from "./oracle/jsplugins/oxlint/cases.mjs";
+import {
+ cases as scopeCases,
+ fileOf as scopeFileOf,
+ globals as scopeGlobals,
+} from "./oracle/jsplugins/scopes/cases.mjs";
+import { cases as tokenCases, fileOf as tokenFileOf } from "./oracle/jsplugins/tokens/cases.mjs";
+import { cases as treeCases } from "./oracle/jsplugins/trees/cases.mjs";
afterAll(endChildren);
@@ -297,8 +307,9 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
timeout,
);
+ // As with oxlint 1.87: the mark is on the plugin's variable, and oxlint's own rules have their own.
test(
- "a variable that a rule marks as used is used for no-unused-vars",
+ "a variable that a rule marks as used is still unused for oxlint's no-unused-vars",
async () => {
const plugin = `
export default {
@@ -327,6 +338,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
["-f", "unix"],
);
expect(stdout.split("\n").filter(it => it.includes("no-unused-vars"))).toEqual([
+ expect.stringMatching(/a\.js:1:7: .*'a'/),
expect.stringMatching(/a\.js:2:7: .*'b'/),
]);
},
@@ -381,6 +393,63 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
timeout,
);
+ // The two reports are oxlint 1.87's.
+ test(
+ "after runs once for a file, also when another rule's create threw for the file before it",
+ async () => {
+ const hooks = `
+ let calls = 0;
+ export default {
+ meta: { name: "hooks" },
+ rules: {
+ count: {
+ createOnce(context) {
+ return {
+ before() {
+ calls = 0;
+ },
+ after() {
+ context.report({ loc: { line: 1, column: 0 }, message: "after, call " + ++calls });
+ },
+ };
+ },
+ },
+ },
+ };`;
+ const throws = `
+ export default {
+ meta: { name: "throws" },
+ rules: {
+ first: {
+ create(context) {
+ if (context.filename.endsWith("a.js")) throw new Error("thrown in create");
+ return {};
+ },
+ },
+ },
+ };`;
+ const { stdout } = await lint(
+ {
+ ".oxlintrc.json": oxlintrc({
+ jsPlugins: ["./hooks.mjs", "./throws.mjs"],
+ rules: { "hooks/count": "error", "throws/first": "error" },
+ }),
+ "hooks.mjs": hooks,
+ "throws.mjs": throws,
+ "a.js": "a;\n",
+ "b.js": "b;\n",
+ "c.js": "c;\n",
+ },
+ ["-f", "unix", "--threads", "1", "a.js", "b.js", "c.js"],
+ );
+ expect(stdout.split("\n").filter(line => line.includes("after, call"))).toEqual([
+ "b.js:1:1: after, call 1 [Error/hooks(count)]",
+ "c.js:1:1: after, call 1 [Error/hooks(count)]",
+ ]);
+ },
+ timeout,
+ );
+
test(
"a plugin in TypeScript, one from a package, one with an alias",
async () => {
@@ -607,18 +676,19 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
const notes = async (files: Record, more: object, ...flags: string[]) =>
(await lint({ ...files, ".oxlintrc.json": besideNode(more) }, [...flags, "a.js"])).stderr
.split("\n")
- .filter(it => it.startsWith("note: "));
- const advice = `remove it from "jsPlugins" and add "node" to "plugins".`;
+ .filter(it => it.startsWith("note: ") || it.startsWith(" To use "));
test(
"a package, with its version",
async () => {
const jsPlugins = ["eslint-plugin-n"];
expect(await notes(packaged("17.16.2"), { jsPlugins, rules })).toEqual([
- `note: 1 rule of "n" ran in JavaScript (eslint-plugin-n 17.16.2, from "jsPlugins"). bun lint has it built in, as of 18.4.1: ${advice} Reports may differ.`,
+ `note: 1 "n" rule ran in JavaScript from eslint-plugin-n 17.16.2, but bun lint has it built in (version 18.4.1)`,
+ ` To use the built-in rule, remove eslint-plugin-n from "jsPlugins" and add "node" to "plugins". Reports may differ.`,
]);
expect(await notes(packaged("18.4.9"), { jsPlugins, rules }, "-f", "stylish")).toEqual([
- `note: 1 rule of "n" ran in JavaScript (eslint-plugin-n 18.4.9, from "jsPlugins"). bun lint has it built in, as of 18.4.1: ${advice}`,
+ `note: 1 "n" rule ran in JavaScript from eslint-plugin-n 18.4.9, but bun lint has it built in (version 18.4.1)`,
+ ` To use the built-in rule, remove eslint-plugin-n from "jsPlugins" and add "node" to "plugins".`,
]);
},
timeout,
@@ -633,7 +703,8 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
`"no-new-require": rule("new"), "no-sync": rule("sync"), "only-there"`,
);
expect(await notes({ ...calledN, "n.js": plugin }, { rules: { ...rules, ...more } })).toEqual([
- `note: 2 rules of "n" ran in JavaScript (./n.js, from "jsPlugins"). bun lint has them built in, as of 18.4.1: write them "node/.." and add "node" to "plugins". Keep it for the other 1. Reports may differ.`,
+ `note: 2 "n" rules ran in JavaScript from ./n.js, but bun lint has them built in (version 18.4.1)`,
+ ` To use the built-in rules, rename them to "node/.." and add "node" to "plugins". Keep ./n.js for the other rule. Reports may differ.`,
]);
},
timeout,
@@ -732,6 +803,97 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
timeout,
);
+ // ESLint 10.12.0 keeps these reports too. It prints `null` in JSON and 0 in `stylish`. Only its order differs, because it sorts
+ // with NaN.
+ test.concurrent(
+ "a report whose line or column isn't a number is kept",
+ async () => {
+ const files = {
+ "eslint.config.mjs": `
+ const locs = [{ line: 3 }, 5, { line: "1", column: "2" }, { start: { line: 3 } }, { column: 2 }];
+ const rule = {
+ create: context => ({
+ Program(node) {
+ locs.forEach((loc, i) => context.report({ node, loc, message: "loc " + i }));
+ context.report({ node, message: "last" });
+ },
+ }),
+ };
+ export default [{ plugins: { demo: { rules: { locs: rule } } }, rules: { "demo/locs": "error" } }];`,
+ "a.js": "a;\nb;\nc;\n",
+ };
+ const [json, stylish] = await Promise.all([
+ lint(files, ["-f", "json", "a.js"]),
+ lint(files, ["-f", "stylish", "a.js"]),
+ ]);
+ const places = JSON.parse(json.raw)[0].messages.map((it: any) => [it.message, it.line, it.column]);
+ expect(places).toEqual([
+ ["loc 1", null, null],
+ ["loc 2", null, null],
+ ["loc 4", null, 3],
+ ["last", 1, 1],
+ ["loc 0", 3, null],
+ ["loc 3", 3, null],
+ ]);
+ expect(
+ stylish.stdout
+ .split("\n")
+ .filter(line => line.includes("demo/locs"))
+ .map(line => line.trim().split(/\s+/)[0]),
+ ).toEqual(["0:0", "0:0", "0:3", "1:1", "3:0", "3:0"]);
+ expect({ json: json.exitCode, stylish: stylish.exitCode }).toEqual({ json: 1, stylish: 1 });
+ },
+ timeout,
+ );
+
+ // As under ESLint 10.12.0.
+ test.concurrent(
+ "`-f json` has the `data` of a suggestion that has a `desc`",
+ async () => {
+ const files = {
+ "eslint.config.mjs": `
+ const rule = {
+ meta: { hasSuggestions: true },
+ create: context => ({
+ Program(node) {
+ context.report({ node, message: "bad", suggest: [{ desc: "Use {{name}}.", data: { name: "b" }, fix: fixer => fixer.replaceText(node, "b") }] });
+ },
+ }),
+ };
+ export default [{ plugins: { demo: { rules: { suggests: rule } } }, rules: { "demo/suggests": "error" } }];`,
+ "a.js": "a;\n",
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js"]);
+ expect(JSON.parse(raw)[0].messages[0].suggestions).toEqual([
+ { desc: "Use b.", data: { name: "b" }, fix: { range: [0, 3], text: "b" } },
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // As under ESLint 10.12.0 with eslint-plugin-react-hooks 7.1.1, which passes `desc` and `fix` only.
+ test.concurrent(
+ "`-f json` has no `data` for a built-in rule's suggestion that only has a `desc` upstream",
+ async () => {
+ const files = {
+ "eslint.config.mjs": `export default [{
+ files: ["**/*.jsx"],
+ languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } },
+ plugins: { "react-hooks": { meta: { name: "eslint-plugin-react-hooks" } } },
+ rules: { "react-hooks/exhaustive-deps": "error" },
+ }];`,
+ "a.jsx": `import { useEffect } from "react";\nexport function A({ params }) {\n useEffect(() => { console.log(params); }, []);\n return null;\n}\n`,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.jsx"]);
+ expect(JSON.parse(raw)[0].messages[0].suggestions).toEqual([
+ { desc: "Update the dependencies array to be: [params]", fix: { range: [111, 113], text: "[params]" } },
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
// ESLint 10.12.0 and oxlint 1.87.0 call `fix`, and the `fix` of each suggestion, when a problem is reported, whoever reads what
// they return.
describe("a rule is asked for its fixes whatever is printed", () => {
@@ -1211,7 +1373,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
`);
// What the process prints that evaluates the file is not shown.
expect(stderr).not.toContain("The configuration file runs.");
- expect(stderr).toMatch(/JavaScript: [12] engines, which have loaded [12] modules, /);
+ expect(stderr).toMatch(/JavaScript: [12] engines loaded [12] modules, /);
expect(exitCode).toBe(1);
},
timeout,
@@ -1244,7 +1406,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
const counts = JSON.parse(raw).map((it: any) => it.messages.length);
expect(counts).toEqual([2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1]);
expect(stderr.split("The configuration file runs.").length - 1).toBe(1);
- expect(stderr).toContain(`with the whole configuration file, which alone has the plugin "inline"`);
+ expect(stderr).toContain(`; loaded the whole config file for the plugin "inline"`);
expect(exitCode).toBe(1);
},
timeout,
@@ -1357,7 +1519,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
3 problems"
`);
- expect(stderr).toContain(`with the whole configuration file, which alone has what is in "settings"`);
+ expect(stderr).toContain(`; loaded the whole config file for "settings"`);
expect(exitCode).toBe(1);
},
timeout,
@@ -1525,7 +1687,10 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
// One comment: thousands of them take a debug build minutes.
const text = `foo;\n/*${Buffer.alloc(size, "x")}*/\n`;
for (let i = 0; i < count; i++) files[`src/${i}.${extension}`] = text;
- const { stdout, stderr, exitCode } = await lint(files, ["-f", "unix", "--timing", "--threads", threads, "src"]);
+ // How many engines fit depends on how much memory is free, which is up to the machine that runs this.
+ const variables = { BUN_LINT_MEMORY: String(64 * 2 ** 30) };
+ const args = ["-f", "unix", "--timing", "--threads", threads, "src"];
+ const { stdout, stderr, exitCode } = await lint(files, args, [], variables);
expect(exitCode).toBe(1);
return { stdout, engines: Number(/JavaScript: (\d+) engines/.exec(stderr)?.[1]) };
};
@@ -1641,7 +1806,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
4 problems"
`);
expect(stderr).toContain(
- "2 rules in JavaScript did not run, only the built-in rules have types: typed/at-once, typed/later",
+ "2 rules did not run because rules that run in JavaScript cannot use type information: typed/at-once, typed/later",
);
expect(stderr).not.toContain("You have used a rule");
expect(exitCode).toBe(2);
@@ -1812,7 +1977,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
["-f", "unix", "--timing", "a.js"],
);
expect(stdout).toContain("/a.js:1:1: one [Error/own/one]");
- expect(stderr).toContain("JavaScript: 1 engines, which have loaded 1 modules");
+ expect(stderr).toContain("JavaScript: 1 engines loaded 1 modules");
expect(exitCode).toBe(1);
},
timeout,
@@ -1829,7 +1994,7 @@ describe.concurrent("bun lint with plugins in JavaScript", () => {
},
["a.js"],
);
- expect(stdout + stderr).toContain("./plugin.mjs\n A promise is not settled, and nothing is left to wait for.");
+ expect(stdout + stderr).toContain("./plugin.mjs\n A promise never settled, and nothing is left to wait for.");
expect(exitCode).toBe(1);
},
timeout,
@@ -2211,7 +2376,7 @@ export default {
{ "eslint.config.mjs": `export default [{ rules: { "no-debugger": "error" } }];`, "a.js": "debugger;\n" },
["--timing", "a.js"],
);
- expect(stderr).toContain("JavaScript: 0 engines, which have loaded 0 modules, 0.0 MB of source, in 0.0ms");
+ expect(stderr).toContain("JavaScript: 0 engines loaded 0 modules, 0.0 MB of source, in 0.0ms");
expect(exitCode).toBe(1);
},
timeout,
@@ -2371,7 +2536,7 @@ export default {
);
expect(exitCode).toBe(1);
const seen = raw.split(":1:1: seen [Error/own/grows]").length - 1;
- return { seen, freed: Number(/, freed to stay in the memory: (\d+)/.exec(stderr)?.[1] ?? 0) };
+ return { seen, freed: Number(/, engines freed to save memory: (\d+)/.exec(stderr)?.[1] ?? 0) };
};
const more = Math.max(40, availableParallelism() + 1);
const [one, some, many] = await Promise.all([run(1, "8"), run(96, "8"), run(more, "0")]);
@@ -2626,3 +2791,2166 @@ export default {
timeout,
);
});
+
+describe.concurrent("context.report() in JavaScript plugins", () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "report");
+
+ test(
+ "messages, locations, merged fixes, suggestions and what bad input throws match ESLint",
+ async () => {
+ const { text } = require(join(oracle, "plugin.cjs"));
+ const files = {
+ "plugin.cjs": readFileSync(join(oracle, "plugin.cjs"), "utf8"),
+ "eslint.config.cjs": `const demo = require("./plugin.cjs");
+ module.exports = [{ plugins: { demo }, rules: Object.fromEntries(Object.keys(demo.rules).map(name => ["demo/" + name, "error"])) }];`,
+ "a.js": text,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js"]);
+ // Recorded with ESLint 10.12.0 by record.mjs in that directory.
+ expect(JSON.parse(raw)[0].messages).toEqual(JSON.parse(readFileSync(join(oracle, "expected.json"), "utf8")));
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "a context, a `report` and a fixer kept from an earlier file work on the current file",
+ async () => {
+ const files = {
+ "eslint.config.mjs": `
+ const kept = [];
+ const say = f => { try { return JSON.stringify(f()) ?? "undefined"; } catch (error) { return error.constructor.name; } };
+ process.on("exit", () => {
+ for (const it of kept) console.error("at exit:", say(() => it.report({ node: it.node, message: "late", fix: fixer => fixer.remove(it.node) })), say(() => it.fixer.remove(it.node)));
+ });
+ const rule = {
+ meta: { fixable: "code" },
+ create(context) {
+ return {
+ Program(node) {
+ for (const it of kept) {
+ it.context.report({ node: it.node, message: "the node of " + it.name });
+ it.report({ node: { ...it.node.body[0] }, message: "a copy from " + it.name, fix: fixer => [fixer.insertTextBefore(it.node.body[0], "("), fixer.insertTextAfter(it.node.body[0], ")")] });
+ context.report({ node, message: "the fixer of " + it.name + ": " + say(() => it.fixer.replaceText(it.node.body[0], "x")) });
+ }
+ let fixer;
+ context.report({ node, message: "first", fix: it => ((fixer = it), null) });
+ kept.push({ name: context.filename.slice(-4), context, report: context.report, fixer, node });
+ // Nobody is left to hear this, as in ESLint.
+ Promise.resolve().then(() => context.report({ loc: { line: 1, column: 1 }, message: "between files" }));
+ },
+ };
+ },
+ };
+ export default [{ plugins: { demo: { rules: { keeps: rule } } }, rules: { "demo/keeps": "error" } }];`,
+ // The larger file is linted first.
+ "a.js": "first;\nfile;\nlonger;\n",
+ "b.js": "b;",
+ };
+ const { raw, stderr, exitCode } = await lint(files, ["--threads", "1", "-f", "json", "a.js", "b.js"]);
+ const said = JSON.parse(raw).map((result: any) =>
+ result.messages.map((it: any) => [it.message, it.line, it.column, it.endLine, it.endColumn, it.fix]),
+ );
+ expect(said).toEqual([
+ [["first", 1, 1, 4, 1, undefined]],
+ [
+ ["the node of a.js", 1, 1, 4, 1, undefined],
+ // The text between the two insertions is that of b.js.
+ ["a copy from a.js", 1, 1, 1, 7, { range: [0, 6], text: "(b;)" }],
+ ['the fixer of a.js: {"range":[0,6],"text":"x"}', 1, 1, 1, 3, undefined],
+ ["first", 1, 1, 1, 3, undefined],
+ ],
+ ]);
+ expect(stderr.split("\n").filter(line => line.startsWith("at exit:"))).toEqual([
+ 'at exit: undefined {"range":[0,21],"text":""}',
+ 'at exit: undefined {"range":[0,2],"text":""}',
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+});
+
+// Recorded with ESLint 10.12.0 and @typescript-eslint/parser 8.71.1 by record.mjs in that directory.
+test.concurrent(
+ "the listeners of several rules are called in ESLint's order, for types, selectors, exits and code path events",
+ async () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "calls");
+ const expected: Record = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+ const config = `const log = require("./log.cjs");
+ module.exports = [
+ { files: ${JSON.stringify(Object.keys(callCases))}, plugins: { log }, rules: { "log/a": "error", "log/b": "error", "log/c": "error" } },
+ ...["module", "script"].map(sourceType => ({
+ files: [sourceType + ".js"],
+ languageOptions: { sourceType, parserOptions: { ecmaFeatures: { jsx: true } } },
+ })),
+ { files: ["types.ts"], languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } } },
+ ];`;
+ const files = {
+ "log.cjs": readFileSync(join(oracle, "log.cjs"), "utf8"),
+ "eslint.config.cjs": config,
+ ...callCases,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", ...Object.keys(callCases)]);
+ const results: { filePath: string; messages: { message: string }[] }[] = JSON.parse(raw);
+ for (const file of Object.keys(callCases)) {
+ const result = results.find(it => it.filePath.replaceAll("\\", "/").endsWith(`/${file}`));
+ expect({ file, calls: result?.messages.map(it => it.message.split("\n")) }).toEqual({
+ file,
+ calls: [expected[file].split("\n")],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+);
+
+describe.concurrent("the nodes in JavaScript plugins", () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "trees");
+ const dump = readFileSync(join(oracle, "dump.cjs"), "utf8");
+ // Recorded with ESLint 10.12.0, @typescript-eslint/parser 8.71.1 and oxlint 1.87.0 by record.mjs in that directory.
+ const expected: Record<"eslint" | "oxlint", Record> = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+
+ test(
+ "they have the properties, the order, the attributes and the classes that espree and typescript-estree give them",
+ async () => {
+ const config = `const dump = require("./dump.cjs");
+ module.exports = [
+ { files: ${JSON.stringify(Object.keys(treeCases))}, plugins: { dump }, rules: { "dump/tree": "error" } },
+ ...["module", "script"].map(sourceType => ({
+ files: [sourceType + "*.js"],
+ languageOptions: { sourceType, parserOptions: { ecmaFeatures: { jsx: true } } },
+ })),
+ { files: ["*.ts", "*.tsx"], languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } } },
+ ];`;
+ const { raw, exitCode } = await lint({ "dump.cjs": dump, "eslint.config.cjs": config, ...treeCases }, [
+ "-f",
+ "json",
+ ...Object.keys(treeCases),
+ ]);
+ const results: { filePath: string; messages: { message: string }[] }[] = JSON.parse(raw);
+ // One node to a line, so that a difference can be read.
+ const lines = (tree: string | undefined) => tree?.split(/(?<=[[ ])(?=(?:Node )?\{ type: )/);
+ for (const file of Object.keys(treeCases)) {
+ const result = results.find(it => it.filePath.replaceAll("\\", "/").endsWith(`/${file}`));
+ expect({ file, trees: result?.messages.map(it => lines(it.message)) }).toEqual({
+ file,
+ trees: [lines(expected.eslint[file])],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "they are laid out as in oxlint with its configuration",
+ async () => {
+ const config = { ignorePatterns: ["dump.cjs"], jsPlugins: ["./dump.cjs"], rules: { "dump/shapes": "error" } };
+ const files = Object.keys(expected.oxlint);
+ const { raw, exitCode } = await lint({ "dump.cjs": dump, ".oxlintrc.json": oxlintrc(config), ...treeCases }, [
+ "-f",
+ "json",
+ ...files,
+ ]);
+ const diagnostics: { filename: string; message: string }[] = JSON.parse(raw).diagnostics;
+ for (const file of files) {
+ const found = diagnostics.filter(it => it.filename.replaceAll("\\", "/") === file);
+ expect({ file, shapes: found.map(it => it.message.split("\n")) }).toEqual({
+ file,
+ shapes: [expected.oxlint[file].split("\n")],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+});
+
+describe.concurrent("scopes in JavaScript plugins", () => {
+ // Recorded with ESLint 10.12.0 and @typescript-eslint/parser 8.71.1 by record.mjs in that directory.
+ test(
+ "scopes, variables, definitions and references match eslint-scope and typescript-eslint's scope manager",
+ async () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "scopes");
+ const expected: Record = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+ const config = `const scopes = require("./dump.cjs");
+ const globals = ${JSON.stringify(scopeGlobals)};
+ module.exports = [
+ { plugins: { scopes } },
+ { files: ["scopes-first/**"], rules: { "scopes/all": "error" } },
+ { files: ["references-first/**"], rules: { "scopes/references-first": "error" } },
+ ...["module", "script", "commonjs"].map(sourceType => ({
+ files: ["**/" + sourceType + "/*.js"],
+ languageOptions: { sourceType, parserOptions: { ecmaFeatures: { jsx: true } }, globals },
+ })),
+ {
+ files: ["**/*.ts", "**/*.tsx"],
+ languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } }, globals },
+ },
+ ];`;
+ const files = {
+ "dump.cjs": readFileSync(join(oracle, "dump.cjs"), "utf8"),
+ "eslint.config.cjs": config,
+ ...Object.fromEntries(scopeCases.map(it => [scopeFileOf(it), it.code])),
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const results: { filePath: string; messages: { message: string }[] }[] = JSON.parse(raw);
+ for (const it of scopeCases) {
+ const file = scopeFileOf(it);
+ const result = results.find(result => result.filePath.replaceAll("\\", "/").endsWith(`/${file}`));
+ expect({ file, lines: result?.messages.map(message => message.message.split("\n")) }).toEqual({
+ file,
+ lines: [expected[file].split("\n")],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // ESLint 8 counts them among the configured globals, and its `addDeclaredGlobals` treats them the same.
+ test(
+ "the global scope has the variables of /* eslint-env */ comments with an ESLint 8 configuration",
+ async () => {
+ const plugin = `const show = it =>
+ it && [it.name, it.writeable, it.eslintImplicitGlobalSetting, it.eslintExplicitGlobal, it.references.length].join(" ");
+ module.exports = { rules: { globals: { create: context => ({
+ Program(node) {
+ const scope = context.sourceCode.scopeManager.globalScope;
+ const found = scope.references.map(it => String(show(it.resolved)));
+ const asked = ["document", "process", "it"].map(name => scope.set.has(name) + " " + show(scope.set.get(name) ?? null));
+ const through = scope.through.map(it => it.identifier.name).join(" ");
+ context.report({ node, message: [...found, ...asked, through].join("; ") });
+ },
+ }) } } };`;
+ const files = {
+ ".eslintrc.json": JSON.stringify({ root: true, plugins: ["foo"], rules: { "foo/globals": "error" } }),
+ "node_modules/eslint-plugin-foo/package.json": `{ "name": "eslint-plugin-foo", "main": "index.js" }`,
+ "node_modules/eslint-plugin-foo/index.js": plugin,
+ "a.js": "/* eslint-env browser, mocha */\n/* global it:writable */\nwindow; it; process; location = 1;\n",
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js"]);
+ expect(JSON.parse(raw)[0].messages.map((it: { message: string }) => it.message.split("; "))).toEqual([
+ [
+ "window false readonly false 1",
+ "it true readonly true 1",
+ "null",
+ "location true writable false 1",
+ "true document false readonly false 0",
+ "false null",
+ "true it true readonly true 1",
+ "process",
+ ],
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // The messages under ESLint 10.12.0.
+ test(
+ "a global variable has what ESLint sets on it when a rule gets to it through reference.resolved first",
+ async () => {
+ const config = `const show = it =>
+ it &&
+ [
+ it.name,
+ it.writeable,
+ it.eslintImplicitGlobalSetting,
+ it.eslintExplicitGlobal,
+ it.eslintExplicitGlobalComments?.map(comment => comment.value),
+ it.scope.type,
+ ]
+ .map(part => JSON.stringify(part) ?? "undefined")
+ .join(" ");
+ const rule = {
+ create: context => ({
+ Identifier(node) {
+ const reference = context.sourceCode.getScope(node).references.find(it => it.identifier === node);
+ if (reference) context.report({ node, message: String(show(reference.resolved)) });
+ },
+ }),
+ };
+ module.exports = [
+ {
+ plugins: { p: { rules: { rule } } },
+ languageOptions: { globals: { foo: "readonly", bar: "writable" } },
+ rules: { "p/rule": "error" },
+ },
+ ];`;
+ const code = `/* global fromComment:writable */\nfoo(); bar = 1; JSON.parse(""); fromComment = 2; undeclared();\n`;
+ const { raw, exitCode } = await lint({ "eslint.config.cjs": config, "a.js": code }, ["-f", "json", "a.js"]);
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results[0].messages.map(it => it.message)).toEqual([
+ `"foo" false "readonly" false undefined "global"`,
+ `"bar" true "writable" false undefined "global"`,
+ `"JSON" false "readonly" false undefined "global"`,
+ `"fromComment" true undefined true [" global fromComment:writable "] "global"`,
+ "null",
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // From then on JavaScriptCore stores every array of the realm in another way.
+ // What is expected is what ESLint 10.12.0 with @typescript-eslint/parser 8.71.1 reports.
+ test(
+ "what the libraries of TypeScript define is in the global scope whichever way a rule looks at it first",
+ async () => {
+ const config = `
+ const flagsOf = (object, key) => {
+ const it = Object.getOwnPropertyDescriptor(object, key);
+ return ["value" in it ? "value" : "accessor", it.writable, it.enumerable, it.configurable].join(" ");
+ };
+ const operations = {
+ descriptor: it => [flagsOf(it, "variables"), Object.getOwnPropertyDescriptor(it, "variables").value.length, it.variables === it.variables],
+ keys: it => Object.keys(it).join(),
+ one: it => {
+ const [array, record] = [it.set.get("Array"), it.set.get("Record")];
+ return [it.variables.includes(array), record === it.set.get("Record"), it.variables.includes(record), it.set.size === it.variables.length];
+ },
+ names: it => ["NotThere", "Promise", "const", "__proto__", 1, "\\u00e9"].map(name => [it.set.has(name), it.set.get(name)?.name]),
+ frozen: it => [Object.freeze(it).variables.length, flagsOf(it, "variables")],
+ assigned: it => [(it.variables = [1]), flagsOf(it, "variables"), it.set.size],
+ deleted: it => [delete it.variables, it.variables, "variables" in it, it.set.size],
+ spread: it => [{ ...it }.variables === it.variables, it.variables.length],
+ inherited: it => [Object.create(it).variables === it.variables, it.variables.length],
+ order: it => [[...it.set.keys()].slice(0, 4), [...it.set.keys()].join() === it.variables.map(it => it.name).join(), it.variables.at(-1).name],
+ iterated: it => {
+ let count = 0;
+ for (const [name, variable] of it.set) count += variable.name === name;
+ it.set.forEach(() => count++);
+ return [count, [...it.set.values()].length, [...it.set.entries()].length];
+ },
+ quiet: it => {
+ const variable = it.set.get("WeakRef");
+ const { defs, references, identifiers, isTypeVariable, isValueVariable, eslintImplicitGlobalSetting, writeable } = variable;
+ const values = [defs, references, identifiers, isTypeVariable, isValueVariable, eslintImplicitGlobalSetting, writeable];
+ return [Object.keys(variable).join(), variable.constructor.name, variable.scope === it, ...values];
+ },
+ };
+ const rule = name => ({
+ create: context => ({
+ Program(node) {
+ context.report({ node, message: name + " " + JSON.stringify(operations[name](context.sourceCode.scopeManager.globalScope)) });
+ },
+ }),
+ });
+ const names = Object.keys(operations);
+ const own = { rules: Object.fromEntries(names.map(name => [name, rule(name)])) };
+ const languageOptions = { parser: { meta: { name: "typescript-eslint/parser" } } };
+ module.exports = names.map(name => ({ files: [name + ".ts"], plugins: { own }, rules: { ["own/" + name]: "error" }, languageOptions }));`;
+ const names = "descriptor keys one names frozen assigned deleted spread inherited order iterated quiet".split(
+ " ",
+ );
+ const code = "let a: Promise> = Array;\n";
+ const { raw, exitCode } = await lint(
+ { "eslint.config.cjs": config, ...Object.fromEntries(names.map(name => [`${name}.ts`, code])) },
+ ["-f", "json", ...names.map(name => `${name}.ts`)],
+ );
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results.flatMap(it => it.messages.map(it => it.message)).sort()).toEqual([
+ `assigned [[1],"value true true true",217]`,
+ `deleted [true,null,false,217]`,
+ `descriptor ["value true true true",217,true]`,
+ `frozen [217,"value false true false"]`,
+ `inherited [true,217]`,
+ `iterated [434,217,217]`,
+ `keys "$id,block,childScopes,functionExpressionScope,isStrict,leftToResolve,references,set,through,type,upper,variables,variableScope,implicit"`,
+ `names [[false,null],[true,"Promise"],[true,"const"],[false,null],[false,null],[false,null]]`,
+ `one [true,true,true,true]`,
+ `order [["Intl","Map","WeakMap","SymbolConstructor"],true,"globalThis"]`,
+ `quiet ["$id,defs,eslintUsed,identifiers,name,references,scope,writeable,eslintExplicitGlobal,eslintImplicitGlobalSetting,eslintExplicitGlobalComments,isTypeVariable,isValueVariable","ImplicitLibVariable",true,[],[],[],true,true,"readonly",false]`,
+ `spread [true,217]`,
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // What is expected is what ESLint 10.12.0 with @typescript-eslint/parser 8.71.1 reports.
+ test(
+ "what a plugin writes to the global scope and its variables stays, and nothing of it is trusted",
+ async () => {
+ const config = `
+ const summary = it => [it.variables.length, it.set.size, typeof it.set.get("Array"), it.set.has("mine"), it.set.has("Promise")];
+ const put = value => it => {
+ it.set.set("Array", value);
+ it.set.set("mine", { name: "mine" });
+ return summary(it);
+ };
+ const operations = {
+ putNothing: it => (it.set.set("mine", { name: "mine" }), summary(it)),
+ putNumber: put(1),
+ putNull: it => [...put(null)(it), it.set.get("Array")],
+ putString: put("x"),
+ putObject: put({}),
+ putUndefined: it => [...put(undefined)(it), it.set.has("Array")],
+ putLookalike: it => put(Object.create(Object.getPrototypeOf(it.set.get("WeakRef"))))(it),
+ putThenKeys: it => (it.set.set("Array", 1), it.set.set("mine", 2), [[...it.set.keys()].indexOf("Array") === it.variables.findIndex(it => it.name === "Array"), [...it.set.keys()].at(-1)]),
+ deleted: it => [it.set.delete("Array"), it.set.delete("NotThere"), ...summary(it), it.variables.some(it => it.name === "Array")],
+ deletedAndPutBack: it => { const array = it.set.get("Array"); it.set.delete("Array"); it.set.set("Array", array); return [...summary(it), [...it.set.keys()].at(-1)]; },
+ cleared: it => (it.set.clear(), summary(it)),
+ clearedAfter: it => { const before = it.variables.length; it.set.clear(); return [before, ...summary(it)]; },
+ frozenSet: it => (Object.freeze(it.set), summary(it)),
+ ownGet: it => { it.set.get = () => 1; return summary(it); },
+ ownSet: it => { it.set.set = () => 1; it.set.set("mine", 2); return summary(it); },
+ calledOnMap: it => { Map.prototype.set.call(it.set, "Array", 1); Map.prototype.set.call(it.set, "mine", 2); return summary(it); },
+ noLength: it => { it.variables.length = 0; return summary(it); },
+ noLengthAfter: it => { const before = it.set.size; it.variables.length = 0; return [before, ...summary(it)]; },
+ assignedThenSet: it => { it.variables = []; return summary(it); },
+ pushed: it => { it.variables.push(1); return summary(it); },
+ changedVariable: it => { const array = it.set.get("Array"); delete array.name; array.extra = 1; Object.setPrototypeOf(array, null); return [...summary(it), it.set.get("Array") === array, it.variables.includes(array)]; },
+ changedQuiet: it => { const quiet = it.set.get("WeakRef"); delete quiet.name; Object.setPrototypeOf(quiet, Object.prototype); return [...summary(it), it.set.get("WeakRef") === quiet, it.variables.includes(quiet)]; },
+ changedOther: it => { const other = it.set.get("globalThis"); delete other.name; Object.setPrototypeOf(other, Object.getPrototypeOf(it.set.get("WeakRef"))); return [...summary(it), it.set.get("globalThis") === other, it.variables.at(-1) === other]; },
+ oddNames: it => [1, null, undefined, {}, Symbol.iterator, "", "é", "a".repeat(300)].map(name => [it.set.get(name) === undefined, it.set.has(name)]),
+ copied: it => [new Map(it.set).size, [...it.set].length, Array.from(it.set.values()).length],
+ };
+ const rule = name => ({
+ create: context => ({
+ Program(node) {
+ context.report({ node, message: name + " " + JSON.stringify(operations[name](context.sourceCode.scopeManager.globalScope)) });
+ },
+ }),
+ });
+ const names = Object.keys(operations);
+ const own = { rules: Object.fromEntries(names.map(name => [name, rule(name)])) };
+ const languageOptions = { parser: { meta: { name: "typescript-eslint/parser" } } };
+ module.exports = names.map(name => ({ files: [name + ".ts"], plugins: { own }, rules: { ["own/" + name]: "error" }, languageOptions }));`;
+ const expected = [
+ `assignedThenSet [0,217,"object",false,true]`,
+ `calledOnMap [217,218,"number",true,true]`,
+ `changedOther [217,217,"object",false,true,true,true]`,
+ `changedQuiet [217,217,"object",false,true,true,true]`,
+ `changedVariable [217,217,"object",false,true,true,true]`,
+ `cleared [217,0,"undefined",false,false]`,
+ `clearedAfter [217,217,0,"undefined",false,false]`,
+ `copied [217,217,217]`,
+ `deleted [true,false,217,216,"undefined",false,true,true]`,
+ `deletedAndPutBack [217,217,"object",false,true,"Array"]`,
+ `frozenSet [217,217,"object",false,true]`,
+ `noLength [0,217,"object",false,true]`,
+ `noLengthAfter [217,0,217,"object",false,true]`,
+ `oddNames [[true,false],[true,false],[true,false],[true,false],[true,false],[true,false],[true,false],[true,false]]`,
+ `ownGet [217,217,"number",false,true]`,
+ `ownSet [217,217,"object",false,true]`,
+ `pushed [218,217,"object",false,true]`,
+ `putLookalike [217,218,"object",true,true]`,
+ `putNothing [217,218,"object",true,true]`,
+ `putNull [217,218,"object",true,true,null]`,
+ `putNumber [217,218,"number",true,true]`,
+ `putObject [217,218,"object",true,true]`,
+ `putString [217,218,"string",true,true]`,
+ `putThenKeys [true,"mine"]`,
+ `putUndefined [217,218,"undefined",true,true,true]`,
+ ];
+ const names = expected.map(it => it.slice(0, it.indexOf(" ")));
+ const code = "let a: Promise> = Array;\n";
+ const { raw, exitCode } = await lint(
+ { "eslint.config.cjs": config, ...Object.fromEntries(names.map(name => [`${name}.ts`, code])) },
+ ["-f", "json", ...names.map(name => `${name}.ts`)],
+ );
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results.flatMap(it => it.messages.map(it => it.message)).sort()).toEqual(expected);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // The ids are what oxlint 1.87.0 gives the rule, in a run for each row: it has no two plugins of one name in a run.
+ test(
+ "the name of a plugin, and of the plugin in the name of a rule, without eslint-plugin and oxlint-plugin as oxlint takes them off",
+ async () => {
+ // `meta.name`, the plugin in the key of the rule, `context.id`.
+ const cases = [
+ ["eslint-plugin-foo", "eslint-plugin-foo", "foo/r"],
+ ["eslint-plugin-foo", "foo", "foo/r"],
+ ["oxlint-plugin-foo", "oxlint-plugin-foo", "foo/r"],
+ ["oxlint-plugin-foo", "foo", "foo/r"],
+ ["@scope/eslint-plugin", "@scope/eslint-plugin", "@scope/r"],
+ ["@scope/eslint-plugin", "@scope", "@scope/r"],
+ ["@scope/oxlint-plugin", "@scope/oxlint-plugin", "@scope/r"],
+ ["@scope/oxlint-plugin", "@scope", "@scope/r"],
+ ["@scope/eslint-plugin-foo", "@scope/eslint-plugin-foo", "@scope/foo/r"],
+ ["@scope/eslint-plugin-foo", "@scope/foo", "@scope/foo/r"],
+ ["@scope/oxlint-plugin-bar", "@scope/oxlint-plugin-bar", "@scope/bar/r"],
+ ["@scope/oxlint-plugin-bar", "@scope/bar", "@scope/bar/r"],
+ ["eslint-plugin", "eslint-plugin", "eslint-plugin/r"],
+ ["oxlint-plugin", "oxlint-plugin", "oxlint-plugin/r"],
+ ["@a/b", "@a/b", "@a/b/r"],
+ ["eslint-plugin-eslint-plugin-x", "eslint-plugin-eslint-plugin-x", "eslint-plugin-x/r"],
+ ["@s/eslint-plugin-", "@s/eslint-plugin-", "@s//r"],
+ ["@s/eslint-plugin-", "@s/", "@s//r"],
+ ["plain", "plain", "plain/r"],
+ ["@scope/x/eslint-plugin-y", "@scope/x/eslint-plugin-y", "@scope/x/eslint-plugin-y/r"],
+ ["Eslint-Plugin-Z", "Eslint-Plugin-Z", "Eslint-Plugin-Z/r"],
+ ["eslint-plugin-react-hooks2", "eslint-plugin-react-hooks2", "react-hooks2/r"],
+ ["eslint-plugin-react-hooks2", "react-hooks2", "react-hooks2/r"],
+ ["@s/eslint-plugin/z", "@s/eslint-plugin/z", "@s/eslint-plugin/z/r"],
+ ];
+ const plugin = (name: string) =>
+ `module.exports = { meta: { name: ${JSON.stringify(name)} }, rules: { r: { create: context => ({ Program(node) { context.report({ node, message: context.id }); } }) } } };`;
+ const project = (directory: string, name: string, key: string) => ({
+ [`${directory}p.cjs`]: plugin(name),
+ [`${directory}.oxlintrc.json`]: oxlintrc({
+ jsPlugins: ["./p.cjs"],
+ ignorePatterns: ["p.cjs"],
+ rules: { [`${key}/r`]: "error" },
+ }),
+ [`${directory}a.js`]: "a;\n",
+ });
+ const directory = (i: number) => `d${String(i).padStart(2, "0")}/`;
+ const [accepted, ...refused] = await Promise.all([
+ lint(Object.assign({}, ...cases.map(([name, key], i) => project(directory(i), name, key))), [
+ "-f",
+ "json",
+ ".",
+ ]),
+ // oxlint: "Plugin 'foo' not found", "Plugin '@scope/x/y' not found".
+ lint(project("", "foo/bar", "foo/bar"), ["a.js"]),
+ lint(project("", "@scope/x/eslint-plugin-y", "@scope/x/y"), ["a.js"]),
+ ]);
+ const results: { filePath: string; messages: { message: string; ruleId: string }[] }[] = JSON.parse(accepted.raw);
+ const found = results.flatMap(it => it.messages.map(({ message, ruleId }) => [message, ruleId]));
+ expect(found).toEqual(cases.map(([, , id]) => [id, id]));
+ expect(refused.map(it => [it.stderr.split("\n")[0], it.exitCode])).toEqual([
+ ["error: 1 rule in .oxlintrc.json is not supported: foo/bar/r", 2],
+ ["error: 1 rule in .oxlintrc.json is not supported: @scope/x/y/r", 2],
+ ]);
+ },
+ timeout,
+ );
+
+ // ESLint 10.12.0 reports the same for `both`, and refuses `once`: "Rule must be an object with a `create` method".
+ test(
+ "with a configuration of ESLint a rule with create is created for each file, and the context of createOnce is that of the file being linted",
+ async () => {
+ const files = {
+ "plugin.mjs": `const name = path => path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\\\")) + 1);
+const say = (context, how) =>
+ [how, context.id, name(context.filename), name(context.physicalFilename), JSON.stringify(context.options), context.settings.which, context.languageOptions.sourceType, context.sourceCode.text.trim()].join(" ");
+let calls = 0;
+export default {
+ meta: { name: "p" },
+ rules: {
+ once: {
+ meta: { schema: false },
+ createOnce(context) {
+ const call = ++calls;
+ let seenBefore, program;
+ return {
+ before() { seenBefore = name(context.filename); },
+ Program(node) { program = node; context.report({ node, message: say(context, \`createOnce#\${call} before:\${seenBefore}\`) }); },
+ after() { context.report({ node: program, message: \`after \${name(context.filename)}\` }); },
+ };
+ },
+ },
+ both: {
+ meta: { schema: false },
+ create: context => ({ Program(node) { context.report({ node, message: say(context, "create") }); } }),
+ createOnce: context => ({ Program(node) { context.report({ node, message: say(context, "createOnce") }); } }),
+ },
+ },
+};
+`,
+ "eslint.config.mjs": `
+ import p from "./plugin.mjs";
+ export default [
+ { plugins: { p }, rules: { "p/once": ["error", "all"], "p/both": ["error", "all"] }, settings: { which: "all" } },
+ {
+ files: ["b.js"],
+ rules: { "p/once": ["error", "b"], "p/both": ["error", "b"] },
+ settings: { which: "b" },
+ languageOptions: { sourceType: "script" },
+ },
+ ];`,
+ "a.js": "a;\n",
+ "b.js": "b;\n",
+ "c.js": "c;\n",
+ };
+ const expected = [
+ `a.js p/once | createOnce#1 before:a.js p/once a.js a.js ["all"] all module a;`,
+ `a.js p/both | create p/both a.js a.js ["all"] all module a;`,
+ `a.js p/once | after a.js`,
+ `b.js p/once | createOnce#2 before:b.js p/once b.js b.js ["b"] b script b;`,
+ `b.js p/both | create p/both b.js b.js ["b"] b script b;`,
+ `b.js p/once | after b.js`,
+ `c.js p/once | createOnce#1 before:c.js p/once c.js c.js ["all"] all module c;`,
+ `c.js p/both | create p/both c.js c.js ["all"] all module c;`,
+ `c.js p/once | after c.js`,
+ ];
+ // In one realm, where the third file comes after two others, and in several.
+ const runs = await Promise.all(
+ ["1", "3"].map(threads => lint(files, ["--threads", threads, "-f", "json", "a.js", "b.js", "c.js"])),
+ );
+ for (const { raw, exitCode } of runs) {
+ const results: { filePath: string; messages: { ruleId: string; message: string }[] }[] = JSON.parse(raw);
+ const found = results.flatMap(({ filePath, messages }) =>
+ messages.map(
+ it => `${filePath.slice(-4)} ${it.ruleId} | ${it.message.replace(/createOnce#\d/, "createOnce#N")}`,
+ ),
+ );
+ expect(found).toEqual(expected.map(it => it.replace(/createOnce#\d/, "createOnce#N")));
+ expect(exitCode).toBe(1);
+ }
+ },
+ timeout,
+ );
+
+ // As under ESLint 10.12.0.
+ test(
+ "a range with a hole is read like any other object",
+ async () => {
+ const config = `
+ const rule = {
+ create: context => ({
+ Program(node) {
+ const first = [4, 7], second = [4, 7], both = [4, 7];
+ delete first[0];
+ delete second[1];
+ delete both[0];
+ delete both[1];
+ const texts = [first, second, both, [4, 7]].map(range => context.sourceCode.getText({ range }));
+ context.report({ node, message: JSON.stringify(texts) });
+ },
+ }),
+ };
+ module.exports = [{ plugins: { own: { rules: { rule } } }, rules: { "own/rule": "error" } }];`;
+ const { raw, exitCode } = await lint({ "eslint.config.cjs": config, "a.js": "var abc = 1;\n" }, [
+ "-f",
+ "json",
+ "a.js",
+ ]);
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results.flatMap(it => it.messages.map(it => it.message))).toEqual([`["var abc","","","abc"]`]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "whatever a plugin throws, and wherever, the run ends with an error that can be read",
+ async () => {
+ const config = `
+ const thrown = {
+ plain: () => new Error("real error"),
+ noLoc: node => ((node.loc = null), new Error("real error")),
+ locThrows: node => (Object.defineProperty(node, "loc", { get() { throw new Error("from loc"); } }), new Error("real error")),
+ bare: () => Object.create(null),
+ bareMessage: () => Object.assign(new Error("x"), { message: Object.create(null) }),
+ getter: () => ({ get message() { throw 2; } }),
+ getters: () => ({ get message() { throw { get message() { throw 3; } }; } }),
+ symbol: () => Symbol("s"),
+ nothing: () => undefined,
+ proxy: () => new Proxy({}, { get() { throw new Error("from a proxy"); } }),
+ revoked: () => { const { proxy, revoke } = Proxy.revocable({}, {}); revoke(); return proxy; },
+ toString: () => ({ toString() { throw new Error("from toString"); } }),
+ };
+ const { WHERE: where, WHAT: what } = process.env;
+ const fail = node => { throw thrown[what](node); };
+ const rule = {
+ meta: { fixable: "code", schema: [] },
+ create(context) {
+ if (where === "create") fail({});
+ return {
+ Program(node) {
+ if (where === "listener") fail(node);
+ if (where === "fix") context.report({ node, message: "m", fix() { fail(node); } });
+ if (where === "filter") context.sourceCode.getFirstToken(node, { filter() { fail(node); } });
+ if (where === "data") context.report({ node, message: "{{a}}", data: { get a() { fail(node); } } });
+ },
+ onCodePathStart(path, node) { if (where === "path") fail(node); },
+ };
+ },
+ };
+ const processor = { preprocess: text => [{ text, filename: "0.js" }], postprocess() { fail({}); } };
+ module.exports = [
+ { files: ["**/*.js"], plugins: { own: { rules: { rule } } }, rules: { "own/rule": "error" } },
+ { files: ["**/*.md"], processor },
+ ];`;
+ const cases = [
+ ["listener", "plain", "real error"],
+ ["listener", "noLoc", "real error"],
+ ["listener", "locThrows", "real error"],
+ ["listener", "bare", "No default value"],
+ ["listener", "bareMessage", "No default value"],
+ ["listener", "getter", "2"],
+ ["listener", "getters", "An exception was thrown."],
+ ["listener", "symbol", "Symbol(s)"],
+ ["listener", "nothing", "undefined"],
+ ["listener", "proxy", "from a proxy"],
+ ["listener", "revoked", "Proxy has already been revoked. No more operations are allowed to be performed on it"],
+ ["listener", "toString", "from toString"],
+ // As in ESLint 10.12, which puts the rule into `message`.
+ ["create", "bare", "Error while loading rule 'own/rule': undefined"],
+ ["path", "noLoc", "real error"],
+ ["fix", "getter", "2"],
+ ["filter", "bare", "No default value"],
+ ["data", "getters", "An exception was thrown."],
+ ["postprocess", "bare", "No default value"],
+ ];
+ const results = await Promise.all(
+ cases.map(async ([WHERE, WHAT]) => {
+ const name = WHERE === "postprocess" ? "a.md" : "a.js";
+ const { stderr, exitCode } = await lint({ "eslint.config.cjs": config, [name]: "a;\n" }, [name], [], {
+ WHERE,
+ WHAT,
+ });
+ return [WHERE, WHAT, stderr.split("\n")[0], exitCode];
+ }),
+ );
+ expect(results).toEqual(cases.map(([where, what, message]) => [where, what, `error: ${message}`, 2]));
+ },
+ timeout,
+ );
+
+ test(
+ "a plugin gets at nothing of the host through caller or through what it has put on Array.prototype",
+ async () => {
+ const config = `
+ const seen = [];
+ const original = Array.prototype[Symbol.iterator];
+ Array.prototype[Symbol.iterator] = function () {
+ for (let i = -1; i < 2; i++) {
+ const it = i < 0 ? this : this[i];
+ if (Array.isArray(it) && it[0]?.type === "Program") seen.push(it);
+ }
+ return original.call(this);
+ };
+ let said = false;
+ const rule = {
+ create: context => ({
+ // Not strict, so that it has a \`caller\`.
+ Identifier: new Function("report", "return function listener(node) { var names = []; for (var it = listener.caller; it; it = it.caller) names.push(it.name); report(node, names); };")(
+ (node, names) => { if (!said) context.report({ node, message: "callers: " + names }); said = true; },
+ ),
+ "Program:exit"(node) {
+ for (let i = 0; i < seen.length; i++) { delete seen[i][3]; seen[i].length = 2; seen[i][5e7] = 1; }
+ const { sourceCode } = context;
+ const found = [0, 5, 12, 30].map(index => sourceCode.getNodeByRangeIndex(index).type);
+ const inner = node.body[1].body.body[0];
+ context.report({ node, message: [seen.length, found, sourceCode.scopeManager.scopes.length, sourceCode.getAncestors(inner).length, sourceCode.getScope(inner).type].join(" | ") });
+ },
+ }),
+ };
+ module.exports = [{ languageOptions: { sourceType: "script" }, plugins: { own: { rules: { rule } } }, rules: { "own/rule": "error" } }];`;
+ const { raw, exitCode } = await lint(
+ { "eslint.config.cjs": config, "a.js": "var a = 1; function f(b) { return a + b; }\nf(a);\n" },
+ ["-f", "json", "a.js"],
+ );
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results.flatMap(it => it.messages.map(it => it.message))).toEqual([
+ "0 | VariableDeclaration,VariableDeclarator,FunctionDeclaration,ReturnStatement | 2 | 3 | function",
+ "callers: ",
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "nodes, scopes and code paths are right after a plugin has put an accessor with an index for a name on Array.prototype",
+ async () => {
+ const plugin = `Object.defineProperty(Array.prototype, "4294967290", { get() {}, set() {}, configurable: true });
+ const rule = {
+ create(context) {
+ let segments = 0;
+ return {
+ onCodePathSegmentStart() {
+ segments++;
+ },
+ "Program:exit"(node) {
+ const { scopes } = context.sourceCode.scopeManager;
+ const names = scopes.flatMap(scope => scope.variables.filter(it => it.defs.length > 0).map(it => it.name));
+ const resolved = scopes.flatMap(scope => scope.references.map(it => it.resolved?.name ?? null));
+ const message = JSON.stringify({ statements: node.body.map(it => it.type), segments, names, resolved });
+ context.report({ node, message });
+ },
+ };
+ },
+ };
+ export default { meta: { name: "p" }, rules: { rule } };`;
+ const code = Array.from({ length: 12 }, (_, i) => `let v${i} = ${i === 0 ? "other" : `v${i - 1}`};`).join("\n");
+ const config = { jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } };
+ const files = { "plugin.mjs": plugin, ".oxlintrc.json": oxlintrc(config), "a.js": `${code}\nif (v11) v0;\n` };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const names = Array.from({ length: 12 }, (_, i) => `v${i}`);
+ expect(JSON.parse(raw).diagnostics.map((it: { message: string }) => JSON.parse(it.message))).toEqual([
+ {
+ statements: [...names.map(() => "VariableDeclaration"), "IfStatement"],
+ segments: 3,
+ names,
+ resolved: ["v0", null, ...names.slice(1).flatMap((name, i) => [name, `v${i}`]), "v11", "v0"],
+ },
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "with an oxlint config the scopes follow the kind of file: strict scopes of TypeScript, and arguments in CommonJS",
+ async () => {
+ const plugin = `export default { meta: { name: "p" }, rules: { rule: { create: context => ({
+ Program(node) {
+ const said = context.sourceCode.scopeManager.scopes.map(scope => {
+ const own = scope.variables.filter(it => it.defs.length > 0 || it.name === "arguments");
+ const names = own.map(it => it.name + ":" + it.defs.length + ":" + it.references.length);
+ return scope.type + (scope.isStrict ? "!" : "") + "[" + names + "]";
+ });
+ context.report({ node, message: said.join(" ") });
+ },
+ }) } } };`;
+ const types = [
+ "interface I { m(x: T): void }",
+ "type C = T extends infer U ? U : never;",
+ "type M = { [K in keyof T]: T[K] };",
+ "enum E { A }",
+ "namespace N { function f() {} }",
+ "function g() {}",
+ "",
+ ].join("\n");
+ const declared = "I:1:0,C:1:0,M:1:0,E:1:0,N:1:0,g:1:0";
+ const inner =
+ "type![T:1:1] functionType![x:1:0] type![T:1:1] conditionalType![U:1:1] type![T:1:2] mappedType![K:1:1] tsEnum![A:1:0] tsModule![f:1:0] function![arguments:0:0]";
+ // What oxlint 1.87 says.
+ const expected = {
+ "types.ts": `global[${declared}] ${inner} function[arguments:0:0]`,
+ "types.cts": `global[] function[arguments:0:0,${declared}] ${inner} function[arguments:0:0]`,
+ "types.mts": `global[] module![${declared}] ${inner} function![arguments:0:0]`,
+ "declared.cjs": "global[] function[arguments:1:1]",
+ "declared.js": "global[arguments:1:1]",
+ "implicit.cjs": "global[] function[arguments:0:1,first:1:0]",
+ };
+ const files = {
+ "plugin.mjs": plugin,
+ ".oxlintrc.json": oxlintrc({ jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } }),
+ "types.ts": types,
+ "types.cts": types,
+ "types.mts": types,
+ "declared.cjs": "var arguments;\narguments;\n",
+ "declared.js": "var arguments;\narguments;\n",
+ "implicit.cjs": "var first;\narguments;\n",
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const said = JSON.parse(raw).diagnostics.map((it: { filename: string; message: string }) => [
+ it.filename,
+ it.message,
+ ]);
+ expect(Object.fromEntries(said)).toEqual(expected);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // What oxlint 1.87 says. Its own no-unused-vars doesn't see the mark.
+ test(
+ "with an oxlint config markVariableAsUsed marks the variable it names in every kind of file",
+ async () => {
+ const plugin = `export default { meta: { name: "p" }, rules: { rule: { create: context => ({
+ Program(node) {
+ const returned = context.sourceCode.markVariableAsUsed("first", node);
+ const declared = context.sourceCode.scopeManager.scopes.flatMap(it => it.variables).filter(it => it.defs.length);
+ context.report({ node, message: returned + " " + declared.map(it => it.name + "=" + it.eslintUsed).join(" ") });
+ },
+ }) } } };`;
+ const code = "var first = 1;\nvar second = 2;\n";
+ const files = {
+ "plugin.mjs": plugin,
+ ".oxlintrc.json": oxlintrc({
+ jsPlugins: ["./plugin.mjs"],
+ rules: { "p/rule": "error", "no-unused-vars": "error" },
+ }),
+ "a.cjs": code,
+ "b.js": code,
+ "c.mjs": code,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const said = JSON.parse(raw).diagnostics.map(
+ (it: { filename: string; message: string }) =>
+ `${it.filename} ${it.message.match(/'(\w+)'/)?.[1] ?? it.message}`,
+ );
+ expect(said.sort()).toEqual(
+ ["a.cjs", "b.js", "c.mjs"].flatMap(file => [
+ `${file} first`,
+ `${file} second`,
+ `${file} true first=true second=false`,
+ ]),
+ );
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+});
+
+describe.concurrent("what a JavaScript plugin sees with an oxlint config", () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "oxlint");
+ const dump = readFileSync(join(oracle, "dump.cjs"), "utf8");
+ // By the name of a file. Recorded with oxlint 1.87.0 by record.mjs in that directory.
+ const expected: Record = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+ type Diagnostic = { filename: string; message: string };
+ const slashes = (path: string) => path.replaceAll("\\", "/");
+
+ test(
+ "trees with their values, the traversal, scopes, and what sourceCode says about each node are oxlint's in every kind of file",
+ async () => {
+ const config = { ignorePatterns: ["dump.cjs"], jsPlugins: ["./dump.cjs"], rules: { "dump/all": "error" } };
+ const files = { "dump.cjs": dump, ".oxlintrc.json": oxlintrc(config), ...oxlintCases };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const diagnostics: Diagnostic[] = JSON.parse(raw).diagnostics;
+ const parsed = (message: string) => (message.startsWith("{") ? JSON.parse(message) : message);
+ for (const file of Object.keys(expected)) {
+ const found = diagnostics.filter(it => slashes(it.filename) === file);
+ expect({ file, said: found.map(it => parsed(it.message)) }).toEqual({ file, said: [parsed(expected[file])] });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // In a JavaScript file nothing can fill in the fields of TypeScript, so they aren't made for each node, and an empty list is only made
+ // when it's read. A plugin must not be able to tell. All of this is what the same plugin says under oxlint 1.87.
+ describe("the fields of TypeScript in a JavaScript file", () => {
+ const plugin = String.raw`const describe = (object, key) => { const it = Object.getOwnPropertyDescriptor(object, key); return it && JSON.stringify(it); };
+const rule = { create: context => { const ids = []; return { Identifier(node) { ids.push(node); }, "Program:exit"(program) {
+ const next = () => ids.pop();
+ const said = {};
+ let a = next(), b = next();
+ said.keys = Object.keys(a).join();
+ said.forIn = (() => { const keys = []; for (const key in a) keys.push(key); return keys.join(); })();
+ said.has = [Object.hasOwn(a, "decorators"), "decorators" in a, a.propertyIsEnumerable("decorators")].join();
+ said.descriptor = describe(a, "decorators");
+ said.identity = [a.decorators === a.decorators, a.decorators === b.decorators, Array.isArray(a.decorators), Object.isFrozen(a.decorators), Object.getPrototypeOf(a.decorators) === Array.prototype].join();
+ a.decorators.push(1); said.pushed = a.decorators.length + "/" + b.decorators.length;
+ a = next(); said.json = JSON.stringify(a, (key, value) => (key === "parent" ? undefined : value));
+ a = next(); said.spread = ({ ...a }).decorators === a.decorators;
+ a = next(); said.assign = Object.assign({}, a).decorators === a.decorators;
+ a = next(); said.entries = JSON.stringify(Object.entries(a).find(it => it[0] === "decorators"));
+ a = next(); said.values = Object.values(a).filter(Array.isArray).map(it => it.length).join();
+ a = next(); a.decorators = 5; said.written = [a.decorators, describe(a, "decorators"), Object.keys(a).join() === said.keys].join(" ");
+ a = next(); said.deleted = [delete a.decorators, "decorators" in a, Object.keys(a).length].join();
+ a = next(); Object.freeze(a); said.frozen = [Object.isFrozen(a), describe(a, "decorators"), a.decorators === a.decorators, Object.isFrozen(a.decorators), Object.isFrozen(a)].join(" ");
+ a = next(); Object.seal(a); said.sealed = [describe(a, "decorators"), a.decorators === a.decorators, Object.isSealed(a)].join(" ");
+ a = next(); Object.preventExtensions(a); said.closed = [a.decorators === a.decorators, Object.isExtensible(a), describe(a, "decorators")].join(" ");
+ a = next(); Object.defineProperty(a, "decorators", { enumerable: false }); said.hidden = [describe(a, "decorators"), Object.keys(a).includes("decorators"), a.decorators === a.decorators].join(" ");
+ a = next(); Object.defineProperty(a, "decorators", { writable: false }); said.readOnly = [describe(a, "decorators"), a.decorators === a.decorators].join(" ");
+ a = next(); Object.defineProperty(a, "decorators", { get: () => 7, configurable: true }); said.getter = a.decorators;
+ a = next(); said.inherited = Object.create(a).decorators === a.decorators;
+ a = next(); said.reflect = [Reflect.get(a, "decorators", {}) === a.decorators, Reflect.has(a, "decorators"), Reflect.ownKeys(a).join() === said.keys].join();
+ a = next(); said.reflectSet = [Reflect.set(a, "decorators", 1), a.decorators].join();
+ a = next(); { const other = {}; said.setOnOther = [Reflect.set(a, "decorators", 1, other), other.decorators, Array.isArray(a.decorators)].join(); }
+ a = next(); { const child = Object.create(a); child.decorators = 3; said.setOnChild = [child.decorators, Object.hasOwn(child, "decorators"), Array.isArray(a.decorators)].join(); }
+ a = next(); said.descriptors = JSON.stringify(Object.getOwnPropertyDescriptors(a).decorators);
+ a = next(); said.destructured = (({ decorators, ...rest }) => [decorators === a.decorators, "decorators" in rest].join())(a);
+ a = next(); said.clone = JSON.stringify(structuredClone({ ...a, parent: null }).decorators);
+ a = next(); a.extra = 1; said.added = [Object.keys(a).at(-1), a.decorators.length, a.decorators === a.decorators].join();
+ said.others = [...new Set(ids.map(it => it.decorators))].length === ids.length;
+ context.report({ node: program, message: JSON.stringify(said) });
+} }; } };
+const kinds = { create: context => { const said = []; return {
+ "ObjectPattern, ArrayPattern, AssignmentPattern, RestElement"(node) { said.push(node.type + " " + describe(node, "decorators") + " " + (node.decorators === node.decorators) + " " + Object.keys(node)); },
+ "ImportSpecifier, ExportSpecifier, ExportNamedDeclaration, ExportDefaultDeclaration, ExportAllDeclaration, CallExpression, NewExpression, TaggedTemplateExpression, VariableDeclaration, VariableDeclarator, ArrowFunctionExpression, FunctionExpression, FunctionDeclaration, Property, JSXOpeningElement"(node) { said.push(node.type + " " + JSON.stringify(node, (key, value) => (key === "" || value === null || typeof value !== "object" ? value : Array.isArray(value) ? value.length : "{}"))); },
+ "Program:exit"(node) { context.report({ node, message: said.join("\n") }); } }; } };
+export default { meta: { name: "lazy" }, rules: { rule, kinds } };
+`;
+ const config = oxlintrc({
+ jsPlugins: ["./plugin.mjs"],
+ overrides: [
+ { files: ["ids.js"], rules: { "lazy/rule": "error" } },
+ { files: ["kinds.jsx"], rules: { "lazy/kinds": "error" } },
+ ],
+ });
+ const said = async (file: string, text: string) => {
+ const files = { "plugin.mjs": plugin, ".oxlintrc.json": config, [file]: text };
+ const { raw, exitCode } = await lint(files, ["-f", "json", file]);
+ const diagnostics: Diagnostic[] = JSON.parse(raw).diagnostics;
+ expect(exitCode).toBe(1);
+ return diagnostics.map(it => it.message);
+ };
+
+ test(
+ "`decorators` of an Identifier is a plain property with an array of its own, whatever is done to it first",
+ async () => {
+ const text = Array.from({ length: 40 }, (_, i) => `i${i}`).join("; ") + ";\n";
+ const [message, ...more] = await said("ids.js", text);
+ expect(JSON.parse(message)).toEqual({
+ "keys": "type,decorators,name,optional,typeAnnotation,start,end,range,parent",
+ "forIn": "type,decorators,name,optional,typeAnnotation,start,end,range,parent,loc",
+ "has": "true,true,true",
+ "descriptor": '{"value":[],"writable":true,"enumerable":true,"configurable":true}',
+ "identity": "true,false,true,false,true",
+ "pushed": "1/0",
+ "json":
+ '{"type":"Identifier","decorators":[],"name":"i37","optional":false,"typeAnnotation":null,"start":175,"end":178,"range":[175,178]}',
+ "spread": true,
+ "assign": true,
+ "entries": '["decorators",[]]',
+ "values": "0,2",
+ "written": '5 {"value":5,"writable":true,"enumerable":true,"configurable":true} true',
+ "deleted": "true,false,8",
+ "frozen": 'true {"value":[],"writable":false,"enumerable":true,"configurable":false} true false true',
+ "sealed": '{"value":[],"writable":true,"enumerable":true,"configurable":false} true true',
+ "closed": 'true false {"value":[],"writable":true,"enumerable":true,"configurable":true}',
+ "hidden": '{"value":[],"writable":true,"enumerable":false,"configurable":true} false true',
+ "readOnly": '{"value":[],"writable":false,"enumerable":true,"configurable":true} true',
+ "getter": 7,
+ "inherited": true,
+ "reflect": "true,true,true",
+ "reflectSet": "true,1",
+ "setOnOther": "true,1,true",
+ "setOnChild": "3,true,true",
+ "descriptors": '{"value":[],"writable":true,"enumerable":true,"configurable":true}',
+ "destructured": "true,false",
+ "clone": "[]",
+ "added": "extra,0,true",
+ "others": true,
+ });
+ expect(more).toEqual([]);
+ },
+ timeout,
+ );
+
+ test(
+ "every type that has them has oxlint's values in oxlint's order",
+ async () => {
+ const text =
+ 'import { a as b } from "a";\nexport { b as c };\nexport * from "d";\nexport default b;\nexport const e = ({ f }, [g], h = 1, ...i) => j(f)`k`;\nnew L();\nvar m;\nfunction n() {}\n(function () {});\n({ o: 1, p() {} });\n;\n';
+ const [message, ...more] = await said("kinds.jsx", text);
+ expect(message.split("\n")).toEqual([
+ 'ImportSpecifier {"type":"ImportSpecifier","imported":"{}","local":"{}","importKind":"value","start":9,"end":15,"range":2,"parent":"{}"}',
+ 'ExportNamedDeclaration {"type":"ExportNamedDeclaration","declaration":null,"specifiers":1,"source":null,"exportKind":"value","attributes":0,"start":28,"end":46,"range":2,"parent":"{}"}',
+ 'ExportSpecifier {"type":"ExportSpecifier","local":"{}","exported":"{}","exportKind":"value","start":37,"end":43,"range":2,"parent":"{}"}',
+ 'ExportAllDeclaration {"type":"ExportAllDeclaration","exported":null,"source":"{}","attributes":0,"exportKind":"value","start":47,"end":65,"range":2,"parent":"{}"}',
+ 'ExportDefaultDeclaration {"type":"ExportDefaultDeclaration","declaration":"{}","exportKind":"value","start":66,"end":83,"range":2,"parent":"{}"}',
+ 'ExportNamedDeclaration {"type":"ExportNamedDeclaration","declaration":"{}","specifiers":0,"source":null,"exportKind":"value","attributes":0,"start":84,"end":138,"range":2,"parent":"{}"}',
+ 'VariableDeclaration {"type":"VariableDeclaration","kind":"const","declarations":1,"declare":false,"start":91,"end":138,"range":2,"parent":"{}"}',
+ 'VariableDeclarator {"type":"VariableDeclarator","id":"{}","init":"{}","definite":false,"start":97,"end":137,"range":2,"parent":"{}"}',
+ 'ArrowFunctionExpression {"type":"ArrowFunctionExpression","expression":true,"async":false,"typeParameters":null,"params":4,"returnType":null,"body":"{}","id":null,"generator":false,"start":101,"end":137,"range":2,"parent":"{}"}',
+ 'ObjectPattern {"value":[],"writable":true,"enumerable":true,"configurable":true} true type,decorators,properties,optional,typeAnnotation,start,end,range,parent',
+ 'Property {"type":"Property","kind":"init","key":"{}","value":"{}","method":false,"shorthand":true,"computed":false,"optional":false,"start":104,"end":105,"range":2,"parent":"{}"}',
+ 'ArrayPattern {"value":[],"writable":true,"enumerable":true,"configurable":true} true type,decorators,elements,optional,typeAnnotation,start,end,range,parent',
+ 'AssignmentPattern {"value":[],"writable":true,"enumerable":true,"configurable":true} true type,decorators,left,right,optional,typeAnnotation,start,end,range,parent',
+ 'RestElement {"value":[],"writable":true,"enumerable":true,"configurable":true} true type,decorators,argument,optional,typeAnnotation,value,start,end,range,parent',
+ 'TaggedTemplateExpression {"type":"TaggedTemplateExpression","tag":"{}","typeArguments":null,"quasi":"{}","start":130,"end":137,"range":2,"parent":"{}"}',
+ 'CallExpression {"type":"CallExpression","callee":"{}","typeArguments":null,"arguments":1,"optional":false,"start":130,"end":134,"range":2,"parent":"{}"}',
+ 'NewExpression {"type":"NewExpression","callee":"{}","typeArguments":null,"arguments":0,"start":139,"end":146,"range":2,"parent":"{}"}',
+ 'VariableDeclaration {"type":"VariableDeclaration","kind":"var","declarations":1,"declare":false,"start":148,"end":154,"range":2,"parent":"{}"}',
+ 'VariableDeclarator {"type":"VariableDeclarator","id":"{}","init":null,"definite":false,"start":152,"end":153,"range":2,"parent":"{}"}',
+ 'FunctionDeclaration {"type":"FunctionDeclaration","id":"{}","generator":false,"async":false,"declare":false,"typeParameters":null,"params":0,"returnType":null,"body":"{}","expression":false,"start":155,"end":170,"range":2,"parent":"{}"}',
+ 'FunctionExpression {"type":"FunctionExpression","id":null,"generator":false,"async":false,"declare":false,"typeParameters":null,"params":0,"returnType":null,"body":"{}","expression":false,"start":172,"end":186,"range":2,"parent":"{}"}',
+ 'Property {"type":"Property","kind":"init","key":"{}","value":"{}","method":false,"shorthand":false,"computed":false,"optional":false,"start":192,"end":196,"range":2,"parent":"{}"}',
+ 'Property {"type":"Property","kind":"init","key":"{}","value":"{}","method":true,"shorthand":false,"computed":false,"optional":false,"start":198,"end":204,"range":2,"parent":"{}"}',
+ 'FunctionExpression {"type":"FunctionExpression","id":null,"generator":false,"async":false,"declare":false,"typeParameters":null,"params":0,"returnType":null,"body":"{}","expression":false,"start":199,"end":204,"range":2,"parent":"{}"}',
+ 'JSXOpeningElement {"type":"JSXOpeningElement","name":"{}","typeArguments":null,"attributes":1,"selfClosing":true,"start":209,"end":216,"range":2,"parent":"{}"}',
+ ]);
+ expect(more).toEqual([]);
+ },
+ timeout,
+ );
+ });
+
+ const plugin = `const property = (object, key) => {
+ const it = Object.getOwnPropertyDescriptor(object, key);
+ return key + (it.get ? ":get" : "") + (it.enumerable ? "" : ":hidden");
+ };
+ const shape = it =>
+ (Object.isFrozen(it) ? "frozen " : "") +
+ (Object.getPrototypeOf(it) === Object.prototype ? "" : "other ") +
+ Object.getOwnPropertyNames(it).map(key => property(it, key));
+ const sorted = it => JSON.stringify(Object.fromEntries(Object.entries(it).sort()));
+ const seen = new Set();
+ const api = {
+ create(context) {
+ return {
+ Program() {
+ const { sourceCode, languageOptions } = context;
+ const { parser, parserOptions } = languageOptions;
+ const manager = sourceCode.scopeManager;
+ for (const it of [manager, languageOptions, parser, parserOptions, parserOptions.ecmaFeatures]) seen.add(it);
+ let thrown;
+ try {
+ parser.parse("a");
+ } catch (error) {
+ thrown = error.constructor.name + ": " + error.message;
+ }
+ const message = [
+ "scopeManager " + shape(manager),
+ [manager.getDeclaredVariables, manager.acquire].map(it => it.name + "/" + it.length).join(),
+ "languageOptions " + shape(languageOptions),
+ [languageOptions.sourceType, languageOptions.ecmaVersion].join(),
+ "globals " + (Object.isFrozen(languageOptions.globals) ? "frozen " : "") + sorted(languageOptions.globals),
+ "env " + (Object.isFrozen(languageOptions.env) ? "frozen " : "") + sorted(languageOptions.env),
+ "parserOptions " + shape(parserOptions) + " " + JSON.stringify(parserOptions),
+ "ecmaFeatures " + shape(parserOptions.ecmaFeatures),
+ "parser " + shape(parser),
+ [parser.name, parser.version, parser.parse.name + "/" + parser.parse.length, parser.latestEcmaVersion].join(),
+ thrown,
+ (Object.isFrozen(parser.supportedEcmaVersions) ? "frozen " : "") + parser.supportedEcmaVersions,
+ "Syntax " + [Object.isFrozen(parser.Syntax), Object.getPrototypeOf(parser.Syntax), parser.Syntax === parser.Syntax, Object.keys(parser.Syntax).join() === Object.keys(sourceCode.visitorKeys).join(), parser.Syntax.Program].join(),
+ "same " + [parser.VisitorKeys === sourceCode.visitorKeys, context.parserOptions === parserOptions, seen.size].join(),
+ "parserServices " + shape(sourceCode.parserServices),
+ ].join("\\n");
+ context.report({ loc: { line: 1, column: 0 }, message });
+ },
+ };
+ },
+ };
+ const globals = {
+ create(context) {
+ return {
+ Program() {
+ const { set, variables } = context.sourceCode.scopeManager.globalScope;
+ const { env, globals } = context.languageOptions;
+ const told = ["Array", "window", "process", "describe", "define", "foo", "bar", "baz"];
+ let sum = 0;
+ for (const name of variables.map(it => it.name).sort().join()) sum = (Math.imul(sum, 31) + name.charCodeAt(0)) | 0;
+ const message = [
+ variables.length,
+ sum,
+ Object.keys(env).sort().join() || "-",
+ Object.keys(globals).sort().map(it => it + "=" + globals[it]).join() || "-",
+ told.map(it => it + (set.has(it) ? (set.get(it).writeable ? "+w" : "+r") : "-")).join(" "),
+ ].join(" ");
+ context.report({ loc: { line: 1, column: 0 }, message });
+ },
+ };
+ },
+ };
+ export default { meta: { name: "p" }, rules: { api, globals } };`;
+ const base = { jsPlugins: ["../plugin.mjs"], rules: { "p/globals": "error" } };
+
+ // What oxlint 1.87 says. It goes through `env` and `globals` in the order of a hash map, so the plugin sorts what it prints.
+ test(
+ "scopeManager, languageOptions and parserServices are the frozen objects of oxlint, the same for all files",
+ async () => {
+ const config = {
+ ...base,
+ rules: { "p/api": "error" },
+ env: { amd: true, jest: false },
+ globals: { b: "readonly", a: "writable", Array: "off" },
+ };
+ const kinds = {
+ "a.js": ["script", true, false, false],
+ "b.cjs": ["commonjs", true, true, false],
+ "c.mjs": ["module", true, false, true],
+ "d.ts": ["script", false, false, false],
+ "e.tsx": ["script", true, false, false],
+ };
+ const files = {
+ "plugin.mjs": plugin,
+ ".oxlintrc.json": oxlintrc({}),
+ "api/.oxlintrc.json": oxlintrc(config),
+ ...Object.fromEntries(Object.keys(kinds).map(it => [`api/${it}`, "a;\n"])),
+ };
+ // One thread, so that one VM sees all the files.
+ const { raw, exitCode } = await lint(files, ["-f", "json", "--threads", "1"]);
+ const diagnostics: Diagnostic[] = JSON.parse(raw).diagnostics;
+ const said = Object.fromEntries(diagnostics.map(it => [slashes(it.filename), it.message.split("\n")]));
+ const inScript = [
+ "scopeManager frozen scopes:get,globalScope:get,getDeclaredVariables,acquire",
+ "getDeclaredVariables/1,acquire/2",
+ "languageOptions frozen sourceType:get,ecmaVersion,parser,parserOptions,globals:get,env:get",
+ "script,2026",
+ 'globals frozen {"Array":"off","a":"writable","b":"readonly"}',
+ 'env frozen {"amd":true}',
+ 'parserOptions frozen sourceType:get,ecmaFeatures {"sourceType":"script","ecmaFeatures":{"jsx":true,"globalReturn":false,"impliedStrict":false}}',
+ "ecmaFeatures frozen jsx:get,globalReturn:get,impliedStrict:get",
+ "parser frozen name,version,parse,VisitorKeys,Syntax:get,latestEcmaVersion,supportedEcmaVersions",
+ "oxlint,1.87.0,parse/2,17",
+ "Error: `context.languageOptions.parser.parse` not implemented yet.",
+ "frozen 3,5,6,7,8,9,10,11,12,13,14,15,16,17",
+ "Syntax true,,true,true,Program",
+ "same true,true,5",
+ "parserServices frozen ",
+ ];
+ const options = ([sourceType, jsx, globalReturn, impliedStrict]: (string | boolean)[]) =>
+ JSON.stringify({ sourceType, ecmaFeatures: { jsx, globalReturn, impliedStrict } });
+ expect(said).toEqual(
+ Object.fromEntries(
+ Object.entries(kinds).map(([file, kind]) => [
+ `api/${file}`,
+ inScript.map(it =>
+ it.replace("script,2026", `${kind[0]},2026`).replace(options(kinds["a.js"]), options(kind)),
+ ),
+ ]),
+ ),
+ );
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // What oxlint 1.87 says: how many variables the global scope has, a sum over their names, `env`, `globals`, and some variables.
+ test(
+ "the globals are those of the envs that are on and of globals: builtin only without env, overrides merge, extends doesn't count",
+ async () => {
+ const everyEnv =
+ "amd applescript astro atomtest audioworklet browser builtin bun commonjs embertest es2015 es2016 es2017 es2018 es2019 es2020 es2021 es2022 es2023 es2024 es2025 es2026 es6 greasemonkey jasmine jest jquery meteor mocha mongo nashorn node phantomjs prototypejs protractor qunit serviceworker shared-node-browser shelljs svelte vitest vue webextensions worker";
+ const inSub = (more: object) => ({ files: ["sub/**"], ...more });
+ const configs: Record = {
+ "no-env": {},
+ "env": { env: { browser: true }, globals: { foo: "readonly", bar: "off" } },
+ "empty-env": { env: {} },
+ "env-off": { env: { browser: false } },
+ "unknown-env": { env: { nope: true } },
+ "builtin-off": { env: { builtin: false, amd: true } },
+ "override-adds": { overrides: [inSub({ env: { browser: true }, globals: { foo: "writable" } })] },
+ "override-changes": {
+ env: { browser: true },
+ globals: { foo: "readonly", bar: "off" },
+ overrides: [
+ inSub({
+ env: { builtin: true, browser: false, node: true },
+ globals: { foo: "off", bar: "writable", baz: "readonly" },
+ }),
+ ],
+ },
+ "two-overrides": {
+ overrides: [{ files: ["**/*.js"], env: { amd: true } }, inSub({ env: { amd: false, jest: true } })],
+ },
+ "override-builtin-off": { overrides: [inSub({ env: { builtin: false } })] },
+ "extends": { extends: ["./base.json"] },
+ "extends-and-env": { extends: ["./base.json"], env: { jest: true }, globals: { bar: "readonly" } },
+ "globals": { globals: { foo: true, bar: false, baz: "readable", Array: "writeable", window: "off" } },
+ "every-env": { env: Object.fromEntries(everyEnv.split(" ").map(it => [it, true])) },
+ };
+ const files: Record = { "plugin.mjs": plugin, ".oxlintrc.json": oxlintrc({}) };
+ for (const [name, config] of Object.entries(configs)) {
+ files[`${name}/.oxlintrc.json`] = oxlintrc({ ...base, ...config });
+ files[`${name}/base.json`] = JSON.stringify({ env: { amd: true }, globals: { foo: "writable" } });
+ files[`${name}/a.js`] = files[`${name}/sub/b.js`] = "a;\n";
+ }
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const diagnostics: Diagnostic[] = JSON.parse(raw).diagnostics;
+ expect(Object.fromEntries(diagnostics.map(it => [slashes(it.filename), it.message]))).toEqual({
+ "builtin-off/a.js": "3 616407005 amd - Array- window- process- describe- define+r foo- bar- baz-",
+ "builtin-off/sub/b.js": "3 616407005 amd - Array- window- process- describe- define+r foo- bar- baz-",
+ "empty-env/a.js": "1 94844771 - - Array- window- process- describe- define- foo- bar- baz-",
+ "empty-env/sub/b.js": "1 94844771 - - Array- window- process- describe- define- foo- bar- baz-",
+ "env-off/a.js": "1 94844771 - - Array- window- process- describe- define- foo- bar- baz-",
+ "env-off/sub/b.js": "1 94844771 - - Array- window- process- describe- define- foo- bar- baz-",
+ "env/a.js":
+ "1198 1747972463 browser bar=off,foo=readonly Array- window+r process- describe- define- foo+r bar- baz-",
+ "env/sub/b.js":
+ "1198 1747972463 browser bar=off,foo=readonly Array- window+r process- describe- define- foo+r bar- baz-",
+ "every-env/a.js":
+ "1639 -1319075877 amd,applescript,astro,atomtest,audioworklet,browser,builtin,bun,commonjs,embertest,es2015,es2016,es2017,es2018,es2019,es2020,es2021,es2022,es2023,es2024,es2025,es2026,es6,greasemonkey,jasmine,jest,jquery,meteor,mocha,mongo,nashorn,node,phantomjs,prototypejs,protractor,qunit,serviceworker,shared-node-browser,shelljs,svelte,vitest,vue,webextensions,worker - Array+r window+r process+r describe+r define+r foo- bar- baz-",
+ "every-env/sub/b.js":
+ "1639 -1319075877 amd,applescript,astro,atomtest,audioworklet,browser,builtin,bun,commonjs,embertest,es2015,es2016,es2017,es2018,es2019,es2020,es2021,es2022,es2023,es2024,es2025,es2026,es6,greasemonkey,jasmine,jest,jquery,meteor,mocha,mongo,nashorn,node,phantomjs,prototypejs,protractor,qunit,serviceworker,shared-node-browser,shelljs,svelte,vitest,vue,webextensions,worker - Array+r window+r process+r describe+r define+r foo- bar- baz-",
+ "extends-and-env/a.js":
+ "15 -1557638922 jest bar=readonly Array- window- process- describe+r define- foo- bar+r baz-",
+ "extends-and-env/sub/b.js":
+ "15 -1557638922 jest bar=readonly Array- window- process- describe+r define- foo- bar+r baz-",
+ "extends/a.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "extends/sub/b.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "globals/a.js":
+ "69 -762096136 builtin Array=writable,bar=readonly,baz=readonly,foo=writable,window=off Array+w window- process- describe- define- foo+w bar+r baz+r",
+ "globals/sub/b.js":
+ "69 -762096136 builtin Array=writable,bar=readonly,baz=readonly,foo=writable,window=off Array+w window- process- describe- define- foo+w bar+r baz+r",
+ "no-env/a.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "no-env/sub/b.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "override-adds/a.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "override-adds/sub/b.js":
+ "1263 -1504104892 browser,builtin foo=writable Array+r window+r process- describe- define- foo+w bar- baz-",
+ "override-builtin-off/a.js": "66 930916712 builtin - Array+r window- process- describe- define- foo- bar- baz-",
+ "override-builtin-off/sub/b.js": "1 94844771 - - Array- window- process- describe- define- foo- bar- baz-",
+ "override-changes/a.js":
+ "1198 1747972463 browser bar=off,foo=readonly Array- window+r process- describe- define- foo+r bar- baz-",
+ "override-changes/sub/b.js":
+ "149 -543027797 builtin,node bar=writable,baz=readonly,foo=off Array+r window- process+r describe- define- foo- bar+w baz+r",
+ "two-overrides/a.js": "68 -116936702 amd,builtin - Array+r window- process- describe- define+r foo- bar- baz-",
+ "two-overrides/sub/b.js":
+ "79 -71093976 builtin,jest - Array+r window- process- describe+r define- foo- bar- baz-",
+ "unknown-env/a.js": "1 94844771 nope - Array- window- process- describe- define- foo- bar- baz-",
+ "unknown-env/sub/b.js": "1 94844771 nope - Array- window- process- describe- define- foo- bar- baz-",
+ });
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // What oxlint 1.87 says, and ESLint 10.12 with @typescript-eslint/parser 8.71.1: the same.
+ test.each(["oxlint", "eslint"])(
+ "reference.maybeImplicitGlobal is typescript-eslint's: an object, null or undefined, with a config of %s",
+ async whose => {
+ const rule = `export default { meta: { name: "p" }, rules: { rule: { create: context => ({
+ Program(node) {
+ const said = context.sourceCode.scopeManager.scopes.flatMap(scope =>
+ scope.references.map(it => {
+ const maybe = it.maybeImplicitGlobal;
+ const object = () => Object.keys(maybe) + "=" + maybe.node.type + "," + (maybe.pattern === it.identifier);
+ return it.identifier.name + ":" + (maybe ? object() : maybe);
+ }),
+ );
+ context.report({ node, message: said.join(" ") });
+ },
+ }) } } };`;
+ const code =
+ 'x = 1; function f() { y = 2; x; } var a = 3; Object = 3; for (z in {}); for (var w of []); [p, q = 1] = []; ({ r } = {}); b += 1; c++; function h(d = 1, { e = 2 }) {} function i() { "use strict"; k = 1; } class C { m() { n = 1; } }';
+ const types = " let t: T = 1 as const; (u as any) = 1;";
+ const by = (type: string) => `node,pattern=${type},true`;
+ const assigned = by("AssignmentExpression");
+ const top = (maybe: string, inLoop: string) =>
+ `x:${maybe} a:null Object:${maybe} z:${inLoop} w:null p:${maybe} q:${maybe} q:${maybe} r:${maybe} b:undefined c:undefined`;
+ const inFunctions = (maybe: string) => `y:${maybe} x:undefined d:null e:null k:null n:null`;
+ const expected = {
+ "script.js": `${top(assigned, by("ForInStatement"))} ${inFunctions(assigned)}`,
+ "script.ts": `${top(assigned, by("ForInStatement"))} t:null const:null T:null u:${assigned} ${inFunctions(assigned)}`,
+ "module.mts": `${top("null", "null")} t:null const:null T:null u:null a:null ${inFunctions("null")}`,
+ };
+ const configs = {
+ oxlint: { ".oxlintrc.json": oxlintrc({ jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } }) },
+ eslint: {
+ "eslint.config.mjs": `import p from "./plugin.mjs";
+ const parser = { meta: { name: "typescript-eslint/parser" } };
+ export default [
+ { files: ["**/*.ts", "**/*.js", "**/*.mts"], plugins: { p }, rules: { "p/rule": "error" }, languageOptions: { parser } },
+ { files: ["script.*"], languageOptions: { sourceType: "script", parserOptions: { sourceType: "script" } } },
+ ];`,
+ },
+ };
+ const files = {
+ "plugin.mjs": rule,
+ ...configs[whose as keyof typeof configs],
+ "script.js": `${code}\n`,
+ "script.ts": `${code}${types}\n`,
+ "module.mts": `${code}${types} export { a };\n`,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", ...Object.keys(expected)]);
+ const said: [string, string][] =
+ whose === "oxlint"
+ ? JSON.parse(raw).diagnostics.map((it: Diagnostic) => [it.filename, it.message])
+ : JSON.parse(raw).map((it: { filePath: string; messages: { message: string }[] }) => [
+ slashes(it.filePath).split("/").at(-1),
+ it.messages.map(message => message.message).join("|"),
+ ]);
+ expect(Object.fromEntries(said)).toEqual(expected);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // What oxlint 1.87 says, and ESLint 10.12 with @typescript-eslint/parser 8.71.1: the same.
+ test.each(["oxlint", "eslint"])(
+ "the index of `a[b]!` in a pattern is referred to before the object, like that of `a[b]`, with a config of %s",
+ async whose => {
+ const rule = `export default { meta: { name: "p" }, rules: { rule: { create: context => ({
+ "Program:exit"(node) {
+ const lines = {};
+ for (const it of context.sourceCode.scopeManager.scopes.flatMap(scope => scope.references))
+ (lines[it.identifier.loc.start.line] ??= []).push(it.identifier.name);
+ context.report({ node, message: Object.values(lines).map(it => it.join(" ")).join("|") });
+ },
+ }) } } };`;
+ const rows = [
+ ["[a[b]] = c;", "b a c"],
+ ["[a![b]] = c;", "b a c"],
+ ["[a[b]!] = c;", "b a c"],
+ ["[a![b]!] = c;", "b a c"],
+ ["[a[b]!!] = c;", "b a c"],
+ ["[...a[b]!] = c;", "b a c"],
+ ["[a[b]! = d] = c;", "b a d c"],
+ ["({ k: a[b]! } = c);", "b a c"],
+ ["({ k: a[b]! = d } = c);", "b a d c"],
+ ["({ ...a[b]! } = c);", "b a c"],
+ ["for (a[b]! of c);", "b a c"],
+ ["for (a[b]! in c);", "b a c"],
+ ["a[b]! = c;", "a b c"],
+ ["[a.b!] = c;", "a c"],
+ ["[a[b][d]!] = c;", "d a b c"],
+ ["[a[b]![d]] = c;", "d a b c"],
+ ["[a[b]![d]!] = c;", "d a b c"],
+ ["[[a[b]!]] = c;", "b a c"],
+ ["[x, a[b]!, y[z]] = c;", "x b a z y c"],
+ ["[f(a[b])!.g] = c;", "f a b c"],
+ ["[f(a[b])![g]!] = c;", "g f a b c"],
+ ];
+ const configs = {
+ oxlint: { ".oxlintrc.json": oxlintrc({ jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } }) },
+ eslint: {
+ "eslint.config.mjs": `import p from "./plugin.mjs";
+ const parser = { meta: { name: "typescript-eslint/parser" } };
+ export default [{ files: ["**/*.ts"], plugins: { p }, rules: { "p/rule": "error" }, languageOptions: { parser } }];`,
+ },
+ };
+ const files = {
+ "plugin.mjs": rule,
+ ...configs[whose as keyof typeof configs],
+ "a.ts": rows.map(it => `${it[0]}\n`).join(""),
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.ts"]);
+ const message: string =
+ whose === "oxlint" ? JSON.parse(raw).diagnostics[0].message : JSON.parse(raw)[0].messages[0].message;
+ expect(message.split("|").map((said, i) => [rows[i][0], said])).toEqual(rows);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // `loc`, `decorators`, `ast.tokens` and the properties of `sourceCode` are made when they're read. It must not show who reads them first, in
+ // which realm or in which tier of the engine: they belong to the plugin's realm and stay the same objects.
+ // This is what oxlint 1.87 and ESLint 10.12 say, where all of it is plain data.
+ test.each(["oxlint", "eslint"])(
+ "what is made on first read is the same from a node:vm context and in hot code, with a config of %s",
+ async whose => {
+ const plugin = String.raw`import vm from "node:vm";
+const keys = ["decorators", "loc", "range"];
+// The same functions for each realm. A loop is as long as it takes the JIT compilers to get to it.
+const source =
+ "({" +
+ keys
+ .map(
+ key =>
+ "first_KEY(list, Base) { let mine = 0; const out = []; for (let i = 0; i < list.length; i++) { const it = list[i].KEY; mine += it instanceof Base; out.push(it); } return [mine, out]; }," +
+ "again_KEY(list, seen) { let changed = 0; for (let r = 0; r < 3; r++) for (let i = 0; i < list.length; i++) changed += list[i].KEY !== seen[i]; return changed; },",
+ )
+ .map((text, i) => text.replaceAll("KEY", keys[i]))
+ .join("") +
+ "methods(sourceCode, list) { let mine = 0; for (let r = 0; r < 3; r++) for (let i = 0; i < list.length; i++) mine += (sourceCode.getAncestors(list[i]) instanceof Array) + (sourceCode.getTokens(list[i]) instanceof Array); return mine; }," +
+ "properties(sourceCode) { const { text, ast, lines, visitorKeys, scopeManager, parserServices } = sourceCode; let changed = 0; for (let r = 0; r < 20000; r++) changed += (sourceCode.text !== text) + (sourceCode.ast !== ast) + (sourceCode.lines !== lines) + (sourceCode.visitorKeys !== visitorKeys) + (sourceCode.scopeManager !== scopeManager) + (sourceCode.parserServices !== parserServices) + (sourceCode.hasBOM !== false); return [changed, lines instanceof Array, ast.tokens instanceof Array, ast.comments instanceof Array, ast.tokens[0].loc instanceof Object, scopeManager.scopes[0].variables instanceof Array].join(); }," +
+ "Array, Object })";
+const rule = {
+ create(context) {
+ const found = [];
+ return {
+ Identifier(node) {
+ found.push(node);
+ },
+ "Program:exit"(program) {
+ const { sourceCode } = context;
+ const said = [];
+ for (const [realm, list, it] of [
+ ["main", found.slice(0, found.length / 2), (0, eval)(source)],
+ ["vm", found.slice(found.length / 2), vm.runInContext(source, vm.createContext({}))],
+ ]) {
+ // One read each of a node that nothing has looked at.
+ const node = list.pop();
+ const inContext = text => vm.runInNewContext(text, { node, sourceCode });
+ if (realm === "vm")
+ said.push(
+ "cold " +
+ [
+ inContext("Array.isArray(node.range) && !(node.range instanceof Array)"),
+ inContext("typeof node.loc.start.line"),
+ inContext("'decorators' in node ? node.decorators.length : 'none'"),
+ inContext("sourceCode.getText(node)"),
+ inContext("sourceCode.getFirstToken(node).value"),
+ inContext("sourceCode.text.length"),
+ inContext("Reflect.get(node, 'loc', 42) === node.loc"),
+ node.range instanceof Array,
+ node.loc instanceof Object,
+ ].join(),
+ );
+ for (const key of keys) {
+ if (!(key in list[0])) continue;
+ const [Base, MainBase] = key === "loc" ? [it.Object, Object] : [it.Array, Array];
+ const [ofReader, seen] = it["first_" + key](list, Base);
+ if (key === "decorators") for (const decorators of seen) decorators.push(1);
+ const ofMain = seen.filter(it => it instanceof MainBase).length;
+ const kept = key === "decorators" ? list.filter(it => it.decorators.length === 1).length : "-";
+ said.push([realm, key, "reader's", ofReader, "main", ofMain, "changed", it["again_" + key](list, seen), "kept", kept].join(" "));
+ }
+ said.push([realm, "methods", it.methods(sourceCode, list), "properties", it.properties(sourceCode)].join(" "));
+ }
+ context.report({ node: program, message: said.join("\n") });
+ },
+ };
+ },
+};
+export default { meta: { name: "p" }, rules: { rule } };
+`;
+ const expected = {
+ oxlint: [
+ "main decorators reader's 1500 main 1500 changed 0 kept 1500",
+ "main loc reader's 1500 main 1500 changed 0 kept -",
+ "main range reader's 1500 main 1500 changed 0 kept -",
+ "main methods 9000 properties 0,true,true,true,true,true",
+ "cold true,number,0,v3001,v3001,19909,true,true,true",
+ "vm decorators reader's 0 main 1500 changed 0 kept 1500",
+ "vm loc reader's 0 main 1500 changed 0 kept -",
+ "vm range reader's 0 main 1500 changed 0 kept -",
+ "vm methods 0 properties 0,false,false,false,false,false",
+ ],
+ eslint: [
+ "main loc reader's 1500 main 1500 changed 0 kept -",
+ "main range reader's 1500 main 1500 changed 0 kept -",
+ "main methods 9000 properties 0,true,true,true,true,true",
+ "cold true,number,none,v3001,v3001,19909,true,true,true",
+ "vm loc reader's 0 main 1500 changed 0 kept -",
+ "vm range reader's 0 main 1500 changed 0 kept -",
+ "vm methods 0 properties 0,false,false,false,false,false",
+ ],
+ };
+ const configs = {
+ oxlint: { ".oxlintrc.json": oxlintrc({ jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } }) },
+ eslint: {
+ "eslint.config.mjs": `import p from "./plugin.mjs";
+ export default [{ files: ["**/*.js"], plugins: { p }, rules: { "p/rule": "error" } }];`,
+ },
+ };
+ const files = {
+ "plugin.mjs": plugin,
+ ...configs[whose as keyof typeof configs],
+ "a.js": "// c\n" + Array.from({ length: 3002 }, (_, i) => `v${i};\n`).join(""),
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js"]);
+ const message: string =
+ whose === "oxlint" ? JSON.parse(raw).diagnostics[0].message : JSON.parse(raw)[0].messages[0].message;
+ expect(message.split("\n")).toEqual(expected[whose as keyof typeof expected]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+});
+
+test.concurrent(
+ "getAncestors returns every ancestor after a plugin has put an accessor with an index for a name on Array.prototype",
+ async () => {
+ const plugin = `Object.defineProperty(Array.prototype, "4294967290", { get() {}, set() {}, configurable: true });
+ const rule = {
+ create(context) {
+ return {
+ ReturnStatement(node) {
+ context.report({ node, message: context.sourceCode.getAncestors(node).map(it => it.type).join() });
+ },
+ };
+ },
+ };
+ export default { meta: { name: "p" }, rules: { rule } };`;
+ const config = { jsPlugins: ["./plugin.mjs"], rules: { "p/rule": "error" } };
+ const code = "function f(a) { if (a) { for (;;) { while (a) { return 1; } } } }\n";
+ const { raw, exitCode } = await lint({ "plugin.mjs": plugin, ".oxlintrc.json": oxlintrc(config), "a.js": code }, [
+ "-f",
+ "json",
+ ]);
+ expect(JSON.parse(raw).diagnostics.map((it: { message: string }) => it.message)).toEqual([
+ "Program,FunctionDeclaration,BlockStatement,IfStatement,BlockStatement,ForStatement,BlockStatement,WhileStatement,BlockStatement",
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+);
+
+test.concurrent(
+ "context.sourceCode is laid out and answers as in ESLint: text, lines, locations, indices, ancestors, scopes, directive comments, bad input",
+ async () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "source-code");
+ const { texts } = require(join(oracle, "plugin.cjs"));
+ const files = {
+ "plugin.cjs": readFileSync(join(oracle, "plugin.cjs"), "utf8"),
+ "eslint.config.cjs": `const demo = require("./plugin.cjs");
+ module.exports = [
+ { files: ["**/*.js", "**/*.ts"], plugins: { demo }, rules: { "demo/all": "error" } },
+ { files: ["**/*.ts"], languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } } },
+ ];`,
+ ...texts,
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", ...Object.keys(texts)]);
+ const said = Object.fromEntries(
+ JSON.parse(raw).map((result: any) => [
+ result.filePath.replaceAll("\\", "/").split("/").at(-1),
+ JSON.parse(result.messages.find((it: any) => it.ruleId === "demo/all").message),
+ ]),
+ );
+ // Recorded with ESLint 10.12.0 and @typescript-eslint/parser 8.71.1 by record.mjs in that directory.
+ expect(said).toEqual(JSON.parse(readFileSync(join(oracle, "expected.json"), "utf8")));
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+);
+
+describe.concurrent("code paths in JavaScript plugins", () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "code-paths");
+ const trace = readFileSync(join(oracle, "trace.cjs"), "utf8");
+ // Recorded with ESLint 10.12.0 and @typescript-eslint/parser 8.71.1 by record.mjs in that directory.
+ const expected: Record = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+ const filesOf = (cases: typeof codePathCases) => Object.fromEntries(cases.map(it => [fileOf(it), it.code]));
+ const slashes = (path: string) => path.replaceAll("\\", "/");
+
+ test(
+ "events, graphs, traverseSegments and the properties of the objects match ESLint in JavaScript files",
+ async () => {
+ const cases = codePathCases.filter(it => !isTypeScript(it));
+ const config = `const trace = require("./trace.cjs");
+ module.exports = [
+ { plugins: { trace } },
+ { files: ["layout.js"], rules: { "trace/layout": "error" } },
+ ...["module", "script", "commonjs"].map(sourceType => ({
+ files: [sourceType + "/*.js"],
+ rules: { "trace/all": "error" },
+ languageOptions: { sourceType, parserOptions: { ecmaFeatures: { jsx: true } } },
+ })),
+ ];`;
+ const files = { "trace.cjs": trace, "eslint.config.cjs": config, "layout.js": "a;", ...filesOf(cases) };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const results: { filePath: string; messages: { message: string }[] }[] = JSON.parse(raw);
+ const messagesOf = (file: string) =>
+ results.find(it => slashes(it.filePath).endsWith(`/${file}`))?.messages.map(it => it.message);
+ for (const it of cases) {
+ expect({ name: it.name, traces: messagesOf(fileOf(it)) }).toEqual({
+ name: it.name,
+ traces: [expected[it.name]],
+ });
+ }
+ // The message under ESLint 10.12.0.
+ expect(messagesOf("layout.js")?.map(it => it.split("\n"))).toEqual([
+ [
+ "CodePath own(id:value:wec,origin:value:wec,upper:value:wec,childCodePaths:value:wec,internal:value:) prototype(constructor:value:wc,initialSegment:getter:c,finalSegments:getter:c,returnedSegments:getter:c,thrownSegments:getter:c,traverseSegments:value:wc) keys(id,origin,upper,childCodePaths)",
+ "CodePathSegment own(id:value:wec,nextSegments:value:wec,prevSegments:value:wec,allNextSegments:value:wec,allPrevSegments:value:wec,reachable:value:wec,internal:value:) prototype(constructor:value:wc,isLoopedPrevSegment:value:wc) keys(id,nextSegments,prevSegments,allNextSegments,allPrevSegments,reachable)",
+ "in: initialSegment,traverseSegments,internal",
+ 'JSON: {"id":"s1","origin":"program","upper":null,"childCodePaths":[]} {"id":"s1_1","nextSegments":[],"prevSegments":[],"allNextSegments":[],"allPrevSegments":[],"reachable":true}',
+ "the same array each time: true",
+ "without options: s1_1,s1_1,s1_1",
+ "controller: skip,break",
+ ],
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "events and graphs match ESLint with typescript-eslint's parser in TypeScript files",
+ async () => {
+ const cases = codePathCases.filter(isTypeScript);
+ const config = { ignorePatterns: ["trace.cjs"], jsPlugins: ["./trace.cjs"], rules: { "trace/all": "error" } };
+ const files = { "trace.cjs": trace, ".oxlintrc.json": oxlintrc(config), ...filesOf(cases) };
+ const { raw, exitCode } = await lint(files, ["-f", "json"]);
+ const diagnostics: { filename: string; message: string }[] = JSON.parse(raw).diagnostics;
+ for (const it of cases) {
+ const traces = diagnostics.filter(diagnostic => slashes(diagnostic.filename) === it.name);
+ expect({ name: it.name, traces: traces.map(diagnostic => diagnostic.message) }).toEqual({
+ name: it.name,
+ traces: [expected[it.name]],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // ESLint 9 removed `currentSegments`. The first test checks that it's gone with a flat configuration.
+ test(
+ "codePath.currentSegments follows the traversal with an ESLint 8 configuration",
+ async () => {
+ const plugin = `module.exports = { rules: { paths: { create(context) {
+ const seen = [];
+ const stack = [];
+ const now = label => seen.push(label + " [" + stack.at(-1).currentSegments.map(it => it.id) + "]");
+ return {
+ onCodePathStart: codePath => stack.push(codePath),
+ onCodePathEnd(codePath, node) {
+ now("end");
+ stack.pop();
+ if (node.type === "Program") context.report({ node, message: seen.join(" ") });
+ },
+ onCodePathSegmentStart: segment => now("+" + segment.id),
+ onCodePathSegmentEnd: segment => now("-" + segment.id),
+ onUnreachableCodePathSegmentStart: segment => now("+" + segment.id),
+ onUnreachableCodePathSegmentEnd: segment => now("-" + segment.id),
+ ReturnStatement: () => now("return"),
+ ExpressionStatement: () => now("statement"),
+ "FunctionDeclaration:exit": () => now("exit"),
+ };
+ } } } };`;
+ const files = {
+ ".eslintrc.json": JSON.stringify({ root: true, plugins: ["foo"], rules: { "foo/paths": "error" } }),
+ "node_modules/eslint-plugin-foo/package.json": `{ "name": "eslint-plugin-foo", "main": "index.js" }`,
+ "node_modules/eslint-plugin-foo/index.js": plugin,
+ "a.js": "function f() { if (a) return; b(); throw c; d(); }\n",
+ // Two segments are current in the `finally` block, and the listener for the first already sees both.
+ "b.js": "function f() { try { if (a) return; b(); } finally { c(); } d(); }\n",
+ };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js", "b.js"]);
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ // From ESLint's analyzer with the listeners called while it runs, as ESLint 8 calls them.
+ expect(results.map(result => result.messages.map(it => it.message))).toEqual([
+ [
+ "+s1_1 [s1_1] +s2_1 [s2_1] -s2_1 [s2_1] +s2_2 [s2_2] return [s2_2] -s2_2 [s2_2] +s2_4 [s2_4] statement [s2_4] -s2_4 [s2_4] +s2_5 [s2_5] statement [s2_5] exit [s2_5] -s2_5 [s2_5] end [] -s1_1 [s1_1] end []",
+ ],
+ [
+ "+s1_1 [s1_1] +s2_1 [s2_1] -s2_1 [s2_1] +s2_3 [s2_3] return [s2_3] -s2_3 [s2_3] +s2_5 [s2_5] statement [s2_5] -s2_5 [s2_5] +s2_6 [s2_6,s2_7] +s2_7 [s2_6,s2_7] statement [s2_6,s2_7] -s2_7 [s2_6,s2_7] statement [s2_6] exit [s2_6] -s2_6 [s2_6] end [] -s1_1 [s1_1] end []",
+ ],
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "an error thrown from a code path listener or a traverseSegments callback names the rule",
+ async () => {
+ const plugin = `const fail = () => { throw new Error("thrown on purpose"); };
+ module.exports = { meta: { name: "throws" }, rules: {
+ listener: { create: () => ({ onCodePathSegmentStart: fail }) },
+ callback: { create: () => ({ onCodePathEnd: codePath => codePath.traverseSegments(fail) }) },
+ } };`;
+ const run = async (rule: string) => {
+ const config = `const throws = require("./plugin.cjs");
+ module.exports = [{ plugins: { throws }, rules: { "throws/${rule}": "error" } }];`;
+ const { stderr, exitCode } = await lint({ "eslint.config.cjs": config, "plugin.cjs": plugin, "a.js": "a;\n" }, [
+ "a.js",
+ ]);
+ return { lines: stderr.split("\n").filter(line => /^error:|^Rule:/.test(line)), exitCode };
+ };
+ // ESLint 10.12.0 prints the same two lines and exits with 2.
+ expect(await Promise.all([run("listener"), run("callback")])).toEqual([
+ { lines: ["error: thrown on purpose", 'Rule: "throws/listener"'], exitCode: 2 },
+ { lines: ["error: thrown on purpose", 'Rule: "throws/callback"'], exitCode: 2 },
+ ]);
+ },
+ timeout,
+ );
+});
+
+describe.concurrent("JavaScript plugins and threads", () => {
+ // A file that's linted with types, and standard input, are parsed on a thread that has no VM. A thread that has one parses them again.
+ test(
+ "markVariableAsUsed reaches no-unused-vars in files with types, files without, and standard input",
+ async () => {
+ const code =
+ "function outer() { const keptInner = 1; const lostInner = 2; }\nconst kept = 1;\nconst lost = 2;\nouter();\n";
+ const files = {
+ "tsconfig.json": JSON.stringify({ compilerOptions: { noLib: true, types: [] } }),
+ "eslint.config.mjs": `
+ import own from "./plugin.mjs";
+ export default [
+ { files: ["**/*.js", "**/*.ts"], plugins: { own }, rules: { "own/keeps": "error", "no-unused-vars": "error" } },
+ {
+ files: ["typed/*.ts"],
+ plugins: { "@typescript-eslint": { meta: { name: "@typescript-eslint/eslint-plugin" } } },
+ languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } }, parserOptions: { projectService: true } },
+ rules: { "@typescript-eslint/no-floating-promises": "error" },
+ },
+ ];`,
+ "plugin.mjs": `export default { rules: { keeps: { create: context => ({
+ VariableDeclarator(node) {
+ if (node.id.name.startsWith("kept")) context.sourceCode.markVariableAsUsed(node.id.name, node);
+ },
+ }) } } };`,
+ "plain/a.js": code,
+ "typed/a.ts": code,
+ };
+ using dir = tempDir("bun-lint-js-plugins", files);
+ const run = async (args: string[], stdin: "ignore" | Buffer) => {
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "--threads", "2", "-f", "unix", ...args],
+ env,
+ cwd: String(dir),
+ stdin,
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+ return {
+ names: Array.from(stdout.matchAll(/(\w+\.\w+):\d+:\d+: '(\w+)'/g), it => `${it[1]} ${it[2]}`),
+ exitCode,
+ };
+ };
+ const [ofFiles, ofStdin] = await Promise.all([
+ run(["plain", "typed"], "ignore"),
+ run(["--stdin", "--stdin-filename", "plain/b.js"], Buffer.from(code)),
+ ]);
+ expect(ofFiles).toEqual({ names: ["a.js lostInner", "a.js lost", "a.ts lostInner", "a.ts lost"], exitCode: 1 });
+ expect(ofStdin).toEqual({ names: ["b.js lostInner", "b.js lost"], exitCode: 1 });
+ },
+ timeout,
+ );
+
+ test(
+ "nested .oxlintrc.json files load their own jsPlugins while files are being discovered",
+ async () => {
+ const plugin = (
+ name: string,
+ ) => `export default { meta: { name: "${name}" }, rules: { seen: { create: context => ({
+ Program(node) { context.report({ node, message: "by ${name}" }); },
+ }) } } };`;
+ const config = (name: string) =>
+ JSON.stringify({
+ categories: { correctness: "off" },
+ ignorePatterns: ["own.mjs"],
+ jsPlugins: ["./own.mjs"],
+ rules: { [`${name}/seen`]: "error" },
+ });
+ const files: Record = {
+ ".oxlintrc.json": config("top"),
+ "own.mjs": plugin("top"),
+ "a.js": "1;\n",
+ };
+ const expected = ["a.js:1:1: by top [Error/top(seen)]"];
+ for (let i = 0; i < 8; i++) {
+ files[`d${i}/.oxlintrc.json`] = config(`p${i}`);
+ files[`d${i}/own.mjs`] = plugin(`p${i}`);
+ files[`d${i}/sub/a.js`] = "1;\n";
+ expected.push(`d${i}/sub/a.js:1:1: by p${i} [Error/p${i}(seen)]`);
+ }
+ const { stdout, exitCode } = await lint(files, ["-f", "unix", "--threads", "8"]);
+ expect(
+ stdout
+ .replaceAll("\\", "/")
+ .split("\n")
+ .filter(it => it.includes(": by "))
+ .sort(),
+ ).toEqual(expected.sort());
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "a project where one folder needs a plugin reports the same with 1, 3 and 16 threads, from one VM",
+ async () => {
+ const files: Record = {
+ "eslint.config.mjs": `
+ import demo from "./plugin.mjs";
+ export default [
+ { rules: { "no-unused-vars": "error" } },
+ { files: ["some/*.js"], plugins: { demo }, rules: { "demo/no-foo": "error" } },
+ ];`,
+ "plugin.mjs": noFoo,
+ };
+ for (let i = 0; i < 48; i++) files[`${i % 8 === 0 ? "some" : "other"}/${i}.js`] = `const unused${i} = foo;\n`;
+ const run = async (threads: string) => {
+ const { stdout, stderr, exitCode } = await lint(files, [
+ "-f",
+ "unix",
+ "--timing",
+ "--threads",
+ threads,
+ "some",
+ "other",
+ ]);
+ return { stdout, vms: /JavaScript: (\d+) engines/.exec(stderr)?.[1], exitCode };
+ };
+ const [one, three, many] = await Promise.all(["1", "3", "16"].map(run));
+ expect(one.stdout.split("\n").filter(it => it.endsWith("[Error/demo/no-foo]"))).toHaveLength(6);
+ expect(one.stdout.split("\n").filter(it => it.endsWith("[Error/no-unused-vars]"))).toHaveLength(48);
+ expect(one).toEqual({ stdout: expect.any(String), vms: "1", exitCode: 1 });
+ expect(three).toEqual(one);
+ expect(many).toEqual(one);
+ },
+ timeout,
+ );
+
+ test(
+ "--threads 1 has one VM, also when a file of 256 KB and more is among the files",
+ async () => {
+ const files: Record = {
+ "eslint.config.mjs": `
+ import demo from "./plugin.mjs";
+ export default [{ plugins: { demo }, rules: { "demo/no-foo": "error" } }];`,
+ "plugin.mjs": noFoo,
+ "src/heavy.js": `foo;\n/*${Buffer.alloc(300_000, "x")}*/\n`,
+ };
+ for (let i = 0; i < 4; i++) files[`src/${i}.js`] = "foo;\n";
+ const { stdout, stderr, exitCode } = await lint(files, ["-f", "unix", "--timing", "--threads", "1", "src"]);
+ expect(stdout.split("\n").filter(it => it.endsWith("[Error/demo/no-foo]"))).toHaveLength(5);
+ expect(stderr).toContain("JavaScript: 1 engines");
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ // As ESLint 10.12.0, which lints one file after the other.
+ test(
+ "if a rule throws in several files, the error for the first path is reported, however many threads there are",
+ async () => {
+ const files: Record = {
+ "eslint.config.mjs": `
+ import own from "./plugin.mjs";
+ export default [{ plugins: { own }, rules: { "own/throws": "error" } }];`,
+ "plugin.mjs": `export default { rules: { throws: { create: context => ({
+ Program() { if (context.filename.endsWith("7.js")) throw new Error("thrown on purpose"); },
+ }) } } };`,
+ };
+ // 6 MB, which is work for several VMs.
+ const text = `foo;\n/*${Buffer.alloc(250_000, "x")}*/\n`;
+ for (let i = 0; i < 24; i++) files[`src/${i}.js`] = text;
+ const run = async (threads: string) => {
+ const { stderr, exitCode } = await lint(files, ["--threads", threads, "src"]);
+ return { file: /^Occurred while linting .*[\\/](\d+\.js):1$/m.exec(stderr)?.[1], exitCode };
+ };
+ for (const it of await Promise.all(["1", "4", "8", "8"].map(run))) {
+ expect(it).toEqual({ file: "17.js", exitCode: 2 });
+ }
+ },
+ timeout,
+ );
+
+ test.skipIf(!isLinux)(
+ "a rule that never returns doesn't keep bun lint alive once it's killed",
+ async () => {
+ using dir = tempDir("bun-lint-js-plugins", {
+ "eslint.config.mjs": `
+ import own from "./plugin.mjs";
+ export default [{ plugins: { own }, rules: { "own/spins": "error" } }];`,
+ "plugin.mjs": `export default { rules: { spins: { create: () => ({
+ Program() { console.error("spinning"); for (;;); },
+ }) } } };`,
+ "a.js": "1;\n",
+ });
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", "--threads", "2", "a.js"],
+ env,
+ cwd: String(dir),
+ stdin: "ignore",
+ stdout: "ignore",
+ stderr: "pipe",
+ });
+ const reader = proc.stderr.getReader();
+ let said = "";
+ while (!said.includes("spinning")) {
+ const { value, done } = await reader.read();
+ if (done) break;
+ said += new TextDecoder().decode(value);
+ }
+ expect(said).toContain("spinning");
+ proc.kill("SIGTERM");
+ await proc.exited;
+ expect(proc.signalCode).toBe("SIGTERM");
+ },
+ timeout,
+ );
+});
+
+describe.concurrent("tokens and comments in JavaScript plugins", () => {
+ const oracle = join(import.meta.dir, "oracle", "jsplugins", "tokens");
+ const dump = readFileSync(join(oracle, "dump.cjs"), "utf8");
+ // Recorded with ESLint 10.12.0, @typescript-eslint/parser 8.71.1 and oxlint 1.87.0 by record.mjs in that directory.
+ const expected: Record<"eslint" | "oxlint", Record> = JSON.parse(
+ Buffer.from(Bun.zstdDecompressSync(readFileSync(join(oracle, "expected.json.zst")))).toString(),
+ );
+ const sources = Object.fromEntries(tokenCases.map(it => [tokenFileOf(it), it.code]));
+ const sectionsOf = (message: string | undefined, wanted: RegExp) =>
+ message?.split("\n").filter(line => wanted.test(line));
+
+ test(
+ "every method with every form of options, and the objects, match ESLint",
+ async () => {
+ const config = `const tokens = require("./dump.cjs");
+ module.exports = [
+ { ignores: ["*.cjs"] },
+ { plugins: { tokens }, rules: { "tokens/all": "error" } },
+ ...["module", "script"].map(sourceType => ({
+ files: [sourceType + "/*.js"],
+ languageOptions: { sourceType, parserOptions: { ecmaFeatures: { jsx: true } } },
+ })),
+ { files: ["*.ts", "*.tsx"], languageOptions: { parser: { meta: { name: "typescript-eslint/parser" } } } },
+ ];`;
+ const { raw, exitCode } = await lint({ "dump.cjs": dump, "eslint.config.cjs": config, ...sources }, [
+ "-f",
+ "json",
+ ]);
+ const results: { filePath: string; messages: { message: string }[] }[] = JSON.parse(raw);
+ // Left out: methods that ESLint 10 doesn't have any more.
+ const wanted = /^(?:[BDNE]:|L:(?:program|store|shape|parts|lists) )/;
+ for (const it of tokenCases) {
+ const file = `/${tokenFileOf(it)}`;
+ const messages = results.find(result => result.filePath.replaceAll("\\", "/").endsWith(file))?.messages;
+ expect({ name: it.name, sections: messages?.map(message => sectionsOf(message.message, wanted)) }).toEqual({
+ name: it.name,
+ sections: [sectionsOf(expected.eslint[it.name], wanted)],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "the objects match oxlint with its configuration",
+ async () => {
+ const config = { ignorePatterns: ["dump.cjs"], jsPlugins: ["./dump.cjs"], rules: { "tokens/all": "error" } };
+ const { raw, exitCode } = await lint({ "dump.cjs": dump, ".oxlintrc.json": oxlintrc(config), ...sources }, [
+ "-f",
+ "json",
+ ]);
+ const diagnostics: { filename: string; message: string }[] = JSON.parse(raw).diagnostics;
+ // oxlint has other values or types for a few tokens in these two.
+ for (const it of tokenCases.filter(it => it.name !== "escapes.ts" && it.name !== "jsx-names")) {
+ const found = diagnostics.filter(diagnostic => diagnostic.filename.replaceAll("\\", "/") === tokenFileOf(it));
+ expect({
+ name: it.name,
+ sections: found.map(it => sectionsOf(it.message, /^L:(?:program|shape|parts|lists) /)),
+ }).toEqual({
+ name: it.name,
+ sections: [expected.oxlint[it.name].split("\n")],
+ });
+ }
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "odd arguments, receivers and filters do what they do in ESLint",
+ async () => {
+ const plugin = `
+ const show = value =>
+ Array.isArray(value) ? "[" + value.map(show).join(" ") + "]" : value !== null && typeof value === "object" ? value.value : String(value);
+ const say = call => {
+ try {
+ return show(call());
+ } catch (error) {
+ return error.constructor.name + ": " + error.message;
+ }
+ };
+ const fail = () => {
+ throw new RangeError("thrown on purpose");
+ };
+ module.exports = { meta: { name: "odd" }, rules: { all: { create(context) {
+ const { sourceCode } = context;
+ return { Program(node) {
+ const [first, second] = node.body;
+ let calls = 0;
+ const lines = {
+ inherited: say(() => Object.create(sourceCode).getLastToken(first)),
+ proxy: say(() => new Proxy(sourceCode, {}).getTokenAfter(first)),
+ "node proxy": say(() => sourceCode.getFirstToken(new Proxy(second, {}))),
+ "node inherited": say(() => sourceCode.getFirstToken(Object.create(second))),
+ "only a range": say(() => sourceCode.getTokens({ range: first.range })),
+ "typed array": say(() => sourceCode.getTokens({ range: new Uint32Array(first.range) })),
+ "no node": say(() => sourceCode.getFirstToken()),
+ null: say(() => sourceCode.getTokenBefore(null)),
+ "no range": say(() => sourceCode.getTokenAfter({})),
+ "no right": say(() => sourceCode.getFirstTokenBetween(first)),
+ "range getter throws": say(() => sourceCode.getLastToken({ get range() { return fail(); } })),
+ "location throws": say(() => sourceCode.getLastToken({ range: [0, { valueOf: fail }] })),
+ "options getter throws": say(() => sourceCode.getLastToken(first, { get skip() { return fail(); } })),
+ "filter throws": say(() => sourceCode.getFirstToken(first, fail)),
+ "filter throws later": say(() => sourceCode.getTokens(node, () => (++calls === 3 ? fail() : true))),
+ "after that": say(() => sourceCode.getTokens(first)),
+ "filter calls back": say(() => sourceCode.getFirstTokens(first, { filter: token =>
+ sourceCode.getTokenAfter(token, { filter: it => it.value === ";" }) !== null && sourceCode.getTokens(node).length > 0 })),
+ "filter reports": say(() => sourceCode.getFirstToken(second, token => {
+ context.report({ node: token, message: "from a filter: " + token.value });
+ return true;
+ })),
+ "filter is a class": say(() => sourceCode.getFirstToken(first, class {})),
+ "filter is a number": say(() => sourceCode.getFirstToken(first, { filter: 1 })),
+ "negative skip": say(() => sourceCode.getFirstToken(first, -1)),
+ "negative count": say(() => sourceCode.getFirstTokens(first, -1)),
+ "skip is an object": say(() => sourceCode.getFirstToken(first, { skip: { valueOf: () => 1 } })),
+ "skip is a symbol": say(() => sourceCode.getFirstToken(first, { skip: Symbol.iterator })),
+ "huge skip": say(() => sourceCode.getFirstToken(first, 2 ** 31 - 1)),
+ "huge count": say(() => sourceCode.getFirstTokens(first, 2 ** 31 - 1)),
+ "huge padding": say(() => sourceCode.getTokens(second, 2 ** 31 - 1, 2 ** 31 - 1)),
+ "far away": say(() => sourceCode.getTokenAfter({ range: [2 ** 40, 2 ** 40] })),
+ "not a number": say(() => sourceCode.getTokens({ range: [NaN, NaN] })),
+ same: String(sourceCode.getFirstToken(first) === node.tokens[0] && node.tokens === node.tokens &&
+ sourceCode.getAllComments() === node.comments && sourceCode.getFirstToken(first).loc === node.tokens[0].loc),
+ fresh: String(sourceCode.getTokens(node) !== sourceCode.getTokens(node)),
+ };
+ context.report({ node, message: Object.entries(lines).map(([name, line]) => name + ": " + line).join("\\n") });
+ } };
+ } } } };`;
+ const config = `const odd = require("./plugin.cjs");
+ module.exports = [{ plugins: { odd }, rules: { "odd/all": "error" } }];`;
+ const files = { "plugin.cjs": plugin, "eslint.config.cjs": config, "a.js": "a = b; // c\nd(e);\n" };
+ const { raw, exitCode } = await lint(files, ["-f", "json", "a.js"]);
+ const [{ messages }]: { messages: { message: string }[] }[] = JSON.parse(raw);
+ // What ESLint 10.12.0 reports when Bun runs it.
+ expect(messages.map(it => it.message.split("\n"))).toEqual([
+ [
+ "inherited: ;",
+ "proxy: d",
+ "node proxy: d",
+ "node inherited: d",
+ "only a range: [a = b ;]",
+ "typed array: [a = b ;]",
+ "no node: TypeError: undefined is not an object (evaluating 'node.range')",
+ "null: TypeError: null is not an object (evaluating 'node.range')",
+ "no range: TypeError: undefined is not an object (evaluating 'node.range[1]')",
+ "no right: TypeError: undefined is not an object (evaluating 'right.range')",
+ "range getter throws: RangeError: thrown on purpose",
+ "location throws: RangeError: thrown on purpose",
+ "options getter throws: RangeError: thrown on purpose",
+ "filter throws: RangeError: thrown on purpose",
+ "filter throws later: RangeError: thrown on purpose",
+ "after that: [a = b ;]",
+ "filter calls back: [a = b ;]",
+ "filter reports: d",
+ "filter is a class: TypeError: Cannot call a class constructor without |new|",
+ "filter is a number: Error: options.filter should be a function.",
+ "negative skip: Error: options.skip should be zero or a positive integer.",
+ "negative count: Error: options.count should be zero or a positive integer.",
+ "skip is an object: =",
+ "skip is a symbol: TypeError: Cannot convert a symbol to a number",
+ "huge skip: null",
+ "huge count: [a = b ;]",
+ "huge padding: [a = b ; d ( e ) ;]",
+ "far away: null",
+ "not a number: []",
+ "same: true",
+ "fresh: true",
+ ],
+ ["from a filter: d"],
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+
+ test(
+ "the methods work without a receiver, and throw once the file is done",
+ async () => {
+ const plugin = `
+ const { writeFileSync } = require("node:fs");
+ const say = call => {
+ try {
+ return String(call()?.value);
+ } catch (error) {
+ return error.constructor.name + ": " + error.message;
+ }
+ };
+ let earlier;
+ module.exports = { meta: { name: "late" }, rules: { all: { create(context) {
+ const { sourceCode } = context;
+ return { Program(node) {
+ const { getFirstToken, getTokenAfter } = sourceCode;
+ const token = getFirstToken(node);
+ // What is kept from an earlier file answers about this one.
+ const lines = [token.value, getTokenAfter(token).value, say(() => earlier?.sourceCode.getFirstToken(earlier.node))];
+ earlier ??= { sourceCode, node };
+ context.report({ node, message: lines.join(" ") });
+ queueMicrotask(() => writeFileSync("late.txt", [
+ say(() => sourceCode.getFirstToken(node)),
+ say(() => sourceCode.getAllComments()[0]),
+ say(() => node.tokens[0]),
+ token.value,
+ ].join("\\n")));
+ } };
+ } } } };`;
+ const config = `const late = require("./plugin.cjs");
+ module.exports = [{ plugins: { late }, rules: { "late/all": "error" } }];`;
+ const sources = { "a.js": "a + 1;\n", "b.js": "b - 2;\n" };
+ const { raw, files, exitCode } = await lint(
+ { "plugin.cjs": plugin, "eslint.config.cjs": config, ...sources },
+ ["-f", "json", "--threads", "1", "a.js", "b.js"],
+ ["late.txt"],
+ );
+ const results: { messages: { message: string }[] }[] = JSON.parse(raw);
+ expect(results.map(result => result.messages.map(it => it.message))).toEqual([["a + undefined"], ["b - b"]]);
+ expect(files["late.txt"].split("\n")).toEqual([
+ "TypeError: No file is being linted",
+ "TypeError: No file is being linted",
+ "TypeError: No file is being linted",
+ "b",
+ ]);
+ expect(exitCode).toBe(1);
+ },
+ timeout,
+ );
+});
diff --git a/test/cli/lint/json-parse.test.ts b/test/cli/lint/json-parse.test.ts
new file mode 100644
index 000000000000..524fc938ed4c
--- /dev/null
+++ b/test/cli/lint/json-parse.test.ts
@@ -0,0 +1,303 @@
+// Native rules read package.json and other JSON files with `bun_lint::linter::json_parse`, and `/* eslint rule: .. */` comments are
+// parsed with it too. It behaves like V8's `JSON.parse`: same error messages, and no limit on nesting.
+import { afterAll, describe, expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDir } from "harness";
+import { endChildren, spawn } from "../children";
+
+afterAll(endChildren);
+
+const packages = Object.fromEntries(
+ ["listed", "unlisted"].flatMap(name => [
+ [`node_modules/${name}/package.json`, JSON.stringify({ name, main: "index.js" })],
+ [`node_modules/${name}/index.js`, "module.exports = 1;\n"],
+ ]),
+);
+const code = `import a from "listed";\nimport b from "unlisted";\nconsole.log(a, b);\n`;
+const unlisted = "'unlisted' should be listed in the project's dependencies. Run 'npm i -S unlisted' to add it";
+
+async function lint(files: Record, args: string[]) {
+ using dir = tempDir("bun-lint-json-parse", files);
+ await using proc = spawn({
+ cmd: [bunExe(), "lint", ...args],
+ env: bunEnv,
+ cwd: String(dir),
+ stdout: "pipe",
+ stderr: "pipe",
+ });
+ const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+ return { stdout, stderr, exitCode };
+}
+
+const couldNotBeParsed = "The package.json file could not be parsed: ";
+/** What the rule says is wrong with the text. It also reports the imports, since it knows no dependencies then. */
+const syntaxErrors = (messages: string[]) => messages.filter(it => it.startsWith(couldNotBeParsed));
+
+/**
+ * Runs `import/no-extraneous-dependencies` once per text, with that text as the package.json it reads.
+ * Returns the rule's messages for each text.
+ */
+async function readAsPackageJson(texts: string[]) {
+ const rule = (packageDir: string) => ({ "import/no-extraneous-dependencies": ["error", { packageDir }] });
+ const { stdout, stderr } = await lint(
+ {
+ ...packages,
+ "package.json": `{"name":"root"}`,
+ ".oxlintrc.json": JSON.stringify({
+ plugins: ["import"],
+ categories: { correctness: "off" },
+ overrides: texts.map((_, i) => ({ files: [`${i}.js`], rules: rule(`./${i}`) })),
+ }),
+ ...Object.fromEntries(
+ texts.flatMap((text, i) => [[`${i}.js`, code] as const, [`${i}/package.json`, text] as const]),
+ ),
+ },
+ ["-f", "json", ...texts.map((_, i) => `${i}.js`)],
+ );
+ expect(stderr).toBe("");
+ const found = JSON.parse(stdout).diagnostics as { filename: string; message: string }[];
+ return texts.map((_, i) => found.filter(it => it.filename === `${i}.js`).map(it => it.message));
+}
+
+// Deep enough that anything that recurses once per level overflows an 8 MB stack.
+const depth = 100_000;
+// `String.prototype.repeat` is very slow in debug builds of JavaScriptCore.
+const repeat = (unit: string, count: number) => Buffer.alloc(count * unit.length, unit).toString();
+const nested = {
+ arrays: repeat("[", depth) + repeat("]", depth),
+ objects: repeat('{"a":', depth) + "1" + repeat("}", depth),
+ both: repeat('[{"a":', depth / 2) + "1" + repeat("}]", depth / 2),
+};
+
+describe.concurrent("JSON files that rules read", () => {
+ // What `JSON.parse(text)` throws in Node.js 26. V8 cuts between the halves of a surrogate pair, and half a pair prints as U+FFFD.
+ const invalid: [text: string, message: string][] = [
+ ["", "Unexpected end of JSON input"],
+ [" \n", "Unexpected end of JSON input"],
+ ["{", "Expected property name or '}' in JSON at position 1 (line 1 column 2)"],
+ ["[", "Unexpected end of JSON input"],
+ ["]", "Unexpected token ']', \"]\" is not valid JSON"],
+ ["[1", "Expected ',' or ']' after array element in JSON at position 2 (line 1 column 3)"],
+ ["[1,", "Unexpected end of JSON input"],
+ ["[1,]", "Unexpected token ']', \"[1,]\" is not valid JSON"],
+ ["[,1]", "Unexpected token ',', \"[,1]\" is not valid JSON"],
+ ["[1 2]", "Expected ',' or ']' after array element in JSON at position 3 (line 1 column 4)"],
+ ['{"a"', "Expected ':' after property name in JSON at position 4 (line 1 column 5)"],
+ ['{"a":', "Unexpected end of JSON input"],
+ ['{"a":1', "Expected ',' or '}' after property value in JSON at position 6 (line 1 column 7)"],
+ ['{"a":1,', "Expected double-quoted property name in JSON at position 7 (line 1 column 8)"],
+ ['{"a":1,}', "Expected double-quoted property name in JSON at position 7 (line 1 column 8)"],
+ ["{a:1}", "Expected property name or '}' in JSON at position 1 (line 1 column 2)"],
+ ["{'a':1}", "Expected property name or '}' in JSON at position 1 (line 1 column 2)"],
+ ['{"a" 1}', "Expected ':' after property name in JSON at position 5 (line 1 column 6)"],
+ ['{"a":1 "b":2}', "Expected ',' or '}' after property value in JSON at position 7 (line 1 column 8)"],
+ ["{,}", "Expected property name or '}' in JSON at position 1 (line 1 column 2)"],
+ ["{1:2}", "Expected property name or '}' in JSON at position 1 (line 1 column 2)"],
+ ["-", "No number after minus sign in JSON at position 1 (line 1 column 2)"],
+ ["-a", "No number after minus sign in JSON at position 1 (line 1 column 2)"],
+ ["01", "Unexpected number in JSON at position 1 (line 1 column 2)"],
+ ["-01", "Unexpected number in JSON at position 2 (line 1 column 3)"],
+ ["1.", "Unterminated fractional number in JSON at position 2 (line 1 column 3)"],
+ ["1.e1", "Unterminated fractional number in JSON at position 2 (line 1 column 3)"],
+ ["1e", "Exponent part is missing a number in JSON at position 2 (line 1 column 3)"],
+ ["1e+", "Exponent part is missing a number in JSON at position 3 (line 1 column 4)"],
+ ["0x1", "Unexpected non-whitespace character after JSON at position 1 (line 1 column 2)"],
+ ["+1", "Unexpected token '+', \"+1\" is not valid JSON"],
+ [".5", "Unexpected token '.', \".5\" is not valid JSON"],
+ ["1 2", "Unexpected non-whitespace character after JSON at position 2 (line 1 column 3)"],
+ ['"', "Unterminated string in JSON at position 1 (line 1 column 2)"],
+ ['"a', "Unterminated string in JSON at position 2 (line 1 column 3)"],
+ ['"\\', "Unexpected end of JSON input"],
+ ['"\\x"', "Bad escaped character in JSON at position 2 (line 1 column 3)"],
+ ['"\\u12"', "Bad Unicode escape in JSON at position 5 (line 1 column 6)"],
+ ['"\\u123g"', "Bad Unicode escape in JSON at position 6 (line 1 column 7)"],
+ ['"a\nb"', "Bad control character in string literal in JSON at position 2 (line 1 column 3)"],
+ ['"a\tb"', "Bad control character in string literal in JSON at position 2 (line 1 column 3)"],
+ ['"\\é"', "Bad escaped character in JSON at position 2 (line 1 column 3)"],
+ ["tru", "Unexpected end of JSON input"],
+ ["truex", "Unexpected non-whitespace character after JSON at position 4 (line 1 column 5)"],
+ ["true x", "Unexpected non-whitespace character after JSON at position 5 (line 1 column 6)"],
+ ["nul", "Unexpected end of JSON input"],
+ ["NaN", '"NaN" is not valid JSON'],
+ ["Infinity", '"Infinity" is not valid JSON'],
+ ["-Infinity", "No number after minus sign in JSON at position 1 (line 1 column 2)"],
+ ["undefined", '"undefined" is not valid JSON'],
+ ["[object Object]", '"[object Object]" is not valid JSON'],
+ [" NaN", "Unexpected token 'N', \" NaN\" is not valid JSON"],
+ ["[NaN]", "Unexpected token 'N', \"[NaN]\" is not valid JSON"],
+ ["é", "Unexpected token 'é', \"é\" is not valid JSON"],
+ ["😀", "Unexpected token '\ufffd', \"😀\" is not valid JSON"],
+ ["[😀]", "Unexpected token '\ufffd', \"[😀]\" is not valid JSON"],
+ ["// c\n{}", "Unexpected token '/', \"// c\n{}\" is not valid JSON"],
+ ["{} // c", "Unexpected non-whitespace character after JSON at position 3 (line 1 column 4)"],
+ ["[1]\n\n x", "Unexpected non-whitespace character after JSON at position 7 (line 3 column 3)"],
+ ["[1]\r\n\r\n x", "Unexpected non-whitespace character after JSON at position 9 (line 3 column 3)"],
+ ["[1]\r\r x", "Unexpected non-whitespace character after JSON at position 6 (line 3 column 2)"],
+ ['{\n "a": 1,\n "b": x\n}', 'Unexpected token \'x\', ..."1,\n "b": x\n}" is not valid JSON'],
+ [
+ "[1,2,3,4,5,6,7,8,9,10,x,12,13,14,15,16,17,18]",
+ "Unexpected token 'x', ...\",7,8,9,10,x,12,13,14\"... is not valid JSON",
+ ],
+ ["[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,x]", "Unexpected token 'x', ...\",15,16,17,x]\" is not valid JSON"],
+ ["[x,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]", "Unexpected token 'x', \"[x,2,3,4,5,\"... is not valid JSON"],
+ [" x ", "Unexpected token 'x', ...\" x \"... is not valid JSON"],
+ [" x ", "Unexpected token 'x', \" x \" is not valid JSON"],
+ ['"abc" "def"', "Unexpected non-whitespace character after JSON at position 6 (line 1 column 7)"],
+ ['["a" "b"]', "Expected ',' or ']' after array element in JSON at position 5 (line 1 column 6)"],
+ ['{"a":"b" "c"}', "Expected ',' or '}' after property value in JSON at position 9 (line 1 column 10)"],
+ [
+ '["😀😀😀😀😀😀",y,"😀😀😀😀😀😀"]',
+ 'Unexpected token \'y\', ..."😀😀😀😀",y,"😀😀😀\ufffd"... is not valid JSON',
+ ],
+ ["[1,\u000b2]", "Unexpected token '\u000b', \"[1,\u000b2]\" is not valid JSON"],
+ ["\u0000", "Unexpected token '\u0000', \"\u0000\" is not valid JSON"],
+ ];
+
+ test("syntax errors have V8's messages and positions", async () => {
+ const said = await readAsPackageJson(invalid.map(it => it[0]));
+ expect(said.map((it, i) => [invalid[i][0], syntaxErrors(it)])).toEqual(
+ invalid.map(it => [it[0], [couldNotBeParsed + it[1]]]),
+ );
+ });
+
+ test.each(Object.entries(nested))("deeply nested %s are read", async (_, value) => {
+ const dependencies = `"dependencies":{"listed":"1"}`;
+ const said = await readAsPackageJson([`{${dependencies},"x":${value}}\n`, `{"x":${value},${dependencies}}\n`]);
+ expect(said).toEqual([[unlisted], [unlisted]]);
+ });
+
+ test("an object with 100,000 names is read as fast as any other text of that size", async () => {
+ const names = Array.from({ length: 100_000 }, (_, i) => `"package-${i}":"1"`);
+ expect(await readAsPackageJson([`{"dependencies":{${names.join(",")},"listed":"1"}}`])).toEqual([[unlisted]]);
+ });
+
+ test("the last value of a repeated name counts", async () => {
+ const others = Array.from({ length: 40 }, (_, i) => `"name-${i}":${i}`).join(",");
+ const first = `"dependencies":{"unlisted":"1"}`;
+ const last = `"dependencies":{"listed":"1"}`;
+ const said = await readAsPackageJson([`{${first},${last}}`, `{${first},${others},${last}}`]);
+ expect(said).toEqual([[unlisted], [unlisted]]);
+ });
+
+ test("the closest package.json can be deeply nested", async () => {
+ const { stdout, exitCode } = await lint(
+ {
+ ...packages,
+ ".oxlintrc.json": JSON.stringify({
+ plugins: ["import"],
+ categories: { correctness: "off" },
+ rules: { "import/no-extraneous-dependencies": "error" },
+ }),
+ "package.json": `{"name":"root"}`,
+ "inner/package.json": `{"dependencies":{"listed":"1"},"x":${nested.arrays}}\n`,
+ "inner/src/a.js": code,
+ },
+ ["-f", "unix", "inner"],
+ );
+ expect(stdout).toBe(`inner/src/a.js:2:1: ${unlisted} [Error/import(no-extraneous-dependencies)]\n\n1 problem\n`);
+ expect(exitCode).toBe(1);
+ });
+
+ test("errors in deeply nested text have V8's messages and positions", async () => {
+ const texts: [text: string, message: string][] = [
+ [repeat("[", depth), "Unexpected end of JSON input"],
+ [repeat('{"a":', depth), "Unexpected end of JSON input"],
+ [
+ nested.arrays + "]",
+ `Unexpected non-whitespace character after JSON at position ${2 * depth} (line 1 column ${2 * depth + 1})`,
+ ],
+ [repeat("[", depth) + "}", `Unexpected token '}', ..."[[[[[[[[[[}" is not valid JSON`],
+ [
+ repeat("[\n", depth) + "1 2",
+ `Expected ',' or ']' after array element in JSON at position ${2 * depth + 2} (line ${depth + 1} column 3)`,
+ ],
+ ];
+ const said = await readAsPackageJson(texts.map(it => it[0]));
+ expect(said.map(syntaxErrors)).toEqual(texts.map(it => [couldNotBeParsed + it[1]]));
+ });
+});
+
+// `bun lint` looks for `eslintConfig` in every package.json on the way up.
+test.concurrent("a deeply nested package.json without eslintConfig doesn't stop the run", async () => {
+ const files = { "package.json": `{"name":"a","x":${nested.arrays}}\n`, "a.js": "debugger;\n" };
+ const { stdout, exitCode } = await lint(files, ["-f", "json", "--rule", "no-debugger: error", "a.js"]);
+ expect(JSON.parse(stdout)[0].messages.map((it: { message: string }) => it.message)).toEqual([
+ "Unexpected 'debugger' statement.",
+ ]);
+ expect(exitCode).toBe(1);
+});
+
+describe.concurrent("/* eslint rule: .. */ comments", () => {
+ const plugin = `
+ const create = context => ({
+ Program(node) {
+ let depth = 0;
+ let value = context.options[0];
+ for (; value !== null && typeof value === "object"; depth++) value = Array.isArray(value) ? value[0] : value.a;
+ context.report({ node, message: "depth " + depth + ", innermost " + value });
+ },
+ });
+ const self = { anyOf: [{ type: "number" }, { type: "array", items: { $ref: "#/definitions/self" } }] };
+ export default {
+ rules: {
+ unchecked: { meta: { schema: false }, create },
+ anything: { meta: { schema: [{}] }, create },
+ recursive: { meta: { schema: { definitions: { self }, type: "array", items: [self] } }, create },
+ },
+ };
+ `;
+ const config = `import mini from "./plugin.mjs";\nexport default [{ plugins: { mini } }];\n`;
+
+ /** Shortens runs of brackets: `[[[[[[[[[[[[` becomes `<12 [>`. */
+ const short = (text: string) =>
+ text.replace(/(\[|\]|\{"a":|\})\1{9,}/g, (run, unit) => `<${run.length / unit.length} ${unit}>`);
+
+ async function messages(comment: string) {
+ const files = { "eslint.config.mjs": config, "plugin.mjs": plugin, "a.js": `/* eslint ${comment} */\nlet a;\n` };
+ const { stdout } = await lint(files, ["-f", "json", "a.js"]);
+ const found = JSON.parse(stdout)[0].messages as { ruleId: string | null; message: string }[];
+ return found.map(it => `${it.ruleId}: ${short(it.message)}`);
+ }
+
+ // All of these are what ESLint 10.12 prints.
+ test.each([
+ ["mini/unchecked", nested.arrays, `depth ${depth}, innermost undefined`],
+ ["mini/unchecked", nested.objects, `depth ${depth}, innermost 1`],
+ ["mini/anything", nested.both, `depth ${depth}, innermost 1`],
+ ])("%s gets deeply nested options", async (rule, options, said) => {
+ expect(await messages(`${rule}: [2, ${options}]`)).toEqual([`${rule}: ${said}`]);
+ });
+
+ test("messages about invalid options print deeply nested values", async () => {
+ const said = await Promise.all([nested.arrays, nested.objects].map(it => messages(`eqeqeq: [2, ${it}]`)));
+ const invalid = (value: string, all: string) =>
+ `eqeqeq: Inline configuration for rule "eqeqeq" is invalid:\n` +
+ `\tValue ${value} should be equal to one of the allowed values.\n`.repeat(2) +
+ `\tValue ${all} should match some schema in anyOf.\n`;
+ expect(said).toEqual([
+ [invalid(`<${depth} [><${depth} ]>`, `<${depth + 1} [><${depth + 1} ]>`)],
+ [invalid(`<${depth} {"a":>1<${depth} }>`, `[<${depth} {"a":>1<${depth} }>]`)],
+ ]);
+ });
+
+ test("a schema that refers to itself runs out of stack like Ajv does", async () => {
+ expect(await messages(`mini/recursive: [2, ${repeat("[", depth)}1${repeat("]", depth)}]`)).toEqual([
+ `mini/recursive: Inline configuration for rule "mini/recursive" is invalid:\n\tMaximum call stack size exceeded\n`,
+ ]);
+ });
+
+ test("errors in deeply nested text have V8's messages and positions", async () => {
+ const texts = [repeat("[", depth), nested.arrays + "]", repeat('{"a":', depth)];
+ const failed = `null: Failed to parse JSON from '"eqeqeq": [2, `;
+ expect(await Promise.all(texts.map(it => messages(`eqeqeq: [2, ${it}]`)))).toEqual([
+ [
+ `${failed}<${depth} [>]': Expected ',' or ']' after array element in JSON ` +
+ `at position ${depth + 16} (line 1 column ${depth + 17})`,
+ ],
+ [
+ `${failed}<${depth} [><${depth + 2} ]>': Expected ',' or '}' after property value in JSON ` +
+ `at position ${2 * depth + 16} (line 1 column ${2 * depth + 17})`,
+ ],
+ [`${failed}<${depth} {"a":>]': Unexpected token ']', ..."{"a":{"a":]}" is not valid JSON`],
+ ]);
+ });
+});
diff --git a/test/cli/lint/lint.test.ts b/test/cli/lint/lint.test.ts
index 2872378257ad..23a464a722ba 100644
--- a/test/cli/lint/lint.test.ts
+++ b/test/cli/lint/lint.test.ts
@@ -21,6 +21,7 @@ import {
readdirSync,
readFileSync,
realpathSync,
+ rmSync,
statSync,
symlinkSync,
truncateSync,
@@ -199,7 +200,7 @@ describe.concurrent("bun lint", () => {
const reports = (stdout: string) =>
stdout
.split("\n")
- .flatMap(line => /^\/(\S+?:\d+:\d+): .*?'(\w+)'.* \[Error\/(.*)\]$/.exec(line)?.slice(1).join(" ") ?? []);
+ .flatMap(line => /^\/(\S+?:\d+:\d+): .*?'(\w+)'.* \[\w+\/(.*)\]$/.exec(line)?.slice(1).join(" ") ?? []);
const union = ["a/a.js:1:35 nothing no-undef", "d/build.js:1:39 nothing no-undef"];
test("without a configuration file, with --infer-globals", async () => {
@@ -300,7 +301,9 @@ describe.concurrent("bun lint", () => {
}),
]);
expect(read.stdout).toContain("/a.mjs:1:1: Unexpected var, use let or const instead. [Error/no-var]");
- expect(unread.stderr).toContain("1 file was not linted, only the parser of the configuration can read it: b.mjs.");
+ expect(unread.stderr).toContain(
+ "1 file was not linted because only the parser in your config can read it: b.mjs\n",
+ );
expect([read.exitCode, unread.exitCode]).toEqual([1, 2]);
});
@@ -330,17 +333,17 @@ describe.concurrent("bun lint", () => {
"vendor.min.js": "debugger;\n",
".gitignore": "dist\n",
},
- [],
+ ["-f", "stylish"],
);
expect(stdout).toMatchInlineSnapshot(`
"/a.js
- 2:5 error 'unused' is defined but never used no-unused-vars
- 3:1 error 'undefinedName' is not defined no-undef
+ 2:5 warning 'unused' is defined but never used no-unused-vars
+ 3:1 error 'undefinedName' is not defined no-undef
/b.ts
- 1:17 error Unexpected any. Specify a different type @typescript-eslint/no-explicit-any
+ 1:17 warning Unexpected any. Specify a different type @typescript-eslint/no-explicit-any
- ✖ 3 problems (3 errors, 0 warnings)"
+ ✖ 3 problems (1 error, 2 warnings)"
`);
expect(exitCode).toBe(1);
});
@@ -383,9 +386,14 @@ describe.concurrent("bun lint", () => {
"b.ts": 'import source x from "m";\ndebugger;\n',
"c.js": 'import.source("m");\ndebugger;\n',
"d.tsx": "<>\n<\n/>;\ndebugger;\n",
+ // The attributes of a re-export on the next line, where TypeScript reads a `with` statement. In JavaScript espree reads these.
+ "e.ts": 'export * from "m"\nwith { type: "json" }\ndebugger;\n',
+ "f.ts": 'export * as ns from "m"\nwith { type: "json" }\ndebugger;\n',
+ "g.ts": 'export { a } from "m"\nwith { type: "json" }\ndebugger;\n',
+ "h.ts": 'export { default as k } from "m"\nwith { type: "json" }\ndebugger;\n',
};
const names = Object.keys(files);
- const lines = (stdout: string) => stdout.split("\n").filter(line => /^\S*[a-d]\.\w+:\d/.test(line));
+ const lines = (stdout: string) => stdout.split("\n").filter(line => /^\S*[a-h]\.\w+:\d/.test(line));
const rules = { "no-debugger": "error" };
const ofOxlint = JSON.stringify({ categories: { correctness: "off" }, rules });
const ofEslint = `export default [{ files: ["**/*.{js,ts,tsx}"], rules: ${JSON.stringify(rules)} }];\n`;
@@ -393,8 +401,654 @@ describe.concurrent("bun lint", () => {
lint({ ".oxlintrc.json": ofOxlint, ...files }, ["-f", "unix", ...names]),
lint({ "eslint.config.js": ofEslint, ...files }, ["-f", "unix", ...names]),
]);
- expect(lines(oxlint.stdout).map(line => /no-debugger/.test(line))).toEqual([true, true, true, true]);
- expect(lines(eslint.stdout).map(line => /Parsing error: /.test(line))).toEqual([true, true, true, true]);
+ expect(lines(oxlint.stdout).map(line => /no-debugger/.test(line))).toEqual(names.map(() => true));
+ expect(lines(eslint.stdout).map(line => /Parsing error: /.test(line))).toEqual(names.map(() => true));
+ });
+
+ // Each row is what oxlint 1.87 prints, in its order. tsc, typescript-estree, espree and Babel reject an escape in a name of JSX.
+ test("with .oxlintrc.json a name of JSX with a unicode escape is the text as written", async () => {
+ const rows: [extension: string, code: string, found: string[]][] = [
+ ["tsx", 'const X = () => null;\nexport const a =
;",
+ ["error: Expected corresponding JSX closing tag for 'd\\u0069v'. @29+3"],
+ ],
+ ];
+ const rules = { "no-undef": "error", "no-unused-vars": "warn", "react/no-unknown-property": "error" };
+ const files = Object.fromEntries(rows.map(([extension, code], i) => [`a${i}.${extension}`, code + "\n"]));
+ const { raw } = await lint(
+ { ".oxlintrc.json": JSON.stringify({ categories: { correctness: "off" }, plugins: ["react"], rules }), ...files },
+ ["-f", "json"],
+ );
+ type Diagnostic = { filename: string; code?: string; message: string; labels: { span: Recordx
', 'x
']],
+ "a.mdx": [
+ ['\n', '\n'],
+ ['export const a = cn("p-4 flex");', 'export const a = cn("flex p-4");'],
+ ],
+ "lwc/a.html": [
+ [
+ 'x',
+ 'x',
+ ],
+ ],
+ "a.vue": [
+ [
+ `\n \n`,
+ `\n \n`,
+ ],
+ ],
+ };
+ const text = (at: 0 | 1) => (lines: [string, string][]) => lines.map(it => it[at] || it[0]).join("\n") + "\n";
+ const options = { ...names, overrides: [{ files: "lwc/**", options: { parser: "lwc" } }] };
+ const files = Object.fromEntries(Object.entries(rows).map(([name, lines]) => [name, text(0)(lines)]));
+ const result = await format({ ...project, ...config(options), ...files }, Object.keys(rows));
+ expect(result.stderr).toBe("");
+ expect(Object.fromEntries(Object.keys(rows).map((name, index) => [name, result.files[index]]))).toEqual(
+ Object.fromEntries(Object.entries(rows).map(([name, lines]) => [name, text(1)(lines)])),
+ );
+ expect(result.exitCode).toBe(0);
+ });
+
+ test("a class stays apart from the text of a template that it touches", async () => {
+ // The code, what Bun makes of it, and what the plugin makes of it: one class of `x` and `flex`.
+ const rows: RecordPrix\u00a0: 10\u00a0€
; +export const name = \`名前\u3000太郎\`; +export const pattern = /10\u00a0kg/; +export const total\u00a0= 1; +`, + }; + const { native, eslint } = await inBothModes(files, ["no-irregular-whitespace"]); + expect(native).toEqual(["a.jsx:5:19 error no-irregular-whitespace"]); + expect(eslint).toEqual([ + "a.jsx:1:14 error no-irregular-whitespace", + "a.jsx:1:23 error no-irregular-whitespace", + "a.jsx:2:29 error no-irregular-whitespace", + "a.jsx:2:34 error no-irregular-whitespace", + "a.jsx:3:24 error no-irregular-whitespace", + "a.jsx:4:27 error no-irregular-whitespace", + "a.jsx:5:19 error no-irregular-whitespace", + ]); + }); + + test("a short circuit or a ternary that calls something is a fine statement", async () => { + const code = `export function f(done, a, b) { + done && done(); + done ? a() : b(); + done && a; + done ? a : b; +} +`; + const rule = "no-unused-expressions"; + const bunfig = { "bunfig.toml": `[lint.rules]\n"${rule}" = "warn"\n` }; + const files = { "a.js": code, "b.ts": code }; + const [plain, turnedOn] = await Promise.all([lint(files, []), lint({ ...files, ...bunfig }, [])]); + const own = (reports: string[]) => reports.filter(it => it.endsWith(rule)); + // The core rule is off by default. It gets the same options when it's turned on. + expect(own(plain.reports)).toEqual([ + `b.ts:4:3 warning @typescript-eslint/${rule}`, + `b.ts:5:3 warning @typescript-eslint/${rule}`, + ]); + expect(own(turnedOn.reports)).toEqual([ + `a.js:4:3 warning ${rule}`, + `a.js:5:3 warning ${rule}`, + `b.ts:4:3 warning @typescript-eslint/${rule}`, + `b.ts:5:3 warning @typescript-eslint/${rule}`, + ]); + const { eslint } = await inBothModes({ "a.js": code }, [rule]); + expect(eslint).toEqual([2, 3, 4, 5].map(line => `a.js:${line}:3 error ${rule}`)); + }); + + test("an async function as a JSX event handler isn't a misused promise", async () => { + const files = { + "tsconfig.json": `{ "compilerOptions": { "strict": true, "jsx": "preserve", "types": [] } }`, + "a.tsx": `declare global { + namespace JSX { + interface IntrinsicElements { + form: { onSubmit?: () => void }; + } + } +} +declare function save(): Promise- {[
- a ,
- b ]}
- {on && [
- a ]}
+ {false &&
+);
+`,
+ };
+ const rule = "no-constant-binary-expression";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ expect(native).toEqual([7, 8, 9, 10].map(line => `a.jsx:${line}:6 error ${rule}`));
+ expect(eslint).toEqual([3, 4, 5, 6, 7, 8, 9, 10].map(line => `a.jsx:${line}:6 error ${rule}`));
+ });
+
+ test.each(["a.js", "a.ts"])("%s: an integer that loses precision is an error, a decimal is fine", async name => {
+ const files = {
+ [name]: `export const PI = 3.14159265358979323846;
+export const LAT = 52.520006599999997;
+export const ID = 9007199254740993;
+export const BIG = 1234567890123456789;
+export const HEX = 0xffffffffffffffff;
+export const TINY = 1e-400;
+export const HUGE = 1e400;
+export const HALF = 9007199254740993.5;
+`,
+ };
+ const rule = "no-loss-of-precision";
+ const { native, eslint } = await inBothModes(files, [rule]);
+ const at = (places: string[]) => places.map(place => `${name}:${place} error ${rule}`);
+ const integers = ["3:19", "4:20", "5:20", "6:21", "7:21", "8:21"];
+ expect(native).toEqual(at(integers));
+ expect(eslint).toEqual(at(["1:19", "2:20", ...integers]));
+ });
+
+ test("the options that only bun lint has are invalid with an ESLint config", async () => {
+ const config = `export default [{ rules: { "no-loss-of-precision": ["error", { ignoreDecimals: true }] } }];\n`;
+ const { stderr, exitCode } = await lint({ "a.js": "export {};\n", "eslint.config.mjs": config }, ["a.js"]);
+ expect(stderr).toContain(`Key "rules": Key "no-loss-of-precision":`);
+ expect(exitCode).toBe(2);
+ });
+
+ test("an empty object pattern is fine as a parameter", async () => {
+ const files = { "a.js": "export const a = ({}, use) => use();\nconst {} = a;\n" };
+ const { native, eslint } = await inBothModes(files, ["no-empty-pattern"]);
+ expect(native).toEqual(["a.js:2:7 warning no-empty-pattern"]);
+ expect(eslint).toEqual(["a.js:1:19 error no-empty-pattern", "a.js:2:7 error no-empty-pattern"]);
+ });
+
+ test("a global that the file tests with typeof may be used", async () => {
+ const files = {
+ "a.js": `export function umd(factory) {
+ if (typeof define === "function" && define.amd) define(factory);
+ return typeof myGlobal !== "undefined" ? myGlobal.x : missing.x;
+}
+`,
+ };
+ const { native, eslint } = await inBothModes(files, ["no-undef"]);
+ expect(native).toEqual(["a.js:3:57 error no-undef"]);
+ expect(eslint).toEqual(["2:39", "2:51", "3:44", "3:57"].map(place => `a.js:${place} error no-undef`));
+ const strict = { "bunfig.toml": `[lint.rules]\n"no-undef" = ["error", { typeof = true }]\n` };
+ expect((await inBothModes({ ...files, ...strict }, ["no-undef"])).native).toEqual(
+ ["2:14", "2:39", "2:51", "3:17", "3:44", "3:57"].map(place => `a.js:${place} error no-undef`),
+ );
+ });
+
+ describe("an option you don't set keeps its default", () => {
+ const files = {
+ "a.js": "const _skip = 1;\nexport function f(unused) {}\n",
+ "b.jsx": "export const b = {false && };\nexport const c = 1 > 2;\n",
+ "c.js": "// 10\u00a0kg\nexport const weight = `10\u00a0kg`;\nexport const pattern = /10\u00a0kg/;\n",
+ };
+ const settings = [
+ [`"no-unused-vars"`, `["warn", { args = "none" }]`],
+ [`"no-constant-binary-expression"`, `["error", { checkRelationalComparisons = true }]`],
+ [`"no-irregular-whitespace"`, `["error", { skipRegExps = false }]`],
+ ];
+ const expected = ["b.jsx:2:18 error no-constant-binary-expression", "c.js:3:27 error no-irregular-whitespace"];
+
+ test("without options", async () => {
+ expect((await lint(files, [])).reports).toEqual(["a.js:2:19 warning no-unused-vars"]);
+ });
+
+ test("[lint.rules]", async () => {
+ const bunfig = `[lint.rules]\n${settings.map(it => it.join(" = ")).join("\n")}\n`;
+ expect((await lint({ ...files, "bunfig.toml": bunfig }, [])).reports).toEqual(expected);
+ });
+
+ test("[[lint.overrides]]", async () => {
+ const bunfig = `[[lint.overrides]]\nfiles = ["*"]\nrules = { ${settings.map(it => it.join(" = ")).join(", ")} }\n`;
+ expect((await lint({ ...files, "bunfig.toml": bunfig }, [])).reports).toEqual(expected);
+ });
+
+ test("--rule", async () => {
+ const rules = [
+ "no-unused-vars: [warn, { args: none }]",
+ "no-constant-binary-expression: [error, { checkRelationalComparisons: true }]",
+ "no-irregular-whitespace: [error, { skipRegExps: false }]",
+ ];
+ expect(
+ (
+ await lint(
+ files,
+ rules.flatMap(rule => ["--rule", rule]),
+ )
+ ).reports,
+ ).toEqual(expected);
+ });
+
+ test("a comment in the file", async () => {
+ const commented = {
+ "a.js": `${files["a.js"]}/* eslint no-unused-vars: ["warn", { "args": "none" }] */\n`,
+ "b.jsx": `${files["b.jsx"]}/* eslint no-constant-binary-expression: ["error", { "checkRelationalComparisons": true }] */\n`,
+ "c.js": `${files["c.js"]}/* eslint no-irregular-whitespace: ["error", { "skipRegExps": false }] */\n`,
+ };
+ expect((await lint(commented, [])).reports).toEqual(expected);
+ });
+
+ test("the options of an override replace those of [lint.rules], not the defaults", async () => {
+ const bunfig = `[lint.rules]
+"no-irregular-whitespace" = ["error", { skipComments = false }]
+[[lint.overrides]]
+files = ["c.js"]
+rules = { "no-irregular-whitespace" = ["error", { skipTemplates = false }] }
+`;
+ const { reports } = await lint({ "c.js": files["c.js"], "d.js": files["c.js"], "bunfig.toml": bunfig }, []);
+ expect(reports).toEqual(["c.js:2:26 error no-irregular-whitespace", "d.js:1:6 error no-irregular-whitespace"]);
+ });
+
+ test("objects merge key by key, anything else replaces", async () => {
+ const bunfig = `[lint.rules]
+"@typescript-eslint/no-misused-promises" = ["off", { checksVoidReturn = { arguments = false } }]
+"no-unused-vars" = ["warn", "local"]
+`;
+ const { json } = await lint({ "a.js": "", "bunfig.toml": bunfig }, ["--print-config", "a.js"]);
+ expect(json.rules["@typescript-eslint/no-misused-promises"]).toEqual([
+ 0,
+ {
+ checksVoidReturn: {
+ arguments: false,
+ attributes: false,
+ inheritedMethods: true,
+ properties: true,
+ returns: true,
+ variables: true,
+ },
+ },
+ ]);
+ expect(json.rules["no-unused-vars"]).toEqual([1, "local"]);
+ });
+
+ test("with an ESLint config, options replace options as in ESLint", async () => {
+ const config = `export default [
+ { rules: { "no-irregular-whitespace": ["error", { skipComments: true, skipTemplates: true }] } },
+ { rules: { "no-irregular-whitespace": ["error", { skipRegExps: true }] } },
+];\n`;
+ const { reports } = await lint({ "c.js": files["c.js"], "eslint.config.mjs": config }, ["c.js"]);
+ expect(reports).toEqual(["c.js:1:6 error no-irregular-whitespace", "c.js:2:26 error no-irregular-whitespace"]);
+ });
+ });
+});
+
+describe.concurrent("JSX uses the function it compiles to", () => {
+ const react = `import React from "react";\nexport const A = () => a
;\n`; + const preact = `/** @jsx h */\nimport { h, Fragment } from "preact";\nexport const A = () => (\n <>\na
\n \n);\n`; + + test.each(["a.js", "a.jsx", "a.tsx"])("React isn't unused in %s", async name => { + const { reports } = await lint({ [name]: react }, []); + expect(reports).toEqual([]); + }); + + test.each(["a.jsx", "a.tsx"])("the function that a @jsx comment names isn't unused in %s", async name => { + const { reports } = await lint({ [name]: preact }, []); + expect(reports).toEqual([]); + }); + + test("React is unused in a file without JSX", async () => { + const code = `import React from "react";\nexport const a = 1;\n`; + const { reports } = await lint({ "a.js": code, "b.ts": code }, []); + expect(reports).toEqual(["a.js:1:8 warning no-unused-vars", "b.ts:1:8 warning @typescript-eslint/no-unused-vars"]); + }); + + test("with the automatic runtime, turn react/jsx-uses-react off to find leftover imports", async () => { + const bunfig = `[lint.rules]\n"react/jsx-uses-react" = "off"\n`; + const { reports } = await lint({ "a.jsx": react, "bunfig.toml": bunfig }, []); + expect(reports).toEqual(["a.jsx:1:8 warning no-unused-vars"]); + }); + + test("--quiet doesn't bring the report back", async () => { + const bunfig = `[lint.rules]\n"no-unused-vars" = "error"\n`; + const { reports } = await lint({ "a.jsx": react, "bunfig.toml": bunfig }, ["--quiet"]); + expect(reports).toEqual([]); + }); + + test("with an ESLint config, only the rule from eslint-plugin-react does that", async () => { + const config = `export default [{ + files: ["**/*.jsx"], + languageOptions: { parserOptions: { ecmaFeatures: { jsx: true } } }, + rules: { "no-unused-vars": "error" }, +}];\n`; + const { reports } = await lint({ "a.jsx": react, "eslint.config.mjs": config }, ["a.jsx"]); + expect(reports).toEqual(["a.jsx:1:8 error no-unused-vars"]); + }); +}); + +describe.concurrent("--fix-suggestions never deletes code that does something", () => { + test("an unused variable stays if its initializer can have side effects", async () => { + const code = `const sent = sendEmail(user); +const last = queue.pop(); +const saved = await db.save(user); +const plain = 1; +import unused from "x"; +export {}; +`; + for (const flag of ["--fix-suggestions", "--fix-dangerously"]) { + const { texts, reports } = await lint({ "a.mjs": code }, [flag]); + expect(texts["a.mjs"]).toBe(`const sent = sendEmail(user); +const last = queue.pop(); +const saved = await db.save(user); +import "x"; +export {}; +`); + expect(reports.filter(it => it.endsWith("no-unused-vars"))).toEqual([ + "a.mjs:1:7 warning no-unused-vars", + "a.mjs:2:7 warning no-unused-vars", + "a.mjs:3:7 warning no-unused-vars", + ]); + } + }); + + const removed = [ + "const a = 1;", + 'const b = "text";', + "const c = -1 + 2 * 3;", + "const d = [1, [2], { e: 3, f() {}, get g() {} }];", + "const h = () => call();", + "const i = async function* () {};", + "const j = class extends Base { static k = 1; l = call(); };", + "const m = `text`;", + 'const n = typeof value === "string" ? null : !value;', + "const o = /a/u;", + "let p;", + "function q() { call(); }", + "class r { s = call(); }", + ]; + const kept = [ + "const a = call();", + "const b = new Thing();", + "const c = object.property;", + "const d = object[0];", + "const e = object?.property;", + "const f = [...list];", + "const g = { ...object };", + "const h = { [key]: 1 };", + "const i = tag`text`;", + "const j = `${value}`;", + "const k = (count = 1);", + "const l = count++;", + "const m = delete object.property;", + 'const n = import("x");', + "const o = class { static { call(); } };", + "const p = class { static q = call(); };", + "const r = class extends mixin() {};", + "const s = class { [key]() {} };", + 'const t = "property" in object;', + "const u = value instanceof Thing;", + "const v = [1, { w: [call()] }];", + "const x = true && (false || call());", + "const { y } = object;", + "const [z] = list;", + "class A { static B = call(); }", + "class C extends mixin() {}", + ]; + + test("declarations that only define something are removed, with their lines", async () => { + const { texts } = await lint({ "a.mjs": [...removed, "export {};", ""].join("\n") }, ["--fix-suggestions"]); + expect(texts["a.mjs"]).toBe("export {};\n"); + }); + + test.each([ + [ + "a line that has something else on it stays", + "const a = 1; // why\nconst b = 2; export {};\n", + "// why\nexport {};\n", + ], + ["no space stays at the end of a line", "g(); const a = 1;\nexport {};\n", "g();\nexport {};\n"], + [ + "no doubled space stays", + 'import { a, used } from "./b.js";\nused();\n', + 'import { used } from "./b.js";\nused();\n', + ], + [ + "no empty first line in a block", + "export function f() {\n const a = 1;\n\n return 1;\n}\n", + "export function f() {\n return 1;\n}\n", + ], + [ + "no empty last line in a block", + "export function f() {\n g();\n\n const a = 1;\n}\n", + "export function f() {\n g();\n}\n", + ], + [ + "no two empty lines in a row", + 'import x from "./x.js";\n\nconst a = 1;\n\nexport const y = x;\n', + 'import x from "./x.js";\n\nexport const y = x;\n', + ], + ["no empty line at the start of the file", "const a = 1;\n\nexport {};\n", "export {};\n"], + ["no empty line at the end of the file", "export {};\n\nconst a = 1;\n", "export {};\n"], + [ + "an empty line between two statements stays", + "g();\nconst a = 1;\n\nh();\nexport {};\n", + "g();\n\nh();\nexport {};\n", + ], + [ + "the same with \\r\\n", + "export function f() {\r\n const a = 1;\r\n\r\n return 1;\r\n}\r\n", + "export function f() {\r\n return 1;\r\n}\r\n", + ], + ])("%s", async (_, code, expected) => { + const { texts } = await lint({ "a.mjs": code }, ["--fix-suggestions"]); + expect(texts["a.mjs"]).toBe(expected); + }); + + test("declarations that run other code stay", async () => { + const code = [...kept, "export {};", ""].join("\n"); + const { texts, reports } = await lint({ "a.mjs": code }, ["--fix-suggestions"]); + expect(texts["a.mjs"]).toBe(code); + expect(reports.filter(it => it.endsWith("no-unused-vars")).length).toBe(kept.length); + }); + + test("a parameter stays, because the number of parameters can matter", async () => { + const code = "app.use((error, request, response, next) => {\n response.end(String(error));\n});\nexport {};\n"; + const bunfig = { "bunfig.toml": `[lint.rules]\n"no-unused-vars" = ["warn", { args = "all" }]\n` }; + const { texts, reports } = await lint({ "a.mjs": code, ...bunfig }, ["--fix-suggestions"]); + expect(texts["a.mjs"]).toBe(code); + expect(reports.filter(it => it.endsWith("no-unused-vars"))).toEqual([ + "a.mjs:1:17 warning no-unused-vars", + "a.mjs:1:36 warning no-unused-vars", + ]); + }); + + test("the top level of a classic script stays, because the page can use it", async () => { + const code = "function onClick() {}\nconst settings = { a: 1 };\n(function () {\n const inner = 1;\n})();\n"; + const { texts } = await lint({ "public/app.js": code, "lib.cjs": `${code}module.exports = {};\n` }, [ + "--fix-suggestions", + ]); + expect(texts["public/app.js"]).toBe("function onClick() {}\nconst settings = { a: 1 };\n(function () {\n})();\n"); + expect(texts["lib.cjs"]).toBe("(function () {\n})();\nmodule.exports = {};\n"); + }); + + test("only --fix-dangerously turns any into unknown or rewrites a dependency array", async () => { + const files = { + "package.json": JSON.stringify({ dependencies: { react: "^19.0.0" } }), + "a.ts": "export const then = (value: any) => value.then;\n", + "b.jsx": `import { useEffect } from "react"; +export function Timer({ ms, cb }) { + useEffect(() => { + setTimeout(cb, ms); + }, [ms]); + return null; +} +`, + }; + const [careful, dangerous] = await Promise.all([ + lint(files, ["--fix-suggestions"]), + lint(files, ["--fix-dangerously"]), + ]); + expect(careful.texts).toEqual(files); + expect(careful.reports).toEqual([ + "a.ts:1:29 warning @typescript-eslint/no-explicit-any", + "b.jsx:5:6 warning react-hooks/exhaustive-deps", + ]); + expect(dangerous.texts["a.ts"]).toBe(files["a.ts"].replace("any", "unknown")); + expect(dangerous.texts["b.jsx"]).toBe(files["b.jsx"].replace("[ms]", "[cb, ms]")); + }); + + test("it leaves alone what would change working code or break the type check", async () => { + const files = { + "tsconfig.json": `{ "compilerOptions": { "strict": true, "lib": ["esnext", "dom"], "types": [] } }`, + "a.ts": `// @ts-ignore +export const a: number = 1; +export interface Empty {} +export type Nothing = {}; +export const value = (map: Map-
+ {items.map(it => (
+
- {it} + ))} +
- {first}