feat: add pretty print support

Signed-off-by: Gordon Smith <[email protected]>

Author: Copilot

.gitattributes

@@ -1,3 +1,10 @@
-# Set default behavior to automatically normalize line endings.
+*.wit text eol=lf
+*.snap text eol=lf
+*.ts text eol=lf
+*.json text eol=lf
+*.mjs text eol=lf
+Cargo.toml text eol=lf
+README.md text eol=lf
+LICENSE text eol=lf# Set default behavior to automatically normalize line endings.
 * text=auto
 

package.json

@@ -181,6 +181,11 @@
                 "command": "wit-idl.extractCoreWasm",
                 "title": "Extract Core Wasm",
                 "category": "WIT"
+            },
+            {
+                "command": "wit-idl.formatDocument",
+                "title": "Format Document",
+                "category": "WIT"
             }
         ],
         "submenus": [
@@ -196,6 +201,11 @@
                     "when": "resourceExtname == .wit",
                     "group": "navigation"
                 },
+                {
+                    "command": "wit-idl.formatDocument",
+                    "when": "resourceExtname == .wit",
+                    "group": "1_modification@10"
+                },
                 {
                     "submenu": "wit-idl.generateBindings.submenu",
                     "when": "resourceExtname == .wit || witIdl.isWasmComponent",
@@ -289,6 +299,10 @@
                 {
                     "command": "wit-idl.extractCoreWasm",
                     "when": "witIdl.isWasmComponent"
+                },
+                {
+                    "command": "wit-idl.formatDocument",
+                    "when": "editorLangId == wit"
                 }
             ]
         },
@@ -301,6 +315,11 @@
             {
                 "command": "wit-idl.syntaxCheckWorkspace",
                 "key": "shift+f7"
+            },
+            {
+                "command": "wit-idl.formatDocument",
+                "key": "shift+alt+f",
+                "when": "editorTextFocus && editorLangId == wit"
             }
         ],
         "customEditors": [

src/extension.ts

@@ -0,0 +1,179 @@
+import * as vscode from "vscode";
+
+export class WitFormatter implements vscode.DocumentFormattingEditProvider {
+    private static replaceAll(line: string, replacements: Array<[RegExp, string]>): string {
+        let out = line;
+        for (const [pattern, repl] of replacements) {
+            out = out.replace(pattern, repl);
+        }
+        return out;
+    }
+
+    private static ensureSemicolon(line: string): string {
+        return line.replace(/\s*;\s*$/, ";");
+    }
+
+    private static collapseSpaces(line: string): string {
+        return line.replace(/\s+/g, " ");
+    }
+
+    public provideDocumentFormattingEdits(
+        document: vscode.TextDocument,
+        options: vscode.FormattingOptions
+    ): vscode.TextEdit[] {
+        const text = document.getText();
+        const formatted = this.formatWitContent(text, options);
+        if (formatted === text) {
+            return [];
+        }
+        const fullRange = new vscode.Range(document.positionAt(0), document.positionAt(text.length));
+        return [vscode.TextEdit.replace(fullRange, formatted)];
+    }
+
+    public formatWitContent(content: string, options: vscode.FormattingOptions): string {
+        const tabSize = options.tabSize ?? 2;
+        const insertSpaces = options.insertSpaces !== false;
+        const indentUnit = insertSpaces ? " ".repeat(tabSize) : "\t";
+        const lines = content.split(/\r?\n/);
+        const out: string[] = [];
+        let indentLevel = 0;
+        let inMultiLineTupleAlias = false;
+        let aliasGenericDepth = 0;
+        let inFuncParams = false;
+        for (let i = 0; i < lines.length; i++) {
+            const raw = lines[i];
+            const trimmed = raw.trim();
+            if (trimmed === "") {
+                out.push("");
+                continue;
+            }
+            if (/^\}/.test(trimmed)) {
+                indentLevel = Math.max(0, indentLevel - 1);
+            }
+            if (/^\/\//.test(trimmed)) {
+                const extra = inMultiLineTupleAlias && aliasGenericDepth > 0 && !/^>>/.test(trimmed) ? 1 : 0;
+                out.push(indentUnit.repeat(indentLevel + extra) + trimmed);
+                continue;
+            }
+            const formattedLine = this.formatLine(trimmed);
+            const needsTupleExtra = inMultiLineTupleAlias && aliasGenericDepth > 0 && !/^>>/.test(trimmed);
+            const needsFuncParamExtra = inFuncParams && !/^\)/.test(trimmed);
+            out.push(
+                indentUnit.repeat(indentLevel + (needsTupleExtra ? 1 : 0) + (needsFuncParamExtra ? 1 : 0)) +
+                    formattedLine
+            );
+            if (this.isOpeningBrace(trimmed)) {
+                indentLevel++;
+            }
+            if (!inFuncParams && /func\($/.test(trimmed)) {
+                let lookahead = i + 1;
+                let activate = true;
+                while (lookahead < lines.length) {
+                    const laTrim = lines[lookahead].trim();
+                    if (laTrim === "") {
+                        lookahead++;
+                        continue;
+                    }
+                    if (/^\/\//.test(laTrim)) {
+                        activate = false;
+                    }
+                    break;
+                }
+                if (activate) {
+                    inFuncParams = true;
+                }
+            } else if (inFuncParams && /^\)/.test(trimmed)) {
+                inFuncParams = false;
+            }
+            if (!inMultiLineTupleAlias && /^type\s+[^=]+=.*tuple<\s*$/.test(trimmed)) {
+                inMultiLineTupleAlias = true;
+                aliasGenericDepth = (trimmed.match(/</g) || []).length - (trimmed.match(/>/g) || []).length;
+            } else if (inMultiLineTupleAlias) {
+                const opens = (trimmed.match(/</g) || []).length;
+                const closes = (trimmed.match(/>/g) || []).length;
+                aliasGenericDepth += opens - closes;
+                if (aliasGenericDepth <= 0) {
+                    inMultiLineTupleAlias = false;
+                }
+            }
+        }
+        return out.join("\n");
+    }
+
+    private isOpeningBrace(line: string): boolean {
+        return line.endsWith("{") && !line.includes("}");
+    }
+
+    private formatLine(line: string): string {
+        if (line.startsWith("package ")) return this.formatPackage(line);
+        if (line.startsWith("interface ")) return this.formatNamedBlock(line);
+        if (line.startsWith("world ")) return this.formatNamedBlock(line);
+        if (this.isTypeDecl(line)) return this.formatNamedBlock(line);
+        if (line.startsWith("type ") && line.includes("=")) return this.formatTypeAlias(line);
+        if (this.isFuncDecl(line)) return this.formatFunc(line);
+        if (line.startsWith("import ") || line.startsWith("export ")) return this.formatImportExport(line);
+        if (line.startsWith("use ")) return this.formatUse(line);
+        if (this.isFieldDecl(line)) return this.formatField(line);
+        return line;
+    }
+
+    private isTypeDecl(line: string): boolean {
+        return /^(record|variant|enum|flags|resource)\s+/.test(line);
+    }
+    private isFuncDecl(line: string): boolean {
+        if (line.startsWith("import ") || line.startsWith("export ")) return false;
+        return /^[a-zA-Z][\w-]*\s*:\s*func\b/.test(line) || /:\s*func\b/.test(line) || /->/.test(line);
+    }
+    private isFieldDecl(line: string): boolean {
+        const t = line.trim();
+        return /^[a-zA-Z][a-zA-Z0-9-]*\s*[:,(]/.test(t) || /^[a-zA-Z][a-zA-Z0-9-]*\s*,?\s*$/.test(t);
+    }
+
+    private formatPackage(line: string): string {
+        return WitFormatter.ensureSemicolon(WitFormatter.collapseSpaces(line));
+    }
+    private formatNamedBlock(line: string): string {
+        return WitFormatter.collapseSpaces(line).replace(/\s*{\s*$/, " {");
+    }
+    private formatFunc(line: string): string {
+        const replacements: Array<[RegExp, string]> = [
+            [/:func/, ": func"],
+            [/:\s*func/, ": func"],
+            [/func\s*\(/, "func("],
+            [/\)\s*->\s*/, ") -> "],
+            [/\)->\s*/, ") -> "],
+            [/\)->/, ") -> "],
+            [/,\s*/g, ", "],
+            [/:\s*/g, ": "],
+        ];
+        return WitFormatter.ensureSemicolon(WitFormatter.replaceAll(line, replacements));
+    }
+    private formatImportExport(line: string): string {
+        const base = line.replace(/^(import|export)\s+/, "$1 ");
+        if (base.includes(": func") || base.includes(":func")) return this.formatFunc(base);
+        return WitFormatter.ensureSemicolon(base);
+    }
+    private formatUse(line: string): string {
+        const replacements: Array<[RegExp, string]> = [
+            [/^use\s+/, "use "],
+            [/\s+as\s+/, " as "],
+            [/\s+from\s+/, " from "],
+        ];
+        return WitFormatter.ensureSemicolon(WitFormatter.replaceAll(line, replacements));
+    }
+    private formatTypeAlias(line: string): string {
+        const replacements: Array<[RegExp, string]> = [
+            [/^type\s+/, "type "],
+            [/\s*=\s*/, " = "],
+        ];
+        return WitFormatter.ensureSemicolon(WitFormatter.replaceAll(line, replacements));
+    }
+    private formatField(line: string): string {
+        const replacements: Array<[RegExp, string]> = [
+            [/:\s*/g, ": "],
+            [/,\s*/g, ", "],
+            [/,\s*$/, ","],
+        ];
+        return WitFormatter.replaceAll(line, replacements);
+    }
+}

src/formatter.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeAll } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+vi.mock("vscode", () => ({}));
+let formatter: import("../src/formatter.js").WitFormatter;
+
+function collectWitFiles(dir: string, acc: string[] = []): string[] {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectWitFiles(full, acc);
+        } else if (entry.isFile() && entry.name.endsWith(".wit")) {
+            acc.push(full);
+        }
+    }
+    return acc;
+}
+
+describe("WIT formatter idempotency", () => {
+    const testRoot = path.join(__dirname);
+    const witFiles = collectWitFiles(testRoot).sort();
+    beforeAll(async () => {
+        const mod = await import("../src/formatter.js");
+        formatter = new mod.WitFormatter();
+    });
+
+    it("should find at least one .wit test file", () => {
+        expect(witFiles.length).toBeGreaterThan(0);
+    });
+
+    for (const file of witFiles) {
+        it(path.relative(testRoot, file), () => {
+            const original = fs.readFileSync(file, "utf8");
+            const formatted = formatter.formatWitContent(original, { tabSize: 2, insertSpaces: true });
+            const normalize = (s: string) => s.replace(/\r\n/g, "\n");
+            const origHadFinalNewline = /\n$/.test(original);
+            const nOriginal = normalize(original).replace(/\n+$/g, "") + (origHadFinalNewline ? "\n" : "");
+            const nFormatted = normalize(formatted).replace(/\n+$/g, "") + (origHadFinalNewline ? "\n" : "");
+            expect(nFormatted).toBe(nOriginal);
+        });
+    }
+});

tests/formatter-idempotent.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi } from "vitest";
+import { WitFormatter } from "../src/formatter.js";
+
+vi.mock("vscode", () => ({}));
+
+describe("WitFormatter", () => {
+    const formatter = new WitFormatter();
+    const options: { insertSpaces: boolean; tabSize: number } = { insertSpaces: true, tabSize: 2 };
+
+    it("formats package declaration", () => {
+        const input = "package   foo:bar   ;";
+        const expected = "package foo:bar;";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats interface block", () => {
+        const input = "package foo:bar;\n\ninterface   test{\nf1:func();\nf2:func(a:u32);\nf3:func()->u32;\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  f1: func();\n  f2: func(a: u32);\n  f3: func() -> u32;\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats world block", () => {
+        const input = "package foo:bar;\n\nworld   test{\nimport   test-interface;\nexport   run:func();\n}";
+        const expected = "package foo:bar;\n\nworld test {\n  import test-interface;\n  export run: func();\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats record definition", () => {
+        const input =
+            "package foo:bar;\n\ninterface test{\nrecord   person{\nname:string,\nage:u32,\nactive:bool,\n}\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  record person {\n    name: string,\n    age: u32,\n    active: bool,\n  }\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats complex function signature", () => {
+        const input =
+            "package foo:bar;\n\ninterface test{\ncomplex-func:func(a:u32,b:string,c:bool)->tuple<u32,string>;\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  complex-func: func(a: u32, b: string, c: bool) -> tuple<u32, string>;\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("preserves comments", () => {
+        const input =
+            "package foo:bar;\n\n// This is a line comment\ninterface test{\n/// This is a doc comment\nf1:func();\n/* Block comment */\nf2:func();\n}";
+        const expected =
+            "package foo:bar;\n\n// This is a line comment\ninterface test {\n  /// This is a doc comment\n  f1: func();\n  /* Block comment */\n  f2: func();\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats enum", () => {
+        const input =
+            "package foo:bar;\n\ninterface test{\nenum   status{\npending,\nrunning,\ncompleted,\nfailed,\n}\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  enum status {\n    pending,\n    running,\n    completed,\n    failed,\n  }\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats type aliases", () => {
+        const input = "package foo:bar;\n\ninterface test{\ntype   my-string=string;\ntype   my-list=list<u32>;\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  type my-string = string;\n  type my-list = list<u32>;\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("formats use statements", () => {
+        const input =
+            "package foo:bar;\n\ninterface test{\nuse   other:interface/types.{my-type};\nuse   another   as   alias;\n}";
+        const expected =
+            "package foo:bar;\n\ninterface test {\n  use other:interface/types.{my-type};\n  use another as alias;\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("handles empty document", () => {
+        expect(formatter.formatWitContent("", options)).toBe("");
+    });
+
+    it("is idempotent on already formatted input", () => {
+        const input =
+            "package foo:bar;\n\ninterface test {\n  f1: func();\n  f2: func(a: u32) -> string;\n}\n\nworld test-world {\n  import test;\n  export test;\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(input);
+    });
+
+    it("tuple type alias multiline indentation", () => {
+        const input = "type load-store-all-sizes = future<tuple<\nstring,\nu8,\n>>;";
+        const expected = "type load-store-all-sizes = future<tuple<\n  string,\n  u8,\n>>;";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+
+    it("function params multiline indentation", () => {
+        const input = "interface x {\n  foo: func(\n  a: u8,\n  b: u16,\n  );\n}";
+        const expected = "interface x {\n  foo: func(\n    a: u8,\n    b: u16,\n  );\n}";
+        expect(formatter.formatWitContent(input, options)).toBe(expected);
+    });
+});