📦 Optimized packaging

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/badge/badgeservice.ts

@@ -0,0 +1,64 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * Service represents the notifications service
+ * @module
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Call as $Call, Create as $Create} from "@wailsio/runtime";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as application$0 from "../../application/models.js";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as $models from "./models.js";
+
+/**
+ * RemoveBadge removes the badge label from the application icon.
+ */
+export function RemoveBadge(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2374916939) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceName returns the name of the service.
+ */
+export function ServiceName(): Promise<string> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2428202016) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceShutdown is called when the service is unloaded.
+ */
+export function ServiceShutdown(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3893755233) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceStartup is called when the service is loaded.
+ */
+export function ServiceStartup(options: application$0.ServiceOptions): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(4078800764, options) as any;
+    return $resultPromise;
+}
+
+/**
+ * SetBadge sets the badge label on the application icon.
+ */
+export function SetBadge(label: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(784276339, label) as any;
+    return $resultPromise;
+}
+
+export function SetCustomBadge(label: string, options: $models.Options): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3058653106, label, options) as any;
+    return $resultPromise;
+}

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/badge/index.ts

@@ -0,0 +1,9 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+import * as BadgeService from "./badgeservice.js";
+export {
+    BadgeService
+};
+
+export * from "./models.js";

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/badge/models.ts

@@ -0,0 +1,58 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Create as $Create} from "@wailsio/runtime";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as color$0 from "../../../../../../../image/color/models.js";
+
+export class Options {
+    "TextColour": color$0.RGBA;
+    "BackgroundColour": color$0.RGBA;
+    "FontName": string;
+    "FontSize": number;
+    "SmallFontSize": number;
+
+    /** Creates a new Options instance. */
+    constructor($$source: Partial<Options> = {}) {
+        if (!("TextColour" in $$source)) {
+            this["TextColour"] = (new color$0.RGBA());
+        }
+        if (!("BackgroundColour" in $$source)) {
+            this["BackgroundColour"] = (new color$0.RGBA());
+        }
+        if (!("FontName" in $$source)) {
+            this["FontName"] = "";
+        }
+        if (!("FontSize" in $$source)) {
+            this["FontSize"] = 0;
+        }
+        if (!("SmallFontSize" in $$source)) {
+            this["SmallFontSize"] = 0;
+        }
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new Options instance from a string or object.
+     */
+    static createFrom($$source: any = {}): Options {
+        const $$createField0_0 = $$createType0;
+        const $$createField1_0 = $$createType0;
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        if ("TextColour" in $$parsedSource) {
+            $$parsedSource["TextColour"] = $$createField0_0($$parsedSource["TextColour"]);
+        }
+        if ("BackgroundColour" in $$parsedSource) {
+            $$parsedSource["BackgroundColour"] = $$createField1_0($$parsedSource["BackgroundColour"]);
+        }
+        return new Options($$parsedSource as Partial<Options>);
+    }
+}
+
+// Private type creation functions
+const $$createType0 = color$0.RGBA.createFrom;

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/notifications/index.ts

@@ -0,0 +1,9 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+import * as NotificationService from "./notificationservice.js";
+export {
+    NotificationService
+};
+
+export * from "./models.js";

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/notifications/models.ts

@@ -0,0 +1,107 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Create as $Create} from "@wailsio/runtime";
+
+/**
+ * NotificationAction represents an action button for a notification.
+ */
+export class NotificationAction {
+    "id"?: string;
+    "title"?: string;
+
+    /**
+     * (macOS-specific)
+     */
+    "destructive"?: boolean;
+
+    /** Creates a new NotificationAction instance. */
+    constructor($$source: Partial<NotificationAction> = {}) {
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new NotificationAction instance from a string or object.
+     */
+    static createFrom($$source: any = {}): NotificationAction {
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        return new NotificationAction($$parsedSource as Partial<NotificationAction>);
+    }
+}
+
+/**
+ * NotificationCategory groups actions for notifications.
+ */
+export class NotificationCategory {
+    "id"?: string;
+    "actions"?: NotificationAction[];
+    "hasReplyField"?: boolean;
+    "replyPlaceholder"?: string;
+    "replyButtonTitle"?: string;
+
+    /** Creates a new NotificationCategory instance. */
+    constructor($$source: Partial<NotificationCategory> = {}) {
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new NotificationCategory instance from a string or object.
+     */
+    static createFrom($$source: any = {}): NotificationCategory {
+        const $$createField1_0 = $$createType1;
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        if ("actions" in $$parsedSource) {
+            $$parsedSource["actions"] = $$createField1_0($$parsedSource["actions"]);
+        }
+        return new NotificationCategory($$parsedSource as Partial<NotificationCategory>);
+    }
+}
+
+/**
+ * NotificationOptions contains configuration for a notification
+ */
+export class NotificationOptions {
+    "id": string;
+    "title": string;
+
+    /**
+     * (macOS and Linux only)
+     */
+    "subtitle"?: string;
+    "body"?: string;
+    "categoryId"?: string;
+    "data"?: { [_: string]: any };
+
+    /** Creates a new NotificationOptions instance. */
+    constructor($$source: Partial<NotificationOptions> = {}) {
+        if (!("id" in $$source)) {
+            this["id"] = "";
+        }
+        if (!("title" in $$source)) {
+            this["title"] = "";
+        }
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new NotificationOptions instance from a string or object.
+     */
+    static createFrom($$source: any = {}): NotificationOptions {
+        const $$createField5_0 = $$createType2;
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        if ("data" in $$parsedSource) {
+            $$parsedSource["data"] = $$createField5_0($$parsedSource["data"]);
+        }
+        return new NotificationOptions($$parsedSource as Partial<NotificationOptions>);
+    }
+}
+
+// Private type creation functions
+const $$createType0 = NotificationAction.createFrom;
+const $$createType1 = $Create.Array($$createType0);
+const $$createType2 = $Create.Map($Create.Any, $Create.Any);

frontend/bindings/github.com/wailsapp/wails/v3/pkg/services/notifications/notificationservice.ts

@@ -0,0 +1,110 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * Service represents the notifications service
+ * @module
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Call as $Call, Create as $Create} from "@wailsio/runtime";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as application$0 from "../../application/models.js";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as $models from "./models.js";
+
+export function CheckNotificationAuthorization(): Promise<boolean> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2216952893) as any;
+    return $resultPromise;
+}
+
+/**
+ * OnNotificationResponse registers a callback function that will be called when
+ * a notification response is received from the user.
+ */
+export function OnNotificationResponse(callback: any): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(1642697808, callback) as any;
+    return $resultPromise;
+}
+
+export function RegisterNotificationCategory(category: $models.NotificationCategory): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2917562919, category) as any;
+    return $resultPromise;
+}
+
+export function RemoveAllDeliveredNotifications(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3956282340) as any;
+    return $resultPromise;
+}
+
+export function RemoveAllPendingNotifications(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(108821341) as any;
+    return $resultPromise;
+}
+
+export function RemoveDeliveredNotification(identifier: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(975691940, identifier) as any;
+    return $resultPromise;
+}
+
+export function RemoveNotification(identifier: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3966653866, identifier) as any;
+    return $resultPromise;
+}
+
+export function RemoveNotificationCategory(categoryID: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2032615554, categoryID) as any;
+    return $resultPromise;
+}
+
+export function RemovePendingNotification(identifier: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3729049703, identifier) as any;
+    return $resultPromise;
+}
+
+/**
+ * Public methods that delegate to the implementation.
+ */
+export function RequestNotificationAuthorization(): Promise<boolean> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3933442950) as any;
+    return $resultPromise;
+}
+
+export function SendNotification(options: $models.NotificationOptions): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3968228732, options) as any;
+    return $resultPromise;
+}
+
+export function SendNotificationWithActions(options: $models.NotificationOptions): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(1886542847, options) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceName returns the name of the service.
+ */
+export function ServiceName(): Promise<string> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2704532675) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceShutdown is called when the service is unloaded.
+ */
+export function ServiceShutdown(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2550195434) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceStartup is called when the service is loaded.
+ */
+export function ServiceStartup(options: application$0.ServiceOptions): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(4047820929, options) as any;
+    return $resultPromise;
+}

frontend/bindings/image/color/index.ts

@@ -0,0 +1,4 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+export * from "./models.js";

frontend/bindings/image/color/models.ts

@@ -0,0 +1,46 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Create as $Create} from "@wailsio/runtime";
+
+/**
+ * RGBA represents a traditional 32-bit alpha-premultiplied color, having 8
+ * bits for each of red, green, blue and alpha.
+ * 
+ * An alpha-premultiplied color component C has been scaled by alpha (A), so
+ * has valid values 0 <= C <= A.
+ */
+export class RGBA {
+    "R": number;
+    "G": number;
+    "B": number;
+    "A": number;
+
+    /** Creates a new RGBA instance. */
+    constructor($$source: Partial<RGBA> = {}) {
+        if (!("R" in $$source)) {
+            this["R"] = 0;
+        }
+        if (!("G" in $$source)) {
+            this["G"] = 0;
+        }
+        if (!("B" in $$source)) {
+            this["B"] = 0;
+        }
+        if (!("A" in $$source)) {
+            this["A"] = 0;
+        }
+
+        Object.assign(this, $$source);
+    }
+
+    /**
+     * Creates a new RGBA instance from a string or object.
+     */
+    static createFrom($$source: any = {}): RGBA {
+        let $$parsedSource = typeof $$source === 'string' ? JSON.parse($$source) : $$source;
+        return new RGBA($$parsedSource as Partial<RGBA>);
+    }
+}

frontend/bindings/voidraft/internal/services/configservice.ts

@@ -50,6 +50,14 @@ export function GetSettingsPath(): Promise<string> & { cancel(): void } {
     return $resultPromise;
 }
 
+/**
+ * MigrateConfig 执行配置迁移
+ */
+export function MigrateConfig(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(434292783) as any;
+    return $resultPromise;
+}
+
 /**
  * ResetConfig 强制重置所有配置为默认值
  */

frontend/bindings/voidraft/internal/services/index.ts

@@ -13,11 +13,11 @@ import * as MigrationService from "./migrationservice.js";
 import * as SelfUpdateService from "./selfupdateservice.js";
 import * as StartupService from "./startupservice.js";
 import * as SystemService from "./systemservice.js";
+import * as TestService from "./testservice.js";
 import * as ThemeService from "./themeservice.js";
 import * as TranslationService from "./translationservice.js";
 import * as TrayService from "./trayservice.js";
 import * as WindowService from "./windowservice.js";
-import * as WindowSnapService from "./windowsnapservice.js";
 export {
     BackupService,
     ConfigService,
@@ -31,11 +31,11 @@ export {
     SelfUpdateService,
     StartupService,
     SystemService,
+    TestService,
     ThemeService,
     TranslationService,
     TrayService,
-    WindowService,
-    WindowSnapService
+    WindowService
 };
 
 export * from "./models.js";

frontend/bindings/voidraft/internal/services/testservice.ts

@@ -0,0 +1,55 @@
+// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
+// This file is automatically generated. DO NOT EDIT
+
+/**
+ * TestService 测试服务 - 仅在开发环境使用
+ * @module
+ */
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import {Call as $Call, Create as $Create} from "@wailsio/runtime";
+
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore: Unused imports
+import * as application$0 from "../../../github.com/wailsapp/wails/v3/pkg/application/models.js";
+
+/**
+ * ClearAll 清除所有测试状态
+ */
+export function ClearAll(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(2179720854) as any;
+    return $resultPromise;
+}
+
+/**
+ * ServiceStartup 服务启动时调用
+ */
+export function ServiceStartup(options: application$0.ServiceOptions): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(617408198, options) as any;
+    return $resultPromise;
+}
+
+/**
+ * TestBadge 测试Badge功能
+ */
+export function TestBadge(text: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(4242952145, text) as any;
+    return $resultPromise;
+}
+
+/**
+ * TestNotification 测试通知功能
+ */
+export function TestNotification(title: string, subtitle: string, body: string): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(1697553289, title, subtitle, body) as any;
+    return $resultPromise;
+}
+
+/**
+ * TestUpdateNotification 测试更新通知
+ */
+export function TestUpdateNotification(): Promise<void> & { cancel(): void } {
+    let $resultPromise = $Call.ByID(3091730060) as any;
+    return $resultPromise;
+}

frontend/bindings/voidraft/internal/services/windowsnapservice.ts

@@ -1,79 +0,0 @@
-// Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
-// This file is automatically generated. DO NOT EDIT
-
-/**
- * WindowSnapService 窗口吸附服务
- * @module
- */
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: Unused imports
-import {Call as $Call, Create as $Create} from "@wailsio/runtime";
-
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore: Unused imports
-import * as application$0 from "../../../github.com/wailsapp/wails/v3/pkg/application/models.js";
-
-/**
- * Cleanup 清理资源
- */
-export function Cleanup(): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(2155505498) as any;
-    return $resultPromise;
-}
-
-/**
- * GetCurrentThreshold 获取当前自适应阈值（用于调试或显示）
- */
-export function GetCurrentThreshold(): Promise<number> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(3176419026) as any;
-    return $resultPromise;
-}
-
-/**
- * OnWindowSnapConfigChanged 处理窗口吸附配置变更
- */
-export function OnWindowSnapConfigChanged(enabled: boolean): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(3794787039, enabled) as any;
-    return $resultPromise;
-}
-
-/**
- * RegisterWindow 注册需要吸附管理的窗口
- */
-export function RegisterWindow(documentID: number, window: application$0.WebviewWindow | null, title: string): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(1000222723, documentID, window, title) as any;
-    return $resultPromise;
-}
-
-/**
- * ServiceShutdown 实现服务关闭接口
- */
-export function ServiceShutdown(): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(1172710495) as any;
-    return $resultPromise;
-}
-
-/**
- * SetAppReferences 设置应用和主窗口引用
- */
-export function SetAppReferences(app: application$0.App | null, mainWindow: application$0.WebviewWindow | null): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(1782093351, app, mainWindow) as any;
-    return $resultPromise;
-}
-
-/**
- * SetSnapEnabled 设置是否启用窗口吸附
- */
-export function SetSnapEnabled(enabled: boolean): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(2280126835, enabled) as any;
-    return $resultPromise;
-}
-
-/**
- * UnregisterWindow 取消注册窗口
- */
-export function UnregisterWindow(documentID: number): Promise<void> & { cancel(): void } {
-    let $resultPromise = $Call.ByID(2844230768, documentID) as any;
-    return $resultPromise;
-}

frontend/package.json

@@ -5,20 +5,20 @@
   "type": "module",
   "scripts": {
     "dev": "vite --host --mode development",
-    "build:dev": "vue-tsc && vite build --minify false --mode development",
-    "build": "vue-tsc && vite build --mode production",
+    "build:dev": "cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" vue-tsc && cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" vite build --minify false --mode development",
+    "build": "cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" vue-tsc && cross-env NODE_OPTIONS=\"--max-old-space-size=8192\" vite build --mode production",
     "preview": "vite preview",
     "lint": "eslint",
     "lint:fix": "eslint --fix"
   },
   "dependencies": {
-    "@codemirror/autocomplete": "^6.18.6",
+    "@codemirror/autocomplete": "^6.18.7",
     "@codemirror/commands": "^6.8.1",
     "@codemirror/lang-angular": "^0.1.4",
     "@codemirror/lang-cpp": "^6.0.3",
     "@codemirror/lang-css": "^6.3.1",
     "@codemirror/lang-go": "^6.0.1",
-    "@codemirror/lang-html": "^6.4.9",
+    "@codemirror/lang-html": "^6.4.10",
     "@codemirror/lang-java": "^6.0.2",
     "@codemirror/lang-javascript": "^6.2.4",
     "@codemirror/lang-json": "^6.0.2",
@@ -33,7 +33,6 @@
     "@codemirror/lang-sql": "^6.9.1",
     "@codemirror/lang-vue": "^0.1.3",
     "@codemirror/lang-wast": "^6.0.2",
-    "@codemirror/lang-xml": "^6.1.0",
     "@codemirror/lang-yaml": "^6.1.2",
     "@codemirror/language": "^6.11.3",
     "@codemirror/language-data": "^6.5.1",
@@ -41,40 +40,54 @@
     "@codemirror/lint": "^6.8.5",
     "@codemirror/search": "^6.5.11",
     "@codemirror/state": "^6.5.2",
-    "@codemirror/view": "^6.38.1",
+    "@codemirror/view": "^6.38.2",
     "@lezer/highlight": "^1.2.1",
     "@lezer/lr": "^1.4.2",
+    "@prettier/plugin-xml": "^3.4.2",
+    "@reteps/dockerfmt": "^0.3.6",
     "codemirror": "^6.0.2",
     "codemirror-lang-elixir": "^4.0.0",
     "colors-named": "^1.0.2",
     "colors-named-hex": "^1.0.2",
     "franc-min": "^6.2.0",
     "hsl-matcher": "^1.2.4",
+    "java-parser": "^3.0.1",
+    "jinx-rust": "^0.1.6",
+    "jsox": "^1.2.123",
     "lezer": "^0.13.5",
+    "linguist-languages": "^9.0.0",
+    "node-sql-parser": "^5.3.12",
+    "php-parser": "^3.2.5",
     "pinia": "^3.0.3",
     "pinia-plugin-persistedstate": "^4.5.0",
     "prettier": "^3.6.2",
+    "prettier-plugin-toml": "^2.0.6",
     "remarkable": "^2.0.1",
-    "sass": "^1.90.0",
-    "vue": "^3.5.19",
-    "vue-i18n": "^11.1.11",
+    "sass": "^1.92.1",
+    "sh-syntax": "^0.5.8",
+    "sql-formatter": "^15.6.9",
+    "vue": "^3.5.21",
+    "vue-i18n": "^11.1.12",
     "vue-pick-colors": "^1.8.0",
     "vue-router": "^4.5.1"
   },
   "devDependencies": {
-    "@eslint/js": "^9.34.0",
+    "@eslint/js": "^9.35.0",
     "@lezer/generator": "^1.8.0",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.3.1",
     "@types/remarkable": "^2.0.8",
     "@vitejs/plugin-vue": "^6.0.1",
     "@wailsio/runtime": "latest",
-    "eslint": "^9.34.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.35.0",
     "eslint-plugin-vue": "^10.4.0",
-    "globals": "^16.3.0",
+    "globals": "^16.4.0",
+    "rollup-plugin-visualizer": "^6.0.3",
     "typescript": "^5.9.2",
-    "typescript-eslint": "^8.40.0",
+    "typescript-eslint": "^8.43.0",
     "unplugin-vue-components": "^29.0.0",
-    "vite": "^7.1.3",
+    "vite": "^7.1.5",
+    "vite-plugin-node-polyfills": "^0.24.0",
     "vue-eslint-parser": "^10.2.0",
     "vue-tsc": "^3.0.6"
   }

frontend/public/wasm_exec.js

@@ -0,0 +1,561 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+"use strict";
+
+(() => {
+	const enosys = () => {
+		const err = new Error("not implemented");
+		err.code = "ENOSYS";
+		return err;
+	};
+
+	if (!globalThis.fs) {
+		let outputBuf = "";
+		globalThis.fs = {
+			constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1 }, // unused
+			writeSync(fd, buf) {
+				outputBuf += decoder.decode(buf);
+				const nl = outputBuf.lastIndexOf("\n");
+				if (nl != -1) {
+					console.log(outputBuf.substring(0, nl));
+					outputBuf = outputBuf.substring(nl + 1);
+				}
+				return buf.length;
+			},
+			write(fd, buf, offset, length, position, callback) {
+				if (offset !== 0 || length !== buf.length || position !== null) {
+					callback(enosys());
+					return;
+				}
+				const n = this.writeSync(fd, buf);
+				callback(null, n);
+			},
+			chmod(path, mode, callback) { callback(enosys()); },
+			chown(path, uid, gid, callback) { callback(enosys()); },
+			close(fd, callback) { callback(enosys()); },
+			fchmod(fd, mode, callback) { callback(enosys()); },
+			fchown(fd, uid, gid, callback) { callback(enosys()); },
+			fstat(fd, callback) { callback(enosys()); },
+			fsync(fd, callback) { callback(null); },
+			ftruncate(fd, length, callback) { callback(enosys()); },
+			lchown(path, uid, gid, callback) { callback(enosys()); },
+			link(path, link, callback) { callback(enosys()); },
+			lstat(path, callback) { callback(enosys()); },
+			mkdir(path, perm, callback) { callback(enosys()); },
+			open(path, flags, mode, callback) { callback(enosys()); },
+			read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
+			readdir(path, callback) { callback(enosys()); },
+			readlink(path, callback) { callback(enosys()); },
+			rename(from, to, callback) { callback(enosys()); },
+			rmdir(path, callback) { callback(enosys()); },
+			stat(path, callback) { callback(enosys()); },
+			symlink(path, link, callback) { callback(enosys()); },
+			truncate(path, length, callback) { callback(enosys()); },
+			unlink(path, callback) { callback(enosys()); },
+			utimes(path, atime, mtime, callback) { callback(enosys()); },
+		};
+	}
+
+	if (!globalThis.process) {
+		globalThis.process = {
+			getuid() { return -1; },
+			getgid() { return -1; },
+			geteuid() { return -1; },
+			getegid() { return -1; },
+			getgroups() { throw enosys(); },
+			pid: -1,
+			ppid: -1,
+			umask() { throw enosys(); },
+			cwd() { throw enosys(); },
+			chdir() { throw enosys(); },
+		}
+	}
+
+	if (!globalThis.crypto) {
+		throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
+	}
+
+	if (!globalThis.performance) {
+		throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
+	}
+
+	if (!globalThis.TextEncoder) {
+		throw new Error("globalThis.TextEncoder is not available, polyfill required");
+	}
+
+	if (!globalThis.TextDecoder) {
+		throw new Error("globalThis.TextDecoder is not available, polyfill required");
+	}
+
+	const encoder = new TextEncoder("utf-8");
+	const decoder = new TextDecoder("utf-8");
+
+	globalThis.Go = class {
+		constructor() {
+			this.argv = ["js"];
+			this.env = {};
+			this.exit = (code) => {
+				if (code !== 0) {
+					console.warn("exit code:", code);
+				}
+			};
+			this._exitPromise = new Promise((resolve) => {
+				this._resolveExitPromise = resolve;
+			});
+			this._pendingEvent = null;
+			this._scheduledTimeouts = new Map();
+			this._nextCallbackTimeoutID = 1;
+
+			const setInt64 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+				this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
+			}
+
+			const setInt32 = (addr, v) => {
+				this.mem.setUint32(addr + 0, v, true);
+			}
+
+			const getInt64 = (addr) => {
+				const low = this.mem.getUint32(addr + 0, true);
+				const high = this.mem.getInt32(addr + 4, true);
+				return low + high * 4294967296;
+			}
+
+			const loadValue = (addr) => {
+				const f = this.mem.getFloat64(addr, true);
+				if (f === 0) {
+					return undefined;
+				}
+				if (!isNaN(f)) {
+					return f;
+				}
+
+				const id = this.mem.getUint32(addr, true);
+				return this._values[id];
+			}
+
+			const storeValue = (addr, v) => {
+				const nanHead = 0x7FF80000;
+
+				if (typeof v === "number" && v !== 0) {
+					if (isNaN(v)) {
+						this.mem.setUint32(addr + 4, nanHead, true);
+						this.mem.setUint32(addr, 0, true);
+						return;
+					}
+					this.mem.setFloat64(addr, v, true);
+					return;
+				}
+
+				if (v === undefined) {
+					this.mem.setFloat64(addr, 0, true);
+					return;
+				}
+
+				let id = this._ids.get(v);
+				if (id === undefined) {
+					id = this._idPool.pop();
+					if (id === undefined) {
+						id = this._values.length;
+					}
+					this._values[id] = v;
+					this._goRefCounts[id] = 0;
+					this._ids.set(v, id);
+				}
+				this._goRefCounts[id]++;
+				let typeFlag = 0;
+				switch (typeof v) {
+					case "object":
+						if (v !== null) {
+							typeFlag = 1;
+						}
+						break;
+					case "string":
+						typeFlag = 2;
+						break;
+					case "symbol":
+						typeFlag = 3;
+						break;
+					case "function":
+						typeFlag = 4;
+						break;
+				}
+				this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
+				this.mem.setUint32(addr, id, true);
+			}
+
+			const loadSlice = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return new Uint8Array(this._inst.exports.mem.buffer, array, len);
+			}
+
+			const loadSliceOfValues = (addr) => {
+				const array = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				const a = new Array(len);
+				for (let i = 0; i < len; i++) {
+					a[i] = loadValue(array + i * 8);
+				}
+				return a;
+			}
+
+			const loadString = (addr) => {
+				const saddr = getInt64(addr + 0);
+				const len = getInt64(addr + 8);
+				return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
+			}
+
+			const timeOrigin = Date.now() - performance.now();
+			this.importObject = {
+				_gotest: {
+					add: (a, b) => a + b,
+				},
+				gojs: {
+					// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
+					// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
+					// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
+					// This changes the SP, thus we have to update the SP used by the imported function.
+
+					// func wasmExit(code int32)
+					"runtime.wasmExit": (sp) => {
+						sp >>>= 0;
+						const code = this.mem.getInt32(sp + 8, true);
+						this.exited = true;
+						delete this._inst;
+						delete this._values;
+						delete this._goRefCounts;
+						delete this._ids;
+						delete this._idPool;
+						this.exit(code);
+					},
+
+					// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
+					"runtime.wasmWrite": (sp) => {
+						sp >>>= 0;
+						const fd = getInt64(sp + 8);
+						const p = getInt64(sp + 16);
+						const n = this.mem.getInt32(sp + 24, true);
+						fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
+					},
+
+					// func resetMemoryDataView()
+					"runtime.resetMemoryDataView": (sp) => {
+						sp >>>= 0;
+						this.mem = new DataView(this._inst.exports.mem.buffer);
+					},
+
+					// func nanotime1() int64
+					"runtime.nanotime1": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
+					},
+
+					// func walltime() (sec int64, nsec int32)
+					"runtime.walltime": (sp) => {
+						sp >>>= 0;
+						const msec = (new Date).getTime();
+						setInt64(sp + 8, msec / 1000);
+						this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
+					},
+
+					// func scheduleTimeoutEvent(delay int64) int32
+					"runtime.scheduleTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this._nextCallbackTimeoutID;
+						this._nextCallbackTimeoutID++;
+						this._scheduledTimeouts.set(id, setTimeout(
+							() => {
+								this._resume();
+								while (this._scheduledTimeouts.has(id)) {
+									// for some reason Go failed to register the timeout event, log and try again
+									// (temporary workaround for https://github.com/golang/go/issues/28975)
+									console.warn("scheduleTimeoutEvent: missed timeout event");
+									this._resume();
+								}
+							},
+							getInt64(sp + 8),
+						));
+						this.mem.setInt32(sp + 16, id, true);
+					},
+
+					// func clearTimeoutEvent(id int32)
+					"runtime.clearTimeoutEvent": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getInt32(sp + 8, true);
+						clearTimeout(this._scheduledTimeouts.get(id));
+						this._scheduledTimeouts.delete(id);
+					},
+
+					// func getRandomData(r []byte)
+					"runtime.getRandomData": (sp) => {
+						sp >>>= 0;
+						crypto.getRandomValues(loadSlice(sp + 8));
+					},
+
+					// func finalizeRef(v ref)
+					"syscall/js.finalizeRef": (sp) => {
+						sp >>>= 0;
+						const id = this.mem.getUint32(sp + 8, true);
+						this._goRefCounts[id]--;
+						if (this._goRefCounts[id] === 0) {
+							const v = this._values[id];
+							this._values[id] = null;
+							this._ids.delete(v);
+							this._idPool.push(id);
+						}
+					},
+
+					// func stringVal(value string) ref
+					"syscall/js.stringVal": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, loadString(sp + 8));
+					},
+
+					// func valueGet(v ref, p string) ref
+					"syscall/js.valueGet": (sp) => {
+						sp >>>= 0;
+						const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
+						sp = this._inst.exports.getsp() >>> 0; // see comment above
+						storeValue(sp + 32, result);
+					},
+
+					// func valueSet(v ref, p string, x ref)
+					"syscall/js.valueSet": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
+					},
+
+					// func valueDelete(v ref, p string)
+					"syscall/js.valueDelete": (sp) => {
+						sp >>>= 0;
+						Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
+					},
+
+					// func valueIndex(v ref, i int) ref
+					"syscall/js.valueIndex": (sp) => {
+						sp >>>= 0;
+						storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
+					},
+
+					// valueSetIndex(v ref, i int, x ref)
+					"syscall/js.valueSetIndex": (sp) => {
+						sp >>>= 0;
+						Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
+					},
+
+					// func valueCall(v ref, m string, args []ref) (ref, bool)
+					"syscall/js.valueCall": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const m = Reflect.get(v, loadString(sp + 16));
+							const args = loadSliceOfValues(sp + 32);
+							const result = Reflect.apply(m, v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, result);
+							this.mem.setUint8(sp + 64, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 56, err);
+							this.mem.setUint8(sp + 64, 0);
+						}
+					},
+
+					// func valueInvoke(v ref, args []ref) (ref, bool)
+					"syscall/js.valueInvoke": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.apply(v, undefined, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueNew(v ref, args []ref) (ref, bool)
+					"syscall/js.valueNew": (sp) => {
+						sp >>>= 0;
+						try {
+							const v = loadValue(sp + 8);
+							const args = loadSliceOfValues(sp + 16);
+							const result = Reflect.construct(v, args);
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, result);
+							this.mem.setUint8(sp + 48, 1);
+						} catch (err) {
+							sp = this._inst.exports.getsp() >>> 0; // see comment above
+							storeValue(sp + 40, err);
+							this.mem.setUint8(sp + 48, 0);
+						}
+					},
+
+					// func valueLength(v ref) int
+					"syscall/js.valueLength": (sp) => {
+						sp >>>= 0;
+						setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
+					},
+
+					// valuePrepareString(v ref) (ref, int)
+					"syscall/js.valuePrepareString": (sp) => {
+						sp >>>= 0;
+						const str = encoder.encode(String(loadValue(sp + 8)));
+						storeValue(sp + 16, str);
+						setInt64(sp + 24, str.length);
+					},
+
+					// valueLoadString(v ref, b []byte)
+					"syscall/js.valueLoadString": (sp) => {
+						sp >>>= 0;
+						const str = loadValue(sp + 8);
+						loadSlice(sp + 16).set(str);
+					},
+
+					// func valueInstanceOf(v ref, t ref) bool
+					"syscall/js.valueInstanceOf": (sp) => {
+						sp >>>= 0;
+						this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
+					},
+
+					// func copyBytesToGo(dst []byte, src ref) (int, bool)
+					"syscall/js.copyBytesToGo": (sp) => {
+						sp >>>= 0;
+						const dst = loadSlice(sp + 8);
+						const src = loadValue(sp + 32);
+						if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					// func copyBytesToJS(dst ref, src []byte) (int, bool)
+					"syscall/js.copyBytesToJS": (sp) => {
+						sp >>>= 0;
+						const dst = loadValue(sp + 8);
+						const src = loadSlice(sp + 16);
+						if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
+							this.mem.setUint8(sp + 48, 0);
+							return;
+						}
+						const toCopy = src.subarray(0, dst.length);
+						dst.set(toCopy);
+						setInt64(sp + 40, toCopy.length);
+						this.mem.setUint8(sp + 48, 1);
+					},
+
+					"debug": (value) => {
+						console.log(value);
+					},
+				}
+			};
+		}
+
+		async run(instance) {
+			if (!(instance instanceof WebAssembly.Instance)) {
+				throw new Error("Go.run: WebAssembly.Instance expected");
+			}
+			this._inst = instance;
+			this.mem = new DataView(this._inst.exports.mem.buffer);
+			this._values = [ // JS values that Go currently has references to, indexed by reference id
+				NaN,
+				0,
+				null,
+				true,
+				false,
+				globalThis,
+				this,
+			];
+			this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
+			this._ids = new Map([ // mapping from JS values to reference ids
+				[0, 1],
+				[null, 2],
+				[true, 3],
+				[false, 4],
+				[globalThis, 5],
+				[this, 6],
+			]);
+			this._idPool = [];   // unused ids that have been garbage collected
+			this.exited = false; // whether the Go program has exited
+
+			// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
+			let offset = 4096;
+
+			const strPtr = (str) => {
+				const ptr = offset;
+				const bytes = encoder.encode(str + "\0");
+				new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
+				offset += bytes.length;
+				if (offset % 8 !== 0) {
+					offset += 8 - (offset % 8);
+				}
+				return ptr;
+			};
+
+			const argc = this.argv.length;
+
+			const argvPtrs = [];
+			this.argv.forEach((arg) => {
+				argvPtrs.push(strPtr(arg));
+			});
+			argvPtrs.push(0);
+
+			const keys = Object.keys(this.env).sort();
+			keys.forEach((key) => {
+				argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
+			});
+			argvPtrs.push(0);
+
+			const argv = offset;
+			argvPtrs.forEach((ptr) => {
+				this.mem.setUint32(offset, ptr, true);
+				this.mem.setUint32(offset + 4, 0, true);
+				offset += 8;
+			});
+
+			// The linker guarantees global data starts from at least wasmMinDataAddr.
+			// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
+			const wasmMinDataAddr = 4096 + 8192;
+			if (offset >= wasmMinDataAddr) {
+				throw new Error("total length of command line and environment variables exceeds limit");
+			}
+
+			this._inst.exports.run(argc, argv);
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+			await this._exitPromise;
+		}
+
+		_resume() {
+			if (this.exited) {
+				throw new Error("Go program has already exited");
+			}
+			this._inst.exports.resume();
+			if (this.exited) {
+				this._resolveExitPromise();
+			}
+		}
+
+		_makeFuncWrapper(id) {
+			const go = this;
+			return function () {
+				const event = { id: id, this: this, args: arguments };
+				go._pendingEvent = event;
+				go._resume();
+				return event.result;
+			};
+		}
+	}
+})();

frontend/src/common/prettier/plugins/go/build.bat

@@ -0,0 +1,32 @@
+@echo off
+rem Build script for Go Prettier Plugin WASM
+rem This script compiles the Go code to WebAssembly
+
+echo 🔨 Building Go Prettier Plugin WASM...
+
+rem Set WASM build environment
+set GOOS=js
+set GOARCH=wasm
+
+rem Build the WASM file
+echo Compiling main.go to go.wasm...
+go build -o go.wasm main.go
+
+if %ERRORLEVEL% EQU 0 (
+    echo ✅ Build successful!
+    
+    rem Show file size (Windows version)
+    for %%A in (go.wasm) do echo 📊 WASM file size: %%~zA bytes
+    
+    rem Copy to public directory for browser access
+    if exist "..\..\..\..\..\public" (
+        copy go.wasm ..\..\..\..\..\public\go.wasm > nul
+        echo 📋 Copied to public directory
+    )
+    
+    echo 🎉 Go Prettier Plugin WASM is ready!
+) else (
+    echo ❌ Build failed!
+    pause
+    exit /b 1
+)

frontend/src/common/prettier/plugins/go/build.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# Build script for Go Prettier Plugin WASM
+# This script compiles the Go code to WebAssembly
+
+echo "🔨 Building Go Prettier Plugin WASM..."
+
+# Set WASM build environment
+export GOOS=js
+export GOARCH=wasm
+
+# Build the WASM file
+echo "Compiling main.go to go.wasm..."
+go build -o go.wasm main.go
+
+if [ $? -eq 0 ]; then
+    echo "✅ Build successful!"
+    echo "📊 WASM file size: $(du -h go.wasm | cut -f1)"
+    
+    # Copy to public directory for browser access
+    if [ -d "../../../../../public" ]; then
+        cp go.wasm ../../../../../public/go.wasm
+        echo "📋 Copied to public directory"
+    fi
+    
+    echo "🎉 Go Prettier Plugin WASM is ready!"
+else
+    echo "❌ Build failed!"
+    exit 1
+fi

frontend/src/common/prettier/plugins/go/go.d.ts

@@ -0,0 +1,10 @@
+import { Parser, Plugin } from "prettier";
+
+export declare const languages: Plugin["languages"];
+export declare const parsers: {
+  go: Parser;
+};
+export declare const printers: Plugin["printers"];
+
+declare const plugin: Plugin;
+export default plugin;

frontend/src/common/prettier/plugins/go/go.mjs

@@ -0,0 +1,116 @@
+/**
+ * Go Prettier Plugin for Vite + Vue3 Environment
+ * WebAssembly-based Go code formatter for Prettier
+ */
+
+let initializePromise = null;
+
+// Load WASM file from public directory
+const loadWasm = async () => {
+    try {
+        const response = await fetch('/go.wasm');
+        if (!response.ok) {
+            throw new Error(`Failed to load WASM file: ${response.status} ${response.statusText}`);
+        }
+        return await response.arrayBuffer();
+    } catch (error) {
+        console.error('WASM loading failed:', error);
+        throw error;
+    }
+};
+
+// Initialize Go runtime
+const initGoRuntime = async () => {
+    if (globalThis.Go) return;
+
+    // Auto-load wasm_exec.js if not available
+    try {
+
+        const script = document.createElement('script');
+        script.src = '/wasm_exec.js';
+        document.head.appendChild(script);
+
+        await new Promise((resolve, reject) => {
+            script.onload = resolve;
+            script.onerror = () => reject(new Error('Failed to load wasm_exec.js'));
+            setTimeout(() => reject(new Error('wasm_exec.js loading timeout')), 5000);
+        });
+        if (!globalThis.Go) {
+            throw new Error('Go WASM runtime is not available after loading wasm_exec.js');
+        }
+    } catch (error) {
+        console.error('Failed to load wasm_exec.js:', error);
+        throw error;
+    }
+};
+
+const initialize = async () => {
+    if (initializePromise) return initializePromise;
+
+    initializePromise = (async () => {
+        await initGoRuntime();
+
+        const go = new globalThis.Go();
+        const wasmBuffer = await loadWasm();
+        const {instance} = await WebAssembly.instantiate(wasmBuffer, go.importObject);
+
+        // Run Go program
+        go.run(instance).catch(err => {
+            console.error('Go WASM program exit error:', err);
+        });
+
+        // Wait for initialization to complete
+        await new Promise(resolve => setTimeout(resolve, 200));
+
+        // Check if formatGo function is available
+        if (typeof globalThis.formatGo !== 'function') {
+            throw new Error('Go WASM module not properly initialized - formatGo function not available');
+        }
+    })();
+
+    return initializePromise;
+};
+
+export const languages = [
+    {
+        name: "Go",
+        parsers: ["go"],
+        extensions: [".go"],
+        vscodeLanguageIds: ["go"],
+    },
+];
+
+export const parsers = {
+    go: {
+        parse: (text) => text,
+        astFormat: "go-format",
+        locStart: (node) => 0,
+        locEnd: (node) => node.length,
+    },
+};
+
+export const printers = {
+    "go-format": {
+        print: async (path) => {
+            await initialize();
+            const text = path.getValue();
+
+            if (typeof globalThis.formatGo !== 'function') {
+                throw new Error('Go WASM module not properly initialized - formatGo function missing');
+            }
+
+            try {
+                return globalThis.formatGo(text);
+            } catch (error) {
+                throw new Error(`Go formatting failed: ${error.message}`);
+            }
+        },
+    },
+};
+
+// Default export for Prettier plugin compatibility
+export default {
+    languages,
+    parsers,
+    printers
+};

frontend/src/common/prettier/plugins/go/main.go

@@ -0,0 +1,255 @@
+//go:build js && wasm
+
+// Package main implements a WebAssembly module that provides Go code formatting
+// functionality for the Prettier plugin. This package exposes the formatGo function
+// to JavaScript, enabling web-based Go code formatting with better error tolerance.
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"go/format"
+	"go/parser"
+	"go/token"
+	"strings"
+	"syscall/js"
+)
+
+// formatGoCode attempts to format Go source code with better error tolerance
+func formatGoCode(src string) (string, error) {
+	// Trim input but preserve leading/trailing newlines structure
+	trimmed := strings.TrimSpace(src)
+	if trimmed == "" {
+		return src, nil
+	}
+
+	// First try the standard format.Source for complete, valid code
+	if formatted, err := format.Source([]byte(src)); err == nil {
+		return string(formatted), nil
+	}
+
+	// Create a new file set for parsing
+	fset := token.NewFileSet()
+
+	// Strategy 1: Try as complete Go file
+	if parsed, err := parser.ParseFile(fset, "", src, parser.ParseComments); err == nil {
+		return formatASTNode(fset, parsed)
+	}
+
+	// Strategy 2: Try wrapping as package-level declarations
+	packageWrapped := fmt.Sprintf("package main\n\n%s", trimmed)
+	if parsed, err := parser.ParseFile(fset, "", packageWrapped, parser.ParseComments); err == nil {
+		if formatted, err := formatASTNode(fset, parsed); err == nil {
+			return extractPackageContent(formatted), nil
+		}
+	}
+
+	// Strategy 3: Try wrapping in main function
+	funcWrapped := fmt.Sprintf("package main\n\nfunc main() {\n%s\n}", indentLines(trimmed, "\t"))
+	if parsed, err := parser.ParseFile(fset, "", funcWrapped, parser.ParseComments); err == nil {
+		if formatted, err := formatASTNode(fset, parsed); err == nil {
+			return extractFunctionBody(formatted), nil
+		}
+	}
+
+	// Strategy 4: Try wrapping in anonymous function
+	anonWrapped := fmt.Sprintf("package main\n\nvar _ = func() {\n%s\n}", indentLines(trimmed, "\t"))
+	if parsed, err := parser.ParseFile(fset, "", anonWrapped, parser.ParseComments); err == nil {
+		if formatted, err := formatASTNode(fset, parsed); err == nil {
+			return extractFunctionBody(formatted), nil
+		}
+	}
+
+	// Strategy 5: Try line-by-line formatting for complex cases
+	return formatLineByLine(trimmed, fset)
+}
+
+// formatASTNode formats an AST node using the standard formatter
+func formatASTNode(fset *token.FileSet, node interface{}) (string, error) {
+	var buf bytes.Buffer
+	if err := format.Node(&buf, fset, node); err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}
+
+// extractPackageContent extracts content after package declaration
+func extractPackageContent(formatted string) string {
+	lines := strings.Split(formatted, "\n")
+	var contentLines []string
+	skipNext := false
+
+	for _, line := range lines {
+		if strings.HasPrefix(line, "package ") {
+			skipNext = true
+			continue
+		}
+		if skipNext && strings.TrimSpace(line) == "" {
+			skipNext = false
+			continue
+		}
+		if !skipNext {
+			contentLines = append(contentLines, line)
+		}
+	}
+
+	return strings.Join(contentLines, "\n")
+}
+
+// extractFunctionBody extracts content from within a function body
+func extractFunctionBody(formatted string) string {
+	lines := strings.Split(formatted, "\n")
+	var bodyLines []string
+	inFunction := false
+	braceCount := 0
+
+	for _, line := range lines {
+		if strings.Contains(line, "func ") && strings.Contains(line, "{") {
+			inFunction = true
+			braceCount = 1
+			continue
+		}
+
+		if inFunction {
+			// Count braces to know when function ends
+			braceCount += strings.Count(line, "{")
+			braceCount -= strings.Count(line, "}")
+
+			if braceCount == 0 {
+				break
+			}
+
+			// Remove one level of indentation and add the line
+			if strings.HasPrefix(line, "\t") {
+				bodyLines = append(bodyLines, line[1:])
+			} else {
+				bodyLines = append(bodyLines, line)
+			}
+		}
+	}
+
+	// Remove empty lines from start and end
+	for len(bodyLines) > 0 && strings.TrimSpace(bodyLines[0]) == "" {
+		bodyLines = bodyLines[1:]
+	}
+	for len(bodyLines) > 0 && strings.TrimSpace(bodyLines[len(bodyLines)-1]) == "" {
+		bodyLines = bodyLines[:len(bodyLines)-1]
+	}
+
+	return strings.Join(bodyLines, "\n")
+}
+
+// indentLines adds indentation to each non-empty line
+func indentLines(text, indent string) string {
+	lines := strings.Split(text, "\n")
+	var indentedLines []string
+
+	for _, line := range lines {
+		if strings.TrimSpace(line) == "" {
+			indentedLines = append(indentedLines, "")
+		} else {
+			indentedLines = append(indentedLines, indent+line)
+		}
+	}
+
+	return strings.Join(indentedLines, "\n")
+}
+
+// formatLineByLine attempts to format each statement individually
+func formatLineByLine(src string, fset *token.FileSet) (string, error) {
+	lines := strings.Split(src, "\n")
+	var formattedLines []string
+
+	for _, line := range lines {
+		trimmedLine := strings.TrimSpace(line)
+		if trimmedLine == "" {
+			formattedLines = append(formattedLines, "")
+			continue
+		}
+
+		// Try different wrapping strategies for individual lines
+		attempts := []string{
+			fmt.Sprintf("package main\n\nfunc main() {\n\t%s\n}", trimmedLine),
+			fmt.Sprintf("package main\n\n%s", trimmedLine),
+			fmt.Sprintf("package main\n\nvar _ = %s", trimmedLine),
+		}
+
+		formatted := trimmedLine // fallback
+		for _, attempt := range attempts {
+			if parsed, err := parser.ParseFile(fset, "", attempt, parser.ParseComments); err == nil {
+				if result, err := formatASTNode(fset, parsed); err == nil {
+					if extracted := extractSingleStatement(result, trimmedLine); extracted != "" {
+						formatted = extracted
+						break
+					}
+				}
+			}
+		}
+
+		formattedLines = append(formattedLines, formatted)
+	}
+
+	return strings.Join(formattedLines, "\n"), nil
+}
+
+// extractSingleStatement tries to extract a single formatted statement
+func extractSingleStatement(formatted, original string) string {
+	lines := strings.Split(formatted, "\n")
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed != "" && !strings.HasPrefix(trimmed, "package ") &&
+			!strings.HasPrefix(trimmed, "func ") && !strings.HasPrefix(trimmed, "var _ =") &&
+			trimmed != "{" && trimmed != "}" {
+			// Remove leading tabs/spaces to normalize indentation
+			return strings.TrimLeft(line, " \t")
+		}
+	}
+
+	return original
+}
+
+// formatGo is a JavaScript-callable function that formats Go source code.
+// It attempts multiple strategies to format code, including handling incomplete
+// or syntactically invalid code fragments.
+//
+// Parameters:
+//   - this: The JavaScript 'this' context (unused)
+//   - i: JavaScript arguments array where i[0] should contain the Go source code as a string
+//
+// Returns:
+//   - js.Value: The formatted Go source code as a JavaScript string value
+//   - If formatting fails completely, returns the original code unchanged
+//   - If no arguments are provided, returns js.Null() and logs an error
+func formatGo(this js.Value, i []js.Value) interface{} {
+	if len(i) == 0 {
+		js.Global().Get("console").Call("error", "formatGo: missing code argument")
+		return js.Null()
+	}
+
+	code := i[0].String()
+	if strings.TrimSpace(code) == "" {
+		return js.ValueOf(code)
+	}
+
+	formatted, err := formatGoCode(code)
+	if err != nil {
+		js.Global().Get("console").Call("warn", "Go formatting had issues:", err.Error())
+		return js.ValueOf(code) // Return original code if all attempts fail
+	}
+
+	return js.ValueOf(formatted)
+}
+
+// main initializes the WebAssembly module and exposes the formatGo function
+// to the JavaScript global scope.
+func main() {
+	// Create a channel to keep the Go program running
+	c := make(chan struct{}, 0)
+
+	// Expose the formatGo function to the JavaScript global scope
+	js.Global().Set("formatGo", js.FuncOf(formatGo))
+
+	// Block forever
+	<-c
+}

frontend/src/common/prettier/plugins/java/comments.d.ts

@@ -0,0 +1,17 @@
+import type { IToken } from "java-parser";
+import { type AstPath } from "prettier";
+import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
+export declare function determineFormatterOffOnRanges(cst: JavaNonTerminal): void;
+export declare function isFullyBetweenFormatterOffOn(path: AstPath<JavaNode>): boolean;
+export declare function canAttachComment(node: JavaNode): boolean;
+export declare function handleLineComment(commentNode: JavaComment, _: string, options: JavaParserOptions): boolean;
+export declare function handleRemainingComment(commentNode: JavaComment): boolean;
+export type JavaComment = IToken & {
+    value: string;
+    leading: boolean;
+    trailing: boolean;
+    printed: boolean;
+    enclosingNode?: JavaNonTerminal;
+    precedingNode?: JavaNonTerminal;
+    followingNode?: JavaNonTerminal;
+};

frontend/src/common/prettier/plugins/java/comments.js

@@ -0,0 +1,199 @@
+import { util } from "prettier";
+import parser from "./parser.js";
+import { isEmptyStatement, isNonTerminal, isTerminal } from "./printers/helpers.js";
+const formatterOffOnRangesByCst = new WeakMap();
+export function determineFormatterOffOnRanges(cst) {
+    const { comments } = cst;
+    if (!comments) {
+        return;
+    }
+    const ranges = comments
+        .filter(({ image }) => /^(\/\/\s*@formatter:(off|on)\s*|\/\*\s*@formatter:(off|on)\s*\*\/)$/.test(image))
+        .reduce((ranges, { image, startOffset }) => {
+        const previous = ranges.at(-1);
+        if (image.endsWith("off")) {
+            if ((previous === null || previous === void 0 ? void 0 : previous.on) !== Infinity) {
+                ranges.push({ off: startOffset, on: Infinity });
+            }
+        }
+        else if ((previous === null || previous === void 0 ? void 0 : previous.on) === Infinity) {
+            previous.on = startOffset;
+        }
+        return ranges;
+    }, new Array());
+    formatterOffOnRangesByCst.set(cst, ranges);
+}
+export function isFullyBetweenFormatterOffOn(path) {
+    var _a;
+    const { node, root } = path;
+    const start = parser.locStart(node);
+    const end = parser.locEnd(node);
+    return (((_a = formatterOffOnRangesByCst
+        .get(root)) === null || _a === void 0 ? void 0 : _a.some(range => range.off < start && end < range.on)) === true);
+}
+export function canAttachComment(node) {
+    var _a, _b, _c;
+    if (isTerminal(node)) {
+        const { name, CATEGORIES } = node.tokenType;
+        return (name === "Identifier" ||
+            (CATEGORIES === null || CATEGORIES === void 0 ? void 0 : CATEGORIES.find(({ name }) => name === "BinaryOperator")) !== undefined);
+    }
+    const { children, name } = node;
+    switch (name) {
+        case "argumentList":
+        case "blockStatements":
+        case "emptyStatement":
+        case "enumBodyDeclarations":
+            return false;
+        case "annotationInterfaceMemberDeclaration":
+        case "classMemberDeclaration":
+        case "interfaceMemberDeclaration":
+        case "methodBody":
+            return !children.Semicolon;
+        case "blockStatement":
+            return !children.statement || !isEmptyStatement(children.statement[0]);
+        case "classBodyDeclaration":
+            return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon);
+        case "recordBodyDeclaration":
+            return !((_c = (_b = children.classBodyDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.classMemberDeclaration) === null || _c === void 0 ? void 0 : _c[0].children.Semicolon);
+        case "statement":
+            return !isEmptyStatement(node);
+        case "statementWithoutTrailingSubstatement":
+            return !children.emptyStatement;
+        default:
+            return true;
+    }
+}
+export function handleLineComment(commentNode, _, options) {
+    return [
+        handleBinaryExpressionComments,
+        handleFqnOrRefTypeComments,
+        handleIfStatementComments,
+        handleJumpStatementComments,
+        handleLabeledStatementComments,
+        handleNameComments
+    ].some(fn => fn(commentNode, options));
+}
+export function handleRemainingComment(commentNode) {
+    return [
+        handleFqnOrRefTypeComments,
+        handleMethodDeclaratorComments,
+        handleNameComments,
+        handleJumpStatementComments
+    ].some(fn => fn(commentNode));
+}
+function handleBinaryExpressionComments(commentNode, options) {
+    const { enclosingNode, precedingNode, followingNode } = commentNode;
+    if (enclosingNode &&
+        isNonTerminal(enclosingNode) &&
+        enclosingNode.name === "binaryExpression") {
+        if (isBinaryOperator(followingNode)) {
+            if (options.experimentalOperatorPosition === "start") {
+                util.addLeadingComment(followingNode, commentNode);
+            }
+            else {
+                util.addTrailingComment(followingNode, commentNode);
+            }
+            return true;
+        }
+        else if (options.experimentalOperatorPosition === "start" &&
+            isBinaryOperator(precedingNode)) {
+            util.addLeadingComment(precedingNode, commentNode);
+            return true;
+        }
+    }
+    return false;
+}
+function handleFqnOrRefTypeComments(commentNode) {
+    const { enclosingNode, followingNode } = commentNode;
+    if (enclosingNode &&
+        isNonTerminal(enclosingNode) &&
+        enclosingNode.name === "fqnOrRefType" &&
+        followingNode) {
+        util.addLeadingComment(followingNode, commentNode);
+        return true;
+    }
+    return false;
+}
+function handleIfStatementComments(commentNode) {
+    const { enclosingNode, precedingNode } = commentNode;
+    if (enclosingNode &&
+        isNonTerminal(enclosingNode) &&
+        enclosingNode.name === "ifStatement" &&
+        precedingNode &&
+        isNonTerminal(precedingNode) &&
+        precedingNode.name === "statement") {
+        util.addDanglingComment(enclosingNode, commentNode, undefined);
+        return true;
+    }
+    return false;
+}
+function handleJumpStatementComments(commentNode) {
+    const { enclosingNode, precedingNode, followingNode } = commentNode;
+    if (enclosingNode &&
+        !precedingNode &&
+        !followingNode &&
+        isNonTerminal(enclosingNode) &&
+        ["breakStatement", "continueStatement", "returnStatement"].includes(enclosingNode.name)) {
+        util.addTrailingComment(enclosingNode, commentNode);
+        return true;
+    }
+    return false;
+}
+function handleLabeledStatementComments(commentNode) {
+    const { enclosingNode, precedingNode } = commentNode;
+    if (enclosingNode &&
+        precedingNode &&
+        isNonTerminal(enclosingNode) &&
+        enclosingNode.name === "labeledStatement" &&
+        isTerminal(precedingNode) &&
+        precedingNode.tokenType.name === "Identifier") {
+        util.addLeadingComment(precedingNode, commentNode);
+        return true;
+    }
+    return false;
+}
+function handleMethodDeclaratorComments(commentNode) {
+    const { enclosingNode } = commentNode;
+    if (enclosingNode &&
+        isNonTerminal(enclosingNode) &&
+        enclosingNode.name === "methodDeclarator" &&
+        !enclosingNode.children.receiverParameter &&
+        !enclosingNode.children.formalParameterList &&
+        enclosingNode.children.LBrace[0].startOffset < commentNode.startOffset &&
+        commentNode.startOffset < enclosingNode.children.RBrace[0].startOffset) {
+        util.addDanglingComment(enclosingNode, commentNode, undefined);
+        return true;
+    }
+    return false;
+}
+function handleNameComments(commentNode) {
+    const { enclosingNode, precedingNode } = commentNode;
+    if (enclosingNode &&
+        precedingNode &&
+        isNonTerminal(enclosingNode) &&
+        isTerminal(precedingNode) &&
+        precedingNode.tokenType.name === "Identifier" &&
+        [
+            "ambiguousName",
+            "classOrInterfaceTypeToInstantiate",
+            "expressionName",
+            "moduleDeclaration",
+            "moduleName",
+            "packageDeclaration",
+            "packageName",
+            "packageOrTypeName",
+            "typeName"
+        ].includes(enclosingNode.name)) {
+        util.addTrailingComment(precedingNode, commentNode);
+        return true;
+    }
+    return false;
+}
+function isBinaryOperator(node) {
+    var _a;
+    return (node !== undefined &&
+        (isNonTerminal(node)
+            ? node.name === "shiftOperator"
+            : (_a = node.tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(({ name }) => name === "BinaryOperator")));
+}

frontend/src/common/prettier/plugins/java/index.d.ts

@@ -0,0 +1,563 @@
+import type { JavaNode } from "./printers/helpers.js";
+declare const _default: {
+    languages: {
+        name: string;
+        parsers: "java"[];
+        group: string;
+        tmScope: string;
+        aceMode: string;
+        codemirrorMode: string;
+        codemirrorMimeType: string;
+        extensions: string[];
+        linguistLanguageId: number;
+        vscodeLanguageIds: string[];
+    }[];
+    parsers: {
+        java: {
+            parse(text: string, options: import("./printers/helpers.js").JavaParserOptions): import("./printers/helpers.js").JavaNonTerminal;
+            astFormat: string;
+            hasPragma(text: string): boolean;
+            locStart(node: JavaNode): number;
+            locEnd(node: JavaNode): number;
+        };
+    };
+    printers: {
+        java: {
+            print(path: import("prettier").AstPath<import("java-parser").ArrayInitializerCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableInitializerListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BlockCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BlockStatementsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LocalVariableDeclarationStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LocalVariableDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LabeledStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExpressionStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").IfStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AssertStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SwitchStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SwitchBlockCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SwitchBlockStatementGroupCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SwitchLabelCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SwitchRuleCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").WhileStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DoStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BasicForStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StatementExpressionListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnhancedForStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BreakStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ContinueStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ReturnStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ThrowStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SynchronizedStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TryStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CatchesCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CatchClauseCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CatchFormalParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CatchTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FinallyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TryWithResourcesStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ResourceSpecificationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ResourceListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").YieldStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ForInitCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ForUpdateCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StatementWithoutTrailingSubstatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ForStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BlockStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CaseConstantCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CasePatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EmptyStatementCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StatementExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LocalVariableTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ResourceCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableAccessCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NormalClassDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeParametersCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeParameterListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassExtendsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassImplementsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceTypeListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassMemberDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FieldDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableDeclaratorListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableDeclaratorCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableDeclaratorIdCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannPrimitiveTypeWithOptionalDimsSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannReferenceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodHeaderCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodDeclaratorCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ReceiverParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FormalParameterListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableParaRegularParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableArityParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ThrowsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExceptionTypeListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StaticInitializerCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstructorDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstructorDeclaratorCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstructorBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnqualifiedExplicitConstructorInvocationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").QualifiedExplicitConstructorInvocationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumConstantListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumConstantCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumBodyDeclarationsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordHeaderCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordComponentListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordComponentCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableArityRecordComponentCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CompactConstructorDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableInitializerCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").VariableModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannClassTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassBodyDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InstanceInitializerCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassPermitsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FieldModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstructorModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").SimpleTypeNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExplicitConstructorInvocationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EnumConstantModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExceptionTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FormalParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ResultCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordBodyDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordComponentModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannClassOrInterfaceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannInterfaceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannPrimitiveTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnannTypeVariableCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaParametersCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaParametersWithBracesCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConciseLambdaParameterListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NormalLambdaParameterListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RegularLambdaParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConditionalExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BinaryExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnaryExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnaryExpressionNotPlusMinusCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PrimaryCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PrimarySuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FqnOrRefTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartFirstCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartRestCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FqnOrRefTypePartCommonCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ParenthesisExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PrimitiveCastExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ReferenceTypeCastExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UnqualifiedClassInstanceCreationExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassOrInterfaceTypeToInstantiateCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodInvocationSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ArgumentListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ArrayCreationExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ArrayCreationExpressionWithoutInitializerSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ArrayCreationWithInitializerSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DimExprsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DimExprCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassLiteralSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ArrayAccessSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodReferenceSuffixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").StringTemplateCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TextBlockTemplateCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RecordPatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ComponentPatternListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").GuardCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TemplateCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypePatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CastExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeArgumentsOrDiamondCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DiamondCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ComponentPatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MatchAllPatternCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConciseLambdaParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").EmbeddedExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaParameterListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NormalLambdaParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LambdaParameterTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NewExpressionCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PrimaryPrefixCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TemplateArgumentCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NormalInterfaceDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceExtendsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceMemberDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstantDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceMethodDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceBodyCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceMemberDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DefaultValueCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ElementValuePairListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ElementValuePairCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ElementValueArrayInitializerCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ElementValueListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ElementValueCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ConstantModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfacePermitsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceMethodModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").LiteralCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ShiftOperatorCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").BooleanLiteralCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FloatingPointLiteralCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").IntegerLiteralCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").MethodNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AmbiguousNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeIdentifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExpressionNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PackageNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ModuleNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PackageOrTypeNameCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").CompilationUnitCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").OrdinaryCompilationUnitCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ModularCompilationUnitCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PackageDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ImportDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ModuleDeclarationCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RequiresModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ExportsModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").OpensModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").UsesModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ProvidesModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ModuleDirectiveCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").RequiresModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PackageModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").PrimitiveTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ReferenceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeVariableCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").DimsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeParameterCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeBoundCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").AdditionalBoundCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeArgumentsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeArgumentListCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").WildcardCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").WildcardBoundsCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").InterfaceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").NumericTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").ClassOrInterfaceTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").FloatingPointTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").IntegralTypeCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeArgumentCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").TypeParameterModifierCstNode & {
+                comments?: import("./comments.js").JavaComment[];
+            }> | import("prettier").AstPath<import("java-parser").IToken & {
+                comments?: import("./comments.js").JavaComment[];
+            }>, options: import("prettier").ParserOptions<JavaNode>, print: (path: import("prettier").AstPath<JavaNode>) => import("prettier").Doc, args: unknown): import("prettier/doc.js").builders.Doc;
+            hasPrettierIgnore(path: import("prettier").AstPath<JavaNode>): boolean;
+            canAttachComment: typeof import("./comments.js").canAttachComment;
+            isBlockComment(node: JavaNode): boolean;
+            printComment(commentPath: import("prettier").AstPath<JavaNode>): string | import("prettier/doc.js").builders.Doc[];
+            getCommentChildNodes(node: JavaNode): any[];
+            handleComments: {
+                ownLine: typeof import("./comments.js").handleLineComment;
+                endOfLine: typeof import("./comments.js").handleLineComment;
+                remaining: typeof import("./comments.js").handleRemainingComment;
+            };
+        };
+    };
+    options: {
+        entrypoint: {
+            type: "choice";
+            category: string;
+            default: string;
+            choices: {
+                value: string;
+                description: string;
+            }[];
+            description: string;
+        };
+        arrowParens: {
+            type: "choice";
+            category: string;
+            default: string;
+            choices: {
+                value: string;
+                description: string;
+            }[];
+            description: string;
+        };
+        trailingComma: {
+            type: "choice";
+            category: string;
+            default: string;
+            choices: {
+                value: string;
+                description: string;
+            }[];
+            description: string;
+        };
+        experimentalOperatorPosition: {
+            type: "choice";
+            category: string;
+            default: string;
+            choices: {
+                value: string;
+                description: string;
+            }[];
+            description: string;
+        };
+    };
+    defaultOptions: {
+        arrowParens: "avoid";
+    };
+};
+export default _default;

frontend/src/common/prettier/plugins/java/index.js

@@ -0,0 +1,29 @@
+import options from "./options.js";
+import parser from "./parser.js";
+import printer from "./printer.js";
+export default {
+    languages: [
+        {
+            name: "Java",
+            parsers: ["java"],
+            group: "Java",
+            tmScope: "source.java",
+            aceMode: "java",
+            codemirrorMode: "clike",
+            codemirrorMimeType: "text/x-java",
+            extensions: [".java"],
+            linguistLanguageId: 181,
+            vscodeLanguageIds: ["java"]
+        }
+    ],
+    parsers: {
+        java: parser
+    },
+    printers: {
+        java: printer
+    },
+    options,
+    defaultOptions: {
+        arrowParens: "avoid"
+    }
+};

frontend/src/common/prettier/plugins/java/options.d.ts

@@ -0,0 +1,43 @@
+declare const _default: {
+    entrypoint: {
+        type: "choice";
+        category: string;
+        default: string;
+        choices: {
+            value: string;
+            description: string;
+        }[];
+        description: string;
+    };
+    arrowParens: {
+        type: "choice";
+        category: string;
+        default: string;
+        choices: {
+            value: string;
+            description: string;
+        }[];
+        description: string;
+    };
+    trailingComma: {
+        type: "choice";
+        category: string;
+        default: string;
+        choices: {
+            value: string;
+            description: string;
+        }[];
+        description: string;
+    };
+    experimentalOperatorPosition: {
+        type: "choice";
+        category: string;
+        default: string;
+        choices: {
+            value: string;
+            description: string;
+        }[];
+        description: string;
+    };
+};
+export default _default;

frontend/src/common/prettier/plugins/java/options.js

@@ -0,0 +1,284 @@
+export default {
+    entrypoint: {
+        type: "choice",
+        category: "Global",
+        default: "compilationUnit",
+        // sed -nr 's/.*\.RULE\(([^,]+),.*/\1/p' $(ls path/to/java-parser/rules/folder/*)
+        choices: [
+            { value: "arrayInitializer", description: "" },
+            { value: "variableInitializerList", description: "" },
+            { value: "block", description: "" },
+            { value: "blockStatements", description: "" },
+            { value: "blockStatement", description: "" },
+            { value: "localVariableDeclarationStatement", description: "" },
+            { value: "localVariableDeclaration", description: "" },
+            { value: "localVariableType", description: "" },
+            { value: "statement", description: "" },
+            { value: "statementWithoutTrailingSubstatement", description: "" },
+            { value: "emptyStatement", description: "" },
+            { value: "labeledStatement", description: "" },
+            { value: "expressionStatement", description: "" },
+            { value: "statementExpression", description: "" },
+            { value: "ifStatement", description: "" },
+            { value: "assertStatement", description: "" },
+            { value: "switchStatement", description: "" },
+            { value: "switchBlock", description: "" },
+            { value: "switchBlockStatementGroup", description: "" },
+            { value: "switchLabel", description: "" },
+            { value: "switchRule", description: "" },
+            { value: "caseConstant", description: "" },
+            { value: "casePattern", description: "" },
+            { value: "whileStatement", description: "" },
+            { value: "doStatement", description: "" },
+            { value: "forStatement", description: "" },
+            { value: "basicForStatement", description: "" },
+            { value: "forInit", description: "" },
+            { value: "forUpdate", description: "" },
+            { value: "statementExpressionList", description: "" },
+            { value: "enhancedForStatement", description: "" },
+            { value: "breakStatement", description: "" },
+            { value: "continueStatement", description: "" },
+            { value: "returnStatement", description: "" },
+            { value: "throwStatement", description: "" },
+            { value: "synchronizedStatement", description: "" },
+            { value: "tryStatement", description: "" },
+            { value: "catches", description: "" },
+            { value: "catchClause", description: "" },
+            { value: "catchFormalParameter", description: "" },
+            { value: "catchType", description: "" },
+            { value: "finally", description: "" },
+            { value: "tryWithResourcesStatement", description: "" },
+            { value: "resourceSpecification", description: "" },
+            { value: "resourceList", description: "" },
+            { value: "resource", description: "" },
+            { value: "yieldStatement", description: "" },
+            { value: "variableAccess", description: "" },
+            { value: "classDeclaration", description: "" },
+            { value: "normalClassDeclaration", description: "" },
+            { value: "classModifier", description: "" },
+            { value: "typeParameters", description: "" },
+            { value: "typeParameterList", description: "" },
+            { value: "classExtends", description: "" },
+            { value: "classImplements", description: "" },
+            { value: "interfaceTypeList", description: "" },
+            { value: "classPermits", description: "" },
+            { value: "classBody", description: "" },
+            { value: "classBodyDeclaration", description: "" },
+            { value: "classMemberDeclaration", description: "" },
+            { value: "fieldDeclaration", description: "" },
+            { value: "fieldModifier", description: "" },
+            { value: "variableDeclaratorList", description: "" },
+            { value: "variableDeclarator", description: "" },
+            { value: "variableDeclaratorId", description: "" },
+            { value: "variableInitializer", description: "" },
+            { value: "unannType", description: "" },
+            { value: "unannPrimitiveTypeWithOptionalDimsSuffix", description: "" },
+            { value: "unannPrimitiveType", description: "" },
+            { value: "unannReferenceType", description: "" },
+            { value: "unannClassOrInterfaceType", description: "" },
+            { value: "unannClassType", description: "" },
+            { value: "unannInterfaceType", description: "" },
+            { value: "unannTypeVariable", description: "" },
+            { value: "methodDeclaration", description: "" },
+            { value: "methodModifier", description: "" },
+            { value: "methodHeader", description: "" },
+            { value: "result", description: "" },
+            { value: "methodDeclarator", description: "" },
+            { value: "receiverParameter", description: "" },
+            { value: "formalParameterList", description: "" },
+            { value: "formalParameter", description: "" },
+            { value: "variableParaRegularParameter", description: "" },
+            { value: "variableArityParameter", description: "" },
+            { value: "variableModifier", description: "" },
+            { value: "throws", description: "" },
+            { value: "exceptionTypeList", description: "" },
+            { value: "exceptionType", description: "" },
+            { value: "methodBody", description: "" },
+            { value: "instanceInitializer", description: "" },
+            { value: "staticInitializer", description: "" },
+            { value: "constructorDeclaration", description: "" },
+            { value: "constructorModifier", description: "" },
+            { value: "constructorDeclarator", description: "" },
+            { value: "simpleTypeName", description: "" },
+            { value: "constructorBody", description: "" },
+            { value: "explicitConstructorInvocation", description: "" },
+            { value: "unqualifiedExplicitConstructorInvocation", description: "" },
+            { value: "qualifiedExplicitConstructorInvocation", description: "" },
+            { value: "enumDeclaration", description: "" },
+            { value: "enumBody", description: "" },
+            { value: "enumConstantList", description: "" },
+            { value: "enumConstant", description: "" },
+            { value: "enumConstantModifier", description: "" },
+            { value: "enumBodyDeclarations", description: "" },
+            { value: "recordDeclaration", description: "" },
+            { value: "recordHeader", description: "" },
+            { value: "recordComponentList", description: "" },
+            { value: "recordComponent", description: "" },
+            { value: "variableArityRecordComponent", description: "" },
+            { value: "recordComponentModifier", description: "" },
+            { value: "recordBody", description: "" },
+            { value: "recordBodyDeclaration", description: "" },
+            { value: "compactConstructorDeclaration", description: "" },
+            { value: "isDims", description: "" },
+            { value: "expression", description: "" },
+            { value: "lambdaExpression", description: "" },
+            { value: "lambdaParameters", description: "" },
+            { value: "lambdaParametersWithBraces", description: "" },
+            { value: "lambdaParameterList", description: "" },
+            { value: "conciseLambdaParameterList", description: "" },
+            { value: "normalLambdaParameterList", description: "" },
+            { value: "normalLambdaParameter", description: "" },
+            { value: "regularLambdaParameter", description: "" },
+            { value: "lambdaParameterType", description: "" },
+            { value: "conciseLambdaParameter", description: "" },
+            { value: "lambdaBody", description: "" },
+            { value: "conditionalExpression", description: "" },
+            { value: "binaryExpression", description: "" },
+            { value: "unaryExpression", description: "" },
+            { value: "unaryExpressionNotPlusMinus", description: "" },
+            { value: "primary", description: "" },
+            { value: "primaryPrefix", description: "" },
+            { value: "primarySuffix", description: "" },
+            { value: "fqnOrRefType", description: "" },
+            { value: "fqnOrRefTypePartRest", description: "" },
+            { value: "fqnOrRefTypePartCommon", description: "" },
+            { value: "fqnOrRefTypePartFirst", description: "" },
+            { value: "parenthesisExpression", description: "" },
+            { value: "castExpression", description: "" },
+            { value: "primitiveCastExpression", description: "" },
+            { value: "referenceTypeCastExpression", description: "" },
+            { value: "newExpression", description: "" },
+            { value: "unqualifiedClassInstanceCreationExpression", description: "" },
+            { value: "classOrInterfaceTypeToInstantiate", description: "" },
+            { value: "typeArgumentsOrDiamond", description: "" },
+            { value: "diamond", description: "" },
+            { value: "methodInvocationSuffix", description: "" },
+            { value: "argumentList", description: "" },
+            { value: "arrayCreationExpression", description: "" },
+            {
+                value: "arrayCreationExpressionWithoutInitializerSuffix",
+                description: ""
+            },
+            { value: "arrayCreationWithInitializerSuffix", description: "" },
+            { value: "dimExprs", description: "" },
+            { value: "dimExpr", description: "" },
+            { value: "classLiteralSuffix", description: "" },
+            { value: "arrayAccessSuffix", description: "" },
+            { value: "methodReferenceSuffix", description: "" },
+            { value: "templateArgument", description: "" },
+            { value: "template", description: "" },
+            { value: "stringTemplate", description: "" },
+            { value: "textBlockTemplate", description: "" },
+            { value: "embeddedExpression", description: "" },
+            { value: "pattern", description: "" },
+            { value: "typePattern", description: "" },
+            { value: "recordPattern", description: "" },
+            { value: "componentPatternList", description: "" },
+            { value: "componentPattern", description: "" },
+            { value: "matchAllPattern", description: "" },
+            { value: "guard", description: "" },
+            { value: "isRefTypeInMethodRef", description: "" },
+            { value: "interfaceDeclaration", description: "" },
+            { value: "normalInterfaceDeclaration", description: "" },
+            { value: "interfaceModifier", description: "" },
+            { value: "interfaceExtends", description: "" },
+            { value: "interfacePermits", description: "" },
+            { value: "interfaceBody", description: "" },
+            { value: "interfaceMemberDeclaration", description: "" },
+            { value: "constantDeclaration", description: "" },
+            { value: "constantModifier", description: "" },
+            { value: "interfaceMethodDeclaration", description: "" },
+            { value: "interfaceMethodModifier", description: "" },
+            { value: "annotationInterfaceDeclaration", description: "" },
+            { value: "annotationInterfaceBody", description: "" },
+            { value: "annotationInterfaceMemberDeclaration", description: "" },
+            { value: "annotationInterfaceElementDeclaration", description: "" },
+            { value: "annotationInterfaceElementModifier", description: "" },
+            { value: "defaultValue", description: "" },
+            { value: "annotation", description: "" },
+            { value: "elementValuePairList", description: "" },
+            { value: "elementValuePair", description: "" },
+            { value: "elementValue", description: "" },
+            { value: "elementValueArrayInitializer", description: "" },
+            { value: "elementValueList", description: "" },
+            { value: "literal", description: "" },
+            { value: "integerLiteral", description: "" },
+            { value: "floatingPointLiteral", description: "" },
+            { value: "booleanLiteral", description: "" },
+            { value: "shiftOperator", description: "" },
+            { value: "moduleName", description: "" },
+            { value: "packageName", description: "" },
+            { value: "typeName", description: "" },
+            { value: "expressionName", description: "" },
+            { value: "methodName", description: "" },
+            { value: "packageOrTypeName", description: "" },
+            { value: "ambiguousName", description: "" },
+            { value: "compilationUnit", description: "" },
+            { value: "ordinaryCompilationUnit", description: "" },
+            { value: "modularCompilationUnit", description: "" },
+            { value: "packageDeclaration", description: "" },
+            { value: "packageModifier", description: "" },
+            { value: "importDeclaration", description: "" },
+            { value: "typeDeclaration", description: "" },
+            { value: "moduleDeclaration", description: "" },
+            { value: "moduleDirective", description: "" },
+            { value: "requiresModuleDirective", description: "" },
+            { value: "exportsModuleDirective", description: "" },
+            { value: "opensModuleDirective", description: "" },
+            { value: "usesModuleDirective", description: "" },
+            { value: "providesModuleDirective", description: "" },
+            { value: "requiresModifier", description: "" },
+            { value: "primitiveType", description: "" },
+            { value: "numericType", description: "" },
+            { value: "integralType", description: "" },
+            { value: "floatingPointType", description: "" },
+            { value: "referenceType", description: "" },
+            { value: "classOrInterfaceType", description: "" },
+            { value: "classType", description: "" },
+            { value: "interfaceType", description: "" },
+            { value: "typeVariable", description: "" },
+            { value: "dims", description: "" },
+            { value: "typeParameter", description: "" },
+            { value: "typeParameterModifier", description: "" },
+            { value: "typeBound", description: "" },
+            { value: "additionalBound", description: "" },
+            { value: "typeArguments", description: "" },
+            { value: "typeArgumentList", description: "" },
+            { value: "typeArgument", description: "" },
+            { value: "wildcard", description: "" },
+            { value: "wildcardBounds", description: "" }
+        ],
+        description: "Prettify from the entrypoint, allowing to use prettier on snippet."
+    },
+    arrowParens: {
+        type: "choice",
+        category: "Java",
+        default: "always",
+        choices: [
+            { value: "always", description: "" },
+            { value: "avoid", description: "" }
+        ],
+        description: "Include parentheses around a sole arrow function parameter."
+    },
+    trailingComma: {
+        type: "choice",
+        category: "Java",
+        default: "all",
+        choices: [
+            { value: "all", description: "" },
+            { value: "es5", description: "" },
+            { value: "none", description: "" }
+        ],
+        description: "Print trailing commas wherever possible when multi-line."
+    },
+    experimentalOperatorPosition: {
+        type: "choice",
+        category: "Java",
+        default: "end",
+        choices: [
+            { value: "start", description: "" },
+            { value: "end", description: "" }
+        ],
+        description: "Where to print operators when binary expressions wrap lines."
+    }
+};

frontend/src/common/prettier/plugins/java/parser.d.ts

@@ -0,0 +1,9 @@
+import { type JavaNode, type JavaNonTerminal, type JavaParserOptions } from "./printers/helpers.js";
+declare const _default: {
+    parse(text: string, options: JavaParserOptions): JavaNonTerminal;
+    astFormat: string;
+    hasPragma(text: string): boolean;
+    locStart(node: JavaNode): number;
+    locEnd(node: JavaNode): number;
+};
+export default _default;

frontend/src/common/prettier/plugins/java/parser.js

@@ -0,0 +1,24 @@
+import { parse } from "java-parser";
+import { determineFormatterOffOnRanges } from "./comments.js";
+import { isTerminal } from "./printers/helpers.js";
+export default {
+    parse(text, options) {
+        var _a;
+        const cst = parse(text, options.entrypoint);
+        (_a = cst.comments) === null || _a === void 0 ? void 0 : _a.forEach(comment => {
+            comment.value = comment.image;
+        });
+        determineFormatterOffOnRanges(cst);
+        return cst;
+    },
+    astFormat: "java",
+    hasPragma(text) {
+        return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
+    },
+    locStart(node) {
+        return isTerminal(node) ? node.startOffset : node.location.startOffset;
+    },
+    locEnd(node) {
+        return (isTerminal(node) ? node.endOffset : node.location.endOffset) + 1;
+    }
+};

frontend/src/common/prettier/plugins/java/printer.d.ts

@@ -0,0 +1,18 @@
+import type { AstPath } from "prettier";
+import { canAttachComment, handleLineComment, handleRemainingComment } from "./comments.js";
+import { type JavaNode } from "./printers/helpers.js";
+declare const _default: {
+    print(path: DistributedAstPath<JavaNode>, options: import("prettier").ParserOptions<JavaNode>, print: (path: AstPath<JavaNode>) => import("prettier").Doc, args: unknown): import("prettier/doc.js").builders.Doc;
+    hasPrettierIgnore(path: AstPath<JavaNode>): boolean;
+    canAttachComment: typeof canAttachComment;
+    isBlockComment(node: JavaNode): boolean;
+    printComment(commentPath: AstPath<JavaNode>): string | import("prettier/doc.js").builders.Doc[];
+    getCommentChildNodes(node: JavaNode): any[];
+    handleComments: {
+        ownLine: typeof handleLineComment;
+        endOfLine: typeof handleLineComment;
+        remaining: typeof handleRemainingComment;
+    };
+};
+export default _default;
+type DistributedAstPath<T> = T extends any ? AstPath<T> : never;

frontend/src/common/prettier/plugins/java/printer.js

@@ -0,0 +1,40 @@
+import { canAttachComment, handleLineComment, handleRemainingComment, isFullyBetweenFormatterOffOn } from "./comments.js";
+import { isNonTerminal, isTerminal, printComment } from "./printers/helpers.js";
+import { printerForNodeType } from "./printers/index.js";
+export default {
+    print(path, options, print, args) {
+        return hasTerminal(path)
+            ? path.node.image
+            : printerForNodeType(path.node.name)(path, print, options, args);
+    },
+    hasPrettierIgnore(path) {
+        var _a;
+        const { node } = path;
+        return (((_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ image }) => /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(image))) === true ||
+            (canAttachComment(node) && isFullyBetweenFormatterOffOn(path)));
+    },
+    canAttachComment,
+    isBlockComment(node) {
+        return isTerminal(node) && node.tokenType.name === "TraditionalComment";
+    },
+    printComment(commentPath) {
+        const { node } = commentPath;
+        if (isNonTerminal(node) || node.tokenType.GROUP !== "comments") {
+            throw new Error(`Not a comment: ${JSON.stringify(node)}`);
+        }
+        return printComment(node);
+    },
+    getCommentChildNodes(node) {
+        return isNonTerminal(node)
+            ? Object.values(node.children).flatMap(child => child)
+            : [];
+    },
+    handleComments: {
+        ownLine: handleLineComment,
+        endOfLine: handleLineComment,
+        remaining: handleRemainingComment
+    }
+};
+function hasTerminal(path) {
+    return isTerminal(path.node);
+}

frontend/src/common/prettier/plugins/java/printers/arrays.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    arrayInitializer(path: import("prettier").AstPath<import("java-parser").ArrayInitializerCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): import("prettier/doc.js").builders.Group | "{}";
+    variableInitializerList(path: import("prettier").AstPath<import("java-parser").VariableInitializerListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): import("prettier/doc.js").builders.Doc[];
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/arrays.js

@@ -0,0 +1,9 @@
+import { printArrayInitializer, printList } from "./helpers.js";
+export default {
+    arrayInitializer(path, print, options) {
+        return printArrayInitializer(path, print, options, "variableInitializerList");
+    },
+    variableInitializerList(path, print) {
+        return printList(path, print, "variableInitializer");
+    }
+};

frontend/src/common/prettier/plugins/java/printers/blocks-and-statements.d.ts

@@ -0,0 +1,117 @@
+import { builders } from "prettier/doc";
+import { printSingle } from "./helpers.js";
+declare const _default: {
+    block(path: import("prettier").AstPath<import("java-parser").BlockCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    blockStatements(path: import("prettier").AstPath<import("java-parser").BlockStatementsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    blockStatement: typeof printSingle;
+    localVariableDeclarationStatement(path: import("prettier").AstPath<import("java-parser").LocalVariableDeclarationStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    localVariableDeclaration(path: import("prettier").AstPath<import("java-parser").LocalVariableDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    localVariableType: typeof printSingle;
+    statement: typeof printSingle;
+    statementWithoutTrailingSubstatement: typeof printSingle;
+    emptyStatement(): string;
+    labeledStatement(path: import("prettier").AstPath<import("java-parser").LabeledStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    expressionStatement(path: import("prettier").AstPath<import("java-parser").ExpressionStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    statementExpression: typeof printSingle;
+    ifStatement(path: import("prettier").AstPath<import("java-parser").IfStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    assertStatement(path: import("prettier").AstPath<import("java-parser").AssertStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchStatement(path: import("prettier").AstPath<import("java-parser").SwitchStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchBlock(path: import("prettier").AstPath<import("java-parser").SwitchBlockCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    switchBlockStatementGroup(path: import("prettier").AstPath<import("java-parser").SwitchBlockStatementGroupCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    switchLabel(path: import("prettier").AstPath<import("java-parser").SwitchLabelCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): "default" | builders.Group | builders.Doc[];
+    switchRule(path: import("prettier").AstPath<import("java-parser").SwitchRuleCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    caseConstant: typeof printSingle;
+    casePattern: typeof printSingle;
+    whileStatement(path: import("prettier").AstPath<import("java-parser").WhileStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    doStatement(path: import("prettier").AstPath<import("java-parser").DoStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): (string | builders.Group | builders.Doc[])[];
+    forStatement: typeof printSingle;
+    basicForStatement(path: import("prettier").AstPath<import("java-parser").BasicForStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    forInit: typeof printSingle;
+    forUpdate: typeof printSingle;
+    statementExpressionList(path: import("prettier").AstPath<import("java-parser").StatementExpressionListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    enhancedForStatement(path: import("prettier").AstPath<import("java-parser").EnhancedForStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    breakStatement(path: import("prettier").AstPath<import("java-parser").BreakStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "break;";
+    continueStatement(path: import("prettier").AstPath<import("java-parser").ContinueStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[] | "continue;";
+    returnStatement(path: import("prettier").AstPath<import("java-parser").ReturnStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    throwStatement(path: import("prettier").AstPath<import("java-parser").ThrowStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    synchronizedStatement(path: import("prettier").AstPath<import("java-parser").SynchronizedStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    tryStatement(path: import("prettier").AstPath<import("java-parser").TryStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    catches(path: import("prettier").AstPath<import("java-parser").CatchesCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchClause(path: import("prettier").AstPath<import("java-parser").CatchClauseCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchFormalParameter(path: import("prettier").AstPath<import("java-parser").CatchFormalParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    catchType(path: import("prettier").AstPath<import("java-parser").CatchTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    finally(path: import("prettier").AstPath<import("java-parser").FinallyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    tryWithResourcesStatement(path: import("prettier").AstPath<import("java-parser").TryWithResourcesStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    resourceSpecification(path: import("prettier").AstPath<import("java-parser").ResourceSpecificationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "()";
+    resourceList(path: import("prettier").AstPath<import("java-parser").ResourceListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    resource: typeof printSingle;
+    yieldStatement(path: import("prettier").AstPath<import("java-parser").YieldStatementCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    variableAccess: typeof printSingle;
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/blocks-and-statements.js

@@ -0,0 +1,337 @@
+import { builders } from "prettier/doc";
+import { call, definedKeys, indentInParentheses, isBinaryExpression, isEmptyStatement, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printDanglingComments, printSingle, printWithModifiers } from "./helpers.js";
+const { group, hardline, ifBreak, indent, join, line, softline } = builders;
+export default {
+    block(path, print) {
+        const statements = path.node.children.blockStatements
+            ? call(path, print, "blockStatements")
+            : [];
+        return printBlock(path, statements.length ? [statements] : []);
+    },
+    blockStatements(path, print) {
+        return join(hardline, map(path, statementPath => {
+            const { node, previous } = statementPath;
+            const statement = print(statementPath);
+            return previous &&
+                lineStartWithComments(node) > lineEndWithComments(previous) + 1
+                ? [hardline, statement]
+                : statement;
+        }, "blockStatement").filter(doc => doc !== ""));
+    },
+    blockStatement: printSingle,
+    localVariableDeclarationStatement(path, print) {
+        return [call(path, print, "localVariableDeclaration"), ";"];
+    },
+    localVariableDeclaration(path, print) {
+        const declaration = join(" ", [
+            call(path, print, "localVariableType"),
+            call(path, print, "variableDeclaratorList")
+        ]);
+        return printWithModifiers(path, print, "variableModifier", declaration);
+    },
+    localVariableType: printSingle,
+    statement: printSingle,
+    statementWithoutTrailingSubstatement: printSingle,
+    emptyStatement() {
+        return "";
+    },
+    labeledStatement(path, print) {
+        return [
+            call(path, print, "Identifier"),
+            ": ",
+            call(path, print, "statement")
+        ];
+    },
+    expressionStatement(path, print) {
+        return [call(path, print, "statementExpression"), ";"];
+    },
+    statementExpression: printSingle,
+    ifStatement(path, print) {
+        var _a;
+        const { children } = path.node;
+        const hasEmptyStatement = isEmptyStatement(children.statement[0]);
+        const statements = map(path, print, "statement");
+        const statement = [
+            "if ",
+            indentInParentheses(call(path, print, "expression")),
+            hasEmptyStatement ? ";" : [" ", statements[0]]
+        ];
+        if (children.Else) {
+            const danglingComments = printDanglingComments(path);
+            if (danglingComments.length) {
+                statement.push(hardline, ...danglingComments, hardline);
+            }
+            else {
+                const elseHasBlock = ((_a = children.statement[0].children
+                    .statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.block) !==
+                    undefined;
+                statement.push(elseHasBlock ? " " : hardline);
+            }
+            const elseHasEmptyStatement = isEmptyStatement(children.statement[1]);
+            statement.push("else", elseHasEmptyStatement ? ";" : [" ", statements[1]]);
+        }
+        return statement;
+    },
+    assertStatement(path, print) {
+        return ["assert ", ...join([" : "], map(path, print, "expression")), ";"];
+    },
+    switchStatement(path, print) {
+        return join(" ", [
+            "switch",
+            indentInParentheses(call(path, print, "expression")),
+            call(path, print, "switchBlock")
+        ]);
+    },
+    switchBlock(path, print) {
+        const { children } = path.node;
+        const caseKeys = definedKeys(children, [
+            "switchBlockStatementGroup",
+            "switchRule"
+        ]);
+        const cases = caseKeys.length === 1 ? map(path, print, caseKeys[0]) : [];
+        return printBlock(path, cases);
+    },
+    switchBlockStatementGroup(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        const switchLabel = call(path, print, "switchLabel");
+        if (!children.blockStatements) {
+            return [switchLabel, ":"];
+        }
+        const blockStatements = call(path, print, "blockStatements");
+        const statements = children.blockStatements[0].children.blockStatement;
+        const onlyStatementIsBlock = statements.length === 1 &&
+            ((_b = (_a = statements[0].children.statement) === null || _a === void 0 ? void 0 : _a[0].children.statementWithoutTrailingSubstatement) === null || _b === void 0 ? void 0 : _b[0].children.block) !== undefined;
+        return [
+            switchLabel,
+            ":",
+            onlyStatementIsBlock
+                ? [" ", blockStatements]
+                : indent([hardline, blockStatements])
+        ];
+    },
+    switchLabel(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        if (!((_b = (_a = children.caseConstant) !== null && _a !== void 0 ? _a : children.casePattern) !== null && _b !== void 0 ? _b : children.Null)) {
+            return "default";
+        }
+        const values = [];
+        if (children.Null) {
+            values.push("null");
+            if (children.Default) {
+                values.push("default");
+            }
+        }
+        else {
+            const valuesKey = onlyDefinedKey(children, [
+                "caseConstant",
+                "casePattern"
+            ]);
+            values.push(...map(path, print, valuesKey));
+        }
+        const hasMultipleValues = values.length > 1;
+        const label = hasMultipleValues
+            ? ["case", indent([line, ...join([",", line], values)])]
+            : ["case ", values[0]];
+        return children.guard
+            ? [
+                group([...label, hasMultipleValues ? line : " "]),
+                call(path, print, "guard")
+            ]
+            : group(label);
+    },
+    switchRule(path, print) {
+        const { children } = path.node;
+        const bodyKey = onlyDefinedKey(children, [
+            "block",
+            "expression",
+            "throwStatement"
+        ]);
+        const parts = [
+            call(path, print, "switchLabel"),
+            " -> ",
+            call(path, print, bodyKey)
+        ];
+        if (children.Semicolon) {
+            parts.push(";");
+        }
+        return parts;
+    },
+    caseConstant: printSingle,
+    casePattern: printSingle,
+    whileStatement(path, print) {
+        const statement = call(path, print, "statement");
+        const hasEmptyStatement = isEmptyStatement(path.node.children.statement[0]);
+        return [
+            "while ",
+            indentInParentheses(call(path, print, "expression")),
+            ...[hasEmptyStatement ? ";" : " ", statement]
+        ];
+    },
+    doStatement(path, print) {
+        const hasEmptyStatement = isEmptyStatement(path.node.children.statement[0]);
+        return [
+            "do",
+            hasEmptyStatement ? ";" : [" ", call(path, print, "statement")],
+            " while ",
+            indentInParentheses(call(path, print, "expression")),
+            ";"
+        ];
+    },
+    forStatement: printSingle,
+    basicForStatement(path, print) {
+        const { children } = path.node;
+        const danglingComments = printDanglingComments(path);
+        if (danglingComments.length) {
+            danglingComments.push(hardline);
+        }
+        const expressions = ["forInit", "expression", "forUpdate"].map(expressionKey => expressionKey in children ? call(path, print, expressionKey) : "");
+        const hasEmptyStatement = isEmptyStatement(children.statement[0]);
+        return [
+            ...danglingComments,
+            "for ",
+            expressions.some(expression => expression !== "")
+                ? indentInParentheses(join([";", line], expressions))
+                : "(;;)",
+            hasEmptyStatement ? ";" : [" ", call(path, print, "statement")]
+        ];
+    },
+    forInit: printSingle,
+    forUpdate: printSingle,
+    statementExpressionList(path, print) {
+        return group(map(path, print, "statementExpression").map((expression, index) => index === 0 ? expression : [",", indent([line, expression])]));
+    },
+    enhancedForStatement(path, print) {
+        var _a;
+        const statementNode = path.node.children.statement[0];
+        const forStatement = [
+            printDanglingComments(path),
+            "for ",
+            "(",
+            call(path, print, "localVariableDeclaration"),
+            " : ",
+            call(path, print, "expression"),
+            ")"
+        ];
+        if (isEmptyStatement(statementNode)) {
+            forStatement.push(";");
+        }
+        else {
+            const hasStatementBlock = ((_a = statementNode.children.statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.block) !== undefined;
+            const statement = call(path, print, "statement");
+            forStatement.push(hasStatementBlock ? [" ", statement] : indent([line, statement]));
+        }
+        return group(forStatement);
+    },
+    breakStatement(path, print) {
+        return path.node.children.Identifier
+            ? ["break ", call(path, print, "Identifier"), ";"]
+            : "break;";
+    },
+    continueStatement(path, print) {
+        return path.node.children.Identifier
+            ? ["continue ", call(path, print, "Identifier"), ";"]
+            : "continue;";
+    },
+    returnStatement(path, print) {
+        const { children } = path.node;
+        const statement = ["return"];
+        if (children.expression) {
+            statement.push(" ");
+            const expression = call(path, print, "expression");
+            if (isBinaryExpression(children.expression[0])) {
+                statement.push(group([
+                    ifBreak("("),
+                    indent([softline, expression]),
+                    softline,
+                    ifBreak(")")
+                ]));
+            }
+            else {
+                statement.push(expression);
+            }
+        }
+        statement.push(";");
+        return statement;
+    },
+    throwStatement(path, print) {
+        return ["throw ", call(path, print, "expression"), ";"];
+    },
+    synchronizedStatement(path, print) {
+        return [
+            "synchronized ",
+            indentInParentheses(call(path, print, "expression")),
+            " ",
+            call(path, print, "block")
+        ];
+    },
+    tryStatement(path, print) {
+        const { children } = path.node;
+        if (children.tryWithResourcesStatement) {
+            return call(path, print, "tryWithResourcesStatement");
+        }
+        const blocks = ["try", call(path, print, "block")];
+        if (children.catches) {
+            blocks.push(call(path, print, "catches"));
+        }
+        if (children.finally) {
+            blocks.push(call(path, print, "finally"));
+        }
+        return join(" ", blocks);
+    },
+    catches(path, print) {
+        return join(" ", map(path, print, "catchClause"));
+    },
+    catchClause(path, print) {
+        return [
+            "catch ",
+            indentInParentheses(call(path, print, "catchFormalParameter")),
+            " ",
+            call(path, print, "block")
+        ];
+    },
+    catchFormalParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "catchType"),
+            call(path, print, "variableDeclaratorId")
+        ]);
+    },
+    catchType(path, print) {
+        return join([line, "| "], [call(path, print, "unannClassType"), ...map(path, print, "classType")]);
+    },
+    finally(path, print) {
+        return ["finally ", call(path, print, "block")];
+    },
+    tryWithResourcesStatement(path, print) {
+        const { children } = path.node;
+        const blocks = [
+            "try",
+            call(path, print, "resourceSpecification"),
+            call(path, print, "block")
+        ];
+        if (children.catches) {
+            blocks.push(call(path, print, "catches"));
+        }
+        if (children.finally) {
+            blocks.push(call(path, print, "finally"));
+        }
+        return join(" ", blocks);
+    },
+    resourceSpecification(path, print) {
+        const resources = [call(path, print, "resourceList")];
+        if (path.node.children.Semicolon) {
+            resources.push(ifBreak(";"));
+        }
+        return indentInParentheses(resources);
+    },
+    resourceList(path, print) {
+        return join([";", line], map(path, print, "resource"));
+    },
+    resource: printSingle,
+    yieldStatement(path, print) {
+        return ["yield ", call(path, print, "expression"), ";"];
+    },
+    variableAccess: printSingle
+};

frontend/src/common/prettier/plugins/java/printers/classes.d.ts

@@ -0,0 +1,157 @@
+import type { ClassBodyCstNode, EnumBodyDeclarationsCstNode } from "java-parser";
+import type { AstPath } from "prettier";
+import { builders } from "prettier/doc";
+import { printClassPermits, printClassType, printSingle, type JavaPrintFn } from "./helpers.js";
+declare const _default: {
+    classDeclaration(path: AstPath<import("java-parser").ClassDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    normalClassDeclaration(path: AstPath<import("java-parser").NormalClassDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    classModifier: typeof printSingle;
+    typeParameters(path: AstPath<import("java-parser").TypeParametersCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group;
+    typeParameterList(path: AstPath<import("java-parser").TypeParameterListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    classExtends(path: AstPath<import("java-parser").ClassExtendsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    classImplements(path: AstPath<import("java-parser").ClassImplementsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group;
+    classPermits: typeof printClassPermits;
+    interfaceTypeList(path: AstPath<import("java-parser").InterfaceTypeListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group;
+    classBody(path: AstPath<ClassBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    classBodyDeclaration: typeof printSingle;
+    classMemberDeclaration(path: AstPath<import("java-parser").ClassMemberDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    fieldDeclaration(path: AstPath<import("java-parser").FieldDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    fieldModifier: typeof printSingle;
+    variableDeclaratorList(path: AstPath<import("java-parser").VariableDeclaratorListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | builders.Doc[];
+    variableDeclarator(path: AstPath<import("java-parser").VariableDeclaratorCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    variableDeclaratorId(path: AstPath<import("java-parser").VariableDeclaratorIdCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    variableInitializer: typeof printSingle;
+    unannType: typeof printSingle;
+    unannPrimitiveTypeWithOptionalDimsSuffix(path: AstPath<import("java-parser").UnannPrimitiveTypeWithOptionalDimsSuffixCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    unannPrimitiveType: typeof printSingle;
+    unannReferenceType(path: AstPath<import("java-parser").UnannReferenceTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    unannClassOrInterfaceType: typeof printSingle;
+    unannClassType: typeof printClassType;
+    unannInterfaceType: typeof printSingle;
+    unannTypeVariable: typeof printSingle;
+    methodDeclaration(path: AstPath<import("java-parser").MethodDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    methodModifier: typeof printSingle;
+    methodHeader(path: AstPath<import("java-parser").MethodHeaderCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group;
+    result: typeof printSingle;
+    methodDeclarator(path: AstPath<import("java-parser").MethodDeclaratorCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    receiverParameter(path: AstPath<import("java-parser").ReceiverParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    formalParameterList(path: AstPath<import("java-parser").FormalParameterListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    formalParameter: typeof printSingle;
+    variableParaRegularParameter(path: AstPath<import("java-parser").VariableParaRegularParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    variableArityParameter(path: AstPath<import("java-parser").VariableArityParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    variableModifier: typeof printSingle;
+    throws(path: AstPath<import("java-parser").ThrowsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    exceptionTypeList(path: AstPath<import("java-parser").ExceptionTypeListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    exceptionType: typeof printSingle;
+    methodBody: typeof printSingle;
+    instanceInitializer: typeof printSingle;
+    staticInitializer(path: AstPath<import("java-parser").StaticInitializerCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    constructorDeclaration(path: AstPath<import("java-parser").ConstructorDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    constructorModifier: typeof printSingle;
+    constructorDeclarator(path: AstPath<import("java-parser").ConstructorDeclaratorCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    simpleTypeName: typeof printSingle;
+    constructorBody(path: AstPath<import("java-parser").ConstructorBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    explicitConstructorInvocation: typeof printSingle;
+    unqualifiedExplicitConstructorInvocation(path: AstPath<import("java-parser").UnqualifiedExplicitConstructorInvocationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    qualifiedExplicitConstructorInvocation(path: AstPath<import("java-parser").QualifiedExplicitConstructorInvocationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    enumDeclaration(path: AstPath<import("java-parser").EnumDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    enumBody(path: AstPath<import("java-parser").EnumBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    enumConstantList(path: AstPath<import("java-parser").EnumConstantListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    enumConstant(path: AstPath<import("java-parser").EnumConstantCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    enumConstantModifier: typeof printSingle;
+    enumBodyDeclarations(path: AstPath<EnumBodyDeclarationsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    recordDeclaration(path: AstPath<import("java-parser").RecordDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    recordHeader(path: AstPath<import("java-parser").RecordHeaderCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "()";
+    recordComponentList(path: AstPath<import("java-parser").RecordComponentListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    recordComponent(path: AstPath<import("java-parser").RecordComponentCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group;
+    variableArityRecordComponent(path: AstPath<import("java-parser").VariableArityRecordComponentCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    recordComponentModifier: typeof printSingle;
+    recordBody(path: AstPath<import("java-parser").RecordBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    recordBodyDeclaration: typeof printSingle;
+    compactConstructorDeclaration(path: AstPath<import("java-parser").CompactConstructorDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/classes.js

@@ -0,0 +1,446 @@
+import { builders } from "prettier/doc";
+import { call, each, hasDeclarationAnnotations, hasLeadingComments, indentInParentheses, isBinaryExpression, lineEndWithComments, lineStartWithComments, map, onlyDefinedKey, printBlock, printClassPermits, printClassType, printDanglingComments, printList, printSingle, printWithModifiers } from "./helpers.js";
+const { group, hardline, indent, indentIfBreak, join, line, softline } = builders;
+export default {
+    classDeclaration(path, print) {
+        const declarationKey = onlyDefinedKey(path.node.children, [
+            "enumDeclaration",
+            "normalClassDeclaration",
+            "recordDeclaration"
+        ]);
+        const declaration = call(path, print, declarationKey);
+        return printWithModifiers(path, print, "classModifier", declaration, true);
+    },
+    normalClassDeclaration(path, print) {
+        const { classExtends, classImplements, classPermits, typeParameters } = path.node.children;
+        const header = ["class ", call(path, print, "typeIdentifier")];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
+        if (classExtends) {
+            header.push(indent([line, call(path, print, "classExtends")]));
+        }
+        if (classImplements) {
+            header.push(indent([line, call(path, print, "classImplements")]));
+        }
+        if (classPermits) {
+            header.push(indent([line, call(path, print, "classPermits")]));
+        }
+        return [group(header), " ", call(path, print, "classBody")];
+    },
+    classModifier: printSingle,
+    typeParameters(path, print) {
+        return group([
+            "<",
+            indent([softline, call(path, print, "typeParameterList")]),
+            softline,
+            ">"
+        ]);
+    },
+    typeParameterList(path, print) {
+        return printList(path, print, "typeParameter");
+    },
+    classExtends(path, print) {
+        return ["extends ", call(path, print, "classType")];
+    },
+    classImplements(path, print) {
+        return group([
+            "implements",
+            indent([line, call(path, print, "interfaceTypeList")])
+        ]);
+    },
+    classPermits: printClassPermits,
+    interfaceTypeList(path, print) {
+        return group(printList(path, print, "interfaceType"));
+    },
+    classBody(path, print) {
+        return printBlock(path, printClassBodyDeclarations(path, print));
+    },
+    classBodyDeclaration: printSingle,
+    classMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    fieldDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "variableDeclaratorList"),
+            ";"
+        ];
+        return printWithModifiers(path, print, "fieldModifier", declaration);
+    },
+    fieldModifier: printSingle,
+    variableDeclaratorList(path, print) {
+        var _a;
+        const declarators = map(path, print, "variableDeclarator");
+        return declarators.length > 1 &&
+            path.node.children.variableDeclarator.some(({ children }) => children.Equals)
+            ? group(indent(join([",", line], declarators)), {
+                shouldBreak: ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) !== "forInit"
+            })
+            : join(", ", declarators);
+    },
+    variableDeclarator(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        const variableInitializer = (_a = children.variableInitializer) === null || _a === void 0 ? void 0 : _a[0];
+        const declaratorId = call(path, print, "variableDeclaratorId");
+        if (!variableInitializer) {
+            return declaratorId;
+        }
+        const expression = (_b = variableInitializer.children.expression) === null || _b === void 0 ? void 0 : _b[0];
+        const declarator = [declaratorId, " ", call(path, print, "Equals")];
+        const initializer = call(path, print, "variableInitializer");
+        if (hasLeadingComments(variableInitializer) ||
+            (expression && isBinaryExpression(expression))) {
+            declarator.push(group(indent([line, initializer])));
+        }
+        else {
+            const groupId = Symbol("assignment");
+            declarator.push(group(indent(line), { id: groupId }), indentIfBreak(initializer, { groupId }));
+        }
+        return group(declarator);
+    },
+    variableDeclaratorId(path, print) {
+        const { dims, Underscore } = path.node.children;
+        if (Underscore) {
+            return "_";
+        }
+        const identifier = call(path, print, "Identifier");
+        return dims ? [identifier, call(path, print, "dims")] : identifier;
+    },
+    variableInitializer: printSingle,
+    unannType: printSingle,
+    unannPrimitiveTypeWithOptionalDimsSuffix(path, print) {
+        const type = call(path, print, "unannPrimitiveType");
+        return path.node.children.dims ? [type, call(path, print, "dims")] : type;
+    },
+    unannPrimitiveType: printSingle,
+    unannReferenceType(path, print) {
+        const type = call(path, print, "unannClassOrInterfaceType");
+        return path.node.children.dims ? [type, call(path, print, "dims")] : type;
+    },
+    unannClassOrInterfaceType: printSingle,
+    unannClassType: printClassType,
+    unannInterfaceType: printSingle,
+    unannTypeVariable: printSingle,
+    methodDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "methodHeader"),
+            path.node.children.methodBody[0].children.Semicolon ? "" : " ",
+            call(path, print, "methodBody")
+        ];
+        return printWithModifiers(path, print, "methodModifier", declaration);
+    },
+    methodModifier: printSingle,
+    methodHeader(path, print) {
+        const { typeParameters, annotation, throws } = path.node.children;
+        const header = [];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
+        if (annotation) {
+            header.push(join(line, map(path, print, "annotation")));
+        }
+        header.push(call(path, print, "result"), call(path, print, "methodDeclarator"));
+        return throws
+            ? group([
+                ...join(" ", header),
+                group(indent([line, call(path, print, "throws")]))
+            ])
+            : group(join(" ", header));
+    },
+    result: printSingle,
+    methodDeclarator(path, print) {
+        const { dims, formalParameterList, receiverParameter } = path.node.children;
+        const declarator = [call(path, print, "Identifier")];
+        const parameters = [];
+        if (receiverParameter) {
+            parameters.push(call(path, print, "receiverParameter"));
+        }
+        if (formalParameterList) {
+            parameters.push(call(path, print, "formalParameterList"));
+        }
+        const items = parameters.length
+            ? join([",", line], parameters)
+            : printDanglingComments(path);
+        declarator.push(items.length ? indentInParentheses(items) : "()");
+        if (dims) {
+            declarator.push(call(path, print, "dims"));
+        }
+        return declarator;
+    },
+    receiverParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "unannType"),
+            path.node.children.Identifier
+                ? [call(path, print, "Identifier"), ".this"]
+                : "this"
+        ]);
+    },
+    formalParameterList(path, print) {
+        return printList(path, print, "formalParameter");
+    },
+    formalParameter: printSingle,
+    variableParaRegularParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "unannType"),
+            call(path, print, "variableDeclaratorId")
+        ]);
+    },
+    variableArityParameter(path, print) {
+        const type = join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "unannType"),
+            ...map(path, print, "annotation")
+        ]);
+        return [type, "... ", call(path, print, "Identifier")];
+    },
+    variableModifier: printSingle,
+    throws(path, print) {
+        return ["throws ", call(path, print, "exceptionTypeList")];
+    },
+    exceptionTypeList(path, print) {
+        return join(", ", map(path, print, "exceptionType"));
+    },
+    exceptionType: printSingle,
+    methodBody: printSingle,
+    instanceInitializer: printSingle,
+    staticInitializer(path, print) {
+        return ["static ", call(path, print, "block")];
+    },
+    constructorDeclaration(path, print) {
+        const declaration = [call(path, print, "constructorDeclarator")];
+        if (path.node.children.throws) {
+            declaration.push(group(indent([line, call(path, print, "throws")])));
+        }
+        declaration.push(" ", call(path, print, "constructorBody"));
+        return printWithModifiers(path, print, "constructorModifier", declaration, true);
+    },
+    constructorModifier: printSingle,
+    constructorDeclarator(path, print) {
+        const { children } = path.node;
+        const parameters = [];
+        if (children.receiverParameter) {
+            parameters.push(call(path, print, "receiverParameter"));
+        }
+        if (children.formalParameterList) {
+            parameters.push(call(path, print, "formalParameterList"));
+        }
+        const header = [call(path, print, "simpleTypeName")];
+        header.push(parameters.length
+            ? indentInParentheses(join([",", line], parameters))
+            : "()");
+        return children.typeParameters
+            ? [call(path, print, "typeParameters"), " ", ...header]
+            : header;
+    },
+    simpleTypeName: printSingle,
+    constructorBody(path, print) {
+        const { children } = path.node;
+        const statements = [];
+        if (children.explicitConstructorInvocation) {
+            statements.push(call(path, print, "explicitConstructorInvocation"));
+        }
+        if (children.blockStatements) {
+            statements.push(call(path, print, "blockStatements"));
+        }
+        return printBlock(path, statements);
+    },
+    explicitConstructorInvocation: printSingle,
+    unqualifiedExplicitConstructorInvocation(path, print) {
+        const { children } = path.node;
+        const invocation = [];
+        if (children.typeArguments) {
+            invocation.push(call(path, print, "typeArguments"));
+        }
+        invocation.push(children.Super ? "super" : "this");
+        if (children.argumentList) {
+            invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
+        }
+        else {
+            invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
+        }
+        invocation.push(";");
+        return invocation;
+    },
+    qualifiedExplicitConstructorInvocation(path, print) {
+        const { children } = path.node;
+        const invocation = [call(path, print, "expressionName"), "."];
+        if (children.typeArguments) {
+            invocation.push(call(path, print, "typeArguments"));
+        }
+        invocation.push("super");
+        if (children.argumentList) {
+            invocation.push(group(["(", call(path, print, "argumentList"), ")"]));
+        }
+        else {
+            invocation.push(indentInParentheses(printDanglingComments(path), { shouldBreak: true }));
+        }
+        invocation.push(";");
+        return invocation;
+    },
+    enumDeclaration(path, print) {
+        const header = ["enum", call(path, print, "typeIdentifier")];
+        if (path.node.children.classImplements) {
+            header.push(call(path, print, "classImplements"));
+        }
+        return join(" ", [...header, call(path, print, "enumBody")]);
+    },
+    enumBody(path, print, options) {
+        var _a;
+        const { children } = path.node;
+        const contents = [];
+        const hasNonEmptyDeclaration = ((_a = children.enumBodyDeclarations) !== null && _a !== void 0 ? _a : [])
+            .flatMap(({ children }) => { var _a; return (_a = children.classBodyDeclaration) !== null && _a !== void 0 ? _a : []; })
+            .some(({ children }) => { var _a; return !((_a = children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.Semicolon); });
+        if (children.enumConstantList) {
+            contents.push(call(path, print, "enumConstantList"));
+            if (!hasNonEmptyDeclaration && options.trailingComma !== "none") {
+                contents.push(",");
+            }
+        }
+        if (hasNonEmptyDeclaration) {
+            contents.push(";", hardline, call(path, print, "enumBodyDeclarations"));
+        }
+        return printBlock(path, contents.length ? [contents] : []);
+    },
+    enumConstantList(path, print) {
+        return join([",", hardline], map(path, constantPath => {
+            const constant = print(constantPath);
+            const { node, previous } = constantPath;
+            return !previous ||
+                lineStartWithComments(node) <= lineEndWithComments(previous) + 1
+                ? constant
+                : [hardline, constant];
+        }, "enumConstant"));
+    },
+    enumConstant(path, print) {
+        const { argumentList, classBody } = path.node.children;
+        const initializer = [call(path, print, "Identifier")];
+        if (argumentList) {
+            initializer.push(group(["(", call(path, print, "argumentList"), ")"]));
+        }
+        if (classBody) {
+            initializer.push(" ", call(path, print, "classBody"));
+        }
+        return printWithModifiers(path, print, "enumConstantModifier", initializer);
+    },
+    enumConstantModifier: printSingle,
+    enumBodyDeclarations(path, print) {
+        return join(hardline, printClassBodyDeclarations(path, print));
+    },
+    recordDeclaration(path, print) {
+        const { children } = path.node;
+        const header = ["record ", call(path, print, "typeIdentifier")];
+        if (children.typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
+        header.push(call(path, print, "recordHeader"));
+        if (children.classImplements) {
+            header.push(" ", call(path, print, "classImplements"));
+        }
+        return [group(header), " ", call(path, print, "recordBody")];
+    },
+    recordHeader(path, print) {
+        return path.node.children.recordComponentList
+            ? indentInParentheses(call(path, print, "recordComponentList"))
+            : indentInParentheses(printDanglingComments(path), { shouldBreak: true });
+    },
+    recordComponentList(path, print) {
+        return join([",", line], map(path, componentPath => {
+            const { node, previous } = componentPath;
+            const blankLine = previous &&
+                lineStartWithComments(node) > lineEndWithComments(previous) + 1;
+            const component = print(componentPath);
+            return blankLine ? [softline, component] : component;
+        }, "recordComponent"));
+    },
+    recordComponent(path, print) {
+        const { children } = path.node;
+        const component = [call(path, print, "unannType")];
+        if (children.Identifier ||
+            children.variableArityRecordComponent[0].children.annotation) {
+            component.push(" ");
+        }
+        const suffixKey = onlyDefinedKey(children, [
+            "Identifier",
+            "variableArityRecordComponent"
+        ]);
+        component.push(call(path, print, suffixKey));
+        return group(join(line, [...map(path, print, "recordComponentModifier"), component]));
+    },
+    variableArityRecordComponent(path, print) {
+        return [
+            ...join(" ", map(path, print, "annotation")),
+            "... ",
+            call(path, print, "Identifier")
+        ];
+    },
+    recordComponentModifier: printSingle,
+    recordBody(path, print) {
+        const declarations = [];
+        let previousRequiresPadding = false;
+        each(path, declarationPath => {
+            var _a, _b, _c, _d;
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            const { node, previous } = declarationPath;
+            const fieldDeclaration = (_c = (_b = (_a = node.children.classBodyDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.classMemberDeclaration) === null || _b === void 0 ? void 0 : _b[0].children.fieldDeclaration) === null || _c === void 0 ? void 0 : _c[0].children;
+            const currentRequiresPadding = !fieldDeclaration ||
+                hasDeclarationAnnotations((_d = fieldDeclaration.fieldModifier) !== null && _d !== void 0 ? _d : []);
+            const blankLine = declarations.length > 0 &&
+                (previousRequiresPadding ||
+                    currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1);
+            declarations.push(blankLine ? [hardline, declaration] : declaration);
+            previousRequiresPadding = currentRequiresPadding;
+        }, "recordBodyDeclaration");
+        return printBlock(path, declarations);
+    },
+    recordBodyDeclaration: printSingle,
+    compactConstructorDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "simpleTypeName"),
+            " ",
+            call(path, print, "constructorBody")
+        ];
+        return printWithModifiers(path, print, "constructorModifier", declaration, true);
+    }
+};
+function printClassBodyDeclarations(path, print) {
+    var _a;
+    if (!path.node.children.classBodyDeclaration) {
+        return [];
+    }
+    const declarations = [];
+    let previousRequiresPadding = path.node.name === "enumBodyDeclarations" ||
+        ((_a = path.grandparent) === null || _a === void 0 ? void 0 : _a.name) ===
+            "normalClassDeclaration";
+    each(path, declarationPath => {
+        var _a, _b, _c;
+        const declaration = print(declarationPath);
+        if (declaration === "") {
+            return;
+        }
+        const { node, previous } = declarationPath;
+        const fieldDeclaration = (_b = (_a = node.children.classMemberDeclaration) === null || _a === void 0 ? void 0 : _a[0].children.fieldDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
+        const currentRequiresPadding = fieldDeclaration
+            ? hasDeclarationAnnotations((_c = fieldDeclaration.fieldModifier) !== null && _c !== void 0 ? _c : [])
+            : true;
+        const blankLine = previousRequiresPadding ||
+            (declarations.length > 0 &&
+                (currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1));
+        declarations.push(blankLine ? [hardline, declaration] : declaration);
+        previousRequiresPadding = currentRequiresPadding;
+    }, "classBodyDeclaration");
+    return declarations;
+}

frontend/src/common/prettier/plugins/java/printers/expressions.d.ts

@@ -0,0 +1,134 @@
+import type { StringTemplateCstNode, TextBlockTemplateCstNode } from "java-parser";
+import type { AstPath } from "prettier";
+import { builders } from "prettier/doc";
+import type { JavaComment } from "../comments.js";
+import { printSingle, type JavaPrintFn } from "./helpers.js";
+declare const _default: {
+    expression: typeof printSingle;
+    lambdaExpression(path: AstPath<import("java-parser").LambdaExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn, _: import("./helpers.js").JavaParserOptions, args?: unknown): builders.Doc[];
+    lambdaParameters(path: AstPath<import("java-parser").LambdaParametersCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
+    lambdaParametersWithBraces(path: AstPath<import("java-parser").LambdaParametersWithBracesCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
+    lambdaParameterList: typeof printSingle;
+    conciseLambdaParameterList(path: AstPath<import("java-parser").ConciseLambdaParameterListCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    normalLambdaParameterList(path: AstPath<import("java-parser").NormalLambdaParameterListCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    normalLambdaParameter: typeof printSingle;
+    regularLambdaParameter(path: AstPath<import("java-parser").RegularLambdaParameterCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    lambdaParameterType: typeof printSingle;
+    conciseLambdaParameter: typeof printSingle;
+    lambdaBody: typeof printSingle;
+    conditionalExpression(path: AstPath<import("java-parser").ConditionalExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    binaryExpression(path: AstPath<import("java-parser").BinaryExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Doc;
+    unaryExpression(path: AstPath<import("java-parser").UnaryExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    unaryExpressionNotPlusMinus(path: AstPath<import("java-parser").UnaryExpressionNotPlusMinusCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    primary(path: AstPath<import("java-parser").PrimaryCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    primaryPrefix: typeof printSingle;
+    primarySuffix(path: AstPath<import("java-parser").PrimarySuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    fqnOrRefType(path: AstPath<import("java-parser").FqnOrRefTypeCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn, _: import("./helpers.js").JavaParserOptions, args: unknown): builders.Doc[];
+    fqnOrRefTypePartFirst(path: AstPath<import("java-parser").FqnOrRefTypePartFirstCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    fqnOrRefTypePartRest(path: AstPath<import("java-parser").FqnOrRefTypePartRestCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    fqnOrRefTypePartCommon(path: AstPath<import("java-parser").FqnOrRefTypePartCommonCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    parenthesisExpression(path: AstPath<import("java-parser").ParenthesisExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "()" | (string | builders.Indent)[];
+    castExpression: typeof printSingle;
+    primitiveCastExpression(path: AstPath<import("java-parser").PrimitiveCastExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    referenceTypeCastExpression(path: AstPath<import("java-parser").ReferenceTypeCastExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    newExpression: typeof printSingle;
+    unqualifiedClassInstanceCreationExpression(path: AstPath<import("java-parser").UnqualifiedClassInstanceCreationExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    classOrInterfaceTypeToInstantiate(path: AstPath<import("java-parser").ClassOrInterfaceTypeToInstantiateCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    typeArgumentsOrDiamond: typeof printSingle;
+    diamond(): string;
+    methodInvocationSuffix(path: AstPath<import("java-parser").MethodInvocationSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | "()";
+    argumentList(path: AstPath<import("java-parser").ArgumentListCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Group | (builders.Indent | builders.Softline)[] | (builders.BreakParent | builders.Group)[];
+    arrayCreationExpression(path: AstPath<import("java-parser").ArrayCreationExpressionCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    arrayCreationExpressionWithoutInitializerSuffix(path: AstPath<import("java-parser").ArrayCreationExpressionWithoutInitializerSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    arrayCreationWithInitializerSuffix(path: AstPath<import("java-parser").ArrayCreationWithInitializerSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    dimExprs(path: AstPath<import("java-parser").DimExprsCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    dimExpr(path: AstPath<import("java-parser").DimExprCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    classLiteralSuffix(path: AstPath<import("java-parser").ClassLiteralSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    arrayAccessSuffix(path: AstPath<import("java-parser").ArrayAccessSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    methodReferenceSuffix(path: AstPath<import("java-parser").MethodReferenceSuffixCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    templateArgument: typeof printSingle;
+    template: typeof printSingle;
+    stringTemplate(path: AstPath<StringTemplateCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Indent;
+    textBlockTemplate(path: AstPath<TextBlockTemplateCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Indent;
+    embeddedExpression: typeof printSingle;
+    pattern: typeof printSingle;
+    typePattern: typeof printSingle;
+    recordPattern(path: AstPath<import("java-parser").RecordPatternCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    componentPatternList(path: AstPath<import("java-parser").ComponentPatternListCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    componentPattern: typeof printSingle;
+    matchAllPattern: typeof printSingle;
+    guard(path: AstPath<import("java-parser").GuardCstNode & {
+        comments?: JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/expressions.js

@@ -0,0 +1,598 @@
+import { builders, utils } from "prettier/doc";
+import { call, definedKeys, each, findBaseIndent, flatMap, hasLeadingComments, indentInParentheses, isBinaryExpression, isNonTerminal, isTerminal, map, onlyDefinedKey, printDanglingComments, printList, printName, printSingle } from "./helpers.js";
+const { breakParent, conditionalGroup, group, hardline, ifBreak, indent, indentIfBreak, join, line, lineSuffixBoundary, softline } = builders;
+const { removeLines, willBreak } = utils;
+export default {
+    expression: printSingle,
+    lambdaExpression(path, print, _, args = {}) {
+        var _a;
+        const hug = (_a = args.hug) !== null && _a !== void 0 ? _a : false;
+        const parameters = call(path, print, "lambdaParameters");
+        const expression = [hug ? removeLines(parameters) : parameters, " ->"];
+        const lambdaExpression = path.node.children.lambdaBody[0].children.expression;
+        const body = call(path, print, "lambdaBody");
+        if (lambdaExpression) {
+            const suffix = indent([line, body]);
+            expression.push(group(hug ? [suffix, softline] : suffix));
+        }
+        else {
+            expression.push(" ", body);
+        }
+        return expression;
+    },
+    lambdaParameters(path, print, options) {
+        const parameters = printSingle(path, print);
+        return !path.node.children.lambdaParametersWithBraces &&
+            options.arrowParens === "always"
+            ? ["(", parameters, ")"]
+            : parameters;
+    },
+    lambdaParametersWithBraces(path, print, options) {
+        var _a;
+        const { lambdaParameterList } = path.node.children;
+        if (!lambdaParameterList) {
+            return "()";
+        }
+        const { conciseLambdaParameterList, normalLambdaParameterList } = lambdaParameterList[0].children;
+        const parameterCount = ((_a = conciseLambdaParameterList === null || conciseLambdaParameterList === void 0 ? void 0 : conciseLambdaParameterList[0].children.conciseLambdaParameter) !== null && _a !== void 0 ? _a : normalLambdaParameterList === null || normalLambdaParameterList === void 0 ? void 0 : normalLambdaParameterList[0].children.normalLambdaParameter).length;
+        const parameters = call(path, print, "lambdaParameterList");
+        if (parameterCount > 1) {
+            return indentInParentheses(parameters);
+        }
+        return conciseLambdaParameterList && options.arrowParens === "avoid"
+            ? parameters
+            : ["(", parameters, ")"];
+    },
+    lambdaParameterList: printSingle,
+    conciseLambdaParameterList(path, print) {
+        return printList(path, print, "conciseLambdaParameter");
+    },
+    normalLambdaParameterList(path, print) {
+        return printList(path, print, "normalLambdaParameter");
+    },
+    normalLambdaParameter: printSingle,
+    regularLambdaParameter(path, print) {
+        return join(" ", [
+            ...map(path, print, "variableModifier"),
+            call(path, print, "lambdaParameterType"),
+            call(path, print, "variableDeclaratorId")
+        ]);
+    },
+    lambdaParameterType: printSingle,
+    conciseLambdaParameter: printSingle,
+    lambdaBody: printSingle,
+    conditionalExpression(path, print) {
+        var _a;
+        const binaryExpression = call(path, print, "binaryExpression");
+        if (!path.node.children.QuestionMark) {
+            return binaryExpression;
+        }
+        const expressions = map(path, print, "expression");
+        const contents = indent(join(line, [
+            binaryExpression,
+            ["? ", expressions[0]],
+            [": ", expressions[1]]
+        ]));
+        const isNestedTernary = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) ===
+            "conditionalExpression";
+        return isNestedTernary ? contents : group(contents);
+    },
+    binaryExpression(path, print, options) {
+        var _a, _b;
+        const { children } = path.node;
+        const operands = flatMap(path, print, definedKeys(children, [
+            "expression",
+            "pattern",
+            "referenceType",
+            "unaryExpression"
+        ]));
+        const operators = flatMap(path, operatorPath => {
+            const { node } = operatorPath;
+            let image;
+            if (isTerminal(node)) {
+                image = node.image;
+            }
+            else if (node.children.Less) {
+                image = "<<";
+            }
+            else {
+                image = node.children.Greater.length === 2 ? ">>" : ">>>";
+            }
+            return { image, doc: print(operatorPath) };
+        }, definedKeys(children, [
+            "AssignmentOperator",
+            "BinaryOperator",
+            "Instanceof",
+            "shiftOperator"
+        ]));
+        const hasNonAssignmentOperators = (operators.length > 0 && !children.AssignmentOperator) ||
+            (children.expression !== undefined &&
+                isBinaryExpression(children.expression[0]));
+        const isInList = ((_a = path.getNode(4)) === null || _a === void 0 ? void 0 : _a.name) === "elementValue" ||
+            ((_b = path.getNode(6)) === null || _b === void 0 ? void 0 : _b.name) === "argumentList";
+        return binary(operands, operators, {
+            hasNonAssignmentOperators,
+            isInList,
+            isRoot: true,
+            operatorPosition: options.experimentalOperatorPosition
+        });
+    },
+    unaryExpression(path, print) {
+        return [
+            ...map(path, print, "UnaryPrefixOperator"),
+            call(path, print, "primary"),
+            ...map(path, print, "UnarySuffixOperator")
+        ];
+    },
+    unaryExpressionNotPlusMinus(path, print) {
+        const { children } = path.node;
+        const expression = [];
+        if (children.UnaryPrefixOperatorNotPlusMinus) {
+            expression.push(...map(path, print, "UnaryPrefixOperatorNotPlusMinus"));
+        }
+        expression.push(call(path, print, "primary"));
+        if (children.UnarySuffixOperator) {
+            expression.push(...map(path, print, "UnarySuffixOperator"));
+        }
+        return join(" ", expression);
+    },
+    primary(path, print) {
+        var _a, _b;
+        const { children } = path.node;
+        if (!children.primarySuffix) {
+            return call(path, print, "primaryPrefix");
+        }
+        const methodInvocations = children.primarySuffix
+            .filter(({ children }) => children.methodInvocationSuffix)
+            .map(({ children }) => children.methodInvocationSuffix[0].children);
+        const hasLambdaMethodParameter = methodInvocations.some(({ argumentList }) => argumentList === null || argumentList === void 0 ? void 0 : argumentList[0].children.expression.some(({ children }) => children.lambdaExpression));
+        const prefixIsCallExpression = children.primaryPrefix[0].children.newExpression;
+        const callExpressionCount = methodInvocations.length +
+            (prefixIsCallExpression ? 1 : 0) +
+            children.primarySuffix.filter(({ children }) => children.unqualifiedClassInstanceCreationExpression).length;
+        const fqnOrRefType = (_a = children.primaryPrefix[0].children.fqnOrRefType) === null || _a === void 0 ? void 0 : _a[0].children;
+        const prefixIsMethodInvocation = (fqnOrRefType === null || fqnOrRefType === void 0 ? void 0 : fqnOrRefType.fqnOrRefTypePartRest) !== undefined &&
+            ((_b = children.primarySuffix) === null || _b === void 0 ? void 0 : _b[0].children.methodInvocationSuffix) !== undefined;
+        const prefixIsStaticMethodInvocation = prefixIsMethodInvocation && isCapitalizedIdentifier(fqnOrRefType);
+        const prefixIsInstanceMethodInvocation = prefixIsMethodInvocation && !prefixIsStaticMethodInvocation;
+        const mustBreakForCallExpressions = methodInvocations.length > 2 && hasLambdaMethodParameter;
+        const separator = mustBreakForCallExpressions ? hardline : softline;
+        const prefix = [
+            call(path, prefixPath => print(prefixPath, {
+                lastSeparator: prefixIsStaticMethodInvocation ||
+                    (prefixIsInstanceMethodInvocation && callExpressionCount === 1)
+                    ? ""
+                    : separator
+            }), "primaryPrefix")
+        ];
+        const canBreakForCallExpressions = callExpressionCount > 2 ||
+            (callExpressionCount === 2 && prefixIsInstanceMethodInvocation) ||
+            willBreak(prefix);
+        const suffixes = [];
+        each(path, suffixPath => {
+            const { node, previous } = suffixPath;
+            const suffix = print(suffixPath);
+            if (node.children.Dot) {
+                if ((canBreakForCallExpressions &&
+                    ((!previous && prefixIsCallExpression) ||
+                        (previous === null || previous === void 0 ? void 0 : previous.children.methodInvocationSuffix) ||
+                        (previous === null || previous === void 0 ? void 0 : previous.children.unqualifiedClassInstanceCreationExpression))) ||
+                    (!node.children.templateArgument && willBreak(suffix))) {
+                    suffixes.push(separator);
+                }
+                suffixes.push(suffix);
+            }
+            else if (previous) {
+                suffixes.push(suffix);
+            }
+            else {
+                prefix.push(prefixIsInstanceMethodInvocation && callExpressionCount >= 2
+                    ? indent(suffix)
+                    : suffix);
+            }
+        }, "primarySuffix");
+        const hasSuffixComments = children.primarySuffix.some(suffix => hasLeadingComments(suffix));
+        return group(canBreakForCallExpressions || hasSuffixComments
+            ? [prefix, indent(suffixes)]
+            : [prefix, ...suffixes]);
+    },
+    primaryPrefix: printSingle,
+    primarySuffix(path, print) {
+        const { children } = path.node;
+        if (!children.Dot) {
+            return printSingle(path, print);
+        }
+        const suffix = ["."];
+        if (children.This) {
+            suffix.push("this");
+        }
+        else if (children.Identifier) {
+            if (children.typeArguments) {
+                suffix.push(call(path, print, "typeArguments"));
+            }
+            suffix.push(call(path, print, "Identifier"));
+        }
+        else {
+            const suffixKey = onlyDefinedKey(children, [
+                "templateArgument",
+                "unqualifiedClassInstanceCreationExpression"
+            ]);
+            suffix.push(call(path, print, suffixKey));
+        }
+        return suffix;
+    },
+    fqnOrRefType(path, print, _, args) {
+        var _a;
+        const lastSeparator = (_a = args.lastSeparator) !== null && _a !== void 0 ? _a : "";
+        const fqnOrRefType = [
+            call(path, print, "fqnOrRefTypePartFirst"),
+            ...map(path, partPath => {
+                const part = print(partPath);
+                return partPath.isLast
+                    ? [willBreak(part) ? hardline : lastSeparator, part]
+                    : part;
+            }, "fqnOrRefTypePartRest")
+        ];
+        fqnOrRefType.push(indent(fqnOrRefType.pop()));
+        return path.node.children.dims
+            ? [fqnOrRefType, call(path, print, "dims")]
+            : fqnOrRefType;
+    },
+    fqnOrRefTypePartFirst(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "fqnOrRefTypePartCommon")
+        ]);
+    },
+    fqnOrRefTypePartRest(path, print) {
+        const common = call(path, print, "fqnOrRefTypePartCommon");
+        const type = path.node.children.typeArguments
+            ? [call(path, print, "typeArguments"), common]
+            : common;
+        return [".", ...join(" ", [...map(path, print, "annotation"), type])];
+    },
+    fqnOrRefTypePartCommon(path, print) {
+        const { children } = path.node;
+        const keywordKey = onlyDefinedKey(children, ["Identifier", "Super"]);
+        const keyword = call(path, print, keywordKey);
+        return children.typeArguments
+            ? [keyword, call(path, print, "typeArguments")]
+            : keyword;
+    },
+    parenthesisExpression(path, print) {
+        var _a;
+        const expression = call(path, print, "expression");
+        const ancestorName = (_a = path.getNode(14)) === null || _a === void 0 ? void 0 : _a.name;
+        const binaryExpression = path.getNode(8);
+        return ancestorName &&
+            ["guard", "returnStatement"].includes(ancestorName) &&
+            binaryExpression &&
+            binaryExpression.name === "binaryExpression" &&
+            Object.keys(binaryExpression.children).length === 1
+            ? indentInParentheses(expression)
+            : ["(", indent(expression), ")"];
+    },
+    castExpression: printSingle,
+    primitiveCastExpression(path, print) {
+        return [
+            "(",
+            call(path, print, "primitiveType"),
+            ") ",
+            call(path, print, "unaryExpression")
+        ];
+    },
+    referenceTypeCastExpression(path, print) {
+        const { children } = path.node;
+        const type = call(path, print, "referenceType");
+        const cast = children.additionalBound
+            ? indentInParentheses(join(line, [type, ...map(path, print, "additionalBound")]))
+            : ["(", type, ")"];
+        const expressionKey = onlyDefinedKey(children, [
+            "lambdaExpression",
+            "unaryExpressionNotPlusMinus"
+        ]);
+        return [cast, " ", call(path, print, expressionKey)];
+    },
+    newExpression: printSingle,
+    unqualifiedClassInstanceCreationExpression(path, print) {
+        const { children } = path.node;
+        const expression = ["new "];
+        if (children.typeArguments) {
+            expression.push(call(path, print, "typeArguments"));
+        }
+        expression.push(call(path, print, "classOrInterfaceTypeToInstantiate"), children.argumentList
+            ? group(["(", call(path, print, "argumentList"), ")"])
+            : "()");
+        if (children.classBody) {
+            expression.push(" ", call(path, print, "classBody"));
+        }
+        return expression;
+    },
+    classOrInterfaceTypeToInstantiate(path, print) {
+        const { children } = path.node;
+        const type = children.annotation
+            ? flatMap(path, childPath => [
+                print(childPath),
+                isNonTerminal(childPath.node) ? " " : "."
+            ], ["annotation", "Identifier"])
+            : printName(path, print);
+        if (children.typeArgumentsOrDiamond) {
+            type.push(call(path, print, "typeArgumentsOrDiamond"));
+        }
+        return type;
+    },
+    typeArgumentsOrDiamond: printSingle,
+    diamond() {
+        return "<>";
+    },
+    methodInvocationSuffix(path, print) {
+        return path.node.children.argumentList
+            ? group(["(", call(path, print, "argumentList"), ")"])
+            : indentInParentheses(printDanglingComments(path), { shouldBreak: true });
+    },
+    argumentList(path, print) {
+        var _a, _b, _c, _d;
+        const expressions = path.node.children.expression;
+        const lastExpression = expressions.at(-1);
+        const lastExpressionLambdaBodyExpression = (_b = (_a = lastExpression.children.lambdaExpression) === null || _a === void 0 ? void 0 : _a[0].children.lambdaBody[0].children.expression) === null || _b === void 0 ? void 0 : _b[0].children;
+        const lastExpressionLambdaBodyTernaryExpression = (_c = lastExpressionLambdaBodyExpression === null || lastExpressionLambdaBodyExpression === void 0 ? void 0 : lastExpressionLambdaBodyExpression.conditionalExpression) === null || _c === void 0 ? void 0 : _c[0].children;
+        const isHuggable = !lastExpression.comments &&
+            (!lastExpressionLambdaBodyExpression ||
+                (lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.QuestionMark) !== undefined ||
+                ((_d = lastExpressionLambdaBodyTernaryExpression === null || lastExpressionLambdaBodyTernaryExpression === void 0 ? void 0 : lastExpressionLambdaBodyTernaryExpression.binaryExpression) === null || _d === void 0 ? void 0 : _d[0].children.unaryExpression.length) === 1) &&
+            expressions.findIndex(({ children }) => children.lambdaExpression) ===
+                expressions.length - 1;
+        const args = map(path, print, "expression");
+        const allArgsExpandable = [
+            indent([softline, ...join([",", line], args)]),
+            softline
+        ];
+        if (!isHuggable || willBreak(args.at(-1)[0])) {
+            return allArgsExpandable;
+        }
+        const headArgs = args.slice(0, -1);
+        const huggedLastArg = path.call(argPath => print(argPath, { hug: true }), "children", "expression", args.length - 1);
+        const lastArgExpanded = join(", ", [
+            ...headArgs,
+            group(huggedLastArg, { shouldBreak: true })
+        ]);
+        if (willBreak(huggedLastArg)) {
+            return [
+                breakParent,
+                conditionalGroup([lastArgExpanded, allArgsExpandable])
+            ];
+        }
+        return conditionalGroup([
+            join(", ", [...headArgs, huggedLastArg]),
+            lastArgExpanded,
+            allArgsExpandable
+        ]);
+    },
+    arrayCreationExpression(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, [
+            "classOrInterfaceType",
+            "primitiveType"
+        ]);
+        const suffixKey = onlyDefinedKey(children, [
+            "arrayCreationExpressionWithoutInitializerSuffix",
+            "arrayCreationWithInitializerSuffix"
+        ]);
+        return ["new ", call(path, print, typeKey), call(path, print, suffixKey)];
+    },
+    arrayCreationExpressionWithoutInitializerSuffix(path, print) {
+        const expressions = call(path, print, "dimExprs");
+        return path.node.children.dims
+            ? [expressions, call(path, print, "dims")]
+            : expressions;
+    },
+    arrayCreationWithInitializerSuffix(path, print) {
+        return [
+            call(path, print, "dims"),
+            " ",
+            call(path, print, "arrayInitializer")
+        ];
+    },
+    dimExprs(path, print) {
+        return map(path, print, "dimExpr");
+    },
+    dimExpr(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            ["[", call(path, print, "expression"), "]"]
+        ]);
+    },
+    classLiteralSuffix(path, print) {
+        const lSquares = map(path, print, "LSquare");
+        const rSquares = map(path, print, "RSquare");
+        return [
+            ...lSquares.flatMap((lSquare, index) => [lSquare, rSquares[index]]),
+            ".class"
+        ];
+    },
+    arrayAccessSuffix(path, print) {
+        return ["[", call(path, print, "expression"), "]"];
+    },
+    methodReferenceSuffix(path, print) {
+        const { children } = path.node;
+        const reference = ["::"];
+        if (children.typeArguments) {
+            reference.push(call(path, print, "typeArguments"));
+        }
+        reference.push(call(path, print, onlyDefinedKey(children, ["Identifier", "New"])));
+        return reference;
+    },
+    templateArgument: printSingle,
+    template: printSingle,
+    stringTemplate(path, print) {
+        return printTemplate(path, print, "StringTemplateBegin", "StringTemplateMid", "StringTemplateEnd");
+    },
+    textBlockTemplate(path, print) {
+        return printTemplate(path, print, "TextBlockTemplateBegin", "TextBlockTemplateMid", "TextBlockTemplateEnd");
+    },
+    embeddedExpression: printSingle,
+    pattern: printSingle,
+    typePattern: printSingle,
+    recordPattern(path, print) {
+        const patterns = path.node.children.componentPatternList
+            ? indentInParentheses(call(path, print, "componentPatternList"))
+            : "()";
+        return [call(path, print, "referenceType"), patterns];
+    },
+    componentPatternList(path, print) {
+        return printList(path, print, "componentPattern");
+    },
+    componentPattern: printSingle,
+    matchAllPattern: printSingle,
+    guard(path, print) {
+        var _a;
+        const expression = call(path, print, "expression");
+        const hasParentheses = ((_a = path.node.children.expression[0].children.conditionalExpression) === null || _a === void 0 ? void 0 : _a[0].children.binaryExpression[0].children.unaryExpression[0].children.primary[0].children.primaryPrefix[0].children.parenthesisExpression) !==
+            undefined;
+        return [
+            "when ",
+            hasParentheses
+                ? expression
+                : group([
+                    ifBreak("("),
+                    indent([softline, expression]),
+                    softline,
+                    ifBreak(")")
+                ])
+        ];
+    }
+};
+function binary(operands, operators, { hasNonAssignmentOperators = false, isInList = false, isRoot = false, operatorPosition }) {
+    let levelOperator;
+    let levelPrecedence;
+    let level = [];
+    while (operators.length) {
+        const nextOperator = operators[0].image;
+        const nextPrecedence = getOperatorPrecedence(nextOperator);
+        if (levelPrecedence === undefined || nextPrecedence === levelPrecedence) {
+            const { image: operator, doc: operatorDoc } = operators.shift();
+            level.push(operands.shift());
+            if (levelOperator !== undefined &&
+                needsParentheses(levelOperator, operator)) {
+                level = [["(", group(indent(level)), ")"]];
+            }
+            const parts = [" ", operatorDoc, line];
+            if (operatorPosition === "start" && !isAssignmentOperator(operator)) {
+                parts.reverse();
+            }
+            level.push(parts);
+            levelOperator = operator;
+            levelPrecedence = nextPrecedence;
+        }
+        else if (nextPrecedence < levelPrecedence) {
+            if (!isRoot) {
+                break;
+            }
+            level.push(operands.shift());
+            const content = group(indent(level));
+            operands.unshift(levelOperator !== undefined &&
+                needsParentheses(levelOperator, nextOperator)
+                ? ["(", content, ")"]
+                : content);
+            level = [];
+            levelOperator = undefined;
+            levelPrecedence = undefined;
+        }
+        else {
+            const content = binary(operands, operators, { operatorPosition });
+            operands.unshift(levelOperator !== undefined &&
+                needsParentheses(nextOperator, levelOperator)
+                ? ["(", indent(content), ")"]
+                : content);
+        }
+    }
+    level.push(operands.shift());
+    if (!levelOperator ||
+        (!isInList &&
+            !isAssignmentOperator(levelOperator) &&
+            levelOperator !== "instanceof")) {
+        return group(level);
+    }
+    if (!isRoot || hasNonAssignmentOperators) {
+        return group(indent(level));
+    }
+    const groupId = Symbol("assignment");
+    return group([
+        level[0],
+        group(indent(level[1]), { id: groupId }),
+        indentIfBreak(level[2], { groupId })
+    ]);
+}
+const precedencesByOperator = new Map([
+    ["||"],
+    ["&&"],
+    ["|"],
+    ["^"],
+    ["&"],
+    ["==", "!="],
+    ["<", ">", "<=", ">=", "instanceof"],
+    ["<<", ">>", ">>>"],
+    ["+", "-"],
+    ["*", "/", "%"]
+].flatMap((operators, index) => operators.map(operator => [operator, index])));
+function getOperatorPrecedence(operator) {
+    var _a;
+    return (_a = precedencesByOperator.get(operator)) !== null && _a !== void 0 ? _a : -1;
+}
+function needsParentheses(operator, parentOperator) {
+    return ((operator === "&&" && parentOperator === "||") ||
+        (["|", "^", "&", "<<", ">>", ">>>"].includes(parentOperator) &&
+            getOperatorPrecedence(operator) >
+                getOperatorPrecedence(parentOperator)) ||
+        [operator, parentOperator].every(o => ["==", "!="].includes(o)) ||
+        [operator, parentOperator].every(o => ["<<", ">>", ">>>"].includes(o)) ||
+        (operator === "*" && parentOperator === "/") ||
+        (operator === "/" && parentOperator === "*") ||
+        (operator === "%" && ["+", "-", "*", "/"].includes(parentOperator)) ||
+        (["*", "/"].includes(operator) && parentOperator === "%"));
+}
+const assignmentOperators = new Set([
+    "=",
+    "*=",
+    "/=",
+    "%=",
+    "+=",
+    "-=",
+    "<<=",
+    ">>=",
+    ">>>=",
+    "&=",
+    "^=",
+    "|="
+]);
+function isAssignmentOperator(operator) {
+    return assignmentOperators.has(operator);
+}
+function isCapitalizedIdentifier(fqnOrRefType) {
+    var _a, _b, _c;
+    const nextToLastIdentifier = (_c = (_b = [
+        fqnOrRefType.fqnOrRefTypePartFirst[0],
+        ...((_a = fqnOrRefType.fqnOrRefTypePartRest) !== null && _a !== void 0 ? _a : [])
+    ].at(-2)) === null || _b === void 0 ? void 0 : _b.children.fqnOrRefTypePartCommon[0].children.Identifier) === null || _c === void 0 ? void 0 : _c[0].image;
+    return /^\p{Uppercase_Letter}/u.test(nextToLastIdentifier !== null && nextToLastIdentifier !== void 0 ? nextToLastIdentifier : "");
+}
+function printTemplate(path, print, beginKey, midKey, endKey) {
+    const begin = call(path, ({ node }) => node.image, beginKey);
+    const mids = map(path, ({ node }) => node.image, midKey);
+    const end = call(path, ({ node }) => node.image, endKey);
+    const lines = [begin, ...mids, end].join("").split("\n").slice(1);
+    const baseIndent = findBaseIndent(lines);
+    const prefix = "\n" + " ".repeat(baseIndent);
+    const parts = [begin, ...mids, end].map(image => join(hardline, image.split(prefix)));
+    return indent([
+        parts[0],
+        ...map(path, (expressionPath, index) => {
+            const expression = group([
+                indent([softline, print(expressionPath), lineSuffixBoundary]),
+                softline
+            ]);
+            return index === 0 ? expression : [parts[index], expression];
+        }, "embeddedExpression"),
+        parts.at(-1)
+    ]);
+}

frontend/src/common/prettier/plugins/java/printers/helpers.d.ts

@@ -0,0 +1,71 @@
+import type { AnnotationCstNode, ClassPermitsCstNode, ClassTypeCtx, CstElement, CstNode, ExpressionCstNode, InterfacePermitsCstNode, IToken, StatementCstNode } from "java-parser";
+import type { AstPath, Doc, ParserOptions } from "prettier";
+import { builders } from "prettier/doc";
+import type { JavaComment } from "../comments.js";
+export declare function onlyDefinedKey<T extends Record<string, any>, K extends Key<T> & string>(obj: T, options?: K[]): K;
+export declare function definedKeys<T extends Record<string, any>, K extends Key<T> & string>(obj: T, options?: K[]): K[];
+export declare function printWithModifiers<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, modifierChild: P, contents: Doc, noTypeAnnotations?: boolean): builders.Doc[];
+export declare function hasDeclarationAnnotations(modifiers: ModifierNode[]): boolean;
+export declare function call<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U;
+export declare function each<T extends CstNode, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, void>, child: P): void;
+export declare function map<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, child: P): U[];
+export declare function flatMap<T extends CstNode, U, P extends IterProperties<T["children"]>>(path: AstPath<T>, callback: MapCallback<IndexValue<IndexValue<T, "children">, P>, U>, children: P[]): U[];
+export declare function printSingle(path: AstPath<JavaNonTerminal>, print: JavaPrintFn, _?: JavaParserOptions, args?: unknown): builders.Doc;
+export declare function lineStartWithComments(node: JavaNonTerminal): number;
+export declare function lineEndWithComments(node: JavaNonTerminal): number;
+export declare function printDanglingComments(path: AstPath<JavaNonTerminal>): builders.Doc[];
+export declare function printComment(node: JavaTerminal): string | builders.Doc[];
+export declare function hasLeadingComments(node: JavaNode): boolean | undefined;
+export declare function indentInParentheses(contents: Doc, opts?: {
+    shouldBreak?: boolean;
+}): builders.Group | "()";
+export declare function printArrayInitializer<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, options: JavaParserOptions, child: P): builders.Group | "{}";
+export declare function printBlock(path: AstPath<JavaNonTerminal>, contents: Doc[]): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+export declare function printName(path: AstPath<JavaNonTerminal & {
+    children: {
+        Identifier: IToken[];
+    };
+}>, print: JavaPrintFn): builders.Doc[];
+export declare function printList<T extends JavaNonTerminal, P extends IterProperties<T["children"]>>(path: AstPath<T>, print: JavaPrintFn, child: P): builders.Doc[];
+export declare function printClassPermits(path: AstPath<ClassPermitsCstNode | InterfacePermitsCstNode>, print: JavaPrintFn): builders.Group;
+export declare function printClassType(path: AstPath<JavaNonTerminal & {
+    children: ClassTypeCtx;
+}>, print: JavaPrintFn): builders.Doc[];
+export declare function isBinaryExpression(expression: ExpressionCstNode): boolean;
+export declare function findBaseIndent(lines: string[]): number;
+export declare function isEmptyStatement(statement: StatementCstNode): boolean;
+export declare function isNonTerminal(node: CstElement): node is JavaNonTerminal;
+export declare function isTerminal(node: CstElement): node is IToken;
+export type JavaNode = CstElement & {
+    comments?: JavaComment[];
+};
+export type JavaNonTerminal = Exclude<JavaNode, IToken>;
+export type JavaTerminal = Exclude<JavaNode, CstNode>;
+export type JavaNodePrinters = {
+    [T in JavaNonTerminal["name"]]: JavaNodePrinter<T>;
+};
+export type JavaNodePrinter<T> = (path: AstPath<Extract<JavaNonTerminal, {
+    name: T;
+}>>, print: JavaPrintFn, options: JavaParserOptions, args?: unknown) => Doc;
+export type JavaPrintFn = (path: AstPath<JavaNode>, args?: unknown) => Doc;
+export type JavaParserOptions = ParserOptions<JavaNode> & {
+    entrypoint?: string;
+};
+export type IterProperties<T> = T extends any[] ? IndexProperties<T> : ArrayProperties<T>;
+type Key<T> = T extends T ? keyof T : never;
+type ModifierNode = JavaNonTerminal & {
+    children: {
+        annotation?: AnnotationCstNode[];
+    };
+};
+type IsTuple<T> = T extends [] ? true : T extends [infer First, ...infer Remain] ? IsTuple<Remain> : false;
+type IndexProperties<T extends {
+    length: number;
+}> = IsTuple<T> extends true ? Exclude<Partial<T>["length"], T["length"]> : number;
+type ArrayProperties<T> = {
+    [K in keyof T]: NonNullable<T[K]> extends readonly any[] ? K : never;
+}[keyof T];
+type ArrayElement<T> = T extends Array<infer E> ? E : never;
+type MapCallback<T, U> = (path: AstPath<ArrayElement<T>>, index: number, value: any) => U;
+type IndexValue<T, P> = T extends any[] ? P extends number ? T[P] : never : P extends keyof T ? T[P] : never;
+export {};

frontend/src/common/prettier/plugins/java/printers/helpers.js

@@ -0,0 +1,239 @@
+import { builders } from "prettier/doc";
+import parser from "../parser.js";
+const { group, hardline, ifBreak, indent, join, line, softline } = builders;
+export function onlyDefinedKey(obj, options) {
+    const keys = definedKeys(obj, options);
+    if (keys.length === 1) {
+        return keys[0];
+    }
+    throw new Error(keys.length > 1
+        ? `More than one defined key found: ${keys}`
+        : "No defined keys found");
+}
+export function definedKeys(obj, options) {
+    return (options !== null && options !== void 0 ? options : Object.keys(obj)).filter(key => obj[key] !== undefined);
+}
+const indexByModifier = [
+    "public",
+    "protected",
+    "private",
+    "abstract",
+    "default",
+    "static",
+    "final",
+    "transient",
+    "volatile",
+    "synchronized",
+    "native",
+    "sealed",
+    "non-sealed",
+    "strictfp"
+].reduce((map, name, index) => map.set(name, index), new Map());
+export function printWithModifiers(path, print, modifierChild, contents, noTypeAnnotations = false) {
+    const declarationAnnotations = [];
+    const otherModifiers = [];
+    const typeAnnotations = [];
+    each(path, modifierPath => {
+        const { children } = modifierPath.node;
+        const modifier = print(modifierPath);
+        if (children.annotation) {
+            (otherModifiers.length ? typeAnnotations : declarationAnnotations).push(modifier);
+        }
+        else {
+            otherModifiers.push(modifier);
+            declarationAnnotations.push(...typeAnnotations);
+            typeAnnotations.length = 0;
+        }
+    }, modifierChild);
+    if (noTypeAnnotations) {
+        declarationAnnotations.push(...typeAnnotations);
+        typeAnnotations.length = 0;
+    }
+    otherModifiers.sort((a, b) => indexByModifier.get(a) - indexByModifier.get(b));
+    return join(hardline, [
+        ...declarationAnnotations,
+        join(" ", [...otherModifiers, ...typeAnnotations, contents])
+    ]);
+}
+export function hasDeclarationAnnotations(modifiers) {
+    let hasAnnotation = false;
+    let hasNonAnnotation = false;
+    for (const modifier of modifiers) {
+        if (modifier.children.annotation) {
+            hasAnnotation = true;
+        }
+        else if (hasAnnotation) {
+            return true;
+        }
+        else {
+            hasNonAnnotation = true;
+        }
+    }
+    return hasAnnotation && !hasNonAnnotation;
+}
+export function call(path, callback, child) {
+    return path.map(callback, "children", child)[0];
+}
+export function each(path, callback, child) {
+    if (path.node.children[child]) {
+        path.each(callback, "children", child);
+    }
+}
+export function map(path, callback, child) {
+    return path.node.children[child] ? path.map(callback, "children", child) : [];
+}
+export function flatMap(path, callback, children) {
+    return children
+        .flatMap(child => map(path, callback, child).map((doc, index) => {
+        const node = path.node.children[child][index];
+        return {
+            doc,
+            startOffset: parser.locStart(node)
+        };
+    }))
+        .sort((a, b) => a.startOffset - b.startOffset)
+        .map(({ doc }) => doc);
+}
+export function printSingle(path, print, _, args) {
+    return call(path, childPath => print(childPath, args), onlyDefinedKey(path.node.children));
+}
+export function lineStartWithComments(node) {
+    const { comments, location } = node;
+    return comments
+        ? Math.min(location.startLine, comments[0].startLine)
+        : location.startLine;
+}
+export function lineEndWithComments(node) {
+    const { comments, location } = node;
+    return comments
+        ? Math.max(location.endLine, comments.at(-1).endLine)
+        : location.endLine;
+}
+export function printDanglingComments(path) {
+    if (!path.node.comments) {
+        return [];
+    }
+    const comments = [];
+    path.each(commentPath => {
+        const comment = commentPath.node;
+        if (comment.leading || comment.trailing) {
+            return;
+        }
+        comment.printed = true;
+        comments.push(printComment(comment));
+    }, "comments");
+    return join(hardline, comments);
+}
+export function printComment(node) {
+    const { image } = node;
+    const lines = image.split("\n").map(line => line.trim());
+    return lines.length > 1 &&
+        lines[0].startsWith("/*") &&
+        lines.slice(1).every(line => line.startsWith("*")) &&
+        lines.at(-1).endsWith("*/")
+        ? join(hardline, lines.map((line, index) => (index === 0 ? line : ` ${line}`)))
+        : image;
+}
+export function hasLeadingComments(node) {
+    var _a;
+    return (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading);
+}
+export function indentInParentheses(contents, opts) {
+    return !Array.isArray(contents) || contents.length
+        ? group(["(", indent([softline, contents]), softline, ")"], opts)
+        : "()";
+}
+export function printArrayInitializer(path, print, options, child) {
+    const list = [];
+    if (child && child in path.node.children) {
+        list.push(call(path, print, child));
+        if (options.trailingComma !== "none") {
+            list.push(ifBreak(","));
+        }
+    }
+    list.push(...printDanglingComments(path));
+    return list.length ? group(["{", indent([line, ...list]), line, "}"]) : "{}";
+}
+export function printBlock(path, contents) {
+    if (!contents.length) {
+        const danglingComments = printDanglingComments(path);
+        return danglingComments.length
+            ? ["{", indent([hardline, ...danglingComments]), hardline, "}"]
+            : "{}";
+    }
+    return group([
+        "{",
+        indent([hardline, ...join(hardline, contents)]),
+        hardline,
+        "}"
+    ]);
+}
+export function printName(path, print) {
+    return join(".", map(path, print, "Identifier"));
+}
+export function printList(path, print, child) {
+    return join([",", line], map(path, print, child));
+}
+export function printClassPermits(path, print) {
+    return group([
+        "permits",
+        indent([line, group(printList(path, print, "typeName"))])
+    ]);
+}
+export function printClassType(path, print) {
+    const { children } = path.node;
+    return definedKeys(children, ["annotation", "Identifier", "typeArguments"])
+        .flatMap(child => children[child].map((node, index) => ({
+        child,
+        index,
+        startOffset: parser.locStart(node)
+    })))
+        .sort((a, b) => a.startOffset - b.startOffset)
+        .flatMap(({ child, index: childIndex }, index, array) => {
+        const node = children[child][childIndex];
+        const next = array.at(index + 1);
+        const nextNode = next && children[next.child][next.index];
+        const docs = [path.call(print, "children", child, childIndex)];
+        if (nextNode) {
+            if (isNonTerminal(node)) {
+                docs.push(node.name === "annotation" ? " " : ".");
+            }
+            else if (isTerminal(nextNode) || nextNode.name === "annotation") {
+                docs.push(".");
+            }
+        }
+        return docs;
+    });
+}
+export function isBinaryExpression(expression) {
+    var _a;
+    const conditionalExpression = (_a = expression.children.conditionalExpression) === null || _a === void 0 ? void 0 : _a[0].children;
+    if (!conditionalExpression) {
+        return false;
+    }
+    const isTernary = conditionalExpression.QuestionMark !== undefined;
+    if (isTernary) {
+        return false;
+    }
+    const hasNonAssignmentOperators = Object.values(conditionalExpression.binaryExpression[0].children).some(child => {
+        var _a;
+        return isTerminal(child[0]) &&
+            !((_a = child[0].tokenType.CATEGORIES) === null || _a === void 0 ? void 0 : _a.some(category => category.name === "AssignmentOperator"));
+    });
+    return hasNonAssignmentOperators;
+}
+export function findBaseIndent(lines) {
+    return lines.length
+        ? Math.min(...lines.map(line => line.search(/\S/)).filter(indent => indent >= 0))
+        : 0;
+}
+export function isEmptyStatement(statement) {
+    var _a;
+    return (((_a = statement.children.statementWithoutTrailingSubstatement) === null || _a === void 0 ? void 0 : _a[0].children.emptyStatement) !== undefined);
+}
+export function isNonTerminal(node) {
+    return !isTerminal(node);
+}
+export function isTerminal(node) {
+    return "tokenType" in node;
+}

frontend/src/common/prettier/plugins/java/printers/index.d.ts

@@ -0,0 +1,2 @@
+import type { JavaNodePrinter, JavaNodePrinters } from "./helpers.js";
+export declare function printerForNodeType<T extends keyof JavaNodePrinters>(type: T): JavaNodePrinter<T>;

frontend/src/common/prettier/plugins/java/printers/index.js

@@ -0,0 +1,13 @@
+import arrays from "./arrays.js";
+import blocksAndStatements from "./blocks-and-statements.js";
+import classes from "./classes.js";
+import expressions from "./expressions.js";
+import interfaces from "./interfaces.js";
+import lexicalStructure from "./lexical-structure.js";
+import names from "./names.js";
+import packagesAndModules from "./packages-and-modules.js";
+import typesValuesAndVariables from "./types-values-and-variables.js";
+const printersByNodeType = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, arrays), blocksAndStatements), classes), expressions), interfaces), lexicalStructure), names), packagesAndModules), typesValuesAndVariables);
+export function printerForNodeType(type) {
+    return printersByNodeType[type];
+}

frontend/src/common/prettier/plugins/java/printers/interfaces.d.ts

@@ -0,0 +1,62 @@
+import { builders } from "prettier/doc";
+import { printClassPermits, printSingle } from "./helpers.js";
+declare const _default: {
+    interfaceDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    normalInterfaceDeclaration(path: import("prettier").AstPath<import("java-parser").NormalInterfaceDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    interfaceModifier: typeof printSingle;
+    interfaceExtends(path: import("prettier").AstPath<import("java-parser").InterfaceExtendsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    interfacePermits: typeof printClassPermits;
+    interfaceBody(path: import("prettier").AstPath<import("java-parser").InterfaceBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    interfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceMemberDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    constantDeclaration(path: import("prettier").AstPath<import("java-parser").ConstantDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    constantModifier: typeof printSingle;
+    interfaceMethodDeclaration(path: import("prettier").AstPath<import("java-parser").InterfaceMethodDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    interfaceMethodModifier: typeof printSingle;
+    annotationInterfaceDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    annotationInterfaceBody(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceBodyCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group | "{}" | (string | builders.Indent | builders.Hardline)[];
+    annotationInterfaceMemberDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceMemberDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    annotationInterfaceElementDeclaration(path: import("prettier").AstPath<import("java-parser").AnnotationInterfaceElementDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    annotationInterfaceElementModifier: typeof printSingle;
+    defaultValue(path: import("prettier").AstPath<import("java-parser").DefaultValueCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    annotation(path: import("prettier").AstPath<import("java-parser").AnnotationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    elementValuePairList(path: import("prettier").AstPath<import("java-parser").ElementValuePairListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    elementValuePair(path: import("prettier").AstPath<import("java-parser").ElementValuePairCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    elementValue: typeof printSingle;
+    elementValueArrayInitializer(path: import("prettier").AstPath<import("java-parser").ElementValueArrayInitializerCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn, options: import("./helpers.js").JavaParserOptions): builders.Group | "{}";
+    elementValueList(path: import("prettier").AstPath<import("java-parser").ElementValueListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/interfaces.js

@@ -0,0 +1,157 @@
+import { builders } from "prettier/doc";
+import { call, each, hasDeclarationAnnotations, indentInParentheses, lineEndWithComments, lineStartWithComments, onlyDefinedKey, printArrayInitializer, printBlock, printClassPermits, printList, printSingle, printWithModifiers } from "./helpers.js";
+const { group, hardline, indent, join, line } = builders;
+export default {
+    interfaceDeclaration(path, print) {
+        const declarationKey = onlyDefinedKey(path.node.children, [
+            "annotationInterfaceDeclaration",
+            "normalInterfaceDeclaration"
+        ]);
+        return printWithModifiers(path, print, "interfaceModifier", call(path, print, declarationKey), true);
+    },
+    normalInterfaceDeclaration(path, print) {
+        const { interfaceExtends, interfacePermits, typeParameters } = path.node.children;
+        const header = ["interface ", call(path, print, "typeIdentifier")];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
+        if (interfaceExtends) {
+            header.push(indent([line, call(path, print, "interfaceExtends")]));
+        }
+        if (interfacePermits) {
+            header.push(indent([line, call(path, print, "interfacePermits")]));
+        }
+        return [group(header), " ", call(path, print, "interfaceBody")];
+    },
+    interfaceModifier: printSingle,
+    interfaceExtends(path, print) {
+        return group([
+            "extends",
+            indent([line, call(path, print, "interfaceTypeList")])
+        ]);
+    },
+    interfacePermits: printClassPermits,
+    interfaceBody(path, print) {
+        const declarations = [];
+        let previousRequiresPadding = false;
+        each(path, declarationPath => {
+            var _a, _b, _c, _d;
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            const { node, previous } = declarationPath;
+            const constantDeclaration = (_a = node.children.constantDeclaration) === null || _a === void 0 ? void 0 : _a[0].children;
+            const methodDeclaration = (_b = node.children.interfaceMethodDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
+            const currentRequiresPadding = (!constantDeclaration && !methodDeclaration) ||
+                (methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.methodBody[0].children.block) !== undefined ||
+                hasDeclarationAnnotations((_d = (_c = constantDeclaration === null || constantDeclaration === void 0 ? void 0 : constantDeclaration.constantModifier) !== null && _c !== void 0 ? _c : methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.interfaceMethodModifier) !== null && _d !== void 0 ? _d : []);
+            const blankLine = declarations.length > 0 &&
+                (previousRequiresPadding ||
+                    currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1);
+            declarations.push(blankLine ? [hardline, declaration] : declaration);
+            previousRequiresPadding = currentRequiresPadding;
+        }, "interfaceMemberDeclaration");
+        return printBlock(path, declarations);
+    },
+    interfaceMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    constantDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "variableDeclaratorList"),
+            ";"
+        ];
+        return printWithModifiers(path, print, "constantModifier", declaration);
+    },
+    constantModifier: printSingle,
+    interfaceMethodDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "methodHeader"),
+            path.node.children.methodBody[0].children.Semicolon ? "" : " ",
+            call(path, print, "methodBody")
+        ];
+        return printWithModifiers(path, print, "interfaceMethodModifier", declaration);
+    },
+    interfaceMethodModifier: printSingle,
+    annotationInterfaceDeclaration(path, print) {
+        return join(" ", [
+            "@interface",
+            call(path, print, "typeIdentifier"),
+            call(path, print, "annotationInterfaceBody")
+        ]);
+    },
+    annotationInterfaceBody(path, print) {
+        const declarations = [];
+        each(path, declarationPath => {
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            declarations.push(declarationPath.isFirst ? declaration : [hardline, declaration]);
+        }, "annotationInterfaceMemberDeclaration");
+        return printBlock(path, declarations);
+    },
+    annotationInterfaceMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    annotationInterfaceElementDeclaration(path, print) {
+        const { dims, defaultValue } = path.node.children;
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "Identifier"),
+            "()"
+        ];
+        if (dims) {
+            declaration.push(call(path, print, "dims"));
+        }
+        if (defaultValue) {
+            declaration.push(" ", call(path, print, "defaultValue"));
+        }
+        declaration.push(";");
+        return printWithModifiers(path, print, "annotationInterfaceElementModifier", declaration);
+    },
+    annotationInterfaceElementModifier: printSingle,
+    defaultValue(path, print) {
+        return ["default ", call(path, print, "elementValue")];
+    },
+    annotation(path, print) {
+        const { children } = path.node;
+        const annotation = ["@", call(path, print, "typeName")];
+        if (children.elementValue || children.elementValuePairList) {
+            const valuesKey = onlyDefinedKey(children, [
+                "elementValue",
+                "elementValuePairList"
+            ]);
+            annotation.push(indentInParentheses(call(path, print, valuesKey)));
+        }
+        return annotation;
+    },
+    elementValuePairList(path, print) {
+        return printList(path, print, "elementValuePair");
+    },
+    elementValuePair(path, print) {
+        return join(" ", [
+            call(path, print, "Identifier"),
+            call(path, print, "Equals"),
+            call(path, print, "elementValue")
+        ]);
+    },
+    elementValue: printSingle,
+    elementValueArrayInitializer(path, print, options) {
+        return printArrayInitializer(path, print, options, "elementValueList");
+    },
+    elementValueList(path, print) {
+        return group(printList(path, print, "elementValue"));
+    }
+};

frontend/src/common/prettier/plugins/java/printers/lexical-structure.d.ts

@@ -0,0 +1,14 @@
+import { builders } from "prettier/doc";
+import { printSingle } from "./helpers.js";
+declare const _default: {
+    literal(path: import("prettier").AstPath<import("java-parser").LiteralCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    integerLiteral: typeof printSingle;
+    floatingPointLiteral: typeof printSingle;
+    booleanLiteral: typeof printSingle;
+    shiftOperator(path: import("prettier").AstPath<import("java-parser").ShiftOperatorCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/lexical-structure.js

@@ -0,0 +1,29 @@
+import { builders } from "prettier/doc";
+import { findBaseIndent, map, onlyDefinedKey, printSingle } from "./helpers.js";
+const { hardline, indent, join } = builders;
+export default {
+    literal(path, print) {
+        const { TextBlock } = path.node.children;
+        if (!TextBlock) {
+            return printSingle(path, print);
+        }
+        const [open, ...lines] = TextBlock[0].image.split("\n");
+        const baseIndent = findBaseIndent(lines);
+        const textBlock = join(hardline, [
+            open,
+            ...lines.map(line => line.slice(baseIndent))
+        ]);
+        const ancestor = path.getNode(14);
+        return (ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "variableInitializer" ||
+            ((ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "binaryExpression" &&
+                ancestor.children.AssignmentOperator)
+            ? indent(textBlock)
+            : textBlock;
+    },
+    integerLiteral: printSingle,
+    floatingPointLiteral: printSingle,
+    booleanLiteral: printSingle,
+    shiftOperator(path, print) {
+        return map(path, print, onlyDefinedKey(path.node.children));
+    }
+};

frontend/src/common/prettier/plugins/java/printers/names.d.ts

@@ -0,0 +1,12 @@
+import { printName, printSingle } from "./helpers.js";
+declare const _default: {
+    typeIdentifier: typeof printSingle;
+    moduleName: typeof printName;
+    packageName: typeof printName;
+    typeName: typeof printName;
+    expressionName: typeof printName;
+    methodName: typeof printSingle;
+    packageOrTypeName: typeof printName;
+    ambiguousName: typeof printName;
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/names.js

@@ -0,0 +1,11 @@
+import { printName, printSingle } from "./helpers.js";
+export default {
+    typeIdentifier: printSingle,
+    moduleName: printName,
+    packageName: printName,
+    typeName: printName,
+    expressionName: printName,
+    methodName: printSingle,
+    packageOrTypeName: printName,
+    ambiguousName: printName
+};

frontend/src/common/prettier/plugins/java/printers/packages-and-modules.d.ts

@@ -0,0 +1,46 @@
+import type { ExportsModuleDirectiveCstNode, ImportDeclarationCstNode, OpensModuleDirectiveCstNode } from "java-parser";
+import type { AstPath } from "prettier";
+import { builders } from "prettier/doc";
+import { printSingle, type JavaPrintFn } from "./helpers.js";
+declare const _default: {
+    compilationUnit(path: AstPath<import("java-parser").CompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    ordinaryCompilationUnit(path: AstPath<import("java-parser").OrdinaryCompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    modularCompilationUnit(path: AstPath<import("java-parser").ModularCompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    packageDeclaration(path: AstPath<import("java-parser").PackageDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    packageModifier: typeof printSingle;
+    importDeclaration(path: AstPath<ImportDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    typeDeclaration(path: AstPath<import("java-parser").TypeDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    moduleDeclaration(path: AstPath<import("java-parser").ModuleDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    moduleDirective: typeof printSingle;
+    requiresModuleDirective(path: AstPath<import("java-parser").RequiresModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    exportsModuleDirective(path: AstPath<ExportsModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    opensModuleDirective(path: AstPath<OpensModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    usesModuleDirective(path: AstPath<import("java-parser").UsesModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    providesModuleDirective(path: AstPath<import("java-parser").ProvidesModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    requiresModifier: typeof printSingle;
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/packages-and-modules.js

@@ -0,0 +1,169 @@
+import { builders } from "prettier/doc";
+import { call, lineEndWithComments, lineStartWithComments, map, printBlock, printDanglingComments, printName, printSingle } from "./helpers.js";
+const { group, hardline, indent, join, line } = builders;
+export default {
+    compilationUnit(path, print) {
+        return [...printDanglingComments(path), printSingle(path, print), hardline];
+    },
+    ordinaryCompilationUnit(path, print) {
+        const { children } = path.node;
+        const declarations = [];
+        if (children.packageDeclaration) {
+            declarations.push(call(path, print, "packageDeclaration"));
+        }
+        if (children.importDeclaration) {
+            const staticCount = sortImports(children.importDeclaration);
+            const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
+            const staticDeclarations = importDeclarations.slice(0, staticCount);
+            const nonStaticDeclarations = importDeclarations.slice(staticCount);
+            declarations.push(...[staticDeclarations, nonStaticDeclarations]
+                .filter(({ length }) => length)
+                .map(declarations => join(hardline, declarations)));
+        }
+        if (children.typeDeclaration) {
+            declarations.push(...map(path, print, "typeDeclaration").filter(declaration => declaration !== ""));
+        }
+        return join([hardline, hardline], declarations);
+    },
+    modularCompilationUnit(path, print) {
+        const { children } = path.node;
+        const declarations = [];
+        if (children.importDeclaration) {
+            const staticCount = sortImports(children.importDeclaration);
+            const importDeclarations = map(path, print, "importDeclaration").filter(doc => doc !== "");
+            const staticDeclarations = importDeclarations.slice(0, staticCount);
+            const nonStaticDeclarations = importDeclarations.slice(staticCount);
+            declarations.push(...[staticDeclarations, nonStaticDeclarations]
+                .filter(({ length }) => length)
+                .map(declarations => join(hardline, declarations)));
+        }
+        declarations.push(call(path, print, "moduleDeclaration"));
+        return join([hardline, hardline], declarations);
+    },
+    packageDeclaration(path, print) {
+        return join(hardline, [
+            ...map(path, print, "packageModifier"),
+            ["package ", printName(path, print), ";"]
+        ]);
+    },
+    packageModifier: printSingle,
+    importDeclaration(path, print) {
+        const { children } = path.node;
+        if (children.emptyStatement) {
+            return call(path, print, "emptyStatement");
+        }
+        const declaration = ["import "];
+        if (children.Static) {
+            declaration.push("static ");
+        }
+        declaration.push(call(path, print, "packageOrTypeName"));
+        if (children.Star) {
+            declaration.push(".*");
+        }
+        declaration.push(";");
+        return declaration;
+    },
+    typeDeclaration(path, print) {
+        return path.node.children.Semicolon ? "" : printSingle(path, print);
+    },
+    moduleDeclaration(path, print) {
+        const { annotation, Open } = path.node.children;
+        const prefix = [];
+        if (annotation) {
+            prefix.push(...map(path, print, "annotation"));
+        }
+        if (Open) {
+            prefix.push("open");
+        }
+        const declarations = map(path, declarationPath => {
+            const declaration = print(declarationPath);
+            const { node, previous } = declarationPath;
+            return !previous ||
+                lineStartWithComments(node) <= lineEndWithComments(previous) + 1
+                ? declaration
+                : [hardline, declaration];
+        }, "moduleDirective");
+        return join(" ", [
+            ...prefix,
+            "module",
+            printName(path, print),
+            printBlock(path, declarations)
+        ]);
+    },
+    moduleDirective: printSingle,
+    requiresModuleDirective(path, print) {
+        return join(" ", [
+            "requires",
+            ...map(path, print, "requiresModifier"),
+            [call(path, print, "moduleName"), ";"]
+        ]);
+    },
+    exportsModuleDirective(path, print) {
+        return printToModuleNamesDirective(path, print, "exports");
+    },
+    opensModuleDirective(path, print) {
+        return printToModuleNamesDirective(path, print, "opens");
+    },
+    usesModuleDirective(path, print) {
+        return ["uses ", call(path, print, "typeName"), ";"];
+    },
+    providesModuleDirective(path, print) {
+        const [firstTypeName, ...restTypeNames] = map(path, print, "typeName");
+        return [
+            "provides ",
+            firstTypeName,
+            group(indent([
+                line,
+                group(indent(["with", line, ...join([",", line], restTypeNames)]))
+            ])),
+            ";"
+        ];
+    },
+    requiresModifier: printSingle
+};
+function sortImports(importDeclarations) {
+    importDeclarations.sort(({ children: a }, { children: b }) => {
+        if (a.Static && !b.Static) {
+            return -1;
+        }
+        else if (b.Static && !a.Static) {
+            return 1;
+        }
+        if (!b.packageOrTypeName) {
+            if (a.packageOrTypeName) {
+                return -1;
+            }
+            return 0;
+        }
+        else if (!a.packageOrTypeName) {
+            return 1;
+        }
+        return compareFqn(a.packageOrTypeName[0], b.packageOrTypeName[0]);
+    });
+    return importDeclarations.reduce((staticCount, importDeclaration) => importDeclaration.children.Static ? staticCount + 1 : staticCount, 0);
+}
+function compareFqn(a, b) {
+    const identifiersA = a.children.Identifier;
+    const identifiersB = b.children.Identifier;
+    const minParts = Math.min(identifiersA.length, identifiersB.length);
+    for (let i = 0; i < minParts; i++) {
+        const imageA = identifiersA[i].image;
+        const imageB = identifiersB[i].image;
+        if (imageA < imageB) {
+            return -1;
+        }
+        else if (imageA > imageB) {
+            return 1;
+        }
+    }
+    return identifiersA.length - identifiersB.length;
+}
+function printToModuleNamesDirective(path, print, prefix) {
+    const directive = [prefix, " ", call(path, print, "packageName")];
+    if (path.node.children.moduleName) {
+        const moduleNames = join([",", line], map(path, print, "moduleName"));
+        directive.push(group(indent([line, group(indent(["to", line, ...moduleNames]))])));
+    }
+    directive.push(";");
+    return directive;
+}

frontend/src/common/prettier/plugins/java/printers/types-values-and-variables.d.ts

@@ -0,0 +1,46 @@
+import { builders } from "prettier/doc";
+import { printClassType, printSingle } from "./helpers.js";
+declare const _default: {
+    primitiveType(path: import("prettier").AstPath<import("java-parser").PrimitiveTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    numericType: typeof printSingle;
+    integralType: typeof printSingle;
+    floatingPointType: typeof printSingle;
+    referenceType(path: import("prettier").AstPath<import("java-parser").ReferenceTypeCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    classOrInterfaceType: typeof printSingle;
+    classType: typeof printClassType;
+    interfaceType: typeof printSingle;
+    typeVariable(path: import("prettier").AstPath<import("java-parser").TypeVariableCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    dims(path: import("prettier").AstPath<import("java-parser").DimsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeParameter(path: import("prettier").AstPath<import("java-parser").TypeParameterCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeParameterModifier: typeof printSingle;
+    typeBound(path: import("prettier").AstPath<import("java-parser").TypeBoundCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    additionalBound(path: import("prettier").AstPath<import("java-parser").AdditionalBoundCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeArguments(path: import("prettier").AstPath<import("java-parser").TypeArgumentsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Group;
+    typeArgumentList(path: import("prettier").AstPath<import("java-parser").TypeArgumentListCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    typeArgument: typeof printSingle;
+    wildcard(path: import("prettier").AstPath<import("java-parser").WildcardCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+    wildcardBounds(path: import("prettier").AstPath<import("java-parser").WildcardBoundsCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+};
+export default _default;

frontend/src/common/prettier/plugins/java/printers/types-values-and-variables.js

@@ -0,0 +1,90 @@
+import { builders } from "prettier/doc";
+import { call, definedKeys, flatMap, isNonTerminal, map, onlyDefinedKey, printClassType, printList, printSingle } from "./helpers.js";
+const { group, indent, join, line, softline } = builders;
+export default {
+    primitiveType(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, ["Boolean", "numericType"]);
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, typeKey)
+        ]);
+    },
+    numericType: printSingle,
+    integralType: printSingle,
+    floatingPointType: printSingle,
+    referenceType(path, print) {
+        const { children } = path.node;
+        const typeKey = onlyDefinedKey(children, [
+            "primitiveType",
+            "classOrInterfaceType"
+        ]);
+        const type = call(path, print, typeKey);
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            children.dims ? [type, call(path, print, "dims")] : type
+        ]);
+    },
+    classOrInterfaceType: printSingle,
+    classType: printClassType,
+    interfaceType: printSingle,
+    typeVariable(path, print) {
+        return join(" ", [
+            ...map(path, print, "annotation"),
+            call(path, print, "Identifier")
+        ]);
+    },
+    dims(path, print) {
+        return flatMap(path, childPath => {
+            const child = print(childPath);
+            return isNonTerminal(childPath.node) ? [child, " "] : child;
+        }, definedKeys(path.node.children, ["annotation", "LSquare", "RSquare"]));
+    },
+    typeParameter(path, print) {
+        const parameter = [
+            ...map(path, print, "typeParameterModifier"),
+            call(path, print, "typeIdentifier")
+        ];
+        if (path.node.children.typeBound) {
+            parameter.push(call(path, print, "typeBound"));
+        }
+        return join(" ", parameter);
+    },
+    typeParameterModifier: printSingle,
+    typeBound(path, print) {
+        const bound = ["extends ", call(path, print, "classOrInterfaceType")];
+        if (path.node.children.additionalBound) {
+            bound.push(group(indent([line, ...join(line, map(path, print, "additionalBound"))])));
+        }
+        return bound;
+    },
+    additionalBound(path, print) {
+        return ["& ", call(path, print, "interfaceType")];
+    },
+    typeArguments(path, print) {
+        return group([
+            "<",
+            indent([softline, call(path, print, "typeArgumentList")]),
+            softline,
+            ">"
+        ]);
+    },
+    typeArgumentList(path, print) {
+        return printList(path, print, "typeArgument");
+    },
+    typeArgument: printSingle,
+    wildcard(path, print) {
+        const wildcard = [...map(path, print, "annotation"), "?"];
+        if (path.node.children.wildcardBounds) {
+            wildcard.push(call(path, print, "wildcardBounds"));
+        }
+        return join(" ", wildcard);
+    },
+    wildcardBounds(path, print) {
+        return [
+            path.node.children.Extends ? "extends" : "super",
+            " ",
+            call(path, print, "referenceType")
+        ];
+    }
+};

frontend/src/common/prettier/plugins/php/index.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "prettier";
+
+declare const plugin: Plugin;
+export default plugin;

frontend/src/common/prettier/plugins/php/index.mjs

@@ -0,0 +1,19 @@
+export {
+  languages, 
+  printers, 
+  parsers, 
+  options, 
+  defaultOptions 
+} from './src/index.mjs';
+
+import { languages, printers, parsers, options, defaultOptions } from './src/index.mjs';
+
+const phpPlugin = {
+  languages,
+  printers, 
+  parsers,
+  options,
+  defaultOptions
+};
+
+export default phpPlugin;

frontend/src/common/prettier/plugins/php/src/clean.mjs

@@ -0,0 +1,111 @@
+import { printNumber, normalizeMagicMethodName } from "./util.mjs";
+
+const ignoredProperties = new Set([
+  "loc",
+  "range",
+  "raw",
+  "comments",
+  "leadingComments",
+  "trailingComments",
+  "parenthesizedExpression",
+  "parent",
+  "prev",
+  "start",
+  "end",
+  "tokens",
+  "errors",
+  "extra",
+]);
+
+/**
+ * This function takes the existing ast node and a copy, by reference
+ * We use it for testing, so that we can compare pre-post versions of the AST,
+ * excluding things we don't care about (like node location, case that will be
+ * changed by the printer, etc.)
+ */
+function clean(node, newObj) {
+  if (node.kind === "string") {
+    // TODO if options are available in this method, replace with
+    // newObj.isDoubleQuote = !useSingleQuote(node, options);
+    delete newObj.isDoubleQuote;
+  }
+
+  if (["array", "list"].includes(node.kind)) {
+    // TODO if options are available in this method, assign instead of delete
+    delete newObj.shortForm;
+  }
+
+  if (node.kind === "inline") {
+    if (node.value.includes("___PSEUDO_INLINE_PLACEHOLDER___")) {
+      return null;
+    }
+
+    newObj.value = newObj.value.replace(/\n/g, "");
+  }
+
+  // continue ((2)); -> continue 2;
+  // continue 1; -> continue;
+  if ((node.kind === "continue" || node.kind === "break") && node.level) {
+    const { level } = newObj;
+
+    if (level.kind === "number") {
+      newObj.level = level.value === "1" ? null : level;
+    }
+  }
+
+  // if () {{ }} -> if () {}
+  if (node.kind === "block") {
+    if (node.children.length === 1 && node.children[0].kind === "block") {
+      while (newObj.children[0].kind === "block") {
+        newObj.children = newObj.children[0].children;
+      }
+    }
+  }
+
+  // Normalize numbers
+  if (node.kind === "number") {
+    newObj.value = printNumber(node.value);
+  }
+
+  const statements = ["foreach", "for", "if", "while", "do"];
+
+  if (statements.includes(node.kind)) {
+    if (node.body && node.body.kind !== "block") {
+      newObj.body = {
+        kind: "block",
+        children: [newObj.body],
+      };
+    } else {
+      newObj.body = newObj.body ? newObj.body : null;
+    }
+
+    if (node.alternate && node.alternate.kind !== "block") {
+      newObj.alternate = {
+        kind: "block",
+        children: [newObj.alternate],
+      };
+    } else {
+      newObj.alternate = newObj.alternate ? newObj.alternate : null;
+    }
+  }
+
+  if (node.kind === "usegroup" && typeof node.name === "string") {
+    newObj.name = newObj.name.replace(/^\\/, "");
+  }
+
+  if (node.kind === "useitem") {
+    newObj.name = newObj.name.replace(/^\\/, "");
+  }
+
+  if (node.kind === "method" && node.name.kind === "identifier") {
+    newObj.name.name = normalizeMagicMethodName(newObj.name.name);
+  }
+
+  if (node.kind === "noop") {
+    return null;
+  }
+}
+
+clean.ignoredProperties = ignoredProperties;
+
+export default clean;

frontend/src/common/prettier/plugins/php/src/index.mjs

@@ -0,0 +1,173 @@
+import { doc } from "prettier";
+import LINGUIST_LANGUAGES_PHP from "linguist-languages/data/PHP";
+import LINGUIST_LANGUAGES_HTML_PHP from "linguist-languages/data/HTML_2b_PHP";
+import parse from "./parser.mjs";
+import print from "./printer.mjs";
+import clean from "./clean.mjs";
+import options from "./options.mjs";
+import {
+  handleOwnLineComment,
+  handleEndOfLineComment,
+  handleRemainingComment,
+  getCommentChildNodes,
+  canAttachComment,
+  isBlockComment,
+} from "./comments.mjs";
+import { hasPragma, insertPragma } from "./pragma.mjs";
+import { locStart, locEnd } from "./loc.mjs";
+
+const { join, hardline } = doc.builders;
+
+function createLanguage(linguistData, { extend, override }) {
+  const language = {};
+
+  for (const key in linguistData) {
+    const newKey = key === "languageId" ? "linguistLanguageId" : key;
+    language[newKey] = linguistData[key];
+  }
+
+  if (extend) {
+    for (const key in extend) {
+      language[key] = (language[key] || []).concat(extend[key]);
+    }
+  }
+
+  for (const key in override) {
+    language[key] = override[key];
+  }
+
+  return language;
+}
+
+const languages = [
+  createLanguage(LINGUIST_LANGUAGES_PHP, {
+    override: {
+      parsers: ["php"],
+      vscodeLanguageIds: ["php"],
+    },
+  }),
+  createLanguage(LINGUIST_LANGUAGES_HTML_PHP, {
+    override: {
+      parsers: ["php"],
+      vscodeLanguageIds: ["php"],
+    },
+  }),
+];
+
+const parsers = {
+  php: {
+    parse,
+    astFormat: "php",
+    locStart,
+    locEnd,
+    hasPragma,
+  },
+};
+
+const ignoredKeys = new Set([
+  "kind",
+  "loc",
+  "errors",
+  "extra",
+  "comments",
+  "leadingComments",
+  "enclosingNode",
+  "precedingNode",
+  "followingNode",
+]);
+function getVisitorKeys(node, nonTraversableKeys) {
+  return Object.keys(node).filter(
+    (key) => !nonTraversableKeys.has(key) && !ignoredKeys.has(key)
+  );
+}
+
+const printers = {
+  php: {
+    print,
+    getVisitorKeys,
+    insertPragma,
+    massageAstNode: clean,
+    getCommentChildNodes,
+    canAttachComment,
+    isBlockComment,
+    handleComments: {
+      ownLine: handleOwnLineComment,
+      endOfLine: handleEndOfLineComment,
+      remaining: handleRemainingComment,
+    },
+    willPrintOwnComments(path) {
+      const { node } = path;
+
+      return node && node.kind === "noop";
+    },
+    printComment(path) {
+      const comment = path.node;
+
+      switch (comment.kind) {
+        case "commentblock": {
+          // for now, don't touch single line block comments
+          if (!comment.value.includes("\n")) {
+            return comment.value;
+          }
+
+          const lines = comment.value.split("\n");
+          // if this is a block comment, handle indentation
+          if (
+            lines
+              .slice(1, lines.length - 1)
+              .every((line) => line.trim()[0] === "*")
+          ) {
+            return join(
+              hardline,
+              lines.map(
+                (line, index) =>
+                  (index > 0 ? " " : "") +
+                  (index < lines.length - 1 ? line.trim() : line.trimLeft())
+              )
+            );
+          }
+
+          // otherwise we can't be sure about indentation, so just print as is
+          return comment.value;
+        }
+        case "commentline": {
+          return comment.value.trimRight();
+        }
+        /* c8 ignore next 2 */
+        default:
+          throw new Error(`Not a comment: ${JSON.stringify(comment)}`);
+      }
+    },
+    hasPrettierIgnore(path) {
+      const isSimpleIgnore = (comment) =>
+        comment.value.includes("prettier-ignore") &&
+        !comment.value.includes("prettier-ignore-start") &&
+        !comment.value.includes("prettier-ignore-end");
+
+      const { node, parent: parentNode } = path;
+
+      return (
+        (node &&
+          node.kind !== "classconstant" &&
+          node.comments &&
+          node.comments.length > 0 &&
+          node.comments.some(isSimpleIgnore)) ||
+        // For proper formatting, the classconstant ignore formatting should
+        // run on the "constant" child
+        (node &&
+          node.kind === "constant" &&
+          parentNode &&
+          parentNode.kind === "classconstant" &&
+          parentNode.comments &&
+          parentNode.comments.length > 0 &&
+          parentNode.comments.some(isSimpleIgnore))
+      );
+    },
+  },
+};
+
+const defaultOptions = {
+  tabWidth: 4,
+};
+
+export { languages, printers, parsers, options, defaultOptions };

frontend/src/common/prettier/plugins/php/src/loc.mjs

@@ -0,0 +1,4 @@
+const loc = (prop) => (node) => node.loc?.[prop]?.offset;
+
+export const locStart = loc("start");
+export const locEnd = loc("end");

frontend/src/common/prettier/plugins/php/src/needs-parens.mjs

@@ -0,0 +1,250 @@
+import { getPrecedence, shouldFlatten, isBitwiseOperator } from "./util.mjs";
+
+function needsParens(path, options) {
+  const { parent } = path;
+
+  if (!parent) {
+    return false;
+  }
+
+  const { key, node } = path;
+
+  if (
+    [
+      //  No need parens for top level children of this nodes
+      "program",
+      "expressionstatement",
+      "namespace",
+      "declare",
+      "block",
+
+      // No need parens
+      "include",
+      "print",
+      "return",
+      "echo",
+    ].includes(parent.kind)
+  ) {
+    return false;
+  }
+
+  switch (node.kind) {
+    case "pre":
+    case "post":
+      if (parent.kind === "unary") {
+        return (
+          node.kind === "pre" &&
+          ((node.type === "+" && parent.type === "+") ||
+            (node.type === "-" && parent.type === "-"))
+        );
+      }
+    // else fallthrough
+    case "unary":
+      switch (parent.kind) {
+        case "unary":
+          return (
+            node.type === parent.type &&
+            (node.type === "+" || node.type === "-")
+          );
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return key === "what";
+        case "bin":
+          return parent.type === "**" && key === "left";
+        default:
+          return false;
+      }
+    case "bin": {
+      switch (parent.kind) {
+        case "assign":
+        case "retif":
+          return ["and", "xor", "or"].includes(node.type);
+        case "silent":
+        case "cast":
+          // TODO: bug https://github.com/glayzzle/php-parser/issues/172
+          return node.parenthesizedExpression;
+        case "pre":
+        case "post":
+        case "unary":
+          return true;
+        case "call":
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+          return key === "what";
+        case "bin": {
+          const po = parent.type;
+          const pp = getPrecedence(po);
+          const no = node.type;
+          const np = getPrecedence(no);
+
+          if (pp > np) {
+            return true;
+          }
+
+          if (po === "||" && no === "&&") {
+            return true;
+          }
+
+          if (pp === np && key === "right") {
+            return true;
+          }
+
+          if (pp === np && !shouldFlatten(po, no)) {
+            return true;
+          }
+
+          if (pp < np && no === "%") {
+            return po === "+" || po === "-";
+          }
+
+          // Add parenthesis when working with bitwise operators
+          // It's not stricly needed but helps with code understanding
+          if (isBitwiseOperator(po)) {
+            return true;
+          }
+
+          return false;
+        }
+
+        default:
+          return false;
+      }
+    }
+    case "propertylookup":
+    case "nullsafepropertylookup":
+    case "staticlookup": {
+      switch (parent.kind) {
+        case "call":
+          return key === "what" && node.parenthesizedExpression;
+
+        default:
+          return false;
+      }
+    }
+    case "clone":
+    case "new": {
+      const requiresParens =
+        node.kind === "clone" ||
+        (node.kind === "new" && options.phpVersion < 8.4);
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return key === "what" && requiresParens;
+        default:
+          return false;
+      }
+    }
+    case "yield": {
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return key === "what";
+
+        case "retif":
+          return key === "test";
+
+        default:
+          return !!(node.key || node.value);
+      }
+    }
+    case "assign": {
+      if (
+        parent.kind === "for" &&
+        (parent.init.includes(node) || parent.increment.includes(node))
+      ) {
+        return false;
+      } else if (parent.kind === "assign") {
+        return false;
+      } else if (parent.kind === "static") {
+        return false;
+      } else if (
+        ["if", "do", "while", "foreach", "switch"].includes(parent.kind)
+      ) {
+        return false;
+      } else if (parent.kind === "silent") {
+        return false;
+      } else if (parent.kind === "call") {
+        return false;
+      }
+
+      return true;
+    }
+    case "retif":
+      switch (parent.kind) {
+        case "cast":
+          return true;
+        case "unary":
+        case "bin":
+        case "retif":
+          if (key === "test" && !parent.trueExpr) {
+            return false;
+          }
+
+          return true;
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          return key === "what";
+
+        default:
+          return false;
+      }
+    case "closure":
+      switch (parent.kind) {
+        case "call":
+          return key === "what";
+
+        // https://github.com/prettier/plugin-php/issues/1675
+        case "propertylookup":
+        case "nullsafepropertylookup":
+          return true;
+
+        default:
+          return false;
+      }
+    case "silence":
+    case "cast":
+      // TODO: bug https://github.com/glayzzle/php-parser/issues/172
+      return node.parenthesizedExpression;
+    // else fallthrough
+    case "string":
+    case "array":
+      switch (parent.kind) {
+        case "propertylookup":
+        case "nullsafepropertylookup":
+        case "staticlookup":
+        case "offsetlookup":
+        case "call":
+          if (
+            ["string", "array"].includes(node.kind) &&
+            parent.kind === "offsetlookup"
+          ) {
+            return false;
+          }
+
+          return key === "what";
+        default:
+          return false;
+      }
+    case "print":
+    case "include":
+      return parent.kind === "bin";
+  }
+
+  return false;
+}
+
+export default needsParens;

frontend/src/common/prettier/plugins/php/src/options.mjs

@@ -0,0 +1,69 @@
+const CATEGORY_PHP = "PHP";
+
+// prettier-ignore
+const SUPPORTED_PHP_VERSIONS = [
+  5.0, 5.1, 5.2, 5.3, 5.4, 5.5, 5.6,
+  7.0, 7.1, 7.2, 7.3, 7.4,
+  8.0, 8.1, 8.2, 8.3, 8.4,
+];
+
+export const LATEST_SUPPORTED_PHP_VERSION = Math.max(...SUPPORTED_PHP_VERSIONS);
+
+/**
+ * Resolve the PHP version to a number based on the provided options.
+ */
+export function resolvePhpVersion(options) {
+  if (!options) {
+    return;
+  }
+  
+  if (options.phpVersion === "auto" || options.phpVersion === "composer") {
+    options.phpVersion = LATEST_SUPPORTED_PHP_VERSION;
+  } else {
+    options.phpVersion = parseFloat(options.phpVersion);
+  }
+}
+
+export default {
+  phpVersion: {
+    since: "0.13.0",
+    category: CATEGORY_PHP,
+    type: "choice",
+    default: "auto",
+    description: "Minimum target PHP version.",
+    choices: [
+      ...SUPPORTED_PHP_VERSIONS.map((v) => ({ value: v.toFixed(1) })),
+      {
+        value: "auto",
+        description: `Use latest PHP Version (${LATEST_SUPPORTED_PHP_VERSION})`,
+      },
+    ],
+  },
+  trailingCommaPHP: {
+    since: "0.0.0",
+    category: CATEGORY_PHP,
+    type: "boolean",
+    default: true,
+    description: "Print trailing commas wherever possible when multi-line.",
+  },
+  braceStyle: {
+    since: "0.10.0",
+    category: CATEGORY_PHP,
+    type: "choice",
+    default: "per-cs",
+    description:
+      "Print one space or newline for code blocks (classes and functions).",
+    choices: [
+      { value: "psr-2", description: "(deprecated) Use per-cs" },
+      { value: "per-cs", description: "Use the PER Coding Style brace style." },
+      { value: "1tbs", description: "Use 1tbs brace style." },
+    ],
+  },
+  singleQuote: {
+    since: "0.0.0",
+    category: CATEGORY_PHP,
+    type: "boolean",
+    default: false,
+    description: "Use single quotes instead of double quotes.",
+  },
+};

frontend/src/common/prettier/plugins/php/src/parser.mjs

@@ -0,0 +1,67 @@
+import engine from "php-parser";
+import { LATEST_SUPPORTED_PHP_VERSION } from "./options.mjs";
+import { resolvePhpVersion } from "./options.mjs";
+
+function parse(text, opts) {
+  const inMarkdown = opts && opts.parentParser === "markdown";
+
+  if (!text && inMarkdown) {
+    return "";
+  }
+  resolvePhpVersion(opts);
+
+  // Todo https://github.com/glayzzle/php-parser/issues/170
+  text = text.replace(/\?>\n<\?/g, "?>\n___PSEUDO_INLINE_PLACEHOLDER___<?");
+
+  // initialize a new parser instance
+  const parser = new engine({
+    parser: {
+      extractDoc: true,
+      version: `${LATEST_SUPPORTED_PHP_VERSION}`,
+    },
+    ast: {
+      withPositions: true,
+      withSource: true,
+    },
+  });
+
+  const hasOpenPHPTag = text.indexOf("<?php") !== -1;
+  const parseAsEval = inMarkdown && !hasOpenPHPTag;
+
+  let ast;
+  try {
+    ast = parseAsEval ? parser.parseEval(text) : parser.parseCode(text);
+  } catch (err) {
+    if (err instanceof SyntaxError && "lineNumber" in err) {
+      err.loc = {
+        start: {
+          line: err.lineNumber,
+          column: err.columnNumber,
+        },
+      };
+
+      delete err.lineNumber;
+      delete err.columnNumber;
+    }
+
+    throw err;
+  }
+
+  ast.extra = {
+    parseAsEval,
+  };
+
+  // https://github.com/glayzzle/php-parser/issues/155
+  // currently inline comments include the line break at the end, we need to
+  // strip those out and update the end location for each comment manually
+  ast.comments.forEach((comment) => {
+    if (comment.value[comment.value.length - 1] === "\n") {
+      comment.value = comment.value.slice(0, -1);
+      comment.loc.end.offset = comment.loc.end.offset - 1;
+    }
+  });
+
+  return ast;
+}
+
+export default parse;

frontend/src/common/prettier/plugins/php/src/pragma.mjs

@@ -0,0 +1,92 @@
+import { memoize } from "./util.mjs";
+import parse from "./parser.mjs";
+
+const reHasPragma = /@prettier|@format/;
+
+const getPageLevelDocBlock = memoize((text) => {
+  const parsed = parse(text);
+
+  const [firstChild] = parsed.children;
+  const [firstDocBlock] = parsed.comments.filter(
+    (el) => el.kind === "commentblock"
+  );
+
+  if (
+    firstChild &&
+    firstDocBlock &&
+    firstDocBlock.loc.start.line < firstChild.loc.start.line
+  ) {
+    return firstDocBlock;
+  }
+});
+
+function hasPragma(text) {
+  // fast path optimization - check if the pragma shows up in the file at all
+  if (!reHasPragma.test(text)) {
+    return false;
+  }
+
+  const pageLevelDocBlock = getPageLevelDocBlock(text);
+
+  if (pageLevelDocBlock) {
+    const { value } = pageLevelDocBlock;
+
+    return reHasPragma.test(value);
+  }
+
+  return false;
+}
+
+function injectPragma(docblock) {
+  let lines = docblock.split("\n");
+
+  if (lines.length === 1) {
+    // normalize to multiline for simplicity
+    const [, line] = /\/*\*\*(.*)\*\//.exec(lines[0]);
+
+    lines = ["/**", ` * ${line.trim()}`, " */"];
+  }
+
+  // find the first @pragma
+  // if there happens to be one on the opening line, just put it on the next line.
+  const pragmaIndex = lines.findIndex((line) => /@\S/.test(line)) || 1;
+
+  // not found => index == -1, which conveniently will splice 1 from the end.
+  lines.splice(pragmaIndex, 0, " * @format");
+
+  return lines.join("\n");
+}
+
+function insertPragma(text) {
+  const pageLevelDocBlock = getPageLevelDocBlock(text);
+
+  if (pageLevelDocBlock) {
+    const {
+      start: { offset: startOffset },
+      end: { offset: endOffset },
+    } = pageLevelDocBlock.loc;
+    const before = text.substring(0, startOffset);
+    const after = text.substring(endOffset);
+
+    return `${before}${injectPragma(pageLevelDocBlock.value, text)}${after}`;
+  }
+
+  const openTag = "<?php";
+
+  if (!text.startsWith(openTag)) {
+    // bail out
+    return text;
+  }
+
+  const splitAt = openTag.length;
+  const phpTag = text.substring(0, splitAt);
+  const after = text.substring(splitAt);
+
+  return `${phpTag}
+/** 
+ * @format 
+ */
+${after}`;
+}
+
+export { hasPragma, insertPragma };

frontend/src/common/prettier/plugins/php/src/util.mjs

@@ -0,0 +1,743 @@
+import { util as prettierUtil } from "prettier";
+import { locStart } from "./loc.mjs";
+
+const { hasNewline, skipEverythingButNewLine, skipNewline } = prettierUtil;
+
+function printNumber(rawNumber) {
+  return (
+    rawNumber
+      .toLowerCase()
+      // Remove unnecessary plus and zeroes from scientific notation.
+      .replace(/^([+-]?[\d.]+e)(?:\+|(-))?0*(\d)/, "$1$2$3")
+      // Remove unnecessary scientific notation (1e0).
+      .replace(/^([+-]?[\d.]+)e[+-]?0+$/, "$1")
+      // Make sure numbers always start with a digit.
+      .replace(/^([+-])?\./, "$10.")
+      // Remove extraneous trailing decimal zeroes.
+      .replace(/(\.\d+?)0+(?=e|$)/, "$1")
+      // Remove unnecessary .e notation
+      .replace(/\.(?=e)/, "")
+  );
+}
+
+// http://php.net/manual/en/language.operators.precedence.php
+const PRECEDENCE = new Map(
+  [
+    ["or"],
+    ["xor"],
+    ["and"],
+    [
+      "=",
+      "+=",
+      "-=",
+      "*=",
+      "**=",
+      "/=",
+      ".=",
+      "%=",
+      "&=",
+      "|=",
+      "^=",
+      "<<=",
+      ">>=",
+    ],
+    ["??"],
+    ["||"],
+    ["&&"],
+    ["|"],
+    ["^"],
+    ["&"],
+    ["==", "===", "!=", "!==", "<>", "<=>"],
+    ["<", ">", "<=", ">="],
+    [">>", "<<"],
+    ["+", "-", "."],
+    ["*", "/", "%"],
+    ["!"],
+    ["instanceof"],
+    ["++", "--", "~"],
+    ["**"],
+  ].flatMap((operators, index) =>
+    operators.map((operator) => [operator, index])
+  )
+);
+function getPrecedence(operator) {
+  return PRECEDENCE.get(operator);
+}
+
+const equalityOperators = ["==", "!=", "===", "!==", "<>", "<=>"];
+const multiplicativeOperators = ["*", "/", "%"];
+const bitshiftOperators = [">>", "<<"];
+
+function isBitwiseOperator(operator) {
+  return (
+    !!bitshiftOperators[operator] ||
+    operator === "|" ||
+    operator === "^" ||
+    operator === "&"
+  );
+}
+
+function shouldFlatten(parentOp, nodeOp) {
+  if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) {
+    return false;
+  }
+
+  // ** is right-associative
+  // x ** y ** z --> x ** (y ** z)
+  if (parentOp === "**") {
+    return false;
+  }
+
+  // x == y == z --> (x == y) == z
+  if (
+    equalityOperators.includes(parentOp) &&
+    equalityOperators.includes(nodeOp)
+  ) {
+    return false;
+  }
+
+  // x * y % z --> (x * y) % z
+  if (
+    (nodeOp === "%" && multiplicativeOperators.includes(parentOp)) ||
+    (parentOp === "%" && multiplicativeOperators.includes(nodeOp))
+  ) {
+    return false;
+  }
+
+  // x * y / z --> (x * y) / z
+  // x / y * z --> (x / y) * z
+  if (
+    nodeOp !== parentOp &&
+    multiplicativeOperators.includes(nodeOp) &&
+    multiplicativeOperators.includes(parentOp)
+  ) {
+    return false;
+  }
+
+  // x << y << z --> (x << y) << z
+  if (
+    bitshiftOperators.includes(parentOp) &&
+    bitshiftOperators.includes(nodeOp)
+  ) {
+    return false;
+  }
+
+  return true;
+}
+
+function nodeHasStatement(node) {
+  return [
+    "block",
+    "program",
+    "namespace",
+    "class",
+    "enum",
+    "interface",
+    "trait",
+    "traituse",
+    "declare",
+  ].includes(node.kind);
+}
+
+function getBodyFirstChild({ body }) {
+  if (!body) {
+    return null;
+  }
+  if (body.kind === "block") {
+    body = body.children;
+  }
+  return body[0];
+}
+
+function getNodeListProperty(node) {
+  const body = node.children || node.body || node.adaptations;
+  return Array.isArray(body) ? body : null;
+}
+
+function getLast(arr) {
+  if (arr.length > 0) {
+    return arr[arr.length - 1];
+  }
+  return null;
+}
+
+function getPenultimate(arr) {
+  if (arr.length > 1) {
+    return arr[arr.length - 2];
+  }
+  return null;
+}
+
+function isFirstChildrenInlineNode(path) {
+  const { node } = path;
+
+  if (node.kind === "program") {
+    const children = getNodeListProperty(node);
+
+    if (!children || children.length === 0) {
+      return false;
+    }
+
+    return children[0].kind === "inline";
+  }
+
+  if (node.kind === "switch") {
+    if (!node.body) {
+      return false;
+    }
+
+    const children = getNodeListProperty(node.body);
+
+    if (children.length === 0) {
+      return false;
+    }
+
+    const [firstCase] = children;
+
+    if (!firstCase.body) {
+      return false;
+    }
+
+    const firstCaseChildren = getNodeListProperty(firstCase.body);
+
+    if (firstCaseChildren.length === 0) {
+      return false;
+    }
+
+    return firstCaseChildren[0].kind === "inline";
+  }
+
+  const firstChild = getBodyFirstChild(node);
+
+  if (!firstChild) {
+    return false;
+  }
+
+  return firstChild.kind === "inline";
+}
+
+function isDocNode(node) {
+  return (
+    node.kind === "nowdoc" ||
+    (node.kind === "encapsed" && node.type === "heredoc")
+  );
+}
+
+/**
+ * Heredoc/Nowdoc nodes need a trailing linebreak if they
+ * appear as function arguments or array elements
+ */
+function docShouldHaveTrailingNewline(path, recurse = 0) {
+  const node = path.getNode(recurse);
+  const parent = path.getNode(recurse + 1);
+  const parentParent = path.getNode(recurse + 2);
+
+  if (!parent) {
+    return false;
+  }
+
+  if (
+    (parentParent &&
+      ["call", "new", "echo"].includes(parentParent.kind) &&
+      !["call", "array"].includes(parent.kind)) ||
+    parent.kind === "parameter"
+  ) {
+    const lastIndex = parentParent.arguments.length - 1;
+    const index = parentParent.arguments.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (parentParent && parentParent.kind === "for") {
+    const initIndex = parentParent.init.indexOf(parent);
+
+    if (initIndex !== -1) {
+      return initIndex !== parentParent.init.length - 1;
+    }
+
+    const testIndex = parentParent.test.indexOf(parent);
+
+    if (testIndex !== -1) {
+      return testIndex !== parentParent.test.length - 1;
+    }
+
+    const incrementIndex = parentParent.increment.indexOf(parent);
+
+    if (incrementIndex !== -1) {
+      return incrementIndex !== parentParent.increment.length - 1;
+    }
+  }
+
+  if (parent.kind === "bin") {
+    return (
+      parent.left === node || docShouldHaveTrailingNewline(path, recurse + 1)
+    );
+  }
+
+  if (parent.kind === "case" && parent.test === node) {
+    return true;
+  }
+
+  if (parent.kind === "staticvariable") {
+    const lastIndex = parentParent.variables.length - 1;
+    const index = parentParent.variables.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "entry") {
+    if (parent.key === node) {
+      return true;
+    }
+
+    const lastIndex = parentParent.items.length - 1;
+    const index = parentParent.items.indexOf(parent);
+
+    return index !== lastIndex;
+  }
+
+  if (["call", "new"].includes(parent.kind)) {
+    const lastIndex = parent.arguments.length - 1;
+    const index = parent.arguments.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "echo") {
+    const lastIndex = parent.expressions.length - 1;
+    const index = parent.expressions.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "array") {
+    const lastIndex = parent.items.length - 1;
+    const index = parent.items.indexOf(node);
+
+    return index !== lastIndex;
+  }
+
+  if (parent.kind === "retif") {
+    return docShouldHaveTrailingNewline(path, recurse + 1);
+  }
+
+  return false;
+}
+
+function lineShouldEndWithSemicolon(path) {
+  const { node, parent: parentNode } = path;
+  if (!parentNode) {
+    return false;
+  }
+  // for single line control structures written in a shortform (ie without a block),
+  // we need to make sure the single body node gets a semicolon
+  if (
+    ["for", "foreach", "while", "do", "if", "switch"].includes(
+      parentNode.kind
+    ) &&
+    node.kind !== "block" &&
+    node.kind !== "if" &&
+    (parentNode.body === node || parentNode.alternate === node)
+  ) {
+    return true;
+  }
+  if (!nodeHasStatement(parentNode)) {
+    return false;
+  }
+  if (node.kind === "echo" && node.shortForm) {
+    return false;
+  }
+  if (node.kind === "traituse") {
+    return !node.adaptations;
+  }
+  if (node.kind === "method" && node.isAbstract) {
+    return true;
+  }
+  if (node.kind === "method") {
+    const { parent } = path;
+    if (parent && parent.kind === "interface") {
+      return true;
+    }
+  }
+  return [
+    "expressionstatement",
+    "do",
+    "usegroup",
+    "classconstant",
+    "propertystatement",
+    "traitprecedence",
+    "traitalias",
+    "goto",
+    "constantstatement",
+    "enumcase",
+    "global",
+    "static",
+    "echo",
+    "unset",
+    "return",
+    "break",
+    "continue",
+    "throw",
+  ].includes(node.kind);
+}
+
+function fileShouldEndWithHardline(path) {
+  const { node } = path;
+  const isProgramNode = node.kind === "program";
+  const lastNode = node.children && getLast(node.children);
+
+  if (!isProgramNode) {
+    return false;
+  }
+
+  if (lastNode && ["halt", "inline"].includes(lastNode.kind)) {
+    return false;
+  }
+
+  if (
+    lastNode &&
+    (lastNode.kind === "declare" || lastNode.kind === "namespace")
+  ) {
+    const lastNestedNode =
+      lastNode.children.length > 0 && getLast(lastNode.children);
+
+    if (lastNestedNode && ["halt", "inline"].includes(lastNestedNode.kind)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function maybeStripLeadingSlashFromUse(name) {
+  const nameWithoutLeadingSlash = name.replace(/^\\/, "");
+  if (nameWithoutLeadingSlash.indexOf("\\") !== -1) {
+    return nameWithoutLeadingSlash;
+  }
+  return name;
+}
+
+function hasDanglingComments(node) {
+  return (
+    node.comments &&
+    node.comments.some((comment) => !comment.leading && !comment.trailing)
+  );
+}
+
+function isLookupNode(node) {
+  return (
+    node.kind === "propertylookup" ||
+    node.kind === "nullsafepropertylookup" ||
+    node.kind === "staticlookup" ||
+    node.kind === "offsetlookup"
+  );
+}
+
+function shouldPrintHardLineAfterStartInControlStructure(path) {
+  const { node } = path;
+
+  if (["try", "catch"].includes(node.kind)) {
+    return false;
+  }
+
+  return isFirstChildrenInlineNode(path);
+}
+
+function shouldPrintHardLineBeforeEndInControlStructure(path) {
+  const { node } = path;
+
+  if (["try", "catch"].includes(node.kind)) {
+    return true;
+  }
+
+  if (node.kind === "switch") {
+    const children = getNodeListProperty(node.body);
+
+    if (children.length === 0) {
+      return true;
+    }
+
+    const lastCase = getLast(children);
+
+    if (!lastCase.body) {
+      return true;
+    }
+
+    const childrenInCase = getNodeListProperty(lastCase.body);
+
+    if (childrenInCase.length === 0) {
+      return true;
+    }
+
+    return childrenInCase[0].kind !== "inline";
+  }
+
+  return !isFirstChildrenInlineNode(path);
+}
+
+function getAlignment(text) {
+  const lines = text.split("\n");
+  const lastLine = lines.pop();
+
+  return lastLine.length - lastLine.trimLeft().length + 1;
+}
+
+function isProgramLikeNode(node) {
+  return ["program", "declare", "namespace"].includes(node.kind);
+}
+
+function isReferenceLikeNode(node) {
+  return [
+    "name",
+    "parentreference",
+    "selfreference",
+    "staticreference",
+  ].includes(node.kind);
+}
+
+// Return `logical` value for `bin` node containing `||` or `&&` type otherwise return kind of node.
+// Require for grouping logical and binary nodes in right way.
+function getNodeKindIncludingLogical(node) {
+  if (node.kind === "bin" && ["||", "&&"].includes(node.type)) {
+    return "logical";
+  }
+
+  return node.kind;
+}
+
+/**
+ * Check if string can safely be converted from double to single quotes and vice-versa, i.e.
+ *
+ * - no embedded variables ("foo $bar")
+ * - no linebreaks
+ * - no special characters like \n, \t, ...
+ * - no octal/hex/unicode characters
+ *
+ * See https://php.net/manual/en/language.types.string.php#language.types.string.syntax.double
+ */
+function useDoubleQuote(node, options) {
+  if (node.isDoubleQuote === options.singleQuote) {
+    // We have a double quote and the user passed singleQuote:true, or the other way around.
+    const rawValue = node.raw.slice(node.raw[0] === "b" ? 2 : 1, -1);
+    const isComplex = rawValue.match(
+      /\\([$nrtfve]|[xX][0-9a-fA-F]{1,2}|[0-7]{1,3}|u{([0-9a-fA-F]+)})|\r?\n|'|"|\$/
+    );
+    return node.isDoubleQuote ? isComplex : !isComplex;
+  }
+  return node.isDoubleQuote;
+}
+
+function hasEmptyBody(path, name = "body") {
+  const { node } = path;
+
+  return (
+    node[name] &&
+    node[name].children &&
+    node[name].children.length === 0 &&
+    (!node[name].comments || node[name].comments.length === 0)
+  );
+}
+
+function isNextLineEmptyAfterNamespace(text, node) {
+  let idx = locStart(node);
+  idx = skipEverythingButNewLine(text, idx);
+  idx = skipNewline(text, idx);
+  return hasNewline(text, idx);
+}
+
+function shouldPrintHardlineBeforeTrailingComma(lastElem) {
+  if (
+    lastElem.kind === "nowdoc" ||
+    (lastElem.kind === "encapsed" && lastElem.type === "heredoc")
+  ) {
+    return true;
+  }
+
+  if (
+    lastElem.kind === "entry" &&
+    (lastElem.value.kind === "nowdoc" ||
+      (lastElem.value.kind === "encapsed" && lastElem.value.type === "heredoc"))
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+function getAncestorCounter(path, typeOrTypes) {
+  const types = [].concat(typeOrTypes);
+  let counter = -1;
+  let ancestorNode;
+  while ((ancestorNode = path.getParentNode(++counter))) {
+    if (types.indexOf(ancestorNode.kind) !== -1) {
+      return counter;
+    }
+  }
+  return -1;
+}
+
+function getAncestorNode(path, typeOrTypes) {
+  const counter = getAncestorCounter(path, typeOrTypes);
+  return counter === -1 ? null : path.getParentNode(counter);
+}
+
+const magicMethods = [
+  "__construct",
+  "__destruct",
+  "__call",
+  "__callStatic",
+  "__get",
+  "__set",
+  "__isset",
+  "__unset",
+  "__sleep",
+  "__wakeup",
+  "__toString",
+  "__invoke",
+  "__set_state",
+  "__clone",
+  "__debugInfo",
+];
+const magicMethodsMap = new Map(
+  magicMethods.map((name) => [name.toLowerCase(), name])
+);
+
+function normalizeMagicMethodName(name) {
+  const loweredName = name.toLowerCase();
+
+  if (magicMethodsMap.has(loweredName)) {
+    return magicMethodsMap.get(loweredName);
+  }
+
+  return name;
+}
+
+/**
+ * @param {string[]} kindsArray
+ * @returns {(node: Node | Comment) => Boolean}
+ */
+function createTypeCheckFunction(kindsArray) {
+  const kinds = new Set(kindsArray);
+  return (node) => kinds.has(node?.kind);
+}
+
+const isSingleWordType = createTypeCheckFunction([
+  "variadicplaceholder",
+  "namedargument",
+  "nullkeyword",
+  "identifier",
+  "parameter",
+  "variable",
+  "variadic",
+  "boolean",
+  "literal",
+  "number",
+  "string",
+  "clone",
+  "cast",
+]);
+
+const isArrayExpression = createTypeCheckFunction(["array"]);
+const isCallLikeExpression = createTypeCheckFunction([
+  "nullsafepropertylookup",
+  "propertylookup",
+  "staticlookup",
+  "offsetlookup",
+  "call",
+  "new",
+]);
+const isArrowFuncExpression = createTypeCheckFunction(["arrowfunc"]);
+
+function getChainParts(node, prev = []) {
+  const parts = prev;
+  if (isCallLikeExpression(node)) {
+    parts.push(node);
+  }
+
+  if (!node.what) {
+    return parts;
+  }
+
+  return getChainParts(node.what, parts);
+}
+
+function isSimpleCallArgument(node, depth = 2) {
+  if (depth <= 0) {
+    return false;
+  }
+
+  const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
+
+  if (isSingleWordType(node)) {
+    return true;
+  }
+
+  if (isArrayExpression(node)) {
+    return node.items.every((x) => x === null || isChildSimple(x));
+  }
+
+  if (isCallLikeExpression(node)) {
+    const parts = getChainParts(node);
+    parts.unshift();
+
+    return (
+      parts.length <= depth &&
+      parts.every((node) =>
+        isLookupNode(node)
+          ? isChildSimple(node.offset)
+          : node.arguments.every(isChildSimple)
+      )
+    );
+  }
+
+  if (isArrowFuncExpression(node)) {
+    return (
+      node.arguments.length <= depth && node.arguments.every(isChildSimple)
+    );
+  }
+
+  return false;
+}
+
+function memoize(fn) {
+  const cache = new Map();
+  return (key) => {
+    if (!cache.has(key)) {
+      cache.set(key, fn(key));
+    }
+    return cache.get(key);
+  };
+}
+
+export {
+  printNumber,
+  getPrecedence,
+  isBitwiseOperator,
+  shouldFlatten,
+  nodeHasStatement,
+  getLast,
+  getPenultimate,
+  getBodyFirstChild,
+  lineShouldEndWithSemicolon,
+  fileShouldEndWithHardline,
+  maybeStripLeadingSlashFromUse,
+  hasDanglingComments,
+  docShouldHaveTrailingNewline,
+  isLookupNode,
+  isFirstChildrenInlineNode,
+  shouldPrintHardLineAfterStartInControlStructure,
+  shouldPrintHardLineBeforeEndInControlStructure,
+  getAlignment,
+  isProgramLikeNode,
+  isReferenceLikeNode,
+  getNodeKindIncludingLogical,
+  useDoubleQuote,
+  hasEmptyBody,
+  isNextLineEmptyAfterNamespace,
+  shouldPrintHardlineBeforeTrailingComma,
+  isDocNode,
+  getAncestorNode,
+  normalizeMagicMethodName,
+  isSimpleCallArgument,
+  memoize,
+};

frontend/src/common/prettier/plugins/rust/format/comments.ts

@@ -0,0 +1,824 @@
+import { CommentOrDocComment, LocArray, Node, NodeType, NodeWithBodyOrCases } from "jinx-rust";
+import {
+	end,
+	getBodyOrCases,
+	getLastParameter,
+	hasOuterAttributes,
+	isInner,
+	is_Attribute,
+	is_AttributeOrDocComment,
+	is_BlockCommentKind,
+	is_BlockCommentNode,
+	is_Comment,
+	is_CommentOrDocComment,
+	is_ExpressionWithBodyOrCases,
+	is_ExternSpecifier,
+	is_FlowControlExpression,
+	is_FunctionDeclaration,
+	is_FunctionNode,
+	is_IfBlockExpression,
+	is_LineCommentKind,
+	is_LineCommentNode,
+	is_LocArray,
+	is_MacroRule,
+	is_NodeWithBodyOrCases,
+	is_ReassignmentNode,
+	is_StatementNode,
+	is_StructLiteralProperty,
+	is_StructLiteralPropertySpread,
+	nisAnyOf,
+	ownStart,
+	start,
+} from "jinx-rust/utils";
+import { is_CallExpression_or_CallLikeMacroInvocation } from "../transform";
+import { Narrow, assert, exit, iLast, last_of, maybe_last_of } from "../utils/common";
+import { is_MemberAccessLike, is_xVariableEqualishLike } from "./core";
+import {
+	AnyComment,
+	CustomOptions,
+	DCM,
+	Doc,
+	MutatedAttribute,
+	NodeWithComments,
+	PrettierCommentInfo,
+	breakParent,
+	cursor,
+	hardline,
+	indent,
+	join,
+	line,
+	lineSuffix,
+	literalline,
+} from "./external";
+import { assertPathAtNode, canAttachComment, getAllComments, getContext, getNode, getOptions, pathCallEach } from "./plugin";
+import { shouldPrintOuterAttributesAbove } from "./styling";
+
+function addCommentHelper(node: Node, comment: AnyComment, leading = false, trailing = false) {
+	__DEV__: assert(!handled(comment));
+	((node as NodeWithComments<Node>).comments ??= []).push(comment);
+	(comment.leading = leading), (comment.trailing = trailing), (comment.printed = false);
+}
+
+function addLeadingComment(node: Node, comment: AnyComment) {
+	addCommentHelper(node, comment, true);
+}
+function addDanglingComment(node: Node, comment: AnyComment, marker: DCM) {
+	addCommentHelper(node, comment);
+	comment.marker = marker;
+}
+function addTrailingComment(node: Node, comment: AnyComment) {
+	addCommentHelper(node, comment, false, true);
+}
+export function setPrettierIgnoreTarget(node: Node, comment: AnyComment) {
+	__DEV__: Narrow<Node & { prettierIgnore?: true }>(node), assert(isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment));
+	comment.unignore = true;
+	node.prettierIgnore = true;
+}
+
+function hasComments<T extends Node>(node: T): node is NodeWithComments<T> {
+	return "comments" in node && node.comments.length > 0;
+}
+
+export function printDanglingComments(enclosingNode: Node, sameIndent: boolean, marker?: DCM) {
+	if (hasComments(enclosingNode)) {
+		const printed: Doc[] = [];
+		pathCallEach(enclosingNode, "comments", (comment) => {
+			if (isDangling(comment) && (!marker || comment.marker === marker)) {
+				printed.push(printComment(comment));
+			}
+		});
+		if (printed.length > 0) {
+			return sameIndent //
+				? join(hardline, printed)
+				: indent([hardline, join(hardline, printed)]);
+		}
+	}
+	return "";
+}
+
+export function needsHardlineAfterDanglingComment(node: Node) {
+	if (!hasComment(node)) return false;
+	const lastDanglingComment = maybe_last_of(getComments(node, CF.Dangling));
+	return lastDanglingComment && is_LineCommentNode(lastDanglingComment);
+}
+export function setDidPrintComment(comment: AnyComment) {
+	comment.printed = true;
+}
+
+function printComment(comment: AnyComment) {
+	__DEV__: assertPathAtNode("printComment", comment);
+	__DEV__: assert(handled(comment), `Assertion failed: Comment was not printed at ${comment.loc.url()}`, comment);
+	setDidPrintComment(comment);
+	return getContext().options.printer.printComment!(getContext().path as any, getOptions());
+}
+
+export function isPreviousLineEmpty(node: Node) {
+	let index = start(node) - 1;
+	index = skipSpaces(index, true) as number;
+	index = skipNewline(index, true) as number;
+	index = skipSpaces(index, true) as number;
+	return index !== skipNewline(index, true);
+}
+export function hasBreaklineBefore(node: Node) {
+	return hasNewline(start(node) - 1, true);
+}
+
+export function hasBreaklineAfter(node: Node) {
+	return hasNewline(end(node));
+}
+
+export function printCommentsSeparately(ignored?: Set<AnyComment>) {
+	const node = getNode();
+	__DEV__: Narrow<Node & { comments?: AnyComment[] }>(node);
+
+	const leading: Doc[] = [];
+	const trailing: Doc[] = [];
+	let hasTrailingLineComment = false;
+	let hadLeadingBlockComment = false;
+
+	if ("comments" in node) {
+		pathCallEach(node, "comments", (comment) => {
+			if (ignored?.has(comment)) {
+				return;
+			} else if (isLeading(comment)) {
+				leading.push(printLeadingComment(comment));
+			} else if (isTrailing(comment)) {
+				trailing.push(printTrailingComment(comment));
+			}
+		});
+	}
+
+	if (node === getOptions().cursorNode) {
+		leading.unshift(cursor);
+		trailing.push(cursor);
+	}
+
+	return (leading.length | trailing.length) > 0 ? { leading, trailing } : ({ leading: "", trailing: "" } as const);
+
+	function printLeadingComment(comment: AnyComment) {
+		if (is_Attribute(comment) && !comment.inner) {
+			const printed = printComment(comment);
+			return [printed, " "];
+		}
+		hadLeadingBlockComment ||= is_BlockCommentKind(comment) && hasBreaklineBefore(comment);
+		return [
+			printComment(comment),
+			is_BlockCommentKind(comment)
+				? hasBreaklineAfter(comment) //
+					? hadLeadingBlockComment
+						? hardline
+						: line
+					: " "
+				: hardline,
+			hasNewline(skipNewline(skipSpaces(end(comment)))) ? hardline : "",
+		];
+	}
+
+	function printTrailingComment(comment: AnyComment) {
+		const printed = printComment(comment);
+		return hasBreaklineBefore(comment)
+			? lineSuffix([hardline, isPreviousLineEmpty(comment) ? hardline : "", printed])
+			: is_BlockCommentNode(comment)
+			? [" ", printed]
+			: lineSuffix([" ", printed, hasTrailingLineComment === (hasTrailingLineComment = true) ? hardline : breakParent]);
+	}
+}
+
+export function getPostLeadingComment(comment: AnyComment) {
+	// console.log(comment.loc.url());
+	// is_BlockCommentKind(comment)
+	// 	? hasBreaklineAfter(comment) //
+	// 		? hasBreaklineBefore(comment)
+	// 			? hardline
+	// 			: line
+	// 		: " "
+	// 	: hardline,
+	return hasNewline(skipNewline(skipSpaces(end(comment)))) ? hardline : "";
+}
+
+export function withComments<D extends Doc>(node: Node, printed: D, ignored?: Set<AnyComment>): D | Doc[] {
+	__DEV__: assertPathAtNode("withComments", node);
+	const { leading, trailing } = printCommentsSeparately(ignored);
+	return leading || trailing ? [...leading!, printed, ...trailing!] : printed;
+	// return needsOuterParens(node) ? group(["(", indent([softline, parts]), softline, ")"]) : parts;
+	// return parts;
+}
+export function getComments(node: Node, ...args: Parameters<typeof getCommentTestFunction>): AnyComment[] {
+	__DEV__: Narrow<Node & { comments?: AnyComment[] }>(node);
+	// if (!node || !node.comments) return [];
+	// if (args.length === 0) return node.comments;
+	// return args.length > 0 ? node.comments.filter(getCommentTestFunction(...args)) : node.comments;
+	return node && node.comments //
+		? args.length > 0
+			? node.comments.filter(getCommentTestFunction(...args))
+			: node.comments
+		: [];
+}
+
+export function getFirstComment(node: Node, flags: CF, fn?: (comment: AnyComment) => boolean): AnyComment | undefined {
+	const r = getComments(node, flags | CF.First, fn);
+	return r.length === 0 ? undefined : r[0];
+}
+
+export function escapeComments(flags: number, fn?: (comment: AnyComment) => boolean) {
+	const comments = getAllComments().filter(getCommentTestFunction(flags, fn)) as AnyComment[];
+	comments.forEach(setDidPrintComment);
+	return new Set(comments);
+}
+
+export const enum CF {
+	Leading = 1 << 1,
+	Trailing = 1 << 2,
+	Dangling = 1 << 3,
+	Block = 1 << 4,
+	Line = 1 << 5,
+	PrettierIgnore = 1 << 6,
+	First = 1 << 7,
+	Last = 1 << 8,
+}
+export function isPrettierIgnoreComment(comment: AnyComment) {
+	return is_Comment(comment) && /^\s*prettier-ignore\s*/.test(comment.value) && !comment.unignore;
+}
+export function isPrettierIgnoreAttribute(node: Node): node is MutatedAttribute {
+	return is_Attribute(node) && /^\s*rustfmt::skip\s*$/.test(node.value);
+}
+function getCommentTestFunction(flags: CF, fn?: (comment: AnyComment) => boolean) {
+	return function (comment: AnyComment, index: number, comments: AnyComment[]) {
+		__DEV__: Narrow<number>(flags), assert(handled(comment));
+		return !(
+			(flags & CF.Leading && !isLeading(comment)) ||
+			(flags & CF.Trailing && !isTrailing(comment)) ||
+			(flags & CF.Dangling && !isDangling(comment)) ||
+			(flags & CF.Block && !is_BlockCommentKind(comment)) ||
+			(flags & CF.Line && !is_LineCommentKind(comment)) ||
+			(flags & CF.First && index !== 0) ||
+			(flags & CF.Last && !iLast(index, comments)) ||
+			(flags & CF.PrettierIgnore && !(isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment))) ||
+			(fn && !fn(comment))
+		);
+	};
+}
+
+export function hasComment(node: Node, flags: number = 0, fn?: (comment: AnyComment) => boolean) {
+	if ("comments" in node && node.comments!.length > 0) {
+		return flags || fn ? (node.comments as AnyComment[]).some(getCommentTestFunction(flags, fn)) : true;
+	}
+	return false;
+}
+export function hasNewlineInRange(leftIndex: number, rightIndex: number) {
+	__DEV__: assert(leftIndex <= rightIndex);
+	const text = getContext().options.originalText;
+	for (var i = leftIndex; i < rightIndex; ++i) if (text.charCodeAt(i) === 10) return true;
+	return false;
+}
+export function isNextLineEmpty(node: Node) {
+	return isNextLineEmptyAfterIndex(end(node));
+}
+export function isNextLineEmptyAfterIndex(index: number | false) {
+	let oldIdx: number | false = -1;
+	let idx: number | false = index;
+	while (idx !== oldIdx) {
+		oldIdx = idx;
+		idx = skipToLineEnd(idx);
+		idx = skipBlockComment(idx);
+		idx = skipSpaces(idx);
+		idx = skipParens(idx);
+	}
+	idx = skipLineComment(idx);
+	idx = skipParens(idx);
+	idx = skipNewline(idx);
+	idx = skipParens(idx);
+	return idx !== false && hasNewline(idx);
+}
+export function hasNewline(index: number | false, backwards = false) {
+	if (index === false) return false;
+	const i = skipSpaces(index, backwards);
+	return i !== false && i !== skipNewline(i, backwards);
+}
+function skipLineComment(index: number | false) {
+	if (index === false) return false;
+	const { commentSpans, originalText } = getContext().options;
+	if (commentSpans.has(index) && originalText.charCodeAt(index + 1) === 47 /** "/" */)
+		return skipEverythingButNewLine(commentSpans.get(index)!);
+	return index;
+}
+function skipBlockComment(index: number | false) {
+	if (index === false) return false;
+	const { commentSpans, originalText } = getContext().options;
+	if (commentSpans.has(index) && originalText.charCodeAt(index + 1) === 42 /** "*" */) return commentSpans.get(index)!;
+	return index;
+}
+const [skipSpaces, skipToLineEnd, skipEverythingButNewLine] = [/[ \t]/, /[,; \t]/, /[^\r\n]/].map(function (re) {
+	return function (index: number | false, backwards = false) {
+		if (index === false) return false;
+		const { originalText: text } = getContext().options;
+		let cursor = index;
+		while (cursor >= 0 && cursor < text.length) {
+			if (re.test(text.charAt(cursor))) backwards ? cursor-- : cursor++;
+			else return cursor;
+		}
+		return cursor === -1 || cursor === text.length ? cursor : false;
+	};
+});
+
+function skipNewline(index: number | false, backwards = false) {
+	if (index === false) return false;
+	const { originalText } = getContext().options;
+	const atIndex = originalText.charCodeAt(index);
+	if (backwards) {
+		if (originalText.charCodeAt(index - 1) === 13 && atIndex === 10) return index - 2;
+		if (atIndex === 10) return index - 1;
+	} else {
+		if (atIndex === 13 && originalText.charCodeAt(index + 1) === 10) return index + 2;
+		if (atIndex === 10) return index + 1;
+	}
+	return index;
+}
+
+function skipParens(index: number | false, backwards = false) {
+	return index;
+	// if (index === false) return false;
+	// const { parensPositions } = getContext().options;
+	// while (parensPositions.has(index)) backwards ? index-- : index++;
+	// return index;
+}
+
+export function getNextNonSpaceNonCommentCharacterIndex(node: Node) {
+	return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(end(node));
+}
+function getNextNonSpaceNonCommentCharacterIndexWithStartIndex(i: number) {
+	let oldIdx = -1;
+	let nextIdx = i;
+	while (nextIdx !== oldIdx) {
+		oldIdx = nextIdx;
+		nextIdx = skipSpaces(nextIdx) as number;
+		nextIdx = skipBlockComment(nextIdx) as number;
+		nextIdx = skipLineComment(nextIdx) as number;
+		nextIdx = skipNewline(nextIdx) as number;
+		nextIdx = skipParens(nextIdx) as number;
+	}
+	return nextIdx;
+}
+export function getNextNonSpaceNonCommentCharacter(node: Node) {
+	return getContext().options.originalText.charAt(getNextNonSpaceNonCommentCharacterIndex(node));
+}
+
+interface CommentContext {
+	comment: AnyComment;
+	precedingNode: Node | undefined;
+	enclosingNode: Node | undefined;
+	followingNode: Node | undefined;
+	text: string;
+	options: CustomOptions;
+	ast: Node;
+	isLastComment: boolean;
+}
+
+function handled(comment: AnyComment) {
+	return "printed" in comment;
+}
+function handleCommon(ctx: CommentContext): boolean {
+	{
+		const { comment, precedingNode, enclosingNode, followingNode } = ctx;
+		if (!enclosingNode) {
+			ctx.enclosingNode = ctx.comment.loc.src.program;
+		} else if (enclosingNode && is_NodeWithBodyOrCases(enclosingNode)) {
+			const body = getBodyOrCases(enclosingNode);
+			if (body) {
+				if (is_ExpressionWithBodyOrCases(enclosingNode) && enclosingNode.label) {
+					if (ctx.precedingNode === enclosingNode.label) {
+						ctx.precedingNode = undefined;
+					}
+					if (followingNode === enclosingNode.label) {
+						ctx.followingNode = undefined;
+					}
+				}
+				if (comment.loc.isBefore(body)) {
+					if (followingNode && body.loc.contains(followingNode)) {
+						ctx.followingNode = undefined;
+					}
+					if (!ctx.precedingNode && !ctx.followingNode) {
+						addLeadingComment(enclosingNode, comment);
+						return true;
+					}
+				} else if (comment.loc.isAfter(body)) {
+					if (precedingNode && body.loc.contains(precedingNode)) {
+						ctx.precedingNode = undefined;
+					}
+					if (!ctx.precedingNode && !ctx.followingNode) {
+						addTrailingComment(enclosingNode, comment);
+						return true;
+					}
+				} else if (body.loc.contains(comment)) {
+					if (precedingNode && !body.loc.contains(precedingNode)) {
+						ctx.precedingNode = undefined;
+					}
+					if (followingNode && !body.loc.contains(followingNode)) {
+						ctx.followingNode = undefined;
+					}
+				}
+			}
+		}
+	}
+	for (const fn of [
+		handleMixedInOuterAttributeComments,
+		handleAttributeComments,
+		handleDanglingComments,
+		handleFunctionComments,
+		handleMacroRuleComments,
+		handleStructLiteralComments,
+		handleVariableDeclaratorComments,
+		handleIfBlockExpressionComments,
+		handleMemberExpressionComments,
+		handleStatementComments,
+		handleFlowControlComments,
+		handleBadComments,
+	]) {
+		fn(ctx);
+		if (handled(ctx.comment)) {
+			// console.log(ctx.comment.loc.url(), fn.name);
+			return true;
+		}
+	}
+
+	const { precedingNode, followingNode, comment } = ctx;
+
+	if (isStartOfLine(comment)) {
+		if (followingNode) {
+			addLeadingComment(followingNode, comment);
+		} else if (precedingNode) {
+			addTrailingComment(precedingNode, comment);
+		} else {
+			exit.never(ctx);
+		}
+	} else if (isEndOfLine(comment)) {
+		if (precedingNode) {
+			addTrailingComment(precedingNode, comment);
+		} else if (followingNode) {
+			addLeadingComment(followingNode, comment);
+		} else {
+			exit.never(ctx);
+		}
+	} else {
+		if (precedingNode && followingNode) {
+			return false;
+		} else if (precedingNode) {
+			addTrailingComment(precedingNode, comment);
+		} else if (followingNode) {
+			addLeadingComment(followingNode, comment);
+		} else {
+			exit.never(ctx);
+		}
+	}
+	return handled(ctx.comment);
+}
+export function handleOwnLineComment(ctx: CommentContext) {
+	return handleCommon(ctx);
+}
+export function handleEndOfLineComment(ctx: CommentContext) {
+	const { precedingNode, enclosingNode, comment } = ctx;
+	if (
+		// handleCallExpressionComments
+		precedingNode &&
+		enclosingNode &&
+		is_CallExpression_or_CallLikeMacroInvocation(enclosingNode) &&
+		enclosingNode.arguments.length > 0 &&
+		precedingNode === (enclosingNode.typeArguments ? last_of(enclosingNode.typeArguments) : enclosingNode.callee)
+	) {
+		addLeadingComment(enclosingNode.arguments[0], comment);
+		return true;
+	} else if (
+		// handlePropertyComments
+		enclosingNode &&
+		is_StructLiteralProperty(enclosingNode)
+	) {
+		addLeadingComment(enclosingNode, comment);
+		return true;
+	} else {
+		return handleCommon(ctx);
+	}
+}
+
+export function handleRemainingComment(ctx: CommentContext) {
+	return handleCommon(ctx);
+}
+
+function handleStructLiteralComments({ enclosingNode, followingNode, comment }: CommentContext) {
+	if (enclosingNode && is_StructLiteralPropertySpread(enclosingNode) && followingNode === enclosingNode.expression) {
+		addLeadingComment(enclosingNode, comment);
+	}
+}
+
+function handleVariableDeclaratorComments({ enclosingNode, followingNode, comment }: CommentContext) {
+	if (
+		enclosingNode &&
+		(is_xVariableEqualishLike(enclosingNode) || is_ReassignmentNode(enclosingNode)) &&
+		followingNode &&
+		(is_BlockCommentKind(comment) ||
+			nisAnyOf(followingNode, [
+				NodeType.StructLiteral,
+				NodeType.StructPattern,
+				NodeType.TupleLiteral,
+				NodeType.TypeTuple,
+				NodeType.TuplePattern,
+				NodeType.ArrayLiteral,
+				NodeType.ArrayPattern,
+				NodeType.SizedArrayLiteral,
+				NodeType.TypeSizedArray,
+			]))
+	) {
+		addLeadingComment(followingNode, comment);
+	}
+}
+
+function handleMixedInOuterAttributeComments({ precedingNode, enclosingNode, followingNode, comment }: CommentContext) {
+	if (enclosingNode && hasOuterAttributes(enclosingNode) && end(comment) <= ownStart(enclosingNode)) {
+		if (isPrettierIgnoreComment(comment) || isPrettierIgnoreAttribute(comment)) {
+			setPrettierIgnoreTarget(enclosingNode, comment);
+		}
+		if (isEndOfLine(comment)) {
+			__DEV__: assert(!!precedingNode && is_Attribute(precedingNode), "", precedingNode);
+			if (shouldPrintOuterAttributesAbove(enclosingNode)) {
+				// #[attr] // comment
+				// node
+				addTrailingComment(precedingNode, comment);
+			} else {
+				// #[attr] /* comment */ node
+				addLeadingComment(followingNode || enclosingNode, comment);
+			}
+		} else {
+			// __DEV__: assert(isStartOfLine(comment));
+			if (followingNode && end(followingNode) <= ownStart(enclosingNode)) {
+				addLeadingComment(followingNode, comment);
+			} else if (precedingNode && enclosingNode.loc.contains(precedingNode)) {
+				addTrailingComment(precedingNode, comment);
+			} else {
+				addLeadingComment(enclosingNode, comment);
+			}
+		}
+	}
+}
+function handleAttributeComments({ precedingNode, enclosingNode, followingNode, comment, ast }: CommentContext) {
+	if (is_AttributeOrDocComment(comment)) {
+		if (
+			comment.inner &&
+			enclosingNode &&
+			is_FunctionDeclaration(enclosingNode) &&
+			(!followingNode || !is_StatementNode(followingNode)) &&
+			(!precedingNode || !is_StatementNode(precedingNode))
+		) {
+			if (enclosingNode.body) {
+				if (canAttachCommentInLocArray(enclosingNode.body)) {
+					addDanglingComment(enclosingNode, comment, DCM["body"]);
+				} else {
+					addLeadingComment(enclosingNode.body[0], comment);
+				}
+			} else {
+				addLeadingComment(enclosingNode, comment);
+			}
+		} else {
+			// if (comment.loc.url().startsWith("tests/samples/macro/attr.rs") && getContext().options.danglingAttributes.includes(comment)) {
+			// 	// debugger;
+			// 	console.log({
+			// 		comment: comment.loc.url(),
+			// 		precedingNode: precedingNode?.loc.url(),
+			// 		enclosingNode: enclosingNode?.loc.url(),
+			// 		followingNode: followingNode?.loc.url(),
+			// 	});
+			// }
+			if (followingNode) {
+				addLeadingComment(followingNode, comment);
+			} else if (enclosingNode) {
+				for (var key in DCM)
+					if (key in enclosingNode) {
+						addDanglingComment(enclosingNode, comment, key as DCM);
+						return;
+					}
+			} else {
+				addDanglingComment(ast, comment, DCM["body"]);
+			}
+		}
+	}
+}
+
+function handleBadComments({ precedingNode, enclosingNode, followingNode, ast, comment }: CommentContext) {
+	if (!enclosingNode) {
+		// console.log(comment.loc.url());
+		if (followingNode) {
+			addLeadingComment(followingNode, comment);
+		} else if (precedingNode) {
+			addTrailingComment(precedingNode, comment);
+		} else {
+			addDanglingComment(enclosingNode || ast, comment, DCM["body"]);
+		}
+	} else if (!precedingNode && !followingNode) {
+		if (enclosingNode && enclosingNode !== ast) {
+			addLeadingComment(enclosingNode, comment);
+		} else {
+			addDanglingComment(ast, comment, DCM["body"]);
+		}
+	}
+}
+function is_ABI_Comment({ precedingNode, enclosingNode, comment }: CommentContext) {
+	return (
+		is_CommentOrDocComment(comment) &&
+		((precedingNode && is_ExternSpecifier(precedingNode)) || (enclosingNode && is_ExternSpecifier(enclosingNode)))
+	);
+}
+function handleFlowControlComments({ precedingNode, enclosingNode, followingNode, comment }: CommentContext) {
+	if (enclosingNode && is_FlowControlExpression(enclosingNode)) {
+		if (!precedingNode && (isOwnLine(comment) || isEndOfLine(comment)) && !followingNode) {
+			addLeadingComment(enclosingNode, comment);
+		}
+	}
+}
+function handleFunctionComments(ctx: CommentContext) {
+	const { precedingNode, enclosingNode, followingNode, comment } = ctx;
+	if (enclosingNode && is_FunctionNode(enclosingNode)) {
+		if (
+			is_FunctionDeclaration(enclosingNode) &&
+			((!is_ABI_Comment(ctx) && comment.loc.isBefore(enclosingNode.generics || enclosingNode.id)) ||
+				(enclosingNode.generics && comment.loc.isBetween(enclosingNode.generics, enclosingNode.parameters)))
+		) {
+			addLeadingComment(enclosingNode, comment);
+		} else if (
+			!enclosingNode.returnType &&
+			comment.loc.isBetween(
+				enclosingNode.parameters,
+				is_FunctionDeclaration(enclosingNode) ? enclosingNode.body! : enclosingNode.expression
+			)
+		) {
+			if (is_FunctionDeclaration(enclosingNode)) {
+				addCommentToBlock(enclosingNode, comment);
+			} else {
+				addLeadingComment(enclosingNode.expression, comment);
+			}
+		} else if (
+			precedingNode && //
+			enclosingNode.parameters.loc.contains(comment)
+		) {
+			if (precedingNode === getLastParameter(enclosingNode)) {
+				addTrailingComment(precedingNode, comment);
+			}
+		} else if (
+			followingNode &&
+			isStartOfLine(comment) &&
+			comment.loc.isAfter(enclosingNode.parameters) &&
+			(!is_FunctionDeclaration(enclosingNode) || !enclosingNode.whereBounds || comment.loc.isAfter(enclosingNode.whereBounds!)) &&
+			(!enclosingNode.returnType || comment.loc.isAfter(enclosingNode.returnType)) &&
+			followingNode === (is_FunctionDeclaration(enclosingNode) ? enclosingNode.body?.[0] : enclosingNode.expression)
+		) {
+			addLeadingComment(followingNode, comment);
+		}
+	}
+}
+function handleMacroRuleComments(ctx: CommentContext) {
+	const { precedingNode, enclosingNode, followingNode, comment } = ctx;
+	if (enclosingNode && is_MacroRule(enclosingNode)) {
+		if (enclosingNode.transform.loc.contains(comment)) {
+			__DEV__: assert(enclosingNode.transform.length > 0);
+			if (!precedingNode || !enclosingNode.transform.loc.contains(precedingNode)) {
+				__DEV__: assert(!!followingNode && enclosingNode.transform.loc.contains(followingNode));
+				addLeadingComment(followingNode, comment);
+			}
+		} else if (enclosingNode.match.loc.contains(comment)) {
+			__DEV__: assert(enclosingNode.match.length > 0);
+			if (!followingNode || !enclosingNode.match.loc.contains(followingNode)) {
+				__DEV__: assert(!!precedingNode && enclosingNode.match.loc.contains(precedingNode));
+				addTrailingComment(precedingNode!, comment);
+			}
+		}
+	}
+}
+
+function handleStatementComments(ctx: CommentContext) {
+	const { precedingNode, comment } = ctx;
+	if (isEndOfLine(comment) && precedingNode && (is_StatementNode(precedingNode) || precedingNode.loc.sliceText().endsWith(";"))) {
+		addTrailingComment(precedingNode, comment);
+	}
+}
+
+function addCommentToBlock(block: NodeWithBodyOrCases, comment: AnyComment) {
+	const body = getBodyOrCases(block);
+	__DEV__: assert(!!body);
+	if (body.length > 0) {
+		addLeadingComment(body![0], comment);
+	} else {
+		addDanglingComment(block, comment, DCM["body"]);
+	}
+}
+
+function handleIfBlockExpressionComments(ctx: CommentContext) {
+	const { comment, enclosingNode } = ctx;
+	if (enclosingNode && is_IfBlockExpression(enclosingNode)) {
+		const { condition, body, else: else_ } = enclosingNode;
+		if (comment.loc.isBefore(condition)) {
+			addLeadingComment(condition, comment);
+		} else if (comment.loc.isBetween(condition, body)) {
+			addTrailingComment(condition, comment);
+		} else if (else_ && comment.loc.isBetween(body, else_)) {
+			if (is_IfBlockExpression(else_)) {
+				addLeadingComment(else_.condition, comment);
+			} else {
+				addCommentToBlock(else_, comment);
+			}
+		}
+	}
+}
+
+function handleMemberExpressionComments({ comment, precedingNode, enclosingNode }: CommentContext) {
+	if (enclosingNode && is_MemberAccessLike(enclosingNode)) {
+		if (isStartOfLine(comment) || !precedingNode) addLeadingComment(enclosingNode, comment);
+		else addTrailingComment(precedingNode, comment);
+		return true;
+	}
+
+	return false;
+}
+
+function handleDanglingComments({ comment, enclosingNode }: CommentContext) {
+	if (enclosingNode) {
+		for (var key in DCM) {
+			if (key in enclosingNode) {
+				var arr: LocArray = enclosingNode[key];
+				if (is_LocArray(arr) && canAttachCommentInLocArray(arr) && arr.loc.contains(comment)) {
+					addDanglingComment(enclosingNode, comment, key as DCM);
+					return;
+				}
+			}
+		}
+	}
+}
+
+function canAttachCommentInLocArray(arr: LocArray) {
+	return arr.length === 0 || arr.every((node) => !canAttachComment(node));
+}
+
+function isOwnLine(comment: AnyComment) {
+	return isStartOfLine(comment) && hasBreaklineAfter(comment);
+}
+function isStartOfLine(comment: AnyComment) {
+	return comment.placement === "ownLine";
+}
+function isEndOfLine(comment: AnyComment) {
+	return comment.placement === "endOfLine";
+}
+export function isDangling(comment: AnyComment) {
+	__DEV__: assert(handled(comment));
+	return !comment.leading && !comment.trailing;
+}
+export function isLeading(comment: AnyComment) {
+	__DEV__: assert(handled(comment));
+	return comment.leading && !comment.trailing;
+}
+export function isTrailing(comment: AnyComment) {
+	__DEV__: assert(handled(comment));
+	return !comment.leading && comment.trailing;
+}
+
+export function print_comment(comment: CommentOrDocComment) {
+	__DEV__: Narrow<PrettierCommentInfo>(comment);
+
+	const doc = is_BlockCommentNode(comment)
+		? isIndentableBlockComment(comment.value)
+			? [
+					(!handled(comment) || isTrailing(comment)) && !hasBreaklineBefore(comment) ? hardline : "",
+					getCommentStart(comment),
+					...comment.value.split(/\n/g).map((line, i, a) =>
+						i === 0 //
+							? [line.trimEnd(), hardline]
+							: !iLast(i, a)
+							? [" " + line.trim(), hardline]
+							: " " + line.trimStart()
+					),
+					"*/",
+			  ]
+			: [
+					getCommentStart(comment), //
+					join(literalline, comment.value.split(/\n/g)),
+					"*/",
+			  ]
+		: [getCommentStart(comment), comment.value.trimEnd()];
+
+	return handled(comment) && isDangling(comment) //
+		? [doc, getPostLeadingComment(comment)]
+		: doc;
+
+	function getCommentStart(comment: CommentOrDocComment) {
+		return is_Comment(comment)
+			? is_BlockCommentKind(comment)
+				? "/*"
+				: "//"
+			: is_BlockCommentKind(comment)
+			? isInner(comment)
+				? "/*!"
+				: "/**"
+			: isInner(comment)
+			? "//!"
+			: "///";
+	}
+	function isIndentableBlockComment(value: string) {
+		const lines = `*${value}*`.split(/\n/g);
+		return lines.length > 1 && lines.every((line) => /^\s*\*/.test(line));
+	}
+}

frontend/src/common/prettier/plugins/rust/format/complexity.ts

@@ -0,0 +1,282 @@
+import {
+	ForLtParametersBody,
+	FunctionSpread,
+	GenericParameterDeclaration,
+	MaybeGenericArgsTarget,
+	MissingNode,
+	Node,
+	NodeType,
+	TypeBound,
+	TypeBoundsConstaint,
+	TypeCallArgument,
+	TypeNamespaceTargetNoSelector,
+	TypeNode,
+} from "jinx-rust";
+import {
+	getAstPath,
+	getOwnChildAstPath,
+	is_BareTypeTraitBound,
+	is_FunctionSpread,
+	is_LetScrutinee,
+	is_Literal,
+	is_MissingNode,
+	is_TypeBoundsStandaloneNode,
+	is_TypeFunctionNode,
+	is_TypeNode,
+	is_VariableDeclarationNode,
+} from "jinx-rust/utils";
+import { exit, has_key_defined, last_of, spliceAll } from "../utils/common";
+import { canBreak } from "./external";
+import { getContext, getNode, getOptions, getPrintFn } from "./plugin";
+
+let DEPTH = 0;
+const ANCESTRY: Node[] = [];
+const LONE_SHORT_ARGUMENT_THRESHOLD_RATE = 0.25;
+
+export function withCheckContext<R>(fn: () => R): R {
+	if (0 === DEPTH) {
+		return fn();
+	} else {
+		DEPTH = 0;
+		const prev = spliceAll(ANCESTRY);
+		try {
+			return fn();
+		} finally {
+			DEPTH = ANCESTRY.push(...prev);
+		}
+	}
+}
+
+export function is_short(str: string) {
+	return str.length <= LONE_SHORT_ARGUMENT_THRESHOLD_RATE * getOptions().printWidth;
+}
+function print(target: Node) {
+	const current = getNode();
+	const keys: (string | number)[] = [...getAstPath(ANCESTRY[0], getNode())];
+	for (let i = 1; i < ANCESTRY.length; i++) keys.push(...getOwnChildAstPath(ANCESTRY[i - 1], ANCESTRY[i]));
+	keys.push(...getOwnChildAstPath(last_of(ANCESTRY), target));
+	try {
+		return getContext().path.call(() => getPrintFn(target)(), ...keys);
+	} catch (e) {
+		console.log({ current, target, keys, ANCESTRY });
+		throw e;
+	}
+}
+
+function IsSimpleFunction<T extends Node>(fn: (node: T) => boolean): (node: T) => boolean {
+	return function (node: T) {
+		if (0 !== DEPTH && node === ANCESTRY[DEPTH - 1]) {
+			return fn(node);
+		}
+
+		if (DEPTH >= 2) {
+			return isShortBasic(node);
+		}
+
+		try {
+			return fn((ANCESTRY[DEPTH++] = node) as any);
+		} finally {
+			ANCESTRY.length = --DEPTH;
+		}
+	} as any;
+}
+
+function HasComplexFunction<T extends Node>(fn: (node: T) => boolean): (node: T) => boolean {
+	return function (node: T) {
+		if (0 !== DEPTH && node === ANCESTRY[DEPTH - 1]) {
+			return fn(node);
+		}
+
+		if (DEPTH >= 2) {
+			return !isShortBasic(node);
+		}
+
+		try {
+			return fn((ANCESTRY[DEPTH++] = node) as any);
+		} finally {
+			ANCESTRY.length = --DEPTH;
+		}
+	} as any;
+}
+
+const isShortBasic = (node: Node) => {
+	switch (node.nodeType) {
+		case NodeType.MissingNode:
+			return true;
+		case NodeType.Identifier:
+		case NodeType.Index:
+		case NodeType.LtIdentifier:
+		case NodeType.LbIdentifier:
+		case NodeType.McIdentifier:
+			return is_short(node.name);
+		case NodeType.Literal:
+			return is_short(node.value) && !/\n/.test(node.value);
+	}
+	return false;
+};
+
+export const isSimpleType = IsSimpleFunction<FunctionSpread | TypeNode | MissingNode>((node): boolean => {
+	switch (node.nodeType) {
+		case NodeType.MissingNode:
+		case NodeType.FunctionSpread:
+			return true;
+		case NodeType.MacroInvocation:
+			return false;
+		case NodeType.Identifier:
+		case NodeType.TypeNever:
+		case NodeType.TypeInferred:
+			return true;
+		case NodeType.TypePath:
+			return isShortBasic(node.segment) && (!node.namespace || isSimpleType(node.namespace));
+		case NodeType.TypeCall:
+			return isSimpleType(node.typeCallee) && !hasComplexTypeArguments(node);
+		case NodeType.ExpressionTypeSelector:
+			return isSimpleType(node.typeTarget) && (!node.typeExpression || isSimpleType(node.typeExpression));
+		case NodeType.TypeDynBounds:
+			return !hasComplexTypeBounds(node);
+		case NodeType.TypeImplBounds:
+			return !hasComplexTypeBounds(node);
+		case NodeType.TypeFnPointer: {
+			const param = node.parameters[0];
+			return (
+				(!node.extern || !node.extern.abi || isShortBasic(node.extern.abi)) &&
+				!hasComplexLtParameters(node) &&
+				(node.parameters.length === 0 ||
+					(node.parameters.length === 1 &&
+						(is_FunctionSpread(param) ||
+							(!is_TypeFunctionNode(param.typeAnnotation) && isSimpleType(param.typeAnnotation))))) &&
+				(!node.returnType || isSimpleType(node.returnType))
+			);
+		}
+		case NodeType.TypeFunction:
+			return isSimpleType(node.callee) && node.parameters.every(isSimpleType) && (!node.returnType || isSimpleType(node.returnType));
+		case NodeType.TypeSizedArray:
+			return isSimpleType(node.typeExpression) && isShortBasic(node.sizeExpression);
+		case NodeType.TypeSlice:
+			return isSimpleType(node.typeExpression);
+		case NodeType.TypeTuple:
+			return node.items.length === 0 || (node.items.length === 1 && isSimpleType(node.items[0]));
+		case NodeType.TypeReference:
+		case NodeType.TypeDereferenceMut:
+		case NodeType.TypeDereferenceConst:
+		case NodeType.TypeParenthesized:
+			return isSimpleType(node.typeExpression);
+		default:
+			__DEV__: exit.never(node);
+			return false;
+	}
+});
+
+export const hasComplexTypeBounds = HasComplexFunction<Extract<Node, TypeBoundsConstaint>>((node) => {
+	return !!node.typeBounds && node.typeBounds.length > 1 && !node.typeBounds.every(isSimpleTypeBound);
+});
+
+export const isSimpleTypeBound = (node: TypeBound): boolean => {
+	switch (node.nodeType) {
+		case NodeType.TypeParenthesized:
+			return isSimpleTypeBound(node.typeExpression);
+		// #Lifetime
+		case NodeType.LtIdentifier:
+		case NodeType.LtElided:
+		case NodeType.LtStatic:
+			return true;
+		case NodeType.TypeTraitBound:
+			return is_BareTypeTraitBound(node) && isSimpleTypeNamespaceTargetNoSelector(node.typeExpression);
+		default:
+			__DEV__: exit.never(node);
+			return false;
+	}
+	function isSimpleTypeNamespaceTargetNoSelector(node: TypeNamespaceTargetNoSelector): boolean {
+		switch (node.nodeType) {
+			case NodeType.Identifier:
+				return true;
+			case NodeType.TypePath:
+				return undefined === node.namespace || isSimpleTypeNamespaceTargetNoSelector(node.namespace);
+			case NodeType.TypeCall:
+				return false;
+			case NodeType.TypeFunction:
+				return isSimpleTypeNamespaceTargetNoSelector(node.callee) && node.parameters.length === 0 && !node.returnType;
+			default:
+				__DEV__: exit.never(node);
+				return false;
+		}
+	}
+};
+
+const isSimpleTypeArgument = IsSimpleFunction<TypeCallArgument>((node) => {
+	if (is_TypeNode(node)) {
+		return isSimpleType(node);
+	}
+	switch (node.nodeType) {
+		// #Lifetime
+		case NodeType.LtIdentifier:
+		case NodeType.LtElided:
+		case NodeType.LtStatic:
+		case NodeType.Literal:
+			return true;
+		case NodeType.MinusExpression:
+			return is_Literal(node.expression);
+		case NodeType.BlockExpression:
+			return false; //willBreak(getPrintFn(node)("body"));
+		case NodeType.TypeCallNamedArgument:
+			return isSimpleType(node.typeExpression);
+		case NodeType.TypeCallNamedBound:
+			return isSimpleType(node.typeTarget) && !hasComplexTypeBounds(node);
+		default:
+			__DEV__: exit.never(node);
+			return false;
+	}
+});
+
+export const hasComplexTypeArguments = HasComplexFunction<Extract<Node, MaybeGenericArgsTarget>>((node) =>
+	!node.typeArguments || node.typeArguments.length === 0
+		? false
+		: node.typeArguments.length === 1
+		? (() => {
+				const arg = node.typeArguments[0];
+				return is_TypeBoundsStandaloneNode(arg) || canBreak(print(arg));
+		  })()
+		: true
+);
+
+export const hasComplexLtParameters = HasComplexFunction<Extract<Node, ForLtParametersBody>>((node) => {
+	const ltParameters = node.ltParameters;
+	if (!ltParameters || ltParameters.length === 0) {
+		return false;
+	}
+	if (ltParameters.length === 1) {
+		const arg = ltParameters[0];
+		if (arg.ltBounds && arg.ltBounds.length > 1) {
+			return true;
+		}
+
+		return false;
+	}
+	return true;
+});
+
+export const isShortGenericParameterDeclaration = IsSimpleFunction<GenericParameterDeclaration>((node) => {
+	switch (node.nodeType) {
+		case NodeType.GenericTypeParameterDeclaration:
+			return !node.typeBounds && !node.typeDefault;
+		case NodeType.ConstTypeParameterDeclaration:
+			return (!node.typeAnnotation || is_MissingNode(node)) && !node.typeDefault;
+		case NodeType.GenericLtParameterDeclaration:
+			return !node.ltBounds;
+		default:
+			exit.never();
+	}
+});
+
+export const hasComplexGenerics = HasComplexFunction<Node>((node) => {
+	return has_key_defined(node, "generics") && node.generics.length > 0 && !node.generics.every(isShortGenericParameterDeclaration);
+});
+
+export const hasComplexTypeAnnotation = HasComplexFunction<Node>((node) => {
+	if (is_VariableDeclarationNode(node) && !is_LetScrutinee(node)) {
+		const { typeAnnotation } = node;
+		return !!typeAnnotation && !is_MissingNode(typeAnnotation) && !isSimpleType(typeAnnotation);
+	} else {
+		return false;
+	}
+});

frontend/src/common/prettier/plugins/rust/format/external.ts

@@ -0,0 +1,126 @@
+import { Attribute, AttributeOrDocComment, Comment, DocCommentAttribute, LocArray, MemberExpression, Node, SourceFile } from "jinx-rust";
+import { PickProps } from "jinx-rust/utils";
+import type { Doc, ParserOptions, Printer } from "prettier";
+import { doc } from "prettier";
+import { AssertTypesEq } from "../utils/common";
+
+export type { Doc, ParserOptions, Plugin, Printer } from "prettier";
+
+
+export const {
+	join,
+	line,
+	softline,
+	hardline,
+	literalline,
+	group,
+	conditionalGroup,
+	fill,
+	lineSuffix,
+	lineSuffixBoundary,
+	cursor,
+	breakParent,
+	ifBreak,
+	trim,
+	indent,
+	indentIfBreak,
+	align,
+	addAlignmentToDoc,
+	markAsRoot,
+	dedentToRoot,
+	dedent,
+	hardlineWithoutBreakParent,
+	literallineWithoutBreakParent,
+	label,
+} = doc.builders;
+
+export const {
+	willBreak,
+	traverseDoc,
+	findInDoc,
+	mapDoc,
+	removeLines,
+	stripTrailingHardline,
+} = doc.utils;
+
+// Fallback implementations for removed common in prettier 3
+export const isConcat = (doc: any): boolean => Array.isArray(doc);
+export const getDocParts = (doc: any): any[] => Array.isArray(doc) ? doc : [doc];
+export const propagateBreaks = (doc: any): any => doc;
+export const normalizeParts = (parts: any[]): any[] => parts.flat();
+export const normalizeDoc = (doc: any): any => doc;
+export const cleanDoc = (doc: any): any => doc;
+export const canBreak = (doc: any): boolean => {
+	if (!doc) return false;
+	if (typeof doc === 'string') return false;
+	if (Array.isArray(doc)) return doc.some(canBreak);
+	if (doc.type === 'group' || doc.type === 'fill') return true;
+	return willBreak(doc);
+};
+
+export const Symbol_comments = Symbol.for("comments");
+
+export interface CustomOptions extends ParserOptions<Node> {
+	[Symbol_comments]: AnyComment[];
+	rsParsedFile: SourceFile;
+	commentSpans: Map<number, number>;
+	printer: Printer<Node>;
+	cursorNode: any;
+
+	comments: Comment[];
+	danglingAttributes: AttributeOrDocComment[];
+	actuallyMethodNodes: WeakSet<MemberExpression>;
+}
+
+export type NodeWithComments<T extends Node> = T & { comments: AnyComment[] };
+export interface MutatedComment extends Comment, PrettierCommentInfo {}
+export interface MutatedAttribute extends Attribute, PrettierCommentInfo {}
+export interface MutatedDocComment extends DocCommentAttribute, PrettierCommentInfo {}
+export type AnyComment = MutatedComment | MutatedAttribute | MutatedDocComment;
+
+type keyofDelimitedArrayProps<T> = T extends never ? never : keyof PickProps<T, LocArray<any, "()" | "[]" | "{}" | "<>">>;
+
+__DEV__: AssertTypesEq<keyof typeof DCM, keyofDelimitedArrayProps<Node>>();
+
+export enum DCM {
+	"arguments" = "arguments",
+	"parameters" = "parameters",
+	"items" = "items",
+	"properties" = "properties",
+	"members" = "members",
+	"body" = "body",
+	"cases" = "cases",
+	"typeArguments" = "typeArguments",
+	"ltParameters" = "ltParameters",
+	"generics" = "generics",
+	"specifiers" = "specifiers",
+	"rules" = "rules",
+	"match" = "match",
+	"transform" = "transform",
+	"segments" = "segments",
+}
+
+export interface PrettierCommentInfo {
+	trailing: boolean;
+	leading: boolean;
+	unignore: boolean;
+	printed: boolean;
+	placement: "ownLine" | "endOfLine" | "remaining";
+	// nodeDescription?: any;
+	marker?: DCM;
+}
+
+export interface AstPath<T = Node> {
+	stack: (Node | string | number)[];
+	callParent<R>(callback: (path: this) => R, count?: number): R;
+	getName(): PropertyKey | null;
+	getValue(): T;
+	getNode(count?: number): T | null;
+	getParentNode(count?: number): T | null;
+
+	match(...predicates: ((node: Node, name: string | null, number: number | null) => boolean)[]): boolean;
+
+	call<R>(callback: (path: AstPath, index: number, value: any) => R, ...props: (string | number)[]): R;
+	each(callback: (path: AstPath, index: number, value: any) => void, ...props: (string | number)[]): void;
+	map<R>(callback: (path: AstPath, index: number, value: any) => R, ...props: (string | number)[]): R[];
+}

frontend/src/common/prettier/plugins/rust/format/plugin.ts

@@ -0,0 +1,367 @@
+import { AttributeOrComment, IfBlockExpression, Node, Program, rs } from "jinx-rust";
+import {
+	ArrayProps,
+	BoolProps,
+	NodeProps,
+	end,
+	hasAttributes,
+	insertNodes,
+	is_Attribute,
+	is_AttributeOrComment,
+	is_BlockCommentKind,
+	is_BlockCommentNode,
+	is_Comment,
+	is_DocCommentAttribute,
+	is_ElseBlock,
+	is_LineCommentNode,
+	is_MacroInvocation,
+	is_MacroRule,
+	is_MissingNode,
+	is_Node,
+	is_PunctuationToken,
+	is_UnionPattern,
+	start,
+} from "jinx-rust/utils";
+import { getCommentChildNodes, isTransformed, transform_ast } from "../transform";
+import { Narrow, assert, color, each, exit, iLast, is_array, map_tagged_template, print_string } from "../utils/common";
+import {
+	CF,
+	escapeComments,
+	getComments,
+	handleEndOfLineComment,
+	handleOwnLineComment,
+	handleRemainingComment,
+	hasBreaklineAfter,
+	hasComment,
+	isDangling,
+	isPrettierIgnoreAttribute,
+	setDidPrintComment,
+	withComments,
+} from "./comments";
+import { withCheckContext } from "./complexity";
+import { isNoopExpressionStatement, maybeEmptyLine } from "./core";
+import { AstPath, CustomOptions, Doc, Plugin, Symbol_comments, group, hardline, indent, line, softline, ParserOptions } from "./external";
+import { printer } from "./printer";
+import { needsInnerParens, needsOuterSoftbreakParens, shouldPrintOuterAttributesAbove } from "./styling";
+
+export function is_printing_macro() {
+	return getContext().path.stack.some((node) => is_Node(node) && (is_MacroInvocation(node) || is_Attribute(node)));
+}
+
+export function assertPathAtNode(name: string, node: Node, ...ctx: any[]) {
+	__DEV__: if (getNode() !== node)
+		exit(`Attempted to call ${name}() in wrong prettier path context`, { asserted: node, actual: getNode() }, ...ctx);
+}
+
+export function f(...args: [strings: TemplateStringsArray, ...values: Doc[]]) {
+	let cancel = false;
+	const res = map_tagged_template(args, (doc) => {
+		cancel ||= !doc || (is_array(doc) && doc.length === 0);
+		return doc;
+	});
+	return cancel ? "" : res;
+}
+
+export function sg_single(s: TemplateStringsArray, v_0: Doc) {
+	return group([s[0], indent([softline, v_0]), softline, s[1]]);
+}
+export function sg_duo(s: TemplateStringsArray, v_0: Doc, v_1: Doc) {
+	return group([s[0], indent([softline, v_0, s[1], line, v_1]), softline, s[2]]);
+}
+
+let ctx: {
+	path: AstPath;
+	options: CustomOptions;
+	print: (path?: AstPath | string | [] | undefined, args?: any) => Doc;
+	args: any;
+};
+
+export const getNode = () => ctx.path.stack[ctx.path.stack.length - 1] as Node;
+export const stackIncludes = (x: Node | string | number) => ctx.path.stack.includes(x);
+export const getContext = () => ctx;
+export const getOptions = () => ctx.options;
+export const getProgram = () => ctx.options.rsParsedFile.program;
+export const getAllComments = () => ctx.options[Symbol_comments];
+export const getParentNode = (child?: Node) => {
+	__DEV__: if (child) assertPathAtNode("getParentNode", child);
+	return ctx.path.getParentNode();
+};
+export const getGrandParentNode = () => ctx.path.getParentNode(1) as Node;
+export const getPrintFn = <T extends Node>(forNode?: T | undefined): print<T> => {
+	__DEV__: if (forNode) assertPathAtNode("getPrintFn", forNode);
+	return print as print<T>;
+};
+
+const get = (property: keyof any) => getNode()[property];
+const has = (property: keyof any) => !!get(property);
+
+export function pathCall<T extends Node, K extends keyof NodeProps<T> & keyof T, R>(node: T, key: K, fn: (child: T[K]) => R): R {
+	return ctx.path.call(() => fn(getNode() as any), key as any);
+}
+
+export function pathCallEach<T extends Node, K extends AK<T>>(
+	node: T,
+	key: K, // @ts-expect-error
+	fn: (child: NonNullable<T[K]>[number], index: number) => void
+) {
+	__DEV__: assertPathAtNode("", node); // @ts-expect-error
+	ctx.path.each((_, i) => fn(getNode() as any, i), key);
+}
+
+export function pathCallAtParent<T extends Node, R>(parent: T, fn: (parent: T) => R): R {
+	return ctx.path.callParent(() => {
+		__DEV__: assertPathAtNode("pathCallParent", parent);
+		return fn(parent);
+	});
+}
+export function pathCallParentOf<T extends Node, R>(child: Node, fn: (parent: T) => R): R {
+	__DEV__: assertPathAtNode("pathCallParentOf", child);
+	return ctx.path.callParent((p) => fn(getNode() as any));
+}
+
+export function pathCallTopMostIfBlockExpression<R>(node: IfBlockExpression, fn: (node: IfBlockExpression) => R): R {
+	const parent = getParentNode(node)!;
+	return is_ElseBlock(node, parent) ? pathCallAtParent(parent, (parent) => pathCallTopMostIfBlockExpression(parent, fn)) : fn(node);
+}
+
+function print(property?: any, args?: any): Doc | Doc[] {
+	if (!property) return ctx.print(undefined!, args);
+	if (Array.isArray(property)) return ctx.print(property as any, args);
+	const value = get(property);
+	return !!value ? (Array.isArray(value) ? ctx.path.map(ctx.print, property) : ctx.print(property, args)) : "";
+}
+
+namespace print {
+	export function b(property: string, res = `${property} `): Doc {
+		return has(property) ? res : "";
+	}
+	export function map(property: string, mapItem?: MapFn<any, any>): Doc[] {
+		return !has(property) ? [] : ctx.path.map(mapItem ? (p, i, a) => mapItem(a[i], i, a) : () => ctx.print(), property);
+	}
+	export function join(property: string, sep: SepFn<any, any> | Doc, trailingSep: TrailingSepFn<any, any> | Doc = ""): Doc[] {
+		return map_join(property, () => ctx.print(), sep, trailingSep);
+	}
+	export function map_join(
+		property: string,
+		mapFn: MapFn<any, any>,
+		sep: SepFn<any, any> | Doc,
+		sepTrailing: TrailingSepFn<any, any> | Doc = ""
+	) {
+		const sepFn = typeof sep === "function" ? sep : () => sep;
+		return map(property, (v, i, a) => [
+			mapFn(v, i, a),
+			iLast(i, a as any)
+				? typeof sepTrailing === "function"
+					? sepTrailing(v)
+					: sepTrailing
+				: sepFn(v, a[i + 1], i === 0 ? undefined : a[i - 1]),
+		]);
+	}
+}
+
+// prettier-ignore
+type SepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number], next_item: A[number], prev_item: A[number] | undefined) => Doc;
+type MapFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number], index: number, arr: A) => Doc;
+type TrailingSepFn<T extends Node = Node, K extends AK<T> = AK<T>> = <A extends AV<T, K>>(item: A[number]) => Doc;
+type AV<T extends Node, K extends keyof T> = Extract<NonNullable<T[K]>, ReadonlyArray<unknown>>;
+type AK<T extends Node> = keyof ArrayProps<T> & keyof T;
+// type AK<T extends Node> = keyof PickProps<T, {nodeType:number}|{nodeType:number}[]> & keyof T;
+
+export interface print<T extends Node> {
+	(property?: [], args?: any): Doc;
+	(property?: [AK<T>, number], args?: any): Doc;
+	(property?: AK<T>, args?: any): Doc[];
+	// (property?: T extends {rules:{nodeType:number}|{nodeType:number}[]} ? "rules" : never, args?: any): Doc[];
+	(property?: keyof NodeProps<T> & keyof T, args?: any): Doc;
+	b(property: keyof BoolProps<T>, res?: string): Doc;
+	map<K extends AK<T>>(property: K & keyof ArrayProps<T>, mapFn?: MapFn<T, K>): Doc[];
+	join<K extends AK<T>>(property: K, sep: SepFn<T, K> | Doc, trailingSep?: TrailingSepFn<T, K> | Doc): Doc[];
+	map_join<K extends AK<T>>(property: K, mapFn: MapFn<T, K>, sep: SepFn<T, K> | Doc, trailingSep?: TrailingSepFn<T, K> | Doc): Doc[];
+}
+
+function genericPrint() {
+	return withCheckContext(() => {
+		const node = getNode();
+		__DEV__: assert(node.nodeType in printer);
+
+		let printed: Doc = hasPrettierIgnore(node) //
+			? node.loc.getOwnText()
+			: printer[node.nodeType]!(print as any, node as never);
+
+		const inner_parens = needsInnerParens(node);
+
+		if (inner_parens) {
+			printed = group(["(", printed, ")"]);
+		}
+
+		if (hasAttributes(node)) {
+			const print_above = shouldPrintOuterAttributesAbove(node); /*  || node.attributes.length > 1 */
+			printed = [
+				...print.join(
+					"attributes",
+					(attr) =>
+						print_above
+							? maybeEmptyLine(attr)
+							: is_LineCommentNode(attr) || (is_BlockCommentNode(attr) && hasBreaklineAfter(attr))
+							? hardline
+							: " ",
+					(attr) =>
+						print_above && is_DocCommentAttribute(attr)
+							? maybeEmptyLine(attr)
+							: print_above || is_LineCommentNode(attr) || (is_BlockCommentNode(attr) && hasBreaklineAfter(attr))
+							? hardline
+							: " "
+				),
+				printed,
+			];
+		}
+
+		printed = withComments(
+			node,
+			printed,
+			hasPrettierIgnore(node) || ((is_Attribute(node) || is_MacroInvocation(node)) && !isTransformed(node))
+				? escapeComments(0, (comment) => node.loc.ownContains(comment))
+				: is_MacroRule(node)
+				? escapeComments(0, (comment) => node.transform.loc.contains(comment))
+				: is_UnionPattern(getParentNode() ?? ({ nodeType: 0 } as any))
+				? new Set(getComments(node, CF.Leading | CF.Trailing, (comment) => !isDangling(comment)))
+				: undefined
+		);
+
+		if (!inner_parens && needsOuterSoftbreakParens(node)) {
+			printed = [group(["(", indent([softline, printed]), softline, ")"])];
+		}
+
+		return printed;
+	});
+
+	function hasPrettierIgnore(node: Node) {
+		return (
+			(node as any).prettierIgnore ||
+			hasComment(node, CF.PrettierIgnore) ||
+			(hasAttributes(node) && node.attributes.some(isPrettierIgnoreAttribute))
+		);
+	}
+}
+
+export function canAttachComment(n: Node) {
+	return !is_Comment(n) && !isNoopExpressionStatement(n) && !is_MissingNode(n) && !is_PunctuationToken(n);
+}
+
+export const plugin: Plugin<Node> = {
+	languages: [
+		{
+			name: "Rust",
+			aliases: ["rs"],
+			parsers: ["jinx-rust"],
+			extensions: [".rs", ".rs.in"],
+			linguistLanguageId: 327,
+			vscodeLanguageIds: ["rust"],
+			tmScope: "source.rust",
+			aceMode: "rust",
+			codemirrorMode: "rust",
+			codemirrorMimeType: "text/x-rustsrc",
+		},
+	],
+	parsers: {
+		"jinx-rust": {
+			astFormat: "jinx-rust",
+			locStart: start,
+			locEnd: end,
+			parse(code: string, options: ParserOptions<Node> & Partial<CustomOptions>) {
+				const customOptions = options as CustomOptions;
+				ctx = { options: customOptions } as any;
+
+				customOptions.rsParsedFile = rs.parseFile((customOptions.originalText = code), { filepath: customOptions.filepath });
+
+				customOptions.actuallyMethodNodes = new WeakSet();
+				customOptions.danglingAttributes = [];
+				customOptions.comments = [];
+
+				transform_ast(customOptions);
+
+				const comments: AttributeOrComment[] = [];
+				insertNodes(comments, customOptions.comments);
+				insertNodes(comments, customOptions.danglingAttributes);
+
+				// @ts-expect-error
+				customOptions.rsParsedFile.program.comments = comments;
+
+				customOptions.commentSpans = new Map(comments.map((n) => [start(n), end(n)]));
+
+				return customOptions.rsParsedFile.program;
+			},
+		},
+	},
+	printers: {
+		"jinx-rust": {
+			preprocess: (node: Node) => (node as Program).loc?.src || node,
+			print(path, options, print, args) {
+				if (path.stack.length === 1) {
+					__DEV__: Narrow<CustomOptions>(options);
+					ctx = { path, options, print: print as any, args };
+					try {
+						const printed = genericPrint();
+						__DEV__: devEndCheck(printed);
+						return printed;
+					} finally {
+						ctx = undefined!;
+					}
+				} else if (args || ctx.args) {
+					const prev_args = ctx.args;
+					try {
+						ctx.args = args;
+						return genericPrint();
+					} finally {
+						ctx.args = prev_args;
+					}
+				} else {
+					return genericPrint();
+				}
+			},
+			hasPrettierIgnore: () => false,
+			willPrintOwnComments: () => true,
+			isBlockComment: (node: Node): boolean => {
+				return is_AttributeOrComment(node) && is_BlockCommentKind(node as any);
+			},
+			canAttachComment: canAttachComment,
+			getCommentChildNodes: getCommentChildNodes,
+			printComment: genericPrint,
+			handleComments: {
+				// @ts-expect-error
+				avoidAstMutation: true,
+				ownLine: handleOwnLineComment,
+				endOfLine: handleEndOfLineComment,
+				remaining: handleRemainingComment,
+			},
+		},
+	},
+	options: {},
+	defaultOptions: {
+		// default prettier (2)  -> rustfmt (4)
+		tabWidth: 4,
+		// default prettier (80) -> rustfmt (100)
+		printWidth: 100,
+	},
+};
+
+function devEndCheck(printed: Doc) {
+	let first = false;
+	const comments = getAllComments();
+	each(comments, (comment, index) => {
+		if (!comment.printed) {
+			if (!first) (first = true), console.log(color.red(`Unprinted comments:`));
+			const len = 40;
+			const msg =
+				color.magenta(
+					(comment.marker ? `Dangling "${comment.marker}" ` : "") +
+						(is_Attribute(comment) ? "Attribute " : is_DocCommentAttribute(comment) ? "DocCommentAttribute" : "Comment") +
+						` ${index}/${comments.length}` +
+						color.yellow(` ${print_string(comment.loc.sliceText(0, len))}${comment.loc.len() > len ? " ..." : ""}`)
+				) + color.grey(`\n    at ${comment.loc.url()}`);
+			if (globalThis.TESTS_FORMAT_DEV) exit(msg);
+			else console.log(msg);
+			setDidPrintComment(comment);
+		}
+	});
+}

frontend/src/common/prettier/plugins/rust/format/printer.ts

@@ -0,0 +1,719 @@
+import { DelimKind, Node, NodeType, NTMap } from "jinx-rust";
+import {
+	getDelimChars,
+	hasSuffix,
+	is_ArrayOrTupleLiteral,
+	is_BlockExpression,
+	is_ClosureFunctionExpression,
+	is_Identifier,
+	is_IfBlockExpression,
+	is_LiteralNumberLike,
+	is_StructLiteral,
+	start,
+} from "jinx-rust/utils";
+import {
+	BlockLikeMacroInvocation,
+	CallLikeMacroInvocation,
+	is_BlockLikeMacroInvocation,
+	is_CallLikeMacroInvocation,
+	isTransformed,
+} from "../transform";
+import { exit } from "../utils/common";
+import { hasComment, print_comment } from "./comments";
+import { isSimpleType } from "./complexity";
+import {
+	adjustClause,
+	parenthesize_if_break,
+	printAnnotatedPattern,
+	printArrayLike,
+	printArrowFunction,
+	printAssignment,
+	printBinaryishExpression,
+	printBlockBody,
+	printBodyOrCases,
+	printCallArguments,
+	printCallExpression,
+	printCondition,
+	printDanglingCommentsForInline,
+	printDeclarationTypeBounds,
+	printEnumBody,
+	printFlowControlExpression,
+	printGenerics_x_whereBounds,
+	printIfBlock,
+	printIfBlockCondition,
+	printImplTraitForType,
+	printLtBounds,
+	printLtParameters,
+	printMacroRules,
+	printMaybeBlockBody,
+	printMemberExpression,
+	printNumber,
+	printObject,
+	printParametersAndReturnType,
+	printRuleMatch,
+	printRuleTransform,
+	printTypeAnnotation,
+	printTypeArguments,
+	printTypeBounds,
+	printUnaryExpression,
+	printUnionPattern,
+} from "./core";
+import { DCM, Doc, group, hardline, ifBreak, indent, join, line, softline, willBreak } from "./external";
+import { f, getOptions, getParentNode, pathCall, sg_duo, sg_single, type print } from "./plugin";
+import { needsParens, stmtNeedsSemi } from "./styling";
+
+type nPrint<T extends Node> = (print: print<T>, node: T) => Doc | never;
+
+export const printer: { [K in NodeType]: nPrint<Extract<NTMap[K], Node>> } = {
+	[NodeType.MissingNode](print, node) {
+		return "";
+	},
+	[NodeType.SourceFile](print, node) {
+		return [
+			print.b("UTF8BOM", "\uFEFF"), //
+			print("shebang"),
+			print("program"),
+		];
+	},
+	[NodeType.Shebang](print, node) {
+		return [`#!${node.value}`, hardline];
+	},
+	[NodeType.Program](print, node) {
+		return printBodyOrCases(print, node);
+	},
+	[NodeType.Snippet](print, node) {
+		exit.never();
+	},
+	[NodeType.Identifier](print, node) {
+		return node.name;
+	},
+	[NodeType.Index](print, node) {
+		return node.name;
+	},
+	[NodeType.LbIdentifier](print, node) {
+		return node.name;
+	},
+	[NodeType.McIdentifier](print, node) {
+		return node.name;
+	},
+	[NodeType.LtIdentifier](print, node) {
+		return node.name;
+	},
+	[NodeType.PunctuationToken](print, node) {
+		return node.token;
+	},
+	[NodeType.DelimGroup](print, node) {
+		return node.loc.getOwnText();
+	},
+	[NodeType.Literal](print, node) {
+		let { value } = node;
+		if (is_LiteralNumberLike(node)) value = printNumber(value);
+		return hasSuffix(node) ? [value, print("suffix")] : value;
+	},
+	[NodeType.ItemPath](print, node) {
+		return [print("namespace"), "::", print("segment")];
+	},
+	[NodeType.ExpressionPath](print, node) {
+		return [print("namespace"), "::", print("segment")];
+	},
+	[NodeType.TypePath](print, node) {
+		return [print("namespace"), "::", print("segment")];
+	},
+	[NodeType.Comment](print, node) {
+		return print_comment(node);
+	},
+	[NodeType.DocCommentAttribute](print, node) {
+		return print_comment(node);
+	},
+	[NodeType.Attribute](print, node) {
+		return [
+			node.inner ? "#![" : "#[",
+			isTransformed(node)
+				? [print("segments"), printDanglingCommentsForInline(node)] //
+				: node.segments.loc.sliceText(1, -1).trim(),
+			"]",
+		];
+	},
+	[NodeType.MacroInvocation](print, node) {
+		const hasCurlyBrackets = node.segments.dk === DelimKind["{}"];
+		const delim = getDelimChars(node.segments);
+		if (node.segments.length === 0) {
+			return [print("callee"), "!", hasCurlyBrackets ? " " : "", delim.left, printDanglingCommentsForInline(node), delim.right];
+		}
+		if (isTransformed(node)) {
+			if (is_CallLikeMacroInvocation(node)) {
+				return [print("callee"), "!", printCallArguments(print as print<CallLikeMacroInvocation>, node)];
+			}
+			if (is_BlockLikeMacroInvocation(node)) {
+				return [print("callee"), "!", " ", printBlockBody(print as print<BlockLikeMacroInvocation>, node)];
+			}
+		}
+		let content = node.segments.loc.sliceText(1, -1);
+		if (content.trim().length === 0) {
+			content = "";
+		} else if (!content.includes("\n")) {
+			content = content.trim();
+			if (hasCurlyBrackets) content = " " + content + " ";
+		}
+		return [print("callee"), "!", hasCurlyBrackets ? " " : "", delim.left, content, delim.right];
+	},
+	[NodeType.MacroRulesDeclaration](print, node) {
+		return ["macro_rules! ", print("id"), printMacroRules(print, node)];
+	},
+	[NodeType.MacroRuleDeclaration](print, node) {
+		return [printRuleMatch(print, node), " => ", printRuleTransform(print, node), ";"];
+	},
+	[NodeType.MacroDeclaration](print, node) {
+		return [print("pub"), "macro ", print("id"), printMacroRules(print, node)];
+	},
+	[NodeType.MacroInlineRuleDeclaration](print, node) {
+		return [printRuleMatch(print, node), " ", printRuleTransform(print, node)];
+	},
+	[NodeType.MacroGroup](print, node) {
+		return node.loc.getOwnText();
+	},
+	[NodeType.MacroParameterDeclaration](print, node) {
+		return [print("id"), ":", print("ty")];
+	},
+	[NodeType.PubSpecifier](print, node) {
+		if (!node.location) return "pub ";
+		if (is_Identifier(node.location)) {
+			switch (node.location.name) {
+				case "crate":
+					if (start(node) === start(node.location)) {
+						return "crate ";
+					} else {
+						return ["pub(", print("location"), ") "];
+					}
+				case "self":
+				case "super":
+					return ["pub(", print("location"), ") "];
+			}
+		}
+		return ["pub(in ", print("location"), ") "];
+	},
+	[NodeType.ExternSpecifier](print, node) {
+		return ["extern ", f`${print("abi")} `];
+	},
+	[NodeType.ExpressionStatement](print, node) {
+		return [print("expression"), stmtNeedsSemi(node) ? ";" : ""];
+	},
+	[NodeType.UseStatement](print, node) {
+		return [print("pub"), "use ", print("import"), ";"];
+	},
+	[NodeType.DestructuredImport](print, node) {
+		if (node.specifiers.length === 0) return [print("source"), "::{", printDanglingCommentsForInline(node, DCM["specifiers"]), "}"];
+		let space = true;
+		__DEV__: if (globalThis.TESTS_FORMAT_DEV) space = false;
+		return [
+			print("source"),
+			group([
+				"::{",
+				indent([space ? line : softline, join([",", line], print("specifiers")), ifBreak(",")]),
+				space ? line : softline,
+				"}",
+			]),
+		];
+	},
+	[NodeType.AmbientImport](print, node) {
+		return f`${print("source")}::*` || "*";
+	},
+	[NodeType.AnonymousImport](print, node) {
+		return [print("source"), " as ", "_"];
+	},
+	[NodeType.NamedImport](print, node) {
+		return [print("source"), f` as ${print("local")}`];
+	},
+	[NodeType.ExternCrateStatement](print, node) {
+		return [print("pub"), "extern crate ", print("import"), ";"];
+	},
+	[NodeType.TypeAliasDeclaration](print, node) {
+		return [
+			print("pub"),
+			"type",
+			printAssignment(
+				printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, ":")), //
+				" =",
+				"typeExpression"
+			),
+			";",
+		];
+	},
+	[NodeType.LetVariableDeclaration](print, node) {
+		return [
+			"let ",
+			printAssignment(
+				printAnnotatedPattern(print, node), //
+				" =",
+				"expression"
+			),
+			f` else ${print("else")}`,
+			";",
+		];
+	},
+	[NodeType.ConstVariableDeclaration](print, node) {
+		return [
+			print("pub"),
+			"const ",
+			printAssignment(
+				printAnnotatedPattern(print, node), //
+				" =",
+				"expression"
+			),
+			";",
+		];
+	},
+	[NodeType.StaticVariableDeclaration](print, node) {
+		return [
+			print("pub"),
+			"static ",
+			printAssignment(
+				printAnnotatedPattern(print, node), //
+				" =",
+				"expression"
+			),
+			";",
+		];
+	},
+	[NodeType.ModuleDeclaration](print, node) {
+		return [
+			print("pub"), //
+			print.b("unsafe"),
+			"mod ",
+			print("id"),
+			printMaybeBlockBody(print, node),
+		];
+	},
+	[NodeType.ExternBlockDeclaration](print, node) {
+		return [
+			print("pub"), //
+			print.b("unsafe"),
+			"extern ",
+			f`${print("abi")} `,
+			printBlockBody(print, node),
+		];
+	},
+	[NodeType.FunctionDeclaration](print, node) {
+		return [
+			print("pub"),
+			print.b("const"),
+			print.b("async"),
+			print.b("unsafe"),
+			print("extern"),
+			"fn",
+			printGenerics_x_whereBounds(print, node, printParametersAndReturnType(node)),
+			printMaybeBlockBody(print, node),
+		];
+	},
+	[NodeType.FunctionSelfParameterDeclaration](print, node) {
+		return group([print.b("ref", "&"), f`${print("lt")} `, print.b("mut"), "self", printTypeAnnotation(print, node)]);
+	},
+	[NodeType.FunctionParameterDeclaration](print, node) {
+		return group(printAnnotatedPattern(print, node));
+	},
+	[NodeType.FunctionSpread](print, node) {
+		return "...";
+	},
+	[NodeType.StructDeclaration](print, node) {
+		return [print("pub"), "struct", printGenerics_x_whereBounds(print, node, ""), printObject(print, node)];
+	},
+	[NodeType.StructPropertyDeclaration](print, node) {
+		return [print("pub"), print("id"), printTypeAnnotation(print, node)];
+	},
+	[NodeType.TupleStructDeclaration](print, node) {
+		return [print("pub"), "struct", printGenerics_x_whereBounds(print, node, printArrayLike(print, node)), ";"];
+	},
+	[NodeType.TupleStructItemDeclaration](print, node) {
+		return [print("pub"), print("typeAnnotation")];
+	},
+	[NodeType.UnionDeclaration](print, node) {
+		return [print("pub"), "union", printGenerics_x_whereBounds(print, node, ""), printObject(print, node)];
+	},
+	[NodeType.EnumDeclaration](print, node) {
+		return [print("pub"), "enum", printGenerics_x_whereBounds(print, node, ""), printEnumBody(print, node)];
+	},
+	[NodeType.EnumMemberDeclaration](print, node) {
+		return [
+			print("pub"),
+			printAssignment(
+				print("id"), //
+				" =",
+				"value"
+			),
+		];
+	},
+	[NodeType.EnumMemberTupleDeclaration](print, node) {
+		return [
+			print("pub"),
+			printAssignment(
+				[print("id"), printArrayLike(print, node)], //
+				" =",
+				"value"
+			),
+		];
+	},
+	[NodeType.EnumMemberStructDeclaration](print, node) {
+		return [
+			print("pub"),
+			printAssignment(
+				[print("id"), printObject(print, node)], //
+				" =",
+				"value"
+			),
+		];
+	},
+	[NodeType.TraitDeclaration](print, node) {
+		return [
+			print("pub"),
+			print.b("unsafe"),
+			"trait",
+			printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, ":")),
+			adjustClause(node, printBlockBody(print, node)),
+		];
+	},
+	[NodeType.AutoTraitDeclaration](print, node) {
+		return [
+			print("pub"),
+			print.b("unsafe"),
+			"auto trait ",
+			print("id"),
+			" ",
+			printBlockBody(print, node as any), // see "transform.ts"
+		];
+	},
+	[NodeType.TraitAliasDeclaration](print, node) {
+		return [
+			print("pub"),
+			print.b("unsafe"),
+			"trait",
+			printGenerics_x_whereBounds(print, node, printDeclarationTypeBounds(print, node, " =")),
+			";",
+		];
+	},
+	[NodeType.ImplDeclaration](print, node) {
+		return [
+			print("pub"),
+			print.b("unsafe"),
+			"impl",
+			printGenerics_x_whereBounds(print, node, [print.b("const"), printImplTraitForType(print, node)]),
+			adjustClause(node, printBlockBody(print, node)),
+		];
+	},
+	[NodeType.NegativeImplDeclaration](print, node) {
+		return [
+			print("pub"),
+			"impl",
+			printGenerics_x_whereBounds(print, node, ["!", printImplTraitForType(print, node)]),
+			" ",
+			printBlockBody(print, node as any), // see "transform.ts"
+		];
+	},
+	[NodeType.ExpressionTypeSelector](print, node) {
+		return group(["<", print("typeTarget"), f` as ${print("typeExpression")}`, ">"]);
+	},
+	[NodeType.ExpressionTypeCast](print, node) {
+		return [print("typeCallee"), f`::${printTypeArguments(print, node)}`];
+	},
+	[NodeType.ExpressionAsTypeCast](print, node) {
+		return [print("expression"), " as ", print("typeExpression")];
+	},
+	[NodeType.ReturnExpression](print, node) {
+		return ["return", printFlowControlExpression(print, node)];
+	},
+	[NodeType.BreakExpression](print, node) {
+		return ["break", f` ${print("label")}`, printFlowControlExpression(print, node)];
+	},
+	[NodeType.ContinueExpression](print, node) {
+		return ["continue", f` ${print("label")}`];
+	},
+	[NodeType.YieldExpression](print, node) {
+		return ["yield", printFlowControlExpression(print, node)];
+	},
+	[NodeType.RangeLiteral](print, node) {
+		return [print("lower"), "..", print.b("last", "="), print("upper")];
+	},
+	[NodeType.CallExpression](print, node) {
+		return printCallExpression(print, node);
+	},
+	[NodeType.MemberExpression](print, node) {
+		return printMemberExpression(print, node);
+	},
+	[NodeType.AwaitExpression](print, node) {
+		return [print("expression"), ".await"];
+	},
+	[NodeType.UnwrapExpression](print, node) {
+		return [print("expression"), "?"];
+	},
+	[NodeType.ParenthesizedExpression](print, node) {
+		exit.never();
+		const shouldHug = !hasComment(node.expression) && (is_ArrayOrTupleLiteral(node.expression) || is_StructLiteral(node.expression));
+		if (shouldHug) return ["(", print("expression"), ")"];
+		return group(["(", indent([softline, print("expression")]), softline, ")"]);
+	},
+	[NodeType.MinusExpression](print, node) {
+		return printUnaryExpression("-", node);
+	},
+	[NodeType.NotExpression](print, node) {
+		return printUnaryExpression("!", node);
+	},
+	[NodeType.OrExpression](print, node) {
+		return printBinaryishExpression(print, node);
+	},
+	[NodeType.AndExpression](print, node) {
+		return printBinaryishExpression(print, node);
+	},
+	[NodeType.ReassignmentExpression](print, node) {
+		return printAssignment(print("left"), " =", "right");
+	},
+	[NodeType.UnassignedExpression](print, node) {
+		return "_";
+	},
+	[NodeType.OperationExpression](print, node) {
+		return printBinaryishExpression(print, node);
+	},
+	[NodeType.ReassignmentOperationExpression](print, node) {
+		return printAssignment(print("left"), " " + node.kind, "right");
+	},
+	[NodeType.ComparisonExpression](print, node) {
+		return printBinaryishExpression(print, node);
+	},
+	[NodeType.LetScrutinee](print, node) {
+		return ["let ", printAssignment(print("pattern"), " =", "expression")];
+	},
+	[NodeType.ClosureFunctionExpression](print, node) {
+		return printArrowFunction(print, node);
+	},
+	[NodeType.ClosureFunctionParameterDeclaration](print, node) {
+		return group(printAnnotatedPattern(print, node));
+	},
+	[NodeType.BlockExpression](print, node) {
+		return [
+			f`${print("label")}: `,
+			print.b("const"),
+			print.b("async"),
+			print.b("move"),
+			print.b("unsafe"),
+			printBlockBody(print, node),
+		];
+	},
+	[NodeType.LoopBlockExpression](print, node) {
+		return [f`${print("label")}: `, "loop ", printBlockBody(print, node)];
+	},
+	[NodeType.WhileBlockExpression](print, node) {
+		return [f`${print("label")}: `, "while ", printCondition(print, node), printBlockBody(print, node)];
+	},
+	[NodeType.ForInBlockExpression](print, node) {
+		return [f`${print("label")}: `, "for ", print("pattern"), " in ", print("expression"), " ", printBlockBody(print, node)];
+	},
+	[NodeType.IfBlockExpression](print, node) {
+		return [f`${print("label")}: `, printIfBlock(print, node)];
+	},
+	[NodeType.TryBlockExpression](print, node) {
+		return [f`${print("label")}: `, "try ", printBlockBody(print, node)];
+	},
+	[NodeType.MatchExpression](print, node) {
+		const id = Symbol("match");
+		const expr = print("expression");
+		const needs_parens = pathCall(node, "expression", needsParens);
+
+		let printed: Doc = [
+			f`${print("label")}: `,
+			"match ",
+			needs_parens ? expr : group([indent([softline, expr]), softline], { id }),
+			needs_parens ? " " : !willBreak(expr) ? ifBreak("", " ", { groupId: id }) : "" /*  ifBreak("", " ", { groupId: id }) */,
+			printBlockBody(print, node),
+		];
+
+		const parent = getParentNode()!;
+		if (is_ClosureFunctionExpression(parent) && parent.expression === node) {
+			printed = parenthesize_if_break([indent([softline, printed]), softline]);
+		}
+		return printed;
+	},
+	[NodeType.MatchExpressionCase](print, node) {
+		return group([
+			group(print("pattern")),
+			" ",
+			printIfBlockCondition(print, node),
+			"=>", //
+			(is_BlockExpression(node.expression) || is_IfBlockExpression(node.expression)) &&
+			!hasComment(node.expression, 0, (comment) => getOptions().danglingAttributes.includes(comment as any))
+				? [" ", print("expression")]
+				: group(indent([line, print("expression")])),
+		]);
+		return printAssignment(
+			[print("pattern"), " ", printIfBlockCondition(print, node)], //
+			"=>",
+			"expression"
+		);
+		return [print("pattern"), " ", printIfBlockCondition(print, node)];
+	},
+	[NodeType.StructLiteral](print, node) {
+		return [print("struct"), printObject(print, node)];
+	},
+	[NodeType.StructLiteralPropertyShorthand](print, node) {
+		return print("value");
+	},
+	[NodeType.StructLiteralProperty](print, node) {
+		return [print("key"), ": ", print("value")];
+	},
+	[NodeType.StructLiteralPropertySpread](print, node) {
+		return ["..", print("expression")];
+	},
+	[NodeType.StructLiteralRestUnassigned](print, node) {
+		return "..";
+	},
+	[NodeType.ArrayLiteral](print, node) {
+		return printArrayLike(print, node);
+	},
+	[NodeType.SizedArrayLiteral](print, node) {
+		return sg_duo`[${print("initExpression")};${print("sizeExpression")}]`;
+	},
+	[NodeType.TupleLiteral](print, node) {
+		return printArrayLike(print, node);
+	},
+	[NodeType.ReferenceExpression](print, node) {
+		return printUnaryExpression(["&", print.b("mut")], node);
+	},
+	[NodeType.RawReferenceExpression](print, node) {
+		return printUnaryExpression(`&raw ${node.kind} `, node);
+	},
+	[NodeType.DereferenceExpression](print, node) {
+		return printUnaryExpression("*", node);
+	},
+	[NodeType.BoxExpression](print, node) {
+		return printUnaryExpression("box ", node);
+	},
+	[NodeType.UnionPattern](print, node) {
+		return printUnionPattern(print, node);
+	},
+	[NodeType.ParenthesizedPattern](print, node) {
+		exit.never();
+		return sg_single`(${print("pattern")})`;
+	},
+	[NodeType.RestPattern](print, node) {
+		return "..";
+	},
+	[NodeType.WildcardPattern](print, node) {
+		return "_";
+	},
+	[NodeType.PatternVariableDeclaration](print, node) {
+		return [print.b("ref"), print.b("mut"), printAssignment(print("id"), " @", "pattern")];
+	},
+	[NodeType.StructPattern](print, node) {
+		return [print("struct"), printObject(print, node)];
+	},
+	[NodeType.StructPatternPropertyDestructured](print, node) {
+		return [print("key"), ": ", print("pattern")];
+	},
+	[NodeType.StructPatternPropertyShorthand](print, node) {
+		return [print.b("box"), print.b("ref"), print.b("mut"), print("id")];
+	},
+	[NodeType.TuplePattern](print, node) {
+		return [print("struct"), printArrayLike(print, node)];
+	},
+	[NodeType.ArrayPattern](print, node) {
+		return printArrayLike(print, node);
+	},
+	[NodeType.ReferencePattern](print, node) {
+		return ["&", print.b("mut"), print("pattern")];
+	},
+	[NodeType.BoxPattern](print, node) {
+		return ["box ", print("pattern")];
+	},
+	[NodeType.MinusPattern](print, node) {
+		return ["-", print("pattern")];
+	},
+	[NodeType.RangePattern](print, node) {
+		return [print("lower"), "..", print.b("last", "="), print("upper")];
+	},
+	[NodeType.TypeCall](print, node) {
+		return [print("typeCallee"), printTypeArguments(print, node)];
+	},
+	[NodeType.TypeCallNamedArgument](print, node) {
+		return printAssignment(print("target"), " =", "typeExpression");
+	},
+	[NodeType.TypeCallNamedBound](print, node) {
+		return [print("typeTarget"), printTypeBounds(":", print, node)];
+	},
+	[NodeType.LtElided](print, node) {
+		return "'_";
+	},
+	[NodeType.LtStatic](print, node) {
+		return "'static";
+	},
+	[NodeType.TypeNever](print, node) {
+		return "!";
+	},
+	[NodeType.TypeInferred](print, node) {
+		return "_";
+	},
+	[NodeType.GenericTypeParameterDeclaration](print, node) {
+		return printAssignment(
+			[print("id"), printTypeBounds(":", print, node)], //
+			" =",
+			"typeDefault"
+		);
+	},
+	[NodeType.ConstTypeParameterDeclaration](print, node) {
+		return [
+			"const ",
+			printAssignment(
+				[print("id"), printTypeAnnotation(print, node)], //
+				" =",
+				"typeDefault"
+			),
+		];
+	},
+	[NodeType.GenericLtParameterDeclaration](print, node) {
+		return [print("id"), printLtBounds(":", print, node)];
+	},
+	[NodeType.WhereTypeBoundDeclaration](print, node) {
+		return [printLtParameters(print, node), print("typeTarget"), printTypeBounds(":", print, node)];
+	},
+	[NodeType.WhereLtBoundDeclaration](print, node) {
+		return [print("ltTarget"), printLtBounds(":", print, node)];
+	},
+	[NodeType.TypeTraitBound](print, node) {
+		return [print.b("maybeConst", "~const "), print.b("optional", "?"), printLtParameters(print, node), print("typeExpression")];
+	},
+	[NodeType.TypeDynBounds](print, node) {
+		return printTypeBounds("dyn", print, node);
+	},
+	[NodeType.TypeImplBounds](print, node) {
+		return printTypeBounds("impl", print, node);
+	},
+	[NodeType.TypeFnPointer](print, node) {
+		return [printLtParameters(print, node), print.b("unsafe"), print("extern"), "fn", printParametersAndReturnType(node)];
+	},
+	[NodeType.TypeFnPointerParameter](print, node) {
+		return [f`${print("id")}: `, print("typeAnnotation")];
+	},
+	[NodeType.TypeFunction](print, node) {
+		return [print("callee"), printParametersAndReturnType(node)];
+	},
+	[NodeType.TypeTuple](print, node) {
+		return printArrayLike(print, node);
+	},
+	[NodeType.TypeSizedArray](print, node) {
+		return sg_duo`[${print("typeExpression")};${print("sizeExpression")}]`;
+		if (isSimpleType(node)) return ["[", print("typeExpression"), "; ", print("sizeExpression"), "]"];
+	},
+	[NodeType.TypeSlice](print, node) {
+		if (isSimpleType(node)) return ["[", print("typeExpression"), "]"];
+		return sg_single`[${print("typeExpression")}]`;
+	},
+	[NodeType.TypeReference](print, node) {
+		return ["&", f`${print("lt")} `, print.b("mut"), print("typeExpression")];
+	},
+	[NodeType.TypeDereferenceConst](print, node) {
+		return ["*const ", print("typeExpression")];
+	},
+	[NodeType.TypeDereferenceMut](print, node) {
+		return ["*mut ", print("typeExpression")];
+	},
+	[NodeType.TypeParenthesized](print, node) {
+		exit.never();
+		return sg_single`(${print("typeExpression")})`;
+	},
+};

frontend/src/common/prettier/plugins/rust/format/styling.ts

@@ -0,0 +1,645 @@
+import {
+	ClosureFunctionExpression,
+	ComparisonExpression,
+	ConditionExpression,
+	EnumDeclaration,
+	EnumMemberStructDeclaration,
+	ExpressionAsTypeCast,
+	ExpressionNode,
+	ExpressionStatement,
+	ExpressionWithBody,
+	LeftRightExpression,
+	LogicalExpression,
+	MacroDeclaration,
+	MacroRulesDeclaration,
+	MissingNode,
+	Node,
+	NodeType,
+	NodeWithBody,
+	NodeWithBodyOrCases,
+	OperationExpression,
+	PRCD,
+	StructDeclaration,
+	StructLiteral,
+	StructPattern,
+	TK,
+	UnionDeclaration,
+} from "jinx-rust";
+import {
+	can_have_OuterAttributes,
+	getAstPath,
+	getPrecedence,
+	hasAttributes,
+	hasBody,
+	hasCondition,
+	hasItems,
+	hasLetScrutineeCondition,
+	hasOuterAttributes,
+	hasProperties,
+	is_Attribute,
+	is_AttributeOrDocComment,
+	is_AwaitExpression,
+	is_BitwiseOperator,
+	is_CallExpression,
+	is_ClosureFunctionExpression,
+	is_ComparisonExpression,
+	is_DocCommentAttribute,
+	is_ElseBlock,
+	is_EnumMemberDeclaration,
+	is_EqualityOperator,
+	is_ExpressionAsTypeCast,
+	is_ExpressionStatement,
+	is_ExpressionWithBody,
+	is_ExpressionWithBodyOrCases,
+	is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation,
+	is_FlowControlExpression,
+	is_FlowControlMaybeValueExpression,
+	is_ForInBlockExpression,
+	is_Identifier,
+	is_IfBlockExpression,
+	is_ImplicitReturnAbleNode,
+	is_LeftRightExpression,
+	is_LetScrutinee,
+	is_Literal,
+	is_LiteralNumberLike,
+	is_LogicalExpression,
+	is_LoopBlockExpression,
+	is_MatchExpression,
+	is_MatchExpressionCase,
+	is_MemberExpression,
+	is_NodeWithBodyNoBody,
+	is_NodeWithMaybePatternNoUnionBody,
+	is_OperationExpression,
+	is_ParenthesizedNode,
+	is_PatternVariableDeclaration,
+	is_PostfixExpression,
+	is_RangeLiteral,
+	is_ReassignmentNode,
+	is_ReturnExpression,
+	is_StatementNode,
+	is_StructLiteral,
+	is_StructLiteralProperty,
+	is_StructPatternProperty,
+	is_StructPropertyDeclaration,
+	is_TypeBoundsStandaloneNode,
+	is_TypeFunctionNode,
+	is_TypeTraitBound,
+	is_UnaryExpression,
+	is_UnaryType,
+	is_UnionPattern,
+	is_WhileBlockExpression,
+	is_YieldExpression,
+	is_bitshiftOperator,
+	is_multiplicativeOperator,
+} from "jinx-rust/utils";
+import { BlockLikeMacroInvocation, is_BlockLikeMacroInvocation, is_CallExpression_or_CallLikeMacroInvocation } from "../transform";
+import { exit, last_of } from "../utils/common";
+import { CF, hasBreaklineAfter, hasComment } from "./comments";
+import { flowControlExpressionNeedsOuterParens } from "./core";
+import { Doc, hardline, softline, willBreak } from "./external";
+import {
+	assertPathAtNode,
+	getContext,
+	getGrandParentNode,
+	getNode,
+	getOptions,
+	getParentNode,
+	getPrintFn,
+	is_printing_macro,
+	pathCallAtParent,
+	pathCallParentOf,
+	stackIncludes,
+} from "./plugin";
+
+export function needsOuterSoftbreakParens(node: Node) {
+	const parent = getParentNode(node);
+
+	if (!parent) return false;
+
+	if (is_ExpressionAsTypeCast(node)) {
+		return precedenceNeedsParens(node, parent);
+	}
+
+	if (
+		is_FlowControlMaybeValueExpression(parent) && //
+		parent.expression === node &&
+		flowControlExpressionNeedsOuterParens(parent)
+	) {
+		return true;
+	}
+	if (
+		is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node) &&
+		(false ||
+			(is_MemberExpression(parent) && parent.expression === node) ||
+			(is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(parent) && !is_ElseBlock(node, parent)))
+	) {
+		return true;
+	}
+
+	if (is_UnionPattern(node) && is_NodeWithMaybePatternNoUnionBody(parent)) {
+		return true;
+	}
+
+	if (hasComment(node)) {
+		if (is_UnaryExpression(parent)) {
+			return true;
+		}
+
+		if (hasComment(node, CF.Line)) {
+			if (is_ReturnExpression(parent) || (is_YieldExpression(parent) && parent.expression === node)) {
+				return true;
+			}
+		}
+
+		if (
+			hasComment(node, CF.Leading, (comment) => is_Attribute(comment) && !comment.inner) &&
+			!can_have_OuterAttributes(node, parent, true)
+		) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export function needsInnerParens(node: Node) {
+	if (needsOuterSoftbreakParens(node)) {
+		return false;
+	}
+
+	const parent = getParentNode(node);
+
+	if (!parent) {
+		return false;
+	}
+
+	if (is_Identifier(node)) {
+		return false;
+	}
+
+	if (is_Literal(node)) {
+		return is_LiteralNumberLike(node) && is_MemberExpression(parent) && node === parent.expression;
+	}
+
+	if (is_CallExpression(parent) && parent.callee === node && is_MemberExpression(node)) {
+		return !getOptions().actuallyMethodNodes.has(node);
+	}
+
+	if (is_ReassignmentNode(node)) {
+		if (is_printing_macro()) {
+			return false;
+		}
+
+		if (is_ClosureFunctionExpression(parent) && node === parent.expression) {
+			return true;
+		}
+
+		if (is_ExpressionStatement(parent)) {
+			return is_StructLiteral(node.left);
+		}
+
+		if (is_ReassignmentNode(parent)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	if (is_ParenthesizedNode(parent)) {
+		return false;
+	}
+
+	if (is_ExpressionStatement(parent)) {
+		return false;
+	}
+
+	if (is_RangeLiteral(node)) {
+		return (
+			is_ExpressionAsTypeCast(parent) ||
+			is_LogicalExpression(parent) ||
+			is_UnaryExpression(parent) ||
+			is_PostfixExpression(parent) ||
+			(is_MemberExpression(parent) && node === parent.expression) ||
+			(is_CallExpression(parent) && node === parent.callee) ||
+			is_OperationExpression(parent) ||
+			is_ComparisonExpression(parent)
+		);
+	}
+
+	if (is_LetScrutinee(parent) && is_LogicalExpression(node) && parent.expression === (node as any)) {
+		return true;
+	}
+
+	if (is_UnaryExpression(node)) {
+		switch (parent.nodeType) {
+			case NodeType.MemberExpression:
+			case NodeType.AwaitExpression:
+				return node === parent.expression;
+			case NodeType.CallExpression:
+				return node === parent.callee;
+			default:
+				return false;
+		}
+	}
+
+	if (is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node)) {
+		if (is_ExpressionWithBodyOrCases(parent)) {
+			return !is_ElseBlock(node, parent);
+		}
+		if (is_LetScrutinee(parent) && parent.expression === node && is_ExpressionWithBodyOrCases(getGrandParentNode())) {
+			return true;
+		}
+		return (
+			is_ExpressionAsTypeCast(parent) ||
+			is_LogicalExpression(parent) ||
+			is_UnaryExpression(parent) ||
+			is_PostfixExpression(parent) ||
+			(is_MemberExpression(parent) && node === parent.expression) ||
+			(is_CallExpression(parent) && node === parent.callee) ||
+			is_OperationExpression(parent) ||
+			is_ComparisonExpression(parent) ||
+			is_RangeLiteral(parent)
+		);
+	}
+
+	if (is_StructLiteral(node)) {
+		if (is_ExpressionWithBodyOrCases(parent)) {
+			return true;
+		}
+
+		if (is_LetScrutinee(parent) && parent.expression === node && is_ExpressionWithBodyOrCases(getGrandParentNode())) {
+			return true;
+		}
+		if (is_UnaryExpression(parent) || is_PostfixExpression(parent) || is_MemberExpression(parent)) {
+			return parent.expression === node;
+		}
+		if (is_CallExpression(parent)) {
+			return parent.callee === node;
+		}
+	}
+
+	if (is_LogicalExpression(node) || is_OperationExpression(node) || is_ComparisonExpression(node) || is_ClosureFunctionExpression(node)) {
+		return precedenceNeedsParens(node, parent);
+	}
+
+	if (is_TypeFunctionNode(node)) {
+		const gp = getGrandParentNode();
+		if (node.returnType && is_TypeTraitBound(parent) && is_TypeBoundsStandaloneNode(gp) && last_of(gp.typeBounds) !== parent) {
+			return true;
+		}
+	}
+
+	if (is_TypeBoundsStandaloneNode(node)) {
+		return (
+			(is_UnaryType(parent) && node.typeBounds.length > 1) ||
+			is_TypeBoundsStandaloneNode(parent) ||
+			is_TypeTraitBound(parent) ||
+			(is_TypeFunctionNode(parent) && parent.returnType === node)
+		);
+	}
+
+	if (is_PatternVariableDeclaration(parent)) {
+		return is_UnionPattern(node);
+	}
+
+	return false;
+}
+
+function precedenceNeedsParens(node: LeftRightExpression | ClosureFunctionExpression | ExpressionAsTypeCast, parent: Node) {
+	if (is_UnaryExpression(parent) || is_PostfixExpression(parent)) return true;
+	if (is_ReassignmentNode(parent)) return parent.left === node;
+	if (is_MemberExpression(parent)) return parent.expression === node;
+	if (is_CallExpression(parent)) return parent.callee === node;
+	if (is_ExpressionAsTypeCast(parent)) return !is_ExpressionAsTypeCast(node);
+	if (is_LogicalExpression(parent)) return is_LogicalExpression(node) ? parent.nodeType !== node.nodeType : evalPrecedence(node, parent);
+	if (is_OperationExpression(parent) || is_ComparisonExpression(parent)) return evalPrecedence(node, parent);
+	return false;
+	function evalPrecedence(
+		child: LeftRightExpression | ClosureFunctionExpression | ExpressionAsTypeCast,
+		parent: ComparisonExpression | OperationExpression | LogicalExpression
+	) {
+		if (is_ExpressionAsTypeCast(child) || is_ClosureFunctionExpression(child)) {
+			return true;
+		}
+		function getPrec(node, bool) {
+			// if (is_EqualityOperator(node.tk)) {
+			// 	return 11.3;
+			// }
+			// if (is_LargerLesserOperator(node.tk)) {
+			// 	return 11.6;
+			// }
+			return getPrecedence(node, bool);
+		}
+
+		const childPRCD = getPrec(child, is_insideScrutinee(child));
+		const parentPRCD = getPrec(parent, is_insideScrutinee(parent));
+
+		if (parentPRCD > childPRCD) {
+			return true;
+		}
+
+		if (parentPRCD === childPRCD && parent.right === child) {
+			return true;
+		}
+
+		if (parentPRCD === childPRCD && !shouldFlatten(parent, child)) {
+			return true;
+		}
+
+		if (parentPRCD < childPRCD && child.tk === TK["%"]) {
+			return parentPRCD === PRCD["+-"];
+		}
+
+		if (is_BitwiseOperator(parent.tk) || (is_BitwiseOperator(child.tk) && is_EqualityOperator(parent.tk))) {
+			return true;
+		}
+
+		return false;
+	}
+}
+
+export function shouldFlatten(parent: ExpressionNode | ConditionExpression, node: ExpressionNode | ConditionExpression) {
+	if (getPrecedence(node, is_insideScrutinee(node)) !== getPrecedence(parent, is_insideScrutinee(parent))) return false;
+	if (is_ComparisonExpression(parent) && is_ComparisonExpression(node)) return false;
+	if (is_OperationExpression(parent) && is_OperationExpression(node)) {
+		if (
+			(node.tk === TK["%"] && is_multiplicativeOperator(parent.tk)) ||
+			(parent.tk === TK["%"] && is_multiplicativeOperator(node.tk)) ||
+			(node.tk !== parent.tk && is_multiplicativeOperator(node.tk) && is_multiplicativeOperator(parent.tk)) ||
+			(is_bitshiftOperator(node.tk) && is_bitshiftOperator(parent.tk))
+		)
+			return false;
+	}
+	return true;
+}
+
+export function needsParens(node: Node) {
+	return needsOuterSoftbreakParens(node) || needsInnerParens(node);
+}
+
+export function stmtNeedsSemi(stmt: ExpressionStatement, disregardExprType = false) {
+	return pathCallParentOf(stmt, (parent) => needsSemi(parent as any, stmt, disregardExprType));
+}
+
+const NoNode = { nodeType: 0 } as MissingNode;
+
+export function needsSemi(parent: NodeWithBody, stmt: ExpressionStatement, disregardExprType = false) {
+	const expr = disregardExprType ? NoNode : stmt.expression!;
+	const hadSemi = !disregardExprType && stmt.semi;
+
+	return (
+		!!expr &&
+		(forcePreserveSemi()
+			? true
+			: shouldNeverSemi()
+			? false
+			: shouldPreserveSemi()
+			? hadSemi || shouldAlwaysSemi() || canAutoCompleteSemi()
+			: true)
+	);
+
+	function forcePreserveSemi() {
+		/** Rust Compiler bug (preserve optional semicolon) */
+		// rust-lang/rust#70844 https://github.com/rust-lang/rust/issues/70844
+		// issue#22 https://github.com/jinxdash/prettier-plugin-rust/issues/22
+		return (
+			hadSemi &&
+			stmt === last_of(parent.body!) &&
+			((is_IfBlockExpression(expr) &&
+				hasLetScrutineeCondition(expr) &&
+				!(is_LetScrutinee(expr.condition) && is_Identifier(expr.condition.expression))) ||
+				(is_MatchExpression(expr) && !is_Identifier(expr.expression)))
+		);
+	}
+	function shouldNeverSemi() {
+		return is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(expr);
+	}
+	function shouldPreserveSemi() {
+		return stmt === last_of(parent.body!) && (is_ImplicitReturnAbleNode(parent) || is_BlockLikeMacroInvocation(parent));
+	}
+	function shouldAlwaysSemi() {
+		return is_FlowControlExpression(expr) || is_ReassignmentNode(expr);
+	}
+	function canAutoCompleteSemi() {
+		return withPathAt(parent, function checkParent(child: NodeWithBodyOrCases): boolean {
+			return pathCallParentOf(child, (parent) => {
+				if (is_IfBlockExpression(parent) && parent.else === child) {
+					// if ... { ... } else if { ... } ...
+					// ^ ------------------------------- parent
+					//                     ^ ----------- child
+					return checkParent(parent);
+				}
+				if (is_ExpressionStatement(parent)) {
+					// { .... { ... } ... }
+					// ^ -----------------^ grandparent
+					//        ^ --- ^       ExpressionStatement<child>
+					if (hasOuterAttributes(parent)) return false;
+					return stmtNeedsSemi(parent, true);
+				}
+				if (is_MatchExpressionCase(parent) && parent.expression === child) {
+					return pathCallParentOf(parent, checkParent);
+				}
+				return false;
+			});
+		});
+	}
+}
+
+export function canInlineBlockBody(node: NodeWithBodyOrCases | BlockLikeMacroInvocation): boolean {
+	if (!is_ExpressionWithBody(node)) {
+		return false;
+	}
+	const body = node.body;
+
+	if (body.length === 0) {
+		return canInlineInlineable(node);
+	}
+
+	if (body.length === 1) {
+		const stmt = body[0];
+		if (is_AttributeOrDocComment(stmt)) {
+			return true;
+		}
+		if (is_ExpressionStatement(stmt) && !needsSemi(node, stmt)) {
+			/**
+			 * parent ( ExpressionStatement | StructLiteralProperty | LetVariableDeclaration | ... )
+			 *   ...
+			 *   node {
+			 *     expr
+			 *   }
+			 *   ...
+			 *
+			 *
+			 * Q: Can you inline "node { expr }" ?
+			 */
+			const expr = stmt.expression!;
+
+			if (
+				is_FlowControlExpression(expr) || //
+				is_ClosureFunctionExpression(expr) ||
+				is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(expr)
+			) {
+				return false;
+			}
+
+			return canInlineInlineable(node);
+		}
+	}
+	return false;
+}
+
+// function q(node: ExpressionWithBody) {
+// 	pathCallTopMostIfBlockExpression(node, (node) => {});
+// }
+
+function canInlineInlineable(node: ExpressionWithBody) {
+	if (is_ForInBlockExpression(node) || is_LoopBlockExpression(node)) {
+		return false;
+	}
+	if (is_WhileBlockExpression(node)) {
+		return true;
+	}
+
+	const parent = getParentNode(node)!;
+
+	if (
+		is_ExpressionStatement(parent) &&
+		(!is_ImplicitReturnAbleNode(node) || pathCallAtParent(parent, (parent) => stmtNeedsSemi(parent, true)))
+	) {
+		return false;
+	}
+
+	if (is_ElseBlock(node, parent)) {
+		return pathCallAtParent(parent, canInlineBlockBody);
+	}
+	// if (is_CaseBlock(node, parent)) {
+	// 	return false;
+	// }
+	if (is_IfBlockExpression(node)) {
+		if (
+			!node.else ||
+			// hasLetScrutineeCondition(node) ||
+			is_ExpressionWithBodyOrCases_or_BlockLikeMacroInvocation(node.condition) ||
+			willBreak(getPrintFn(node)("condition"))
+		) {
+			return false;
+		}
+
+		const grandparent = getGrandParentNode();
+		if (is_ExpressionStatement(parent) && hasBody(grandparent) && grandparent.body.length > 1) {
+			return false;
+		}
+	}
+	return true;
+	return (
+		is_CallExpression_or_CallLikeMacroInvocation(parent) ||
+		hasItems(parent) ||
+		hasProperties(parent) ||
+		is_ClosureFunctionExpression(parent) ||
+		is_MemberExpression(parent) ||
+		is_AwaitExpression(parent) ||
+		is_LeftRightExpression(parent)
+	);
+}
+
+type NodeWithBracketContent =
+	| NodeWithBodyOrCases
+	| BlockLikeMacroInvocation
+	| EnumDeclaration
+	| StructDeclaration
+	| StructLiteral
+	| StructPattern
+	| EnumMemberStructDeclaration
+	| UnionDeclaration
+	| MacroRulesDeclaration
+	| MacroDeclaration;
+
+export function emptyContent(node: NodeWithBracketContent): Doc {
+	switch (node.nodeType) {
+		case NodeType.Program:
+		case NodeType.MacroRulesDeclaration:
+		case NodeType.MacroDeclaration:
+		case NodeType.ExternBlockDeclaration:
+		case NodeType.ModuleDeclaration:
+		case NodeType.TraitDeclaration:
+		case NodeType.StructDeclaration:
+		case NodeType.MacroInvocation:
+		case NodeType.FunctionDeclaration:
+		case NodeType.ImplDeclaration:
+		case NodeType.UnionDeclaration:
+		case NodeType.EnumDeclaration:
+		case NodeType.EnumMemberStructDeclaration:
+		case NodeType.StructLiteral:
+		case NodeType.StructPattern:
+			// case NodeType.MatchExpression:
+			return "";
+		case NodeType.BlockExpression:
+		case NodeType.WhileBlockExpression:
+		case NodeType.ForInBlockExpression:
+		case NodeType.TryBlockExpression:
+		case NodeType.IfBlockExpression:
+			return canInlineInlineable(node)
+				? is_IfBlockExpression(node) || is_ElseBlock(node, getParentNode()!)
+					? softline
+					: ""
+				: hardline;
+		case NodeType.LoopBlockExpression:
+		case NodeType.MatchExpression:
+			return hardline;
+		default:
+			if (is_NodeWithBodyNoBody(node)) {
+				return "";
+			}
+			__DEV__: exit.never(node);
+			return "";
+	}
+}
+
+export function is_insideScrutinee(target: Node) {
+	return withPathAt(target, (n) => stackIncludes("condition") && r(n));
+	function r(CHILD: Node) {
+		switch (CHILD.nodeType) {
+			case NodeType.OrExpression:
+			case NodeType.AndExpression:
+				return pathCallParentOf(CHILD, (PARENT) =>
+					hasCondition(PARENT) && PARENT.condition === CHILD //
+						? hasLetScrutineeCondition(PARENT)
+						: r(PARENT)
+				);
+			case NodeType.LetScrutinee:
+				return true;
+			default:
+				return false;
+		}
+	}
+}
+
+function withPathAt<T extends Node, R>(target: T, callback: (target: T) => R): R {
+	if (target === getNode()) return callback(target);
+	if (target === getParentNode()) return pathCallAtParent(target, () => callback(target));
+	if (stackIncludes(target)) return pathCallAtParent(getParentNode()!, () => withPathAt(target, callback));
+	return getContext().path.call(() => {
+		__DEV__: assertPathAtNode("withPathAt", target);
+		return callback(target); // @ts-ignore
+	}, ...getAstPath(getNode(), target));
+}
+export function shouldPrintOuterAttributesAbove(node: Node) {
+	return (
+		is_StatementNode(node) ||
+		is_MatchExpressionCase(node) ||
+		(hasAttributes(node) &&
+			node.attributes.some(
+				canInlineOuterAttribute(node)
+					? (attr) => is_DocCommentAttribute(attr) || hasBreaklineAfter(attr) //
+					: is_DocCommentAttribute
+			))
+	);
+	function canInlineOuterAttribute(node: Node) {
+		return (
+			is_EnumMemberDeclaration(node) ||
+			is_StructPropertyDeclaration(node) ||
+			is_StructLiteralProperty(node) ||
+			is_StructPatternProperty(node)
+		);
+	}
+}

frontend/src/common/prettier/plugins/rust/index.ts

@@ -0,0 +1,8 @@
+import { plugin } from "./format/plugin";
+
+export default plugin;
+export const languages = plugin.languages;
+export const parsers = plugin.parsers;
+export const printers = plugin.printers;
+export const options = plugin.options;
+export const defaultOptions = plugin.defaultOptions;

frontend/src/common/prettier/plugins/rust/transform/custom/attribute.ts

@@ -0,0 +1,116 @@
+import {
+	AttrSegment,
+	CallExpression,
+	DelimKind,
+	ExpressionPath,
+	Identifier,
+	Literal,
+	LocArray,
+	MacroInvocation,
+	NodeType,
+	PunctuationToken,
+	ReassignmentExpression,
+	TK,
+	rs,
+} from "jinx-rust";
+import { isTK, start } from "jinx-rust/utils";
+import { assert, exit } from "../../utils/common";
+import { isIdent } from "./utils";
+
+type SimpleAttrItem =
+	| Identifier //
+	| Literal
+	| ExpressionPath
+	| CallExpression
+	| ReassignmentExpression
+	| MacroInvocation;
+
+export function transform_simpleAttrSyntax(segments: MacroInvocation["segments"]) {
+	assert(segments.length !== 0, segments.loc.url());
+	return transform_segments(segments, false);
+
+	function transform_segments<N extends boolean>(
+		seq: LocArray<AttrSegment>,
+		nestedCall: N
+	): N extends true ? LocArray<SimpleAttrItem, "()"> : SimpleAttrItem {
+		let i = 0;
+
+		if (nestedCall) {
+			const args = rs.createLocArray<SimpleAttrItem, any>(DelimKind["()"], seq.loc.clone());
+			while (i !== seq.length) {
+				args.push(read(true));
+				if (i === seq.length) break;
+				assert(isTK(seq[i++], TK[","]));
+			}
+			return args as any;
+		} else {
+			const res = read(true);
+			assert(i === seq.length, res.loc.url());
+			return res as any;
+		}
+
+		function read(allowEq: boolean): SimpleAttrItem {
+			let lhs: Identifier | ExpressionPath;
+
+			switch (seq[i].nodeType) {
+				case NodeType.Literal:
+					return seq[i++] as Literal;
+				case NodeType.Identifier:
+					lhs = seq[i++] as Identifier;
+					break;
+				case NodeType.PunctuationToken:
+					assert((seq[i] as PunctuationToken).tk === TK["::"], seq[i].loc.url());
+					lhs = eatPathSegment(undefined);
+					break;
+				default:
+					exit.never();
+			}
+
+			while (true) {
+				if (i === seq.length) return lhs;
+				const seg = seq[i];
+				switch (seg.nodeType) {
+					case NodeType.PunctuationToken:
+						switch (seg.tk) {
+							case TK[","]:
+								assert(nestedCall);
+								return lhs;
+							case TK["="]: {
+								assert(allowEq);
+								const right = (i++, read(false));
+								return rs.mockNode(NodeType.ReassignmentExpression, right.loc.cloneFrom(start(lhs)), {
+									tk: TK["="],
+									kind: DelimKind["="],
+									left: lhs,
+									right,
+								});
+							}
+							case TK["::"]:
+								lhs = eatPathSegment(lhs);
+								continue;
+							default:
+								exit.never();
+						}
+					case NodeType.DelimGroup:
+						assert(seg.segments.dk === DelimKind["()"]);
+						return rs.mockNode(NodeType.CallExpression, seq[i++].loc.cloneFrom(start(lhs)), {
+							callee: lhs,
+							typeArguments: undefined,
+							method: undefined,
+							arguments: transform_segments(seg.segments, true),
+						});
+					default:
+						exit.never();
+				}
+			}
+		}
+
+		function eatPathSegment(left: undefined | Identifier | ExpressionPath) {
+			const segment = seq[i + 1];
+			assert(isIdent(segment));
+			const res = rs.mockNode(NodeType.ExpressionPath, segment.loc.cloneFrom(start(left ?? seq[i])), { namespace: left, segment });
+			i += 2;
+			return res;
+		}
+	}
+}

frontend/src/common/prettier/plugins/rust/transform/custom/cfg_if.ts

@@ -0,0 +1,92 @@
+import {
+	DelimGroup,
+	DelimKind,
+	IfBlockExpression,
+	LocArray,
+	MacroInvocation,
+	NodeType,
+	NodeWithBody,
+	rs,
+	Segment,
+	Snippet,
+	StatementNode,
+	TK,
+} from "jinx-rust";
+import { insertNodes, start, transferAttributes } from "jinx-rust/utils";
+import { assert, iLast } from "../../utils/common";
+import { isGroup, isIdent, isToken } from "./utils";
+
+export function transform_macro_cfg_if(segments: MacroInvocation["segments"]) {
+	const danglingAttributes: Snippet["danglingAttributes"] = [];
+	const comments: Snippet["comments"] = [];
+
+	const block = (function create_if_block(i: number): IfBlockExpression | undefined {
+		if (i >= segments.length) return undefined;
+
+		const _if = segments[i];
+		const pound = segments[i + 1];
+		const grp = segments[i + 2];
+		const block = segments[i + 3];
+		const _else = segments[i + 4];
+
+		assert(
+			isIdent(_if, "if") &&
+				isToken(pound, TK["#"]) &&
+				isGroup(grp, DelimKind["[]"]) &&
+				isGroup(block, DelimKind["{}"]) &&
+				(!_else || isIdent(_else, "else"))
+		);
+
+		return create_block(block, (body) =>
+			rs.mockNode(NodeType.IfBlockExpression, block.loc.cloneFrom(start(_if)), {
+				label: undefined,
+				condition: rs.mockNode(NodeType.Attribute, grp.loc.cloneFrom(start(pound)), {
+					segments: grp.segments,
+					value: grp.segments.loc.sliceText(),
+					line: false,
+					inner: false,
+				}) as any,
+				body: body,
+				else: (_else && iLast(i + 5, segments)
+					? function create_else_block(i: number) {
+							const block = segments[i];
+							assert(isGroup(block, DelimKind["{}"]));
+							return create_block(block, (body) =>
+								rs.mockNode(NodeType.BlockExpression, body.loc.clone(), {
+									label: undefined,
+									body,
+								})
+							);
+					  }
+					: create_if_block)(i + 5),
+			})
+		);
+	})(0);
+
+	const ast = rs.createLocArray(
+		segments.dk,
+		segments.loc,
+		block && [
+			rs.mockNode(NodeType.ExpressionStatement, block.loc.clone(), {
+				expression: block,
+				semi: false,
+			}),
+		]
+	);
+
+	return rs.mockNode(NodeType.Snippet, segments.loc.clone(), { ast, danglingAttributes, comments });
+
+	function create_block<R extends NodeWithBody>(
+		group: DelimGroup<Segment> & { segments: { dk: 3 } },
+		fn: (statements: LocArray<StatementNode, "{}">) => R
+	): R {
+		const snippet = rs.toBlockBody(group.segments);
+
+		insertNodes(danglingAttributes, snippet.danglingAttributes);
+		insertNodes(comments, snippet.comments);
+
+		const block = fn(snippet.ast);
+		transferAttributes(snippet, block);
+		return block;
+	}
+}

frontend/src/common/prettier/plugins/rust/transform/custom/utils.ts

@@ -0,0 +1,16 @@
+import { DelimGroup, DelimKind, Identifier, LocArray, PunctuationToken, Segment, TK } from "jinx-rust";
+import { isTK, is_DelimGroup, is_Identifier, is_PunctuationToken } from "jinx-rust/utils";
+
+export function isIdent(node: Segment | undefined, name?: string): node is Identifier {
+	return !!node && is_Identifier(node) && (null == name || node.name === name);
+}
+export function isToken(node: Segment | undefined, tk?: TK): node is PunctuationToken {
+	return !!node && (null == tk ? is_PunctuationToken(node) : isTK(node, tk));
+}
+export function isGroup<D extends DelimKind>(node: Segment | undefined, dk?: D): node is DelimGroup & { segments: LocArray<any, D> } {
+	return !!node && is_DelimGroup(node) && (null == dk || node.segments.dk === dk);
+}
+
+export function isCallLike(tk_1: Segment | undefined, tk_2: Segment | undefined): boolean {
+	return !!tk_1 && !!tk_2 && is_Identifier(tk_1) && is_DelimGroup(tk_2) && tk_2.segments.dk === DelimKind["()"];
+}

frontend/src/common/prettier/plugins/rust/transform/index.ts

@@ -0,0 +1,568 @@
+import {
+	Attribute,
+	AttributeOrDocComment,
+	CallExpression,
+	DelimKind,
+	ExpressionNode,
+	LocArray,
+	MacroInvocation,
+	MemberExpression,
+	Node,
+	NodeType,
+	NodeWithBodyNoBody,
+	NodeWithTypeBounds,
+	NTMap,
+	ProgramLike,
+	rs,
+	Snippet,
+	StatementNode,
+	StructLiteral,
+	StructPattern,
+	TK,
+	TypeBound,
+	TypeBoundsStandaloneNode,
+	TypeDynBounds,
+	TypeTraitBound,
+} from "jinx-rust";
+import {
+	countActualNodeChildren,
+	deleteAttributes,
+	each_childNode,
+	end,
+	getActualNodeChildren,
+	getBodyOrCases,
+	getMacroName,
+	getNodeChildren,
+	hasAttributes,
+	hasMethod,
+	hasTypeBounds,
+	includesTK,
+	insertNode,
+	insertNodes,
+	is_AttributeOrDocComment,
+	is_BareTypeTraitBound,
+	is_BlockExpression,
+	is_CallExpression,
+	is_ClosureFunctionExpression,
+	is_DocCommentAttribute,
+	is_ExpressionStatement,
+	is_ExpressionWithBodyOrCases,
+	is_FlowControlExpression,
+	is_IfBlockExpression,
+	is_MacroInvocation,
+	is_Node,
+	is_NodeWithBodyNoBody,
+	is_NodeWithBodyOrCases,
+	is_Program,
+	is_PunctuationToken,
+	is_ReassignmentNode,
+	is_Snippet,
+	is_TypeBoundsStandaloneNode,
+	is_TypeDynBounds,
+	is_TypeImplBounds,
+	is_TypeTraitBound,
+	ownStart,
+	reassignNodeProperty,
+	start,
+	transferAttributes,
+	unsafe_set_nodeType,
+} from "jinx-rust/utils";
+import { isPrettierIgnoreAttribute, setPrettierIgnoreTarget } from "../format/comments";
+import { is_StructSpread } from "../format/core";
+import { CustomOptions } from "../format/external";
+import { getOptions } from "../format/plugin";
+import {
+	Array_replace,
+	Array_splice,
+	assert,
+	binarySearchIn,
+	each,
+	exit,
+	iLast,
+	last_of,
+	Map_get,
+	spliceAll,
+	try_eval,
+} from "../utils/common";
+import { transform_simpleAttrSyntax } from "./custom/attribute";
+import { transform_macro_cfg_if } from "./custom/cfg_if";
+
+export interface ExpressionLikeAttribute extends Attribute {
+	segments: LocArray<any, "[]">;
+}
+
+export interface CallLikeMacroInvocation extends MacroInvocation {
+	segments: LocArray<any, any>;
+	callee: MacroInvocation["callee"];
+	method: undefined;
+	typeArguments: undefined;
+	arguments: LocArray<ExpressionNode, "()" | "[]" | "{}">;
+}
+
+export interface BlockLikeMacroInvocation extends MacroInvocation {
+	segments: LocArray<any, any>;
+	body: LocArray<StatementNode, "()" | "[]" | "{}">;
+	attributes?: AttributeOrDocComment[];
+}
+
+export function is_CallLikeMacroInvocation(node: Node): node is CallLikeMacroInvocation {
+	return is_MacroInvocation(node) && "arguments" in node;
+}
+
+export function is_BlockLikeMacroInvocation(node: Node): node is BlockLikeMacroInvocation {
+	return is_MacroInvocation(node) && "body" in node;
+}
+
+export function is_CallExpression_or_CallLikeMacroInvocation(node: any): node is CallExpression | CallLikeMacroInvocation {
+	return is_CallExpression(node) || is_CallLikeMacroInvocation(node);
+}
+
+const IGNORED_MACROS = new Set([
+	// std
+	// crates
+	"quote",
+]);
+
+const HARDCODED_MACRO_DELIMS = new Map<string, MacroInvocation["segments"]["dk"]>();
+each(
+	{
+		[DelimKind["{}"]]: [
+			// std
+			"thread_local",
+			// crates
+			"cfg_if",
+		],
+		[DelimKind["()"]]: [
+			// std
+			"assert_eq",
+			"assert_ne",
+			"assert",
+			"cfg",
+			"concat_bytes",
+			"concat_idents",
+			"concat",
+			"debug_assert_eq",
+			"debug_assert_ne",
+			"debug_assert",
+			"eprint",
+			"eprintln",
+			"format_args_nl",
+			"format_args",
+			"format",
+			"matches",
+			"panic",
+			"print",
+			"println",
+			"try",
+			"unimplemented",
+			"unreachable",
+			"write",
+			"writeln",
+			// crates
+		],
+		[DelimKind["[]"]]: [
+			// std
+			"vec",
+			// crates
+		],
+	},
+	(names, tk) =>
+		each(names, (name) => {
+			HARDCODED_MACRO_DELIMS.set(name, +tk as MacroInvocation["segments"]["dk"]);
+		})
+);
+
+let _COMMENTS: CustomOptions["comments"] = undefined!;
+let _DANGLING_ATTRIBUTES: CustomOptions["danglingAttributes"] = undefined!;
+
+export function transform_ast(options: CustomOptions) {
+	try {
+		_COMMENTS = options.comments;
+		_DANGLING_ATTRIBUTES = options.danglingAttributes;
+		transformNode(options.rsParsedFile);
+	} finally {
+		_depth = 0;
+		_COMMENTS = undefined!;
+		_DANGLING_ATTRIBUTES = undefined!;
+	}
+}
+
+let _depth = 0;
+const isReadingSnippet = () => 0 !== _depth;
+
+function maybe_transform_node<T extends Node, S extends Snippet>(
+	node: T,
+	read_snippet: () => S,
+	fn: (node: T, snippet: S) => void
+): T | undefined {
+	const snippet = try_eval(read_snippet);
+	if (snippet) {
+		++_depth;
+		transformNode(snippet);
+		--_depth;
+		fn(node, snippet);
+		transformed.add(node);
+		return node;
+	}
+}
+const transformed = new WeakSet<Node>();
+export function isTransformed(node: Node) {
+	return transformed.has(node);
+}
+
+const transform: { [K in NodeType]?: (node: NTMap[K]) => void } = {
+	[NodeType.Attribute](node) {
+		try_eval(() => {
+			node.segments = rs.createLocArray(node.segments.dk, node.segments.loc.clone(), [
+				transform_simpleAttrSyntax(node.segments),
+			]) as any;
+			transformed.add(node);
+		});
+	},
+	[NodeType.MacroInlineRuleDeclaration](node) {
+		node.match.dk = DelimKind["()"];
+		node.transform.dk = DelimKind["{}"];
+	},
+	[NodeType.MacroInvocation](node) {
+		const name = getMacroName(node);
+
+		if (
+			IGNORED_MACROS.has(name) ||
+			node.segments.length === 0 ||
+			(node.segments.length === 1 && is_PunctuationToken(node.segments[0]))
+		) {
+			return;
+		}
+
+		const tk = transformMacroDelim(name, node);
+
+		if (name === "matches") {
+			//
+		}
+
+		if (name === "if_chain") {
+			//
+		}
+
+		if (name === "cfg_if") {
+			transformBlockLike(() => transform_macro_cfg_if(node.segments) as any);
+		} else if (tk === DelimKind["{}"]) {
+			transformBlockLike(); /* || (includesTK(node, TK[","]) && transformCallLike()); */
+		} else {
+			transformCallLike(); /* || (includesTK(node, TK[";"]) && transformBlockLike()); */
+		}
+
+		function transformBlockLike(transform = () => rs.toBlockBody(node.segments)) {
+			return maybe_transform_node(node as BlockLikeMacroInvocation, transform, (node, snippet) => {
+				const _body = snippet.ast;
+				_body.dk = tk;
+
+				node.body = _body;
+				node.segments = _body;
+				transferAttributes(snippet, node);
+			});
+		}
+
+		function transformCallLike() {
+			return maybe_transform_node(
+				node as CallLikeMacroInvocation,
+				() => rs.toCallExpressionArguments(node.segments),
+				(node, snippet) => {
+					const _arguments = snippet.ast;
+					_arguments.dk = tk;
+
+					node.method = undefined;
+					node.typeArguments = undefined;
+					node.arguments = _arguments;
+					node.segments = _arguments;
+				}
+			);
+		}
+	},
+	[NodeType.CallExpression](node) {
+		if (hasMethod(node)) {
+			node.callee = rs.mockNode(NodeType.MemberExpression, node.method.loc.cloneFrom(start(node.callee)), {
+				expression: node.callee,
+				property: node.method,
+				computed: false,
+			});
+			node.method = undefined!;
+			getOptions().actuallyMethodNodes.add(node.callee as MemberExpression);
+		}
+	},
+
+	[NodeType.AutoTraitDeclaration](node) {
+		mockBodyNoBody(node);
+	},
+	[NodeType.NegativeImplDeclaration](node) {
+		mockBodyNoBody(node);
+	},
+
+	[NodeType.StructLiteral](node) {
+		moveSpreadsToEnd(node);
+	},
+	[NodeType.StructPattern](node) {
+		moveSpreadsToEnd(node);
+	},
+};
+
+function moveSpreadsToEnd(node: StructLiteral | StructPattern) {
+	const props = node.properties;
+	if (props.some((p, i, a) => is_StructSpread(p) && !iLast(i, a))) {
+		const spreads: any[] = [];
+		for (let i = 0; i < props.length; i++) {
+			const prop = props[i];
+			if (is_StructSpread(prop)) {
+				Array_splice(props, prop, i--);
+				spreads.push(prop);
+			}
+		}
+		props.push(...spreads);
+	}
+}
+
+function mockBodyNoBody(node: NodeWithBodyNoBody) {
+	// @ts-expect-error
+	node.body = rs.createLocArray(last_of(rs.toTokens(node).ast).loc.clone(), DelimKind["{}"]);
+}
+
+function transformMacroDelim(name: string, node: MacroInvocation): 1 | 2 | 3 {
+	if (HARDCODED_MACRO_DELIMS.has(name)) {
+		return HARDCODED_MACRO_DELIMS.get(name)!;
+	}
+	if (node.segments.dk === DelimKind["{}"] && includesTK(node, TK[","])) {
+		return DelimKind["()"];
+	}
+	if (node.segments.dk === DelimKind["()"] && includesTK(node, TK[";"])) {
+		return DelimKind["{}"];
+	}
+	return node.segments.dk;
+}
+
+// export function createTransformed<S extends Node>(create: () => S): S {
+// 	return transformNode(create());
+// }
+
+const seen = new WeakSet<Node>();
+function transformNode<T extends Node>(node: T, parent?: Node, key?: string, index?: any): T {
+	if (!seen.has(node)) {
+		seen.add(node);
+		if (is_Snippet(node) || is_Program(node)) {
+			registerPogramLike(node);
+		}
+
+		each_childNode(node, transformNode);
+
+		insert_blocks(node, parent, key, index);
+
+		transform[node.nodeType]?.(node as any);
+
+		flatten_typeBounds(node);
+
+		transform_nodeAttributes(node);
+	}
+	return node;
+}
+
+function insert_blocks(node: Node, parent?: Node, key?: string, index?: any) {
+	if (parent && key) {
+		if (
+			!is_ExpressionStatement(parent) &&
+			(false ||
+				// "1 + break" -> "1 + { break; }"
+				is_FlowControlExpression(node) ||
+				// "1 + a = b" -> "1 + { a = b; }"
+				(!isReadingSnippet() && is_ReassignmentNode(node) && !(is_ReassignmentNode(parent) && parent.left === node)))
+		) {
+			reassignNodeProperty(blockify(node), parent, key, index);
+		} else if (
+			is_ClosureFunctionExpression(node) &&
+			(false ||
+				// "|| -> T x" -> "|| -> T { x }"
+				(!!node.returnType && !is_BlockExpression(node.expression)) ||
+				// "|| match x {}" -> "|| { match x {} }"
+				(is_ExpressionWithBodyOrCases(node.expression) &&
+					!is_BlockExpression(node.expression) &&
+					!is_IfBlockExpression(node.expression)))
+		) {
+			node.expression = blockify(node.expression);
+		}
+	}
+	function blockify(node: ExpressionNode) {
+		const block = rs.mockNode(NodeType.BlockExpression, node.loc.clone(), {
+			label: undefined,
+			body: rs.createLocArray(DelimKind["{}"], node.loc.clone(), [
+				rs.mockNode(NodeType.ExpressionStatement, node.loc.clone(), { semi: false, expression: node }),
+			]),
+		});
+		transferAttributes(node, block);
+		return block;
+	}
+}
+
+function flatten_typeBounds(topNode: Node) {
+	if (hasTypeBounds(topNode)) {
+		const nestedBounds: TypeTraitBound[] = topNode.typeBounds.filter(isBoundWithNestedBounds);
+		const [first, ...subsequent] = nestedBounds;
+
+		const flatten = (bound: TypeTraitBound) =>
+			Array_replace(topNode.typeBounds, bound, ...(bound.typeExpression as unknown as TypeDynBounds).typeBounds);
+
+		if (nestedBounds.every(isBareBoundWithNestedBoundsNoPrefix)) {
+			// A + (B + C)
+			// -> A + B + C
+			each(nestedBounds, flatten);
+		} else if (
+			!hasDefinedPrefix(topNode) &&
+			first === topNode.typeBounds[0] &&
+			!isBareBoundWithNestedBoundsNoPrefix(first) &&
+			subsequent.every(isBareBoundWithNestedBoundsNoPrefix)
+		) {
+			if (is_TypeDynBounds(topNode)) {
+				if (is_TypeImplBounds(first.typeExpression)) {
+					// (impl A) + B
+					// -> impl A + B
+					unsafe_set_nodeType(topNode, NodeType.TypeImplBounds);
+				} else {
+					// (dyn A) + B
+					// -> dyn A + B
+					topNode.dyn = true;
+				}
+				each(nestedBounds, flatten);
+			} else {
+				each(subsequent, flatten);
+				(first.typeExpression as unknown as TypeDynBounds).typeBounds.push(...topNode.typeBounds.slice(1));
+				topNode.typeBounds.length = 1;
+			}
+		}
+	}
+
+	function isBoundWithNestedBounds(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeBoundsStandaloneNode } {
+		return is_TypeTraitBound(bound) && is_TypeBoundsStandaloneNode(bound.typeExpression);
+	}
+	function isBareBoundWithNestedBounds(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeBoundsStandaloneNode } {
+		return isBoundWithNestedBounds(bound) && is_BareTypeTraitBound(bound);
+	}
+	function isBareBoundWithNestedBoundsNoPrefix(bound: TypeBound): bound is TypeTraitBound & { typeExpression: TypeDynBounds } {
+		return isBareBoundWithNestedBounds(bound) && !hasDefinedPrefix(bound.typeExpression);
+	}
+	function hasDefinedPrefix(node: NodeWithTypeBounds) {
+		return (is_TypeDynBounds(node) && node.dyn) || is_TypeImplBounds(node);
+	}
+}
+
+function transform_nodeAttributes(node: Node) {
+	/**
+	 * # Inside Token trees:
+	 *
+	 *  1. DocCommentAttribute 	--is parsed as--> 	Comment
+	 *  2. Attribute 			--is parsed as--> 	Token<'#'>, DelimGroup<'[]'>
+	 *
+	 * # Transforming tokens into a Snippet:
+	 *
+	 *  1. DocCommentAttribute <--replace from-- Comment
+	 *    a) Remove node with same loc from comments
+	 *    b) Merge Snippet.danglingAttributes with Program.danglingAttributes
+	 *
+	 *  2. Attribute (no action needed)
+	 *
+	 */
+	if (hasAttributes(node)) {
+		const attrs = node.attributes;
+		for (let i = 0; i < attrs.length; i++) {
+			const attr = attrs[i];
+			if (isReadingSnippet() && is_DocCommentAttribute(attr)) {
+				const index = binarySearchIn(_COMMENTS, start(attr), start);
+				__DEV__: assert(index !== -1), assert(end(_COMMENTS[index]) === end(attr));
+				_COMMENTS.splice(index, 1);
+			}
+			if (attr.inner) {
+				if (isPrettierIgnoreAttribute(attr)) {
+					setPrettierIgnoreTarget(is_Program(node) ? node.loc.src : node, attr);
+				}
+				// @ts-expect-error Inserting Attribute into StatementNode[]
+				insertNode(is_Snippet(node) ? node.ast : getBodyOrCases(node)!, attr);
+				Array_splice(attrs, attr, i--);
+			}
+		}
+		if (attrs.length === 0) {
+			deleteAttributes(node);
+		}
+	}
+}
+
+function registerPogramLike(program: Extract<Node, ProgramLike>) {
+	const comments = spliceAll(program.comments);
+	const danglingAttributes = spliceAll(program.danglingAttributes);
+	for (let i = 0; i < danglingAttributes.length; i++) {
+		const attr = danglingAttributes[i];
+		// if (isReadingSnippet() && is_DocCommentAttribute(attr)) {
+		// }
+		if (is_DocCommentAttribute(attr)) {
+			if (isReadingSnippet()) {
+				const index = binarySearchIn(_COMMENTS, start(attr), start);
+				__DEV__: assert(index !== -1), assert(end(_COMMENTS[index]) === end(attr));
+				_COMMENTS.splice(index, 1);
+			}
+		} else {
+			transformNode(danglingAttributes[i], program, "danglingAttributes", i);
+		}
+	}
+	if (!isReadingSnippet()) insertNodes(_COMMENTS, comments);
+	insertNodes(_DANGLING_ATTRIBUTES, danglingAttributes);
+}
+
+const CommentChildNodes = new WeakMap<Node, Node[]>();
+
+export function getCommentChildNodes(n: any): Node[] {
+	const children = Map_get(CommentChildNodes, n, getTransformedNodeChildren);
+	/**
+	 * parent {
+	 *  #[attr]
+	 * 	#![attr] <-------- list misplaced inner attrs as part of "#[attr] child {}"
+	 * 	child {}
+	 * }
+	 */
+	if (is_NodeWithBodyOrCases(n) || is_BlockLikeMacroInvocation(n)) {
+		for (let i = 0; i < children.length; i++) {
+			const attr = children[i];
+			if (is_AttributeOrDocComment(attr)) {
+				const target = children.find((n) => start(n) <= start(attr) && ownStart(n) >= end(attr));
+				if (target) {
+					children.splice(i--, 1);
+					insertNode(Map_get(CommentChildNodes, target, getTransformedNodeChildren), attr);
+				}
+			}
+		}
+	}
+	return children;
+
+	function getTransformedNodeChildren(node: Node) {
+		if (is_Program(node)) node.comments ??= []; // prettier core deletes this property
+		const children = getNodeChildren(node);
+
+		if (is_NodeWithBodyNoBody(node)) {
+			insertNodes(children, (node as any).body);
+		}
+
+		__DEV__: {
+			const actual_count = countActualNodeChildren(node);
+			if (
+				children.length !== actual_count &&
+				!(is_MacroInvocation(node) && actual_count - node.segments.length === children.length)
+			) {
+				const actual = getActualNodeChildren(node);
+				const missing = actual.filter((n) => !children.includes(n));
+				const unknown = children.filter((n) => !actual.includes(n));
+				const duplicates_in_object = actual.filter((n, i, a) => i !== 0 && n === a[i - 1]);
+				const duplicates_in_childNodes = children.filter((n, i, a) => i !== 0 && n === a[i - 1]);
+				const ctx = { missing, unknown, duplicates_in_object, duplicates_in_childNodes };
+				for (let key in ctx) if (ctx[key].length === 0) delete ctx[key];
+				exit(`${node.type} was transformed but did not patch its childNodes list`, ctx, node.loc.url(), node);
+			}
+			for (const child of children)
+				if (!is_Node(child)) exit(`${node.type}'s childNodes includes unexpected entries`, { node, child });
+		}
+		return children;
+	}
+}

frontend/src/common/prettier/plugins/rust/utils/common.ts

@@ -0,0 +1,246 @@
+import { createCustomError } from "./debug";
+
+declare global {
+	interface ImportMeta {
+		url: string;
+	}
+}
+
+export function Narrow<T extends R, R = unknown>(value: R): asserts value is T {}
+export function AssertTypesEq<A extends B, B>(...args: [B] extends [A] ? [] : [RIGHT_TYPES_NOT_ASSIGNABLE_TO_LEFT: Exclude<B, A>]) {}
+
+// prettier-ignore
+type indexof<A> = A extends readonly any[] ? A extends 0 ? any : keyof A & number : A extends Set<unknown> ? never : A extends Map<infer U, unknown> ? U 
+	: A extends Iterable<unknown> ? never : A extends object ? keyof A & (number | string) : never;
+// prettier-ignore
+type valueof<A> = A extends ReadonlyArray<infer U> ? A extends 0 ? any : U : A extends Set<infer U> ? U : A extends Map<unknown, infer U> ? U 
+	: A extends Iterable<infer U> ? U : A extends object ? A[keyof A & (number | string)] : never;
+// prettier-ignore
+type vObject<V extends unknown = unknown, K extends unknown = unknown> = | object | readonly V[] | { [key: string]: V } | anySet<V> | anyMap<K, V>;
+export type itfn<A, R> = (value: valueof<A>, key: indexof<A>) => R;
+type anySet<V extends unknown = unknown> = Set<V>;
+type anyMap<K extends unknown = unknown, V extends unknown = unknown> = Map<K, V>;
+type anyfunction<A extends any[] = unknown[], R = unknown> = (...args: A) => R;
+type objlike = object | anyfunction;
+type anymap<K extends unknown = unknown, V extends unknown = unknown> = K extends objlike ? Map<K, V> | WeakMap<K, V> : Map<K, V>;
+
+export function exit(message: string, ...ctx: any[]): never {
+	if (ctx.length > 0) console.log("Error context:", { ...ctx });
+	throw createCustomError({ message });
+}
+exit.never = function never(...ctx: any[]): never {
+	exit("Reached unreachable code", ...ctx);
+};
+export function assert(predicate: boolean, err?: string, ...ctx: any[]): asserts predicate {
+	__DEV__: if (typeof predicate !== "boolean") exit("Expected boolean", predicate);
+	if (false === predicate) exit(err ?? "Assertion failed", ...ctx);
+}
+export function Identity<T>(v: T): T {
+	return v;
+}
+
+export function last_of<T extends ArrayLike<any>>(arr: T): T extends readonly [...infer A, infer U] ? U : T[number] {
+	__DEV__: isArrayLike(arr) || exit("Expected Array"), arr.length > 0 || exit("Attempted to retrieve last item of an empty array", arr);
+	return arr[arr.length - 1];
+}
+export function maybe_last_of<T extends readonly any[] | undefined>(
+	arr: T
+): T extends any[] ? (T extends readonly [...infer A, infer U] ? U : T[number]) : undefined {
+	return (undefined === arr || 0 === arr.length ? undefined : last_of(arr as any[])) as any;
+}
+
+export function normPath(filepath: string) {
+	return filepath.replace(/^file:\/\/\//, "").replace(/\\\\?/g, "/");
+}
+
+export function print_string(str: string) {
+	return /[\u0000-\u0020]/.test(str)
+		? str
+				.replace(/ /g, "•")
+				.replace(/\n/g, "↲")
+				.replace(/\t/g, "╚")
+				.replace(/[\u0000-\u0020]/g, "□")
+		: str;
+}
+
+function isArrayLike(value: any): value is ArrayLike<unknown> {
+	return is_object(value) && oisArrayLike(value);
+}
+
+function oisArrayLike(value: {}): value is ArrayLike<unknown> {
+	return "length" in value && (0 === (value as any).length || "0" in value);
+}
+
+export function binarySearchIn<T extends {}>(array: ArrayLike<T>, target: number, toValue: (item: T) => number) {
+	if (isEmpty(array)) return -1;
+	let i = 0;
+	let low = 0;
+	let high = array.length - 1;
+	let value = toValue(array[high]);
+	if (target >= value) return high;
+	else high--;
+	while (low <= high) {
+		i = low + ((high - low) >> 1);
+		value = toValue(array[i]);
+		if (target === value) return i;
+		if (target > value) low = i + 1;
+		else high = i - 1;
+	}
+	return low - 1;
+}
+
+export function getTerminalWidth(fallbackWidth = 200) {
+	return globalThis?.process?.stdout?.columns ?? fallbackWidth;
+}
+
+// @ts-ignore
+const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+export const color = ((cfn, mfn) => ({
+	black: cfn(30),
+	red: cfn(31),
+	green: cfn(32),
+	yellow: cfn(33),
+	blue: cfn(34),
+	magenta: cfn(35),
+	cyan: cfn(36),
+	white: cfn(37),
+	grey: cfn(90),
+	bold: mfn(1, 22),
+	italic: mfn(3, 23),
+	underline: mfn(4, 24),
+	hidden: mfn(8, 28),
+	hiddenCursor: (str: string) => `\x1B[?25l${str}\x1B[?25h`,
+	unstyle: (str: string) => str.replace(/\x1B\[[0-9][0-9]?m/g, ""),
+	unstyledLength: (str: string) => str.replace(/\x1B\[[0-9][0-9]?m/g, "").length,
+	link: (str: string) => color.underline(color.blue(str)),
+}))(
+	(c1: number) => (isBrowser ? Identity : (str: string) => `\x1B[${c1}m${str.replace(/\x1B\[39m/g, `\x1B[${c1}m`)}\x1B[39m`),
+	(c1: number, c2: number) => (isBrowser ? Identity : (str: string) => `\x1B[${c1}m${str}\x1B[${c2}m`)
+);
+export function Map_get<K extends object, V>(map: WeakMap<K, V>, key: K, init: (key: K) => V): V;
+export function Map_get<K, V>(map: Map<K, V>, key: K, init: (key: K) => V): V;
+export function Map_get<K, V>(map: anymap<K, V>, key: K, init: (key: K) => V): V {
+	if (!map.has(key)) map.set(key, init(key));
+	return map.get(key)!;
+}
+export function isEmpty(array: ArrayLike<any>): boolean {
+	__DEV__: assert(isArrayLike(array));
+	return 0 === array.length;
+}
+export function Array_splice<T extends any[]>(array: T, target: T[number], index: number = array.indexOf(target)) {
+	__DEV__: {
+		const i = arguments.length === 2 ? array.indexOf(target) : index;
+		assert(i === index && i !== -1 && i === array.lastIndexOf(target), "", { array, target, index, i });
+	}
+	array.splice(index, 1);
+}
+export function Array_replace<T extends any[]>(array: T, target: T[number], ...replacements: T[number][]) {
+	const i = array.indexOf(target);
+	__DEV__: if (i === -1 || i !== array.lastIndexOf(target))
+		exit("Array_replace", { index: i, lastIndex: array.lastIndexOf(target), array, target, replacements });
+	array.splice(array.indexOf(target), 1, ...replacements);
+}
+export function has_key_defined<T extends object, K extends T extends never ? never : keyof T>(
+	o: T,
+	k: K
+): o is K extends never
+	? never
+	: T extends { [k in K]: any }
+	? T & { [k in K]: {} }
+	: T extends { [k in K]?: any }
+	? T & { [k in K]: {} }
+	: never {
+	return k in o && undefined !== o[k];
+}
+
+export function is_object(data: unknown): data is object | ({ [key: string]: unknown } | unknown[]) {
+	return "object" === typeof data && null !== data;
+}
+
+export function is_array(data: unknown): data is any[] {
+	return Array.isArray(data);
+}
+
+function ois_vobject(data: any) {
+	__DEV__: assert(is_object(data));
+	switch (data.constructor) {
+		case Array:
+		case Object:
+		case Set:
+		case Map:
+			return true;
+		default:
+			return false;
+	}
+}
+
+export function each<A extends vObject>(data: A, callback: itfn<A, void>): void;
+export function each(data: any, callback: (value: any, index: any) => void): void {
+	__DEV__: assert(ois_vobject(data));
+	// prettier-ignore
+	switch (data.constructor) {
+		case Array: { let i = 0; for (; i < data.length; i++) callback(data[i], i); return; }
+		case Object: { let k; for (k in data) callback(data[k], k); return; }
+		case Set: { let d; for (d of data) callback(d, undefined!); return; }
+		case Map: { let e; for (e of data) callback(e[1], e[0]); return; }
+		default:  { let x; for (x of data) callback(x, undefined!); return; }
+	}
+}
+
+export function iLast(index: number, array: any[]) {
+	return 1 + index === array.length;
+}
+
+export function find_last<T>(arr: T[], test: itfn<T[], boolean>): T | undefined {
+	for (var i = arr.length; --i !== -1; ) if (test(arr[i], i)) return arr[i];
+}
+
+export function try_eval<T>(fn: () => T): T | undefined {
+	try {
+		return fn();
+	} catch (e) {
+		return undefined;
+	}
+}
+
+export function clamp(min: number, max: number, value: number) {
+	return value > min ? (value < max ? value : max) : min;
+}
+
+export type MaybeFlatten<T> = T extends ReadonlyArray<infer U> ? MaybeFlatten<Exclude<U, T>> : T;
+export type FlatArray<T> = MaybeFlatten<T>[];
+export function flat<T extends readonly any[]>(arr: T): FlatArray<T> {
+	return (arr as any as [any]).flat(Infinity);
+}
+export function flatMap<T extends readonly any[], R>(arr: T, mapFn: (item: T[number], index: number, array: T) => R): FlatArray<R> {
+	return flat(arr.map(mapFn as any));
+}
+
+export function joinln(...arr: string[]): string {
+	return arr.join("\n");
+}
+
+export function join_lines(fn: () => Generator<string, void, void>): string {
+	return [...fn()].join("\n");
+}
+
+export function reduce_tagged_template<T>(args: [strings: TemplateStringsArray, ...values: T[]], map: (value: T) => string) {
+	for (var str = "" + args[0][0], i = 1; i < args.length; i++) str += map(args[i] as T) + args[0][i];
+	return str;
+}
+
+export function map_tagged_template<T, R>(args: [strings: TemplateStringsArray, ...values: T[]], map: (value: T) => R) {
+	const arr: (R | string)[] = [args[0][0]];
+	for (var i = 1; i < args.length; i++) arr.push(map(args[i] as T), args[0][i]);
+	return arr;
+}
+
+export function spliceAll<T extends any[]>(array: T): [...T] {
+	const r: [...T] = [...array];
+	array.length = 0;
+	return r;
+}
+
+export function spread<R>(fn: () => Iterable<R>): R[] {
+	return [...fn()];
+}

frontend/src/common/prettier/plugins/rust/utils/debug.ts

@@ -0,0 +1,141 @@
+import { clamp, color, getTerminalWidth, normPath } from "./common";
+
+const cwd = 
+	typeof process === "object" && typeof process?.cwd === "function" ? /* @__PURE__ */ normPath(/* @__PURE__ */ process.cwd() ?? "") : "";
+function normPath_strip_cwd(filepath: string) {
+	let normFilePath = normPath(filepath);
+	return normFilePath.startsWith(cwd) ? normFilePath.slice(cwd.length + 1) : normFilePath;
+}
+
+type StackStyleFn = (callee: string, item: StackItem) => (str: string) => string;
+interface Stack extends Array<StackItem> {
+	message: string;
+	style?: { callee?: StackStyleFn; url?: StackStyleFn } | undefined;
+}
+
+class StackLine {
+	declare readonly raw: string;
+	declare readonly callee: string;
+	declare readonly filepath: string;
+	declare readonly line: string;
+	declare readonly col: string;
+	declare readonly other: string;
+	declare readonly url: string;
+	constructor(raw: string) {
+		({
+			1: this.callee = "",
+			2: this.filepath = "",
+			3: this.line = "",
+			4: this.col = "",
+			5: this.other = "",
+		} = (this.raw = raw).match(/at (?:(.+?)\s+\()?(?:(.+?):([0-9]+)(?::([0-9]+))?|([^)]+))\)?/) ?? ["", "", "", "", "", ""]);
+		this.url = this.filepath //
+			? normPath_strip_cwd(this.filepath) + (this.line && this.col && `:${this.line}:${this.col}`)
+			: this.other === "native"
+			? "<native>"
+			: "";
+	}
+}
+
+function getPrintWidth() {
+	return clamp(0, getTerminalWidth(128), 200) - 4;
+}
+
+class StackItem extends StackLine {
+	constructor(private readonly stack: Stack, readonly i: number, raw: string) {
+		super(raw);
+	}
+	hidden = false;
+	hide() {
+		this.hidden = true;
+		return this;
+	}
+	hideNext(n: number) {
+		for (let i = 0; i < n; i++) this.at(i)?.hide();
+	}
+	hideWhileTrue(test: (line: StackItem) => boolean) {
+		let line: StackItem | undefined = this;
+		while (line && test(line)) line = line.hide().next();
+	}
+	at(relIndex: number) {
+		return this.i + relIndex >= this.stack.length || this.i + relIndex < 0 ? undefined : this.stack[this.i + relIndex];
+	}
+	next() {
+		return this.at(+1);
+	}
+	toString() {
+		const url = this.url;
+		const calleeColor = this.stack.style?.callee?.(this.callee, this) ?? color.cyan;
+		const urlColor = this.stack.style?.url?.(url, this) ?? color.grey;
+		return compose2Cols("    at " + calleeColor(this.callee), urlColor(url), getPrintWidth());
+	}
+}
+
+// prettier-ignore
+function createStack(message: string, Error_stack: string, style: Stack["style"]): Stack {
+	for (var STACK: Stack = [] as any, i = 0, stack = Error_stack.split("\n").slice(2); i < stack.length; i++) STACK[i] = new StackItem(STACK, i, stack[i]);
+	return (STACK.message = message), (STACK.style = style), STACK;
+}
+
+function composeStack(stack: Stack) {
+	var hidden = 0;
+	var str = stack.message;
+	for (var item of stack) item.hidden ? ++hidden : (str += "\n" + item.toString());
+	return str + (hidden > 0 ? "\n" + color.grey(compose2Cols("", `...filtered ${hidden} lines`, getPrintWidth())) : "");
+}
+
+export function get_caller_cmd(offset = 0) {
+	const obj: { stack: string } = {} as any;
+	Error.captureStackTrace(obj, get_caller_cmd);
+	const lines = obj.stack.split("\n");
+	return new StackLine(lines[1 + clamp(0, lines.length - 2, offset)]).url;
+}
+
+var Error_prepareStackTrace;
+let replaced_default_prepareStackTrace = false;
+function custom_prepareStackTrace(err, calls) {
+	return (Error_prepareStackTrace?.(err, calls) ?? calls.join("\n"))?.replace(/file:\/\/\//g, "").replace(/\\\\?/g, "/") ?? calls;
+}
+
+export function overrideDefaultError(silent = false) {
+	if (replaced_default_prepareStackTrace === (replaced_default_prepareStackTrace = true)) return;
+	Error_prepareStackTrace = Error.prepareStackTrace ?? ((_, calls) => calls.join("\n"));
+	Error.prepareStackTrace = custom_prepareStackTrace;
+	if (!silent) console.log(color.grey(`[devtools] Replaced Error.prepareStackTrace at ${get_caller_cmd(1)}`));
+}
+
+export function createCustomError({
+	message = "Unknown Error",
+	editStack = (stack: StackItem[]) => {},
+	style = undefined as Stack["style"],
+	stackTraceLimit = 20,
+}): Error {
+	const _stackTraceLimit = Error.stackTraceLimit;
+	const _prepareStackTrace = Error.prepareStackTrace;
+	if (replaced_default_prepareStackTrace && _prepareStackTrace === custom_prepareStackTrace)
+		Error.prepareStackTrace = Error_prepareStackTrace;
+
+	Error.stackTraceLimit = stackTraceLimit;
+
+	const _ctx: { stack: string } = {} as any;
+
+	Error.captureStackTrace(_ctx, createCustomError);
+
+	const stack = createStack(message, _ctx.stack, style);
+	Error.prepareStackTrace = function (err, calls) {
+		editStack(stack);
+		return composeStack(stack);
+	};
+
+	const err = new Error(message); // (get) to trigger prepareStackTrace, (set) to prevent treeshaking
+	err.stack = err.stack;
+
+	Error.stackTraceLimit = _stackTraceLimit;
+	Error.prepareStackTrace = _prepareStackTrace;
+
+	return err;
+}
+
+function compose2Cols(left: string, right: string, len = 64, min = 1) {
+	return left + " ".repeat(clamp(min, len, len - (color.unstyledLength(left) + color.unstyledLength(right)))) + right;
+}

frontend/src/common/prettier/plugins/shell/index.ts

@@ -0,0 +1,471 @@
+import type { Parser, ParserOptions, Plugin, Printer } from 'prettier'
+import {
+    type File,
+    LangVariant,
+    type Node,
+    type ParseError,
+    type ShOptions,
+    type ShPrintOptions,
+    getProcessor,
+} from 'sh-syntax'
+
+import { languages } from './languages'
+
+// 创建处理器实例
+let processorInstance: any = null
+
+const getProcessorInstance = async () => {
+    if (!processorInstance) {
+        try {
+            // @ts-ignore
+            const initWasm = await import('sh-syntax/main.wasm?init')
+            processorInstance = getProcessor(initWasm.default)
+        } catch {
+            processorInstance = getProcessor(() =>
+                fetch(new URL('sh-syntax/main.wasm', import.meta.url))
+            )
+        }
+    }
+    return processorInstance
+}
+
+export interface DockerfilePrintOptions extends ParserOptions<string> {
+    indent?: number
+    spaceRedirects?: boolean
+}
+
+export interface ShParserOptions
+    extends Partial<ParserOptions<Node>>,
+        ShOptions {
+    filepath?: string
+}
+
+export type { ShPrintOptions }
+
+export interface ShPrinterOptions extends ShPrintOptions {
+    filepath?: string
+    tabWidth: number
+}
+
+export class ShSyntaxParseError<
+    E extends Error = ParseError | SyntaxError,
+> extends SyntaxError {
+    declare cause: E
+
+    declare loc: { start: { column: number; line: number } } | undefined
+
+    constructor(err: E) {
+        const error = err as ParseError | SyntaxError
+        super(('Text' in error && error.Text) || error.message)
+        this.cause = err
+        // `error instanceof ParseError` won't not work because the error is thrown wrapped by `synckit`
+        if ('Pos' in error && error.Pos != null && typeof error.Pos === 'object') {
+            this.loc = { start: { column: error.Pos.Col, line: error.Pos.Line } }
+        }
+    }
+}
+
+function hasPragma(text: string) {
+    /**
+     * We don't want to parse every file twice but Prettier's interface isn't
+     * conducive to caching/memoizing an upstream Parser, so we're going with some
+     * minor Regex hackery.
+     *
+     * Only read empty lines, comments, and shebangs at the start of the file. We
+     * do not support Bash's pseudo-block comments.
+     */
+
+        // No, we don't support unofficial block comments.
+    const commentLineRegex = /^\s*(#(?<comment>.*))?$/gm
+    let lastIndex = -1
+
+    /**
+     * Only read leading comments, skip shebangs, and check for the pragma. We
+     * don't want to have to parse every file twice.
+     */
+    for (;;) {
+        const match = commentLineRegex.exec(text)
+
+        // Found "real" content, EoF, or stuck in a loop.
+        if (match == null || match.index !== lastIndex + 1) {
+            return false
+        }
+
+        lastIndex = commentLineRegex.lastIndex
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- incorrect typing
+        const comment = match.groups?.comment?.trim()
+
+        // Empty lines and shebangs have no captures
+        if (comment == null) {
+            continue
+        }
+
+        if (comment.startsWith('@prettier') || comment.startsWith('@format')) {
+            return true
+        }
+    }
+}
+
+const dockerfileParser: Parser<string> = {
+    astFormat: 'dockerfile',
+    hasPragma,
+    parse: text => text,
+    locStart: () => 0,
+    locEnd: node => node.length,
+}
+
+let formatDockerfileContents_:
+    | any
+    | undefined
+
+const getFormatDockerfileContents = async () => {
+    if (!formatDockerfileContents_) {
+        try {
+            // @ts-ignore - 忽略模块解析错误
+            const dockerfmt = await import('@reteps/dockerfmt')
+            formatDockerfileContents_ = dockerfmt.formatDockerfileContents
+        } catch (error) {
+            console.warn('Failed to load @reteps/dockerfmt:', error)
+            formatDockerfileContents_ = null
+        }
+    }
+    return formatDockerfileContents_
+}
+
+const dockerPrinter: Printer<string> = {
+    // @ts-expect-error -- https://github.com/prettier/prettier/issues/15080#issuecomment-1630987744
+    async print(
+        path,
+        {
+            filepath,
+
+            // parser options
+            keepComments = true,
+            variant,
+            stopAt,
+            recoverErrors,
+
+            // printer options
+            useTabs,
+            tabWidth,
+            indent = useTabs ? 0 : (tabWidth ?? 2),
+            binaryNextLine = true,
+            switchCaseIndent = true,
+            spaceRedirects,
+            // eslint-disable-next-line sonarjs/deprecation
+            keepPadding,
+            minify,
+            singleLine,
+            functionNextLine,
+        }: ShPrintOptions,
+    ) {
+        const formatDockerfileContents = await getFormatDockerfileContents()
+        try {
+            if (formatDockerfileContents) {
+                return await formatDockerfileContents(path.node, {
+                    indent,
+                    spaceRedirects: spaceRedirects ?? false,
+                    trailingNewline: true,
+                })
+            }
+            throw new Error('dockerfmt not available')
+        } catch {
+            /*
+             * `dockerfmt` is buggy now and could throw unexpectedly, so we fallback to
+             * the `sh` printer automatically in this case.
+             *
+             * @see {https://github.com/reteps/dockerfmt/issues/21}
+             * @see {https://github.com/reteps/dockerfmt/issues/25}
+             */
+            const processor = await getProcessorInstance()
+            return processor(path.node, {
+                print: true,
+                filepath,
+                keepComments,
+                variant,
+                stopAt,
+                recoverErrors,
+                useTabs,
+                tabWidth,
+                indent,
+                binaryNextLine,
+                switchCaseIndent,
+                spaceRedirects: spaceRedirects ?? true,
+                keepPadding,
+                minify,
+                singleLine,
+                functionNextLine,
+            })
+        }
+    },
+}
+
+const shParser: Parser<Node> = {
+    astFormat: 'sh',
+    hasPragma,
+    locStart: node => node.Pos.Offset,
+    locEnd: node => node.End.Offset,
+    async parse(
+        text,
+        {
+            filepath = '',
+            keepComments = true,
+            /**
+             * The following `@link` doesn't work as expected, see
+             * {@link https://github.com/microsoft/tsdoc/issues/9}
+             */
+            /** TODO: support {@link LangVariant.LangAuto} */ // eslint-disable-line sonarjs/todo-tag
+            variant,
+            stopAt,
+            recoverErrors,
+        }: ShParserOptions,
+    ) {
+        const processor = await getProcessorInstance()
+        return processor(text, {
+            filepath,
+            keepComments,
+            variant,
+            stopAt,
+            recoverErrors,
+        })
+    },
+}
+
+const shPrinter: Printer<Node | string> = {
+    // @ts-expect-error -- https://github.com/prettier/prettier/issues/15080#issuecomment-1630987744
+    async print(
+        path,
+        {
+            originalText,
+            filepath,
+
+            // parser options
+            keepComments = true,
+            variant,
+            stopAt,
+            recoverErrors,
+
+            // printer options
+            useTabs,
+            tabWidth,
+            indent = useTabs ? 0 : tabWidth,
+            binaryNextLine = true,
+            switchCaseIndent = true,
+            spaceRedirects = true,
+            // eslint-disable-next-line sonarjs/deprecation
+            keepPadding,
+            minify,
+            singleLine,
+            functionNextLine,
+        }: ShPrintOptions,
+    ) {
+        const processor = await getProcessorInstance()
+        return processor(path.node as File, {
+            originalText,
+            filepath,
+            keepComments,
+            variant,
+            stopAt,
+            recoverErrors,
+            useTabs,
+            tabWidth,
+            indent,
+            binaryNextLine,
+            switchCaseIndent,
+            spaceRedirects,
+            keepPadding,
+            minify,
+            singleLine,
+            functionNextLine,
+        })
+    },
+}
+
+export const parsers = {
+    dockerfile: dockerfileParser,
+    sh: shParser,
+}
+
+export const printers = {
+    dockerfile: dockerPrinter,
+    sh: shPrinter,
+}
+
+export const options: Plugin['options'] = {
+    keepComments: {
+        // since: '0.1.0',
+        category: 'Output',
+        type: 'boolean',
+        default: true,
+        description:
+            'KeepComments makes the parser parse comments and attach them to nodes, as opposed to discarding them.',
+    },
+    variant: {
+        // since: '0.1.0',
+        category: 'Config',
+        type: 'choice',
+        choices: [
+            {
+                value: LangVariant.LangBash,
+                description: [
+                    'LangBash corresponds to the GNU Bash language, as described in its manual at https://www.gnu.org/software/bash/manual/bash.html.',
+                    '',
+                    'We currently follow Bash version 5.2.',
+                    '',
+                    'Its string representation is "bash".',
+                ].join('\n'),
+            },
+            {
+                value: LangVariant.LangPOSIX,
+                description: [
+                    'LangPOSIX corresponds to the POSIX Shell language, as described at https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html.',
+                    '',
+                    'Its string representation is "posix" or "sh".',
+                ].join('\n'),
+            },
+            {
+                value: LangVariant.LangMirBSDKorn,
+                description: [
+                    'LangMirBSDKorn corresponds to the MirBSD Korn Shell, also known as mksh, as described at http://www.mirbsd.org/htman/i386/man1/mksh.htm.',
+                    'Note that it shares some features with Bash, due to the shared ancestry that is ksh.',
+                    '',
+                    'We currently follow mksh version 59.',
+                    '',
+                    'Its string representation is "mksh".',
+                ].join('\n'),
+            },
+            {
+                value: LangVariant.LangBats,
+                description: [
+                    'LangBats corresponds to the Bash Automated Testing System language, as described at https://github.com/bats-core/bats-core.',
+                    "Note that it's just a small extension of the Bash language.",
+                    '',
+                    'Its string representation is "bats".',
+                ].join('\n'),
+            },
+            {
+                value: LangVariant.LangAuto,
+                description: [
+                    "LangAuto corresponds to automatic language detection, commonly used by end-user applications like shfmt, which can guess a file's language variant given its filename or shebang.",
+                    '',
+                    'At this time, [Variant] does not support LangAuto.',
+                ].join('\n'),
+            },
+        ],
+        description:
+            'Variant changes the shell language variant that the parser will accept.',
+    },
+    stopAt: {
+        // since: '0.1.0',
+        category: 'Config',
+        type: 'path',
+        description: [
+            'StopAt configures the lexer to stop at an arbitrary word, treating it as if it were the end of the input. It can contain any characters except whitespace, and cannot be over four bytes in size.',
+            'This can be useful to embed shell code within another language, as one can use a special word to mark the delimiters between the two.',
+            'As a word, it will only apply when following whitespace or a separating token. For example, StopAt("$$") will act on the inputs "foo $$" and "foo;$$", but not on "foo \'$$\'".',
+            'The match is done by prefix, so the example above will also act on "foo $$bar".',
+        ].join('\n'),
+    },
+    recoverErrors: {
+        // since: '0.17.0',
+        category: 'Config',
+        type: 'path',
+        description: [
+            'RecoverErrors allows the parser to skip up to a maximum number of errors in the given input on a best-effort basis.',
+            'This can be useful to tab-complete an interactive shell prompt, or when providing diagnostics on slightly incomplete shell source.',
+            '',
+            'Currently, this only helps with mandatory tokens from the shell grammar which are not present in the input. They result in position fields or nodes whose position report [Pos.IsRecovered] as true.',
+            '',
+            'For example, given the input `(foo |`, the result will contain two recovered positions; first, the pipe requires a statement to follow, and as [Stmt.Pos] reports, the entire node is recovered.',
+            'Second, the subshell needs to be closed, so [Subshell.Rparen] is recovered.',
+        ].join('\n'),
+    },
+    indent: {
+        // since: '0.1.0',
+        category: 'Format',
+        type: 'int',
+        description:
+            'Indent sets the number of spaces used for indentation. If set to 0, tabs will be used instead.',
+    },
+    binaryNextLine: {
+        // since: '0.1.0',
+        category: 'Output',
+        type: 'boolean',
+        default: true,
+        description:
+            'BinaryNextLine will make binary operators appear on the next line when a binary command, such as a pipe, spans multiple lines. A backslash will be used.',
+    },
+    switchCaseIndent: {
+        // since: '0.1.0',
+        category: 'Format',
+        type: 'boolean',
+        default: true,
+        description:
+            'SwitchCaseIndent will make switch cases be indented. As such, switch case bodies will be two levels deeper than the switch itself.',
+    },
+    spaceRedirects: {
+        // since: '0.1.0',
+        category: 'Format',
+        type: 'boolean',
+        default: true,
+        description:
+            "SpaceRedirects will put a space after most redirection operators. The exceptions are '>&', '<&', '>(', and '<('.",
+    },
+    keepPadding: {
+        // since: '0.1.0',
+        category: 'Format',
+        type: 'boolean',
+        default: false,
+        description: [
+            'KeepPadding will keep most nodes and tokens in the same column that they were in the original source.',
+            'This allows the user to decide how to align and pad their code with spaces.',
+            '',
+            'Note that this feature is best-effort and will only keep the alignment stable, so it may need some human help the first time it is run.',
+        ].join('\n'),
+        deprecated: [
+            'This formatting option is flawed and buggy, and often does not result in what the user wants when the code gets complex enough.',
+            'The next major version, v4, will remove this feature entirely.',
+            'See: https://github.com/mvdan/sh/issues/658',
+        ].join('\n'),
+    },
+    minify: {
+        // since: '0.1.0',
+        category: 'Output',
+        type: 'boolean',
+        default: false,
+        description: [
+            'Minify will print programs in a way to save the most bytes possible.',
+            'For example, indentation and comments are skipped, and extra whitespace is avoided when possible.',
+        ].join('\n'),
+    },
+    singleLine: {
+        // since: '0.17.0',
+        category: 'Format',
+        type: 'boolean',
+        default: false,
+        description: [
+            'SingleLine will attempt to print programs in one line. For example, lists of commands or nested blocks do not use newlines in this mode.',
+            'Note that some newlines must still appear, such as those following comments or around here-documents.',
+            '',
+            "Print's trailing newline when given a [*File] is not affected by this option.",
+        ].join('\n'),
+    },
+    functionNextLine: {
+        // since: '0.1.0',
+        category: 'Format',
+        type: 'boolean',
+        default: false,
+        description:
+            "FunctionNextLine will place a function's opening braces on the next line.",
+    },
+}
+
+const shellPlugin: Plugin = {
+    languages,
+    parsers,
+    printers,
+    options,
+}
+
+export default shellPlugin
+export { languages }

frontend/src/common/prettier/plugins/shell/languages.ts

@@ -0,0 +1,60 @@
+export const languages = [
+  {
+    name: "Shell",
+    parsers: ["sh"],
+    extensions: [
+      ".sh",
+      ".bash", 
+      ".zsh",
+      ".fish",
+      ".ksh",
+      ".csh",
+      ".tcsh",
+      ".ash",
+      ".dash"
+    ],
+    filenames: [
+      "*.sh",
+      "*.bash",
+      ".bashrc",
+      ".bash_profile",
+      ".bash_login",
+      ".bash_logout",
+      ".zshrc",
+      ".profile"
+    ],
+    interpreters: [
+      "bash",
+      "sh",
+      "zsh",
+      "fish",
+      "ksh",
+      "csh", 
+      "tcsh",
+      "ash",
+      "dash"
+    ],
+    tmScope: "source.shell",
+    aceMode: "sh",
+    codemirrorMode: "shell",
+    linguistLanguageId: 302,
+    vscodeLanguageIds: ["shellscript"]
+  },
+  {
+    name: "Dockerfile",
+    parsers: ["dockerfile"],
+    extensions: [".dockerfile"],
+    filenames: [
+      "Dockerfile",
+      "*.dockerfile",
+      "Containerfile",
+      "*.containerfile"
+    ],
+    tmScope: "source.dockerfile",
+    aceMode: "dockerfile",
+    codemirrorMode: "dockerfile",
+    linguistLanguageId: 99,
+    vscodeLanguageIds: ["dockerfile"]
+  }
+];
+

frontend/src/common/prettier/plugins/sql/languages.js

@@ -0,0 +1,30 @@
+// SQL语言定义
+export const languages = [
+  {
+    name: "SQL",
+    parsers: ["sql"],
+    extensions: [
+      ".sql", 
+      ".ddl", 
+      ".dml", 
+      ".hql", 
+      ".psql", 
+      ".plsql",
+      ".mysql",
+      ".mssql",
+      ".pgsql",
+      ".sqlite",
+      ".bigquery",
+      ".snowflake",
+      ".redshift",
+      ".db2",
+      ".n1ql",
+      ".cql"
+    ],
+    filenames: [
+      "*.sql",
+      "*.ddl", 
+      "*.dml"
+    ]
+  }
+];

frontend/src/common/prettier/plugins/sql/sql.d.ts

@@ -0,0 +1,40 @@
+import { AST, Option } from 'node-sql-parser';
+import { Options, ParserOptions, Plugin } from 'prettier';
+import {
+  FormatOptions,
+  FormatOptionsWithLanguage,
+} from 'sql-formatter';
+
+export type SqlBaseOptions = Option &
+  Partial<
+    | (FormatOptions & { dialect: string })
+    | (FormatOptionsWithLanguage & { dialect?: never })
+  > & {
+    formatter?: 'sql-formatter' | 'node-sql-parser' | 'sql-cst';
+    params?: string;
+    paramTypes?: string;
+    autoDetectDialect?: boolean;
+  };
+
+export type SqlOptions = ParserOptions<AST> & SqlBaseOptions;
+export type SqlFormatOptions = Options & SqlBaseOptions;
+export declare const languages: Plugin["languages"];
+
+export declare const parsers: {
+  sql: {
+    parse(text: string, options?: SqlOptions): AST | string;
+    astFormat: 'sql';
+    locStart(): number;
+    locEnd(): number;
+  };
+};
+
+export declare const printers: Plugin["printers"];
+
+export declare const options: Plugin["options"];
+
+export declare function detectDialect(sql: string): string;
+
+declare const SqlPlugin: Plugin<AST | string>;
+
+export default SqlPlugin;

frontend/src/common/prettier/plugins/sql/sql.mjs

@@ -0,0 +1,459 @@
+import { JSOX } from 'jsox';
+import nodeSqlParser from 'node-sql-parser';
+import {
+  format,
+  formatDialect,
+} from 'sql-formatter';
+import { detectDialect } from './detect.mjs';
+import { languages } from './languages.js';
+
+const parser = new nodeSqlParser.Parser();
+
+const SQL_FORMATTER = 'sql-formatter';
+const NODE_SQL_PARSER = 'node-sql-parser';
+
+// Parsers
+export const parsers = {
+    sql: {
+    parse(text, options = {}) {
+      const { formatter, type, database } = options;
+      
+      return formatter === SQL_FORMATTER
+        ? text
+        : parser.astify(text, { type, database });
+    },
+    astFormat: 'sql',
+    locStart: () => -1,
+    locEnd: () => -1,
+  },
+};
+
+// Printers
+export const printers = {
+  sql: {
+    print(path, options = {}) {
+      const value = path.node;
+      const {
+        formatter = SQL_FORMATTER,
+        type,
+        database,
+        dialect,
+        language,
+        params,
+        paramTypes,
+        autoDetectDialect = true,
+        ...formatOptions
+      } = options;
+
+      let formatted;
+
+      if (typeof value === 'string') {
+        // 准备sql-formatter选项
+        const sqlFormatterOptions = {
+          ...formatOptions,
+          params:
+            params == null
+              ? undefined
+              : JSOX.parse(params),
+          paramTypes:
+            paramTypes == null
+              ? undefined
+              : JSOX.parse(paramTypes),
+        };
+
+        let finalLanguage = language;
+        let finalDialect = dialect;
+        
+        if (autoDetectDialect && !language && !dialect) {
+          const detectedDialect = detectDialect(value);
+          finalLanguage = detectedDialect;
+        }
+
+        // 使用适当的格式化方法
+        if (finalDialect != null) {
+          // 使用formatDialect方法
+          formatted = formatDialect(value, {
+            ...sqlFormatterOptions,
+            dialect: JSOX.parse(finalDialect),
+          });
+        } else {
+          // 使用format方法
+          formatted = format(value, {
+            ...sqlFormatterOptions,
+            language: finalLanguage,
+          });
+        }
+      } else {
+        // 使用node-sql-parser进行格式化
+        formatted = parser.sqlify(value, { type, database });
+      }
+
+      return formatted + '\n';
+    },
+  },
+};
+
+// 插件选项
+export const options = {
+  formatter: {
+    category: 'Config',
+    type: 'choice',
+    default: SQL_FORMATTER,
+    description: 'Choose which formatter to be used',
+    choices: [
+      {
+        value: SQL_FORMATTER,
+        description: 'use `sql-formatter` as formatter',
+      },
+      {
+        value: NODE_SQL_PARSER,
+        description: 'use `node-sql-parser` as formatter',
+      },
+    ],
+  },
+  autoDetectDialect: {
+    category: 'Config',
+    type: 'boolean',
+    default: true,
+    description: 'Automatically detect SQL dialect if language/dialect is not specified',
+  },
+  dialect: {
+    category: 'Config',
+    type: 'string',
+    description: 'SQL dialect for `sql-formatter` formatDialect()',
+  },
+  language: {
+    category: 'Config',
+    type: 'choice',
+    default: 'sql',
+    description: 'SQL dialect for `sql-formatter` format()',
+    choices: [
+      {
+        value: 'sql',
+        description: 'Standard SQL: https://en.wikipedia.org/wiki/SQL:2011',
+      },
+      {
+        value: 'bigquery',
+        description:
+          'Google Standard SQL (Bigquery): https://cloud.google.com/bigquery',
+      },
+      {
+        value: 'db2',
+        description: 'IBM DB2: https://www.ibm.com/products/db2',
+      },
+      {
+        value: 'db2i',
+        description:
+          'IBM DB2i (experimental): https://www.ibm.com/docs/en/i/7.5?topic=overview-db2-i',
+      },
+      {
+        value: 'hive',
+        description: 'Apache Hive: https://hive.apache.org',
+      },
+      {
+        value: 'mariadb',
+        description: 'MariaDB: https://mariadb.com',
+      },
+      {
+        value: 'mysql',
+        description: 'MySQL: https://www.mysql.com',
+      },
+      {
+        value: 'n1ql',
+        description:
+          'Couchbase N1QL: https://www.couchbase.com/products/n1ql',
+      },
+      {
+        value: 'plsql',
+        description:
+          'Oracle PL/SQL: https://www.oracle.com/database/technologies/appdev/plsql.html',
+      },
+      {
+        value: 'postgresql',
+        description: 'PostgreSQL: https://www.postgresql.org',
+      },
+      {
+        value: 'redshift',
+        description:
+          'Amazon Redshift: https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_SQLCommandRef.html',
+      },
+      {
+        value: 'singlestoredb',
+        description:
+          'SingleStoreDB: https://docs.singlestore.com/db/v7.8/en/introduction/singlestore-documentation.html',
+      },
+      {
+        value: 'snowflake',
+        description: 'Snowflake: https://docs.snowflake.com',
+      },
+      {
+        value: 'spark',
+        description: 'Spark: https://spark.apache.org',
+      },
+      {
+        value: 'sqlite',
+        description: 'SQLite: https://www.sqlite.org',
+      },
+      {
+        value: 'transactsql',
+        description:
+          'SQL Server Transact-SQL: https://docs.microsoft.com/en-us/sql/sql-server/',
+      },
+      {
+        value: 'tsql',
+        description:
+          'SQL Server Transact-SQL: https://docs.microsoft.com/en-us/sql/sql-server/',
+      },
+      {
+        value: 'trino',
+        description: 'Trino: https://trino.io',
+      },
+    ],
+  },
+  keywordCase: {
+    category: 'Output',
+    type: 'choice',
+    default: 'preserve',
+    description:
+      'Converts reserved keywords to upper- or lowercase for `sql-formatter`',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'preserves the original case of reserved keywords',
+      },
+      {
+        value: 'upper',
+        description: 'converts reserved keywords to uppercase',
+      },
+      {
+        value: 'lower',
+        description: 'converts reserved keywords to lowercase',
+      },
+    ],
+  },
+  dataTypeCase: {
+    category: 'Output',
+    type: 'choice',
+    default: 'preserve',
+    description:
+      'Converts data types to upper- or lowercase for `sql-formatter`',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'preserves the original case of data types',
+      },
+      {
+        value: 'upper',
+        description: 'converts data types to uppercase',
+      },
+      {
+        value: 'lower',
+        description: 'converts data types to lowercase',
+      },
+    ],
+  },
+  functionCase: {
+    category: 'Output',
+    type: 'choice',
+    default: 'preserve',
+    description:
+      'Converts functions to upper- or lowercase for `sql-formatter`',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'preserves the original case of functions',
+      },
+      {
+        value: 'upper',
+        description: 'converts functions to uppercase',
+      },
+      {
+        value: 'lower',
+        description: 'converts functions to lowercase',
+      },
+    ],
+  },
+  identifierCase: {
+    category: 'Output',
+    type: 'choice',
+    default: 'preserve',
+    description:
+      'Converts identifiers to upper- or lowercase for `sql-formatter`. Only unquoted identifiers are converted. (experimental)',
+    choices: [
+      {
+        value: 'preserve',
+        description: 'preserves the original case of identifiers',
+      },
+      {
+        value: 'upper',
+        description: 'converts identifiers to uppercase',
+      },
+      {
+        value: 'lower',
+        description: 'converts identifiers to lowercase',
+      },
+    ],
+  },
+  uppercase: {
+    category: 'Output',
+    type: 'boolean',
+    deprecated: '0.7.0',
+    description: 'Use `keywordCase` option instead',
+  },
+  indentStyle: {
+    category: 'Format',
+    type: 'choice',
+    default: 'standard',
+    description: `Switches between different indentation styles for \`sql-formatter\`.
+
+    Caveats of using \`"tabularLeft"\` and \`"tabularRight"\`:
+
+    - \`tabWidth\` option is ignored. Indentation will always be 10 spaces, regardless of what is specified by \`tabWidth\``,
+    choices: [
+      {
+        value: 'standard',
+        description:
+          'indents code by the amount specified by `tabWidth` option',
+      },
+      {
+        value: 'tabularLeft',
+        description:
+          'indents in tabular style with 10 spaces, aligning keywords to left',
+      },
+      {
+        value: 'tabularRight',
+        description:
+          'indents in tabular style with 10 spaces, aligning keywords to right',
+      },
+    ],
+  },
+  logicalOperatorNewline: {
+    category: 'Format',
+    type: 'choice',
+    default: 'before',
+    description:
+      'Decides newline placement before or after logical operators (AND, OR, XOR)',
+    choices: [
+      {
+        value: 'before',
+        description: 'adds newline before the operator',
+      },
+      {
+        value: 'after',
+        description: 'adds newline after the operator',
+      },
+    ],
+  },
+  expressionWidth: {
+    category: 'Format',
+    type: 'int',
+    default: 50,
+    description:
+      'Determines maximum length of parenthesized expressions for `sql-formatter`',
+  },
+  linesBetweenQueries: {
+    category: 'Format',
+    type: 'int',
+    default: 1,
+    description:
+      'Decides how many empty lines to leave between SQL statements for `sql-formatter`',
+  },
+  denseOperators: {
+    category: 'Format',
+    type: 'boolean',
+    default: false,
+    description:
+      'Decides whitespace around operators for `sql-formatter`. Does not apply to logical operators (AND, OR, XOR).',
+  },
+  newlineBeforeSemicolon: {
+    category: 'Format',
+    type: 'boolean',
+    default: false,
+    description:
+      'Whether to place query separator (`;`) on a separate line for `sql-formatter`',
+  },
+  params: {
+    category: 'Format',
+    type: 'string',
+    description:
+      'Specifies `JSOX` **stringified** parameter values to fill in for placeholders inside SQL for `sql-formatter`. This option is designed to be used through API (though nothing really prevents usage from command line).',
+  },
+  paramTypes: {
+    category: 'Config',
+    type: 'string',
+    description:
+      'Specifies `JSOX` **stringified** parameter types to support when parsing SQL prepared statements for `sql-formatter`.',
+  },
+  type: {
+    category: 'Config',
+    type: 'choice',
+    default: 'table',
+    description: 'Check the SQL with Authority List for `node-sql-parser`',
+    choices: [
+      {
+        value: 'table',
+        description: '`table` mode',
+      },
+      {
+        value: 'column',
+        description: '`column` mode',
+      },
+    ],
+  },
+  database: {
+    category: 'Config',
+    type: 'choice',
+    default: 'mysql',
+    description: 'SQL dialect for `node-sql-parser`',
+    choices: [
+      {
+        value: 'bigquery',
+        description: 'BigQuery: https://cloud.google.com/bigquery',
+      },
+      {
+        value: 'db2',
+        description: 'IBM DB2: https://www.ibm.com/analytics/db2',
+      },
+      {
+        value: 'hive',
+        description: 'Hive: https://hive.apache.org',
+      },
+      {
+        value: 'mariadb',
+        description: 'MariaDB: https://mariadb.com',
+      },
+      {
+        value: 'mysql',
+        description: 'MySQL: https://www.mysql.com',
+      },
+      {
+        value: 'postgresql',
+        description: 'PostgreSQL: https://www.postgresql.org',
+      },
+      {
+        value: 'transactsql',
+        description:
+          'TransactSQL: https://docs.microsoft.com/en-us/sql/t-sql',
+      },
+      {
+        value: 'flinksql',
+        description:
+          'FlinkSQL: https://ci.apache.org/projects/flink/flink-docs-stable',
+      },
+      {
+        value: 'snowflake',
+        description: 'Snowflake (alpha): https://docs.snowflake.com',
+      },
+    ],
+  },
+};
+
+const SqlPlugin = {
+    languages,
+    parsers,
+  printers,
+  options,
+};
+
+export { languages };
+export default SqlPlugin;

frontend/src/common/utils/configUtils.ts

@@ -1,4 +1,4 @@
-import { LanguageType } from '@/../bindings/voidraft/internal/models/models';
+import { LanguageType } from '../../../bindings/voidraft/internal/models/models';
 import type { SupportedLocaleType } from '@/stores/configStore';
 
 /**

frontend/src/router/index.ts

@@ -8,6 +8,56 @@ import KeyBindingsPage from '@/views/settings/pages/KeyBindingsPage.vue';
 import UpdatesPage from '@/views/settings/pages/UpdatesPage.vue';
 import ExtensionsPage from '@/views/settings/pages/ExtensionsPage.vue';
 import BackupPage from '@/views/settings/pages/BackupPage.vue';
+// 测试页面
+import TestPage from '@/views/settings/pages/TestPage.vue';
+
+// 基础设置子路由
+const settingsChildren: RouteRecordRaw[] = [
+  {
+    path: 'general',
+    name: 'SettingsGeneral',
+    component: GeneralPage
+  },
+  {
+    path: 'editing',
+    name: 'SettingsEditing',
+    component: EditingPage
+  },
+  {
+    path: 'appearance',
+    name: 'SettingsAppearance',
+    component: AppearancePage
+  },
+  {
+    path: 'extensions',
+    name: 'SettingsExtensions',
+    component: ExtensionsPage
+  },
+  {
+    path: 'key-bindings',
+    name: 'SettingsKeyBindings',
+    component: KeyBindingsPage
+  },
+  {
+    path: 'updates',
+    name: 'SettingsUpdates',
+    component: UpdatesPage
+  },
+  {
+    path: 'backup',
+    name: 'SettingsBackup',
+    component: BackupPage
+  }
+];
+
+// 仅在开发环境添加测试页面路由
+if (import.meta.env.DEV) {
+  settingsChildren.push({
+    path: 'test',
+    name: 'SettingsTest',
+    component: TestPage
+  });
+}
 
 const routes: RouteRecordRaw[] = [
   {
@@ -20,43 +70,7 @@ const routes: RouteRecordRaw[] = [
     name: 'Settings',
     redirect: '/settings/general',
     component: Settings,
-    children: [
-      {
-        path: 'general',
-        name: 'SettingsGeneral',
-        component: GeneralPage
-      },
-      {
-        path: 'editing',
-        name: 'SettingsEditing',
-        component: EditingPage
-      },
-      {
-        path: 'appearance',
-        name: 'SettingsAppearance',
-        component: AppearancePage
-      },
-      {
-        path: 'extensions',
-        name: 'SettingsExtensions',
-        component: ExtensionsPage
-      },
-      {
-        path: 'key-bindings',
-        name: 'SettingsKeyBindings',
-        component: KeyBindingsPage
-      },
-      {
-        path: 'updates',
-        name: 'SettingsUpdates',
-        component: UpdatesPage
-      },
-      {
-        path: 'backup',
-        name: 'SettingsBackup',
-        component: BackupPage
-      }
-    ]
+    children: settingsChildren
   }
 ];
 

frontend/src/stores/configStore.ts

@@ -15,7 +15,7 @@ import {
     AuthMethod
 } from '@/../bindings/voidraft/internal/models/models';
 import {useI18n} from 'vue-i18n';
-import {ConfigUtils} from '@/utils/configUtils';
+import {ConfigUtils} from '@/common/utils/configUtils';
 import * as runtime from '@wailsio/runtime';
 // 国际化相关导入
 export type SupportedLocaleType = 'zh-CN' | 'en-US';

frontend/src/stores/themeStore.ts

@@ -29,11 +29,11 @@ export const useThemeStore = defineStore('theme', () => {
   const initializeThemeColors = async () => {
     try {
       const themes = await ThemeService.GetDefaultThemes();
-      if (themes.dark) {
-        Object.assign(themeColors.darkTheme, themes.dark.colors);
+      if (themes[ThemeType.ThemeTypeDark]) {
+        Object.assign(themeColors.darkTheme, themes[ThemeType.ThemeTypeDark].colors);
       }
-      if (themes.light) {
-        Object.assign(themeColors.lightTheme, themes.light.colors);
+      if (themes[ThemeType.ThemeTypeLight]) {
+        Object.assign(themeColors.lightTheme, themes[ThemeType.ThemeTypeLight].colors);
       }
     } catch (error) {
       console.warn('Failed to load themes from database, using defaults:', error);

frontend/src/views/editor/extensions/codeblock/lang-parser/languages.ts

@@ -2,35 +2,33 @@
  * 语言映射和解析器配置
  */
 
-import { jsonLanguage } from "@codemirror/lang-json";
-import { pythonLanguage } from "@codemirror/lang-python";
-import { javascriptLanguage, typescriptLanguage } from "@codemirror/lang-javascript";
-import { htmlLanguage } from "@codemirror/lang-html";
-import { StandardSQL } from "@codemirror/lang-sql";
-import { markdownLanguage } from "@codemirror/lang-markdown";
-import { javaLanguage } from "@codemirror/lang-java";
-import { phpLanguage } from "@codemirror/lang-php";
-import { cssLanguage } from "@codemirror/lang-css";
-import { cppLanguage } from "@codemirror/lang-cpp";
-import { xmlLanguage } from "@codemirror/lang-xml";
-import { rustLanguage } from "@codemirror/lang-rust";
-import { yamlLanguage } from "@codemirror/lang-yaml";
+import {jsonLanguage} from "@codemirror/lang-json";
+import {pythonLanguage} from "@codemirror/lang-python";
+import {javascriptLanguage, typescriptLanguage} from "@codemirror/lang-javascript";
+import {htmlLanguage} from "@codemirror/lang-html";
+import {StandardSQL} from "@codemirror/lang-sql";
+import {markdownLanguage} from "@codemirror/lang-markdown";
+import {javaLanguage} from "@codemirror/lang-java";
+import {phpLanguage} from "@codemirror/lang-php";
+import {cssLanguage} from "@codemirror/lang-css";
+import {cppLanguage} from "@codemirror/lang-cpp";
+import {xmlLanguage} from "@codemirror/lang-xml";
+import {rustLanguage} from "@codemirror/lang-rust";
+import {yamlLanguage} from "@codemirror/lang-yaml";
 
-import { StreamLanguage } from "@codemirror/language";
-import { ruby } from "@codemirror/legacy-modes/mode/ruby";
-import { shell } from "@codemirror/legacy-modes/mode/shell";
-import { go } from "@codemirror/legacy-modes/mode/go";
-import { csharp } from "@codemirror/legacy-modes/mode/clike";
-import { clojure } from "@codemirror/legacy-modes/mode/clojure";
-import { erlang } from "@codemirror/legacy-modes/mode/erlang";
-import { swift } from "@codemirror/legacy-modes/mode/swift";
-import { kotlin } from "@codemirror/legacy-modes/mode/clike";
-import { groovy } from "@codemirror/legacy-modes/mode/groovy";
-import { powerShell } from "@codemirror/legacy-modes/mode/powershell";
-import { scala } from "@codemirror/legacy-modes/mode/clike";
-import { toml } from "@codemirror/legacy-modes/mode/toml";
-import { elixir } from "codemirror-lang-elixir";
-import { SupportedLanguage } from '../types';
+import {StreamLanguage} from "@codemirror/language";
+import {ruby} from "@codemirror/legacy-modes/mode/ruby";
+import {shell} from "@codemirror/legacy-modes/mode/shell";
+import {go} from "@codemirror/legacy-modes/mode/go";
+import {csharp, kotlin, scala} from "@codemirror/legacy-modes/mode/clike";
+import {clojure} from "@codemirror/legacy-modes/mode/clojure";
+import {erlang} from "@codemirror/legacy-modes/mode/erlang";
+import {swift} from "@codemirror/legacy-modes/mode/swift";
+import {groovy} from "@codemirror/legacy-modes/mode/groovy";
+import {powerShell} from "@codemirror/legacy-modes/mode/powershell";
+import {toml} from "@codemirror/legacy-modes/mode/toml";
+import {elixir} from "codemirror-lang-elixir";
+import {SupportedLanguage} from '../types';
 
 import typescriptPlugin from "prettier/plugins/typescript"
 import babelPrettierPlugin from "prettier/plugins/babel"
@@ -38,96 +36,128 @@ import htmlPrettierPlugin from "prettier/plugins/html"
 import cssPrettierPlugin from "prettier/plugins/postcss"
 import markdownPrettierPlugin from "prettier/plugins/markdown"
 import yamlPrettierPlugin from "prettier/plugins/yaml"
+import goPrettierPlugin from "@/common/prettier/plugins/go/go"
+import sqlPrettierPlugin from "@/common/prettier/plugins/sql/sql"
+import phpPrettierPlugin from "@/common/prettier/plugins/php"
+import javaPrettierPlugin from "@/common/prettier/plugins/java"
+import xmlPrettierPlugin from "@prettier/plugin-xml"
+import * as rustPrettierPlugin from "@/common/prettier/plugins/rust";
+import * as shellPrettierPlugin from "@/common/prettier/plugins/shell";
+import tomlPrettierPlugin from "prettier-plugin-toml";
 import * as prettierPluginEstree from "prettier/plugins/estree";
 
 /**
  * 语言信息类
  */
 export class LanguageInfo {
-  constructor(
-    public token: SupportedLanguage,
-    public name: string,
-    public parser: any,
-    public prettier?: {
-      parser: string;
-      plugins: any[];
+    constructor(
+        public token: SupportedLanguage,
+        public name: string,
+        public parser: any,
+        public prettier?: {
+            parser: string;
+            plugins: any[];
+        }) {
     }
-  ) {}
 }
 
 /**
  * 支持的语言列表（与 Worker 中的 LANGUAGES 对应）
  */
 export const LANGUAGES: LanguageInfo[] = [
-  new LanguageInfo("text", "Plain Text", null),
-  new LanguageInfo("json", "JSON", jsonLanguage.parser, {
-    parser: "json",
-    plugins: [babelPrettierPlugin, prettierPluginEstree]
-  }),
-  new LanguageInfo("py", "Python", pythonLanguage.parser),
-  new LanguageInfo("html", "HTML", htmlLanguage.parser, {
-    parser: "html",
-    plugins: [htmlPrettierPlugin]
-  }),
-  new LanguageInfo("sql", "SQL", StandardSQL.language.parser),
-  new LanguageInfo("md", "Markdown", markdownLanguage.parser, {
-    parser: "markdown",
-    plugins: [markdownPrettierPlugin]
-  }),
-  new LanguageInfo("java", "Java", javaLanguage.parser),
-  new LanguageInfo("php", "PHP", phpLanguage.configure({top:"Program"}).parser),
-  new LanguageInfo("css", "CSS", cssLanguage.parser, {
-    parser: "css",
-    plugins: [cssPrettierPlugin]
-  }),
-  new LanguageInfo("xml", "XML", xmlLanguage.parser),
-  new LanguageInfo("cpp", "C++", cppLanguage.parser),
-  new LanguageInfo("rs", "Rust", rustLanguage.parser),
-  new LanguageInfo("cs", "C#", StreamLanguage.define(csharp).parser),
-  new LanguageInfo("rb", "Ruby", StreamLanguage.define(ruby).parser),
-  new LanguageInfo("sh", "Shell", StreamLanguage.define(shell).parser),
-  new LanguageInfo("yaml", "YAML", yamlLanguage.parser, {
-    parser: "yaml",
-    plugins: [yamlPrettierPlugin]
-  }),
-  new LanguageInfo("toml", "TOML", StreamLanguage.define(toml).parser),
-  new LanguageInfo("go", "Go", StreamLanguage.define(go).parser),
-  new LanguageInfo("clj", "Clojure", StreamLanguage.define(clojure).parser),
-  new LanguageInfo("ex", "Elixir", elixir().language.parser),
-  new LanguageInfo("erl", "Erlang", StreamLanguage.define(erlang).parser),
-  new LanguageInfo("js", "JavaScript", javascriptLanguage.parser, {
-    parser: "babel",
-    plugins: [babelPrettierPlugin, prettierPluginEstree]
-  }),
-  new LanguageInfo("ts", "TypeScript", typescriptLanguage.parser, {
-    parser: "typescript",
-    plugins: [typescriptPlugin, prettierPluginEstree]
-  }),
-  new LanguageInfo("swift", "Swift", StreamLanguage.define(swift).parser),
-  new LanguageInfo("kt", "Kotlin", StreamLanguage.define(kotlin).parser),
-  new LanguageInfo("groovy", "Groovy", StreamLanguage.define(groovy).parser),
-  new LanguageInfo("ps1", "PowerShell", StreamLanguage.define(powerShell).parser),
-  new LanguageInfo("dart", "Dart", null), // 暂无解析器
-  new LanguageInfo("scala", "Scala", StreamLanguage.define(scala).parser),
+    new LanguageInfo("text", "Plain Text", null),
+    new LanguageInfo("json", "JSON", jsonLanguage.parser, {
+        parser: "json",
+        plugins: [babelPrettierPlugin, prettierPluginEstree]
+    }),
+    new LanguageInfo("py", "Python", pythonLanguage.parser),
+    new LanguageInfo("html", "HTML", htmlLanguage.parser, {
+        parser: "html",
+        plugins: [htmlPrettierPlugin]
+    }),
+    new LanguageInfo("sql", "SQL", StandardSQL.language.parser, {
+        parser: "sql",
+        plugins: [sqlPrettierPlugin]
+    }),
+    new LanguageInfo("md", "Markdown", markdownLanguage.parser, {
+        parser: "markdown",
+        plugins: [markdownPrettierPlugin]
+    }),
+    new LanguageInfo("java", "Java", javaLanguage.parser,{
+        parser: "java",
+        plugins: [javaPrettierPlugin]
+    }),
+    new LanguageInfo("php", "PHP", phpLanguage.configure({top: "Program"}).parser, {
+        parser: "php",
+        plugins: [phpPrettierPlugin]
+    }),
+    new LanguageInfo("css", "CSS", cssLanguage.parser, {
+        parser: "css",
+        plugins: [cssPrettierPlugin]
+    }),
+    new LanguageInfo("xml", "XML", xmlLanguage.parser,{
+        parser: "xml",
+        plugins: [xmlPrettierPlugin]
+    }),
+    new LanguageInfo("cpp", "C++", cppLanguage.parser),
+    new LanguageInfo("rs", "Rust", rustLanguage.parser,{
+        parser: "jinx-rust",
+        plugins: [rustPrettierPlugin]
+    }),
+    new LanguageInfo("cs", "C#", StreamLanguage.define(csharp).parser),
+    new LanguageInfo("rb", "Ruby", StreamLanguage.define(ruby).parser),
+    new LanguageInfo("sh", "Shell", StreamLanguage.define(shell).parser,{
+        parser: "sh",
+        plugins: [shellPrettierPlugin]
+    }),
+    new LanguageInfo("yaml", "YAML", yamlLanguage.parser, {
+        parser: "yaml",
+        plugins: [yamlPrettierPlugin]
+    }),
+    new LanguageInfo("toml", "TOML", StreamLanguage.define(toml).parser,{
+        parser: "toml",
+        plugins: [tomlPrettierPlugin]
+    }),
+    new LanguageInfo("go", "Go", StreamLanguage.define(go).parser, {
+        parser: "go",
+        plugins: [goPrettierPlugin]
+    }),
+    new LanguageInfo("clj", "Clojure", StreamLanguage.define(clojure).parser),
+    new LanguageInfo("ex", "Elixir", elixir().language.parser),
+    new LanguageInfo("erl", "Erlang", StreamLanguage.define(erlang).parser),
+    new LanguageInfo("js", "JavaScript", javascriptLanguage.parser, {
+        parser: "babel",
+        plugins: [babelPrettierPlugin, prettierPluginEstree]
+    }),
+    new LanguageInfo("ts", "TypeScript", typescriptLanguage.parser, {
+        parser: "typescript",
+        plugins: [typescriptPlugin, prettierPluginEstree]
+    }),
+    new LanguageInfo("swift", "Swift", StreamLanguage.define(swift).parser),
+    new LanguageInfo("kt", "Kotlin", StreamLanguage.define(kotlin).parser),
+    new LanguageInfo("groovy", "Groovy", StreamLanguage.define(groovy).parser),
+    new LanguageInfo("ps1", "PowerShell", StreamLanguage.define(powerShell).parser),
+    new LanguageInfo("dart", "Dart", null), // 暂无解析器
+    new LanguageInfo("scala", "Scala", StreamLanguage.define(scala).parser),
 ];
 
 /**
  * 语言映射表
  */
 export const languageMapping = Object.fromEntries(
-  LANGUAGES.map(l => [l.token, l.parser])
+    LANGUAGES.map(l => [l.token, l.parser])
 );
 
 /**
  * 根据 token 获取语言信息
  */
 export function getLanguage(token: SupportedLanguage): LanguageInfo | undefined {
-  return LANGUAGES.find(lang => lang.token === token);
+    return LANGUAGES.find(lang => lang.token === token);
 }
 
 /**
  * 获取所有语言的 token 列表
  */
 export function getLanguageTokens(): SupportedLanguage[] {
-  return LANGUAGES.map(lang => lang.token);
+    return LANGUAGES.map(lang => lang.token);
 }

frontend/src/views/settings/Settings.vue

@@ -19,6 +19,11 @@ const navItems = [
   { id: 'updates', icon: '🔄', route: '/settings/updates' }
 ];
 
+// 仅在开发环境添加测试页面导航
+if (import.meta.env.DEV) {
+  navItems.push({ id: 'test', icon: '🧪', route: '/settings/test' });
+}
+
 const activeNavItem = ref(route.path.split('/').pop() || 'general');
 
 // 处理导航点击
@@ -56,7 +61,7 @@ const goBackToEditor = async () => {
           @click="handleNavClick(item)"
         >
           <span class="nav-icon">{{ item.icon }}</span>
-          <span class="nav-text">{{ t(`settings.${item.id}`) }}</span>
+          <span class="nav-text">{{ item.id === 'test' ? 'Test' : t(`settings.${item.id}`) }}</span>
         </div>
       </div>
       <div class="settings-footer">

frontend/src/views/settings/pages/TestPage.vue

@@ -0,0 +1,274 @@
+<template>
+  <div class="settings-page">
+    <SettingSection title="Development Test Page">
+      <div class="dev-description">
+        This page is only available in development environment for testing notification and badge services.
+      </div>
+    </SettingSection>
+
+    <!-- Badge测试区域 -->
+    <SettingSection title="Badge Service Test">
+      <SettingItem title="Badge Text">
+        <input
+          v-model="badgeText"
+          type="text"
+          placeholder="Enter badge text (empty to remove)"
+          class="select-input"
+        />
+      </SettingItem>
+      <SettingItem title="Actions">
+        <div class="button-group">
+          <button @click="testBadge" class="test-button primary">
+            Set Badge
+          </button>
+          <button @click="clearBadge" class="test-button">
+            Clear Badge
+          </button>
+        </div>
+      </SettingItem>
+      <div v-if="badgeStatus" class="test-status" :class="badgeStatus.type">
+        {{ badgeStatus.message }}
+      </div>
+    </SettingSection>
+
+    <!-- 通知测试区域 -->
+    <SettingSection title="Notification Service Test">
+      <SettingItem title="Title">
+        <input
+          v-model="notificationTitle"
+          type="text"
+          placeholder="Notification title"
+          class="select-input"
+        />
+      </SettingItem>
+      <SettingItem title="Subtitle">
+        <input
+          v-model="notificationSubtitle"
+          type="text"
+          placeholder="Notification subtitle"
+          class="select-input"
+        />
+      </SettingItem>
+      <SettingItem title="Body">
+        <textarea
+          v-model="notificationBody"
+          placeholder="Notification body text"
+          class="select-input textarea-input"
+          rows="3"
+        ></textarea>
+      </SettingItem>
+      <SettingItem title="Actions">
+        <div class="button-group">
+          <button @click="testNotification" class="test-button primary">
+            Send Test Notification
+          </button>
+          <button @click="testUpdateNotification" class="test-button">
+            Test Update Notification
+          </button>
+        </div>
+      </SettingItem>
+      <div v-if="notificationStatus" class="test-status" :class="notificationStatus.type">
+        {{ notificationStatus.message }}
+      </div>
+    </SettingSection>
+
+    <!-- 清除所有测试状态 -->
+    <SettingSection title="Cleanup">
+      <SettingItem title="Clear All">
+        <button @click="clearAll" class="test-button danger">
+          Clear All Test States
+        </button>
+      </SettingItem>
+      <div v-if="clearStatus" class="test-status" :class="clearStatus.type">
+        {{ clearStatus.message }}
+      </div>
+    </SettingSection>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ref } from 'vue'
+import * as TestService from '@/../bindings/voidraft/internal/services/testservice'
+import SettingSection from '../components/SettingSection.vue'
+import SettingItem from '../components/SettingItem.vue'
+
+// Badge测试状态
+const badgeText = ref('')
+const badgeStatus = ref<{ type: string; message: string } | null>(null)
+
+// 通知测试状态
+const notificationTitle = ref('')
+const notificationSubtitle = ref('')
+const notificationBody = ref('')
+const notificationStatus = ref<{ type: string; message: string } | null>(null)
+
+// 清除状态
+const clearStatus = ref<{ type: string; message: string } | null>(null)
+
+// 显示状态消息的辅助函数
+const showStatus = (statusRef: any, type: 'success' | 'error', message: string) => {
+  statusRef.value = { type, message }
+  setTimeout(() => {
+    statusRef.value = null
+  }, 5000)
+}
+
+// 测试Badge功能
+const testBadge = async () => {
+  try {
+    await TestService.TestBadge(badgeText.value)
+    showStatus(badgeStatus, 'success', `Badge ${badgeText.value ? 'set to: ' + badgeText.value : 'cleared'} successfully`)
+  } catch (error: any) {
+    showStatus(badgeStatus, 'error', `Failed to set badge: ${error.message || error}`)
+  }
+}
+
+// 清除Badge
+const clearBadge = async () => {
+  try {
+    await TestService.TestBadge('')
+    badgeText.value = ''
+    showStatus(badgeStatus, 'success', 'Badge cleared successfully')
+  } catch (error: any) {
+    showStatus(badgeStatus, 'error', `Failed to clear badge: ${error.message || error}`)
+  }
+}
+
+// 测试通知功能
+const testNotification = async () => {
+  try {
+    await TestService.TestNotification(
+      notificationTitle.value,
+      notificationSubtitle.value,
+      notificationBody.value
+    )
+    showStatus(notificationStatus, 'success', 'Notification sent successfully')
+  } catch (error: any) {
+    showStatus(notificationStatus, 'error', `Failed to send notification: ${error.message || error}`)
+  }
+}
+
+// 测试更新通知
+const testUpdateNotification = async () => {
+  try {
+    await TestService.TestUpdateNotification()
+    showStatus(notificationStatus, 'success', 'Update notification sent successfully (badge + notification)')
+  } catch (error: any) {
+    showStatus(notificationStatus, 'error', `Failed to send update notification: ${error.message || error}`)
+  }
+}
+
+// 清除所有测试状态
+const clearAll = async () => {
+  try {
+    await TestService.ClearAll()
+    // 清空表单
+    badgeText.value = ''
+    notificationTitle.value = ''
+    notificationSubtitle.value = ''
+    notificationBody.value = ''
+    showStatus(clearStatus, 'success', 'All test states cleared successfully')
+  } catch (error: any) {
+    showStatus(clearStatus, 'error', `Failed to clear test states: ${error.message || error}`)
+  }
+}
+</script>
+
+<style scoped lang="scss">
+.settings-page {
+  padding: 20px 0 20px 0;
+}
+
+.dev-description {
+  color: var(--settings-text-secondary);
+  font-size: 12px;
+  line-height: 1.4;
+  padding: 8px 0;
+}
+
+.select-input {
+  padding: 6px 8px;
+  border: 1px solid var(--settings-input-border);
+  border-radius: 4px;
+  background-color: var(--settings-input-bg);
+  color: var(--settings-text);
+  font-size: 12px;
+  width: 180px;
+  
+  &:focus {
+    outline: none;
+    border-color: #4a9eff;
+    box-shadow: 0 0 0 2px rgba(74, 158, 255, 0.2);
+  }
+  
+  &.textarea-input {
+    min-height: 60px;
+    resize: vertical;
+    font-family: inherit;
+    line-height: 1.4;
+  }
+}
+
+.button-group {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+}
+
+.test-button {
+  padding: 6px 12px;
+  border: 1px solid var(--settings-border);
+  border-radius: 4px;
+  background-color: var(--settings-card-bg);
+  color: var(--settings-text);
+  cursor: pointer;
+  font-size: 12px;
+  transition: all 0.2s ease;
+  
+  &:hover {
+    background-color: var(--settings-hover);
+  }
+  
+  &.primary {
+    background-color: #4a9eff;
+    color: white;
+    border-color: #4a9eff;
+    
+    &:hover {
+      background-color: #3a8eef;
+      border-color: #3a8eef;
+    }
+  }
+  
+  &.danger {
+    background-color: var(--text-danger);
+    color: white;
+    border-color: var(--text-danger);
+    
+    &:hover {
+      opacity: 0.9;
+    }
+  }
+}
+
+.test-status {
+  margin-top: 12px;
+  padding: 8px 12px;
+  border-radius: 4px;
+  font-size: 11px;
+  font-weight: 500;
+  border: 1px solid;
+  
+  &.success {
+    background-color: rgba(34, 197, 94, 0.1);
+    color: #16a34a;
+    border-color: rgba(34, 197, 94, 0.2);
+  }
+  
+  &.error {
+    background-color: rgba(239, 68, 68, 0.1);
+    color: #dc2626;
+    border-color: rgba(239, 68, 68, 0.2);
+  }
+}
+</style>

frontend/vite.config.ts

@@ -2,6 +2,8 @@ import {defineConfig, loadEnv} from 'vite';
 import vue from '@vitejs/plugin-vue';
 import Components from 'unplugin-vue-components/vite';
 import * as path from 'path';
+import {nodePolyfills} from 'vite-plugin-node-polyfills'
+import {visualizer} from 'rollup-plugin-visualizer'
 
 export default defineConfig(({mode}: { mode: string }): object => {
     const env: Record<string, string> = loadEnv(mode, process.cwd());
@@ -15,6 +17,10 @@ export default defineConfig(({mode}: { mode: string }): object => {
         },
         plugins: [
             vue(),
+            nodePolyfills(),
+            visualizer({open: false,
+                filename: 'visualizer.html',
+                }),
             Components({
                 dts: true,
                 dirs: ['src/components'],
@@ -27,21 +33,91 @@ export default defineConfig(({mode}: { mode: string }): object => {
         build: {
             outDir: "dist",
             assetsDir: "assets",
-            assetsInlineLimit: "4096",
+            assetsInlineLimit: 2048, // 减少内联资源阈值以减少bundle大小
             cssCodeSplit: true,
             sourcemap: false,
             minify: "esbuild",
             write: true,
             emptyOutDir: true,
-            brotliSize: true,
-            chunkSizeWarningLimit: 2000,
+            brotliSize: false, // 跳过 brotli 压缩分析
+            chunkSizeWarningLimit: 1000,
             watch: null,
+            reportCompressedSize: false, // 跳过压缩大小报告
             rollupOptions: {
+                maxParallelFileOps: 2,
+                treeshake: {
+                    moduleSideEffects: false,
+                    propertyReadSideEffects: false,
+                    tryCatchDeoptimization: false
+                },
                 output: {
                     format: 'es',
                     chunkFileNames: 'js/[name]-[hash].js',
                     entryFileNames: 'js/[name]-[hash].js',
                     assetFileNames: '[ext]/[name]-[hash].[ext]',
+                    compact: true,
+                    manualChunks(id: string) {
+                        // CodeMirror
+                        if (id.includes('@codemirror') || id.includes('codemirror')) {
+                            return 'codemirror';
+                        }
+                        // Vue
+                        if (id.includes('vue') && !id.includes('vue-pick-colors')) {
+                            return 'vue';
+                        }
+                        // Lezer
+                        if (id.includes('@lezer') || id.includes('lezer')) {
+                            return 'lezer';
+                        }
+                        // Prettier
+                        if (id.includes('prettier')) {
+                            return 'prettier';
+                        }
+                        // Taplo
+                        if (id.includes('@taplo') || id.includes('taplo')) {
+                            return 'taplo';
+                        }
+                        // Linguist languages
+                        if (id.includes('franc-min') || id.includes('linguist-languages')) {
+                            return 'lang-detect';
+                        }
+                        // Java parser
+                        if (id.includes('java-parser')) {
+                            return 'java-parser';
+                        }
+                        // PHP parser
+                        if (id.includes('php-parser')) {
+                            return 'php-parser';
+                        }
+                        // SQL parser
+                        if (id.includes('node-sql-parser') || id.includes('sql-formatter')) {
+                            return 'sql-parser';
+                        }
+                        // Rust tools
+                        if (id.includes('jinx-rust') || id.includes('sh-syntax')) {
+                            return 'rust-tools';
+                        }
+                        // Color utils
+                        if (id.includes('colors-named') || id.includes('hsl-matcher')) {
+                            return 'color-utils';
+                        }
+                        // Pinia
+                        if (id.includes('pinia')) {
+                            return 'pinia';
+                        }
+                        // Vue Router
+                        if (id.includes('vue-router')) {
+                            return 'vue-router';
+                        }
+                        // Vue i18n
+                        if (id.includes('vue-i18n')) {
+                            return 'vue-i18n';
+                        }
+                        // Vendor
+                        if (id.includes("node_modules")) {
+                            return 'vendor';
+                        }
+                    }
                 },
             }
         }

go.mod

@@ -21,6 +21,7 @@ require (
 require (
 	code.gitea.io/sdk/gitea v0.21.0 // indirect
 	dario.cat/mergo v1.0.2 // indirect
+	git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 // indirect
 	github.com/42wim/httpsig v1.2.3 // indirect
 	github.com/Masterminds/semver/v3 v3.4.0 // indirect
 	github.com/Microsoft/go-winio v0.6.2 // indirect
@@ -77,6 +78,7 @@ require (
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
 	golang.org/x/crypto v0.41.0 // indirect
 	golang.org/x/exp v0.0.0-20250813145105-42675adae3e6 // indirect
+	golang.org/x/image v0.24.0 // indirect
 	golang.org/x/oauth2 v0.30.0 // indirect
 	golang.org/x/time v0.12.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect

go.sum

@@ -2,6 +2,8 @@ code.gitea.io/sdk/gitea v0.21.0 h1:69n6oz6kEVHRo1+APQQyizkhrZrLsTLXey9142pfkD4=
 code.gitea.io/sdk/gitea v0.21.0/go.mod h1:tnBjVhuKJCn8ibdyyhvUyxrR1Ca2KHEoTWoukNhXQPA=
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
+git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3 h1:N3IGoHHp9pb6mj1cbXbuaSXV/UMKwmbKLf53nQmtqMA=
+git.sr.ht/~jackmordaunt/go-toast/v2 v2.0.3/go.mod h1:QtOLZGz8olr4qH2vWK0QH0w0O4T9fEIjMuWpKUsH7nc=
 github.com/42wim/httpsig v1.2.3 h1:xb0YyWhkYj57SPtfSttIobJUPJZB9as1nsfo7KWVcEs=
 github.com/42wim/httpsig v1.2.3/go.mod h1:nZq9OlYKDrUBhptd77IHx4/sZZD+IxTBADvAPI9G/EM=
 github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
@@ -178,6 +180,8 @@ golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
 golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
 golang.org/x/exp v0.0.0-20250813145105-42675adae3e6 h1:SbTAbRFnd5kjQXbczszQ0hdk3ctwYf3qBNH9jIsGclE=
 golang.org/x/exp v0.0.0-20250813145105-42675adae3e6/go.mod h1:4QTo5u+SEIbbKW1RacMZq1YEfOBqeXa19JeshGi+zc4=
+golang.org/x/image v0.24.0 h1:AN7zRgVsbvmTfNyqIbbOraYL8mSwcKncEj8ofjgzcMQ=
+golang.org/x/image v0.24.0/go.mod h1:4b/ITuLfqYq1hqZcjofwctIhi7sZh2WaCjvsBNjjya8=
 golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
 golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=

internal/services/config_migration_service.go

@@ -53,7 +53,6 @@ func NewConfigMigrator(
 
 // AutoMigrate automatically detects and migrates missing configuration fields
 func (cm *ConfigMigrator) AutoMigrate(defaultConfig interface{}, currentConfig *koanf.Koanf) (*MigrationResult, error) {
-	// Load default config into temporary koanf instance
 	defaultKoanf := koanf.New(".")
 	if err := defaultKoanf.Load(structs.Provider(defaultConfig, "json"), nil); err != nil {
 		return nil, fmt.Errorf("failed to load default config: %w", err)
@@ -66,23 +65,20 @@ func (cm *ConfigMigrator) AutoMigrate(defaultConfig interface{}, currentConfig *
 	result := &MigrationResult{
 		MissingFields: missingFields,
 		Migrated:      len(missingFields) > 0,
-		Description:   fmt.Sprintf("Detected %d missing configuration fields", len(missingFields)),
+		Description:   fmt.Sprintf("Found %d missing fields", len(missingFields)),
 	}
 
-	// If no missing fields, return early
+	// No migration needed
 	if !result.Migrated {
-		cm.logger.Info("No missing configuration fields detected")
 		return result, nil
 	}
 
-	// Only create backup if we actually need to migrate (has missing fields)
-	if len(missingFields) > 0 {
-		if backupPath, err := cm.createBackup(); err != nil {
-			cm.logger.Error("Failed to create backup", "error", err)
-		} else {
-			result.BackupPath = backupPath
-		}
+	// Create backup before migration
+	backupPath, err := cm.createBackup()
+	if err != nil {
+		return result, fmt.Errorf("backup creation failed: %w", err)
 	}
+	result.BackupPath = backupPath
 
 	// Merge missing fields from default config
 	if err := cm.mergeDefaultFields(currentConfig, defaultKoanf, missingFields); err != nil {
@@ -94,19 +90,25 @@ func (cm *ConfigMigrator) AutoMigrate(defaultConfig interface{}, currentConfig *
 		return result, fmt.Errorf("failed to save updated config: %w", err)
 	}
 
-	cm.logger.Info("Configuration migration completed successfully", "migratedFields", len(missingFields))
+	// Clean up backup on success
+	if backupPath != "" {
+		if err := os.Remove(backupPath); err != nil {
+			cm.logger.Error("Failed to remove backup", "error", err)
+		}
+	}
+
 	return result, nil
 }
 
 // detectMissingFields detects missing configuration fields
 func (cm *ConfigMigrator) detectMissingFields(current, defaultConfig map[string]interface{}) []string {
-	var missingFields []string
-	cm.findMissingFieldsRecursive("", defaultConfig, current, &missingFields)
-	return missingFields
+	var missing []string
+	cm.findMissing("", defaultConfig, current, &missing)
+	return missing
 }
 
-// findMissingFieldsRecursive recursively finds missing fields
-func (cm *ConfigMigrator) findMissingFieldsRecursive(prefix string, defaultMap, currentMap map[string]interface{}, missing *[]string) {
+// findMissing recursively finds missing fields
+func (cm *ConfigMigrator) findMissing(prefix string, defaultMap, currentMap map[string]interface{}, missing *[]string) {
 	for key, defaultVal := range defaultMap {
 		fullKey := key
 		if prefix != "" {
@@ -115,34 +117,38 @@ func (cm *ConfigMigrator) findMissingFieldsRecursive(prefix string, defaultMap,
 
 		currentVal, exists := currentMap[key]
 		if !exists {
-			// Field is completely missing
+			// Field completely missing - add it
 			*missing = append(*missing, fullKey)
-		} else {
-			// Check nested structures
-			if defaultNestedMap, ok := defaultVal.(map[string]interface{}); ok {
-				if currentNestedMap, ok := currentVal.(map[string]interface{}); ok {
-					cm.findMissingFieldsRecursive(fullKey, defaultNestedMap, currentNestedMap, missing)
-				} else {
-					// Current value is not a map but default is, structure mismatch
-					*missing = append(*missing, fullKey)
-				}
+		} else if defaultNestedMap, ok := defaultVal.(map[string]interface{}); ok {
+			if currentNestedMap, ok := currentVal.(map[string]interface{}); ok {
+				// Both are maps, recurse into them
+				cm.findMissing(fullKey, defaultNestedMap, currentNestedMap, missing)
 			}
+			// Type mismatch: user has different type, don't recurse
 		}
+		// For non-map default values, field exists, preserve user's value
 	}
 }
 
 // mergeDefaultFields merges default values for missing fields into current config
 func (cm *ConfigMigrator) mergeDefaultFields(current, defaultConfig *koanf.Koanf, missingFields []string) error {
+	actuallyMerged := 0
+
 	for _, field := range missingFields {
-		defaultValue := defaultConfig.Get(field)
-		if defaultValue != nil {
-			current.Set(field, defaultValue)
-			cm.logger.Debug("Merged missing field", "field", field, "value", defaultValue)
+		if defaultConfig.Exists(field) {
+			if defaultValue := defaultConfig.Get(field); defaultValue != nil {
+				// Always set the field, even if it causes type conflicts
+				// This allows configuration structure evolution during upgrades
+				current.Set(field, defaultValue)
+				actuallyMerged++
+			}
 		}
 	}
 
-	// Update last modified timestamp
-	current.Set("metadata.lastUpdated", time.Now().Format(time.RFC3339))
+	// Update timestamp if we actually merged fields
+	if actuallyMerged > 0 {
+		current.Set("metadata.lastUpdated", time.Now().Format(time.RFC3339))
+	}
 
 	return nil
 }
@@ -165,7 +171,6 @@ func (cm *ConfigMigrator) createBackup() (string, error) {
 		return "", fmt.Errorf("failed to create backup: %w", err)
 	}
 
-	cm.logger.Info("Configuration backup created", "path", backupPath)
 	return backupPath, nil
 }
 

internal/services/config_migrator_test.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"encoding/json"
+	"fmt"
 	jsonparser "github.com/knadh/koanf/parsers/json"
 	"github.com/knadh/koanf/providers/file"
 	"github.com/knadh/koanf/v2"
@@ -158,10 +159,877 @@ func TestConfigMigrator_AutoMigrate(t *testing.T) {
 	assert.True(t, k.Bool("newSection.enabled"), "newSection.enabled should be added with correct value")
 	assert.Equal(t, "new section", k.String("newSection.value"), "newSection.value should be added with correct value")
 
-	// Check that backup was created
+	// Check that backup was cleaned up after successful migration
 	backupFiles, err := filepath.Glob(filepath.Join(tempDir, "*.backup.*"))
 	if err != nil {
 		t.Fatalf("Failed to list backup files: %v", err)
 	}
-	assert.Equal(t, 1, len(backupFiles), "One backup file should have been created")
+	assert.Equal(t, 0, len(backupFiles), "Backup file should have been cleaned up after successful migration")
+}
+
+// TestConfigMigrator_NoOverwrite tests that user configuration is never overwritten
+func TestConfigMigrator_NoOverwrite(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_no_overwrite_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create user config with custom values that differ from defaults
+	userConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":    "CustomAppName", // Different from default
+			"version": "2.0.0",         // Different from default
+			"theme":   "custom",        // Different from default
+		},
+		"user": map[string]interface{}{
+			"name":  "Custom User",        // Different from default
+			"email": "custom@example.com", // Different from default
+			"settings": map[string]interface{}{
+				"autoSave": false, // Different from default
+				"language": "zh",  // Different from default
+			},
+		},
+	}
+
+	// Create config file
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	// Create migrator and load config
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create default config with different values
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "DefaultApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "light"
+	defaultConfig.User.Name = "Default User"
+	defaultConfig.User.Email = "default@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true     // This should be added
+	defaultConfig.User.Settings.NewSetting2 = "value" // This should be added
+	defaultConfig.NewSection.Enabled = true           // This should be added
+	defaultConfig.NewSection.Value = "new section"    // This should be added
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// Verify user values are preserved
+	assert.Equal(t, "CustomAppName", k.String("app.name"), "User's app name should not be overwritten")
+	assert.Equal(t, "2.0.0", k.String("app.version"), "User's version should not be overwritten")
+	assert.Equal(t, "custom", k.String("app.theme"), "User's theme should not be overwritten")
+	assert.Equal(t, "Custom User", k.String("user.name"), "User's name should not be overwritten")
+	assert.Equal(t, "custom@example.com", k.String("user.email"), "User's email should not be overwritten")
+	assert.False(t, k.Bool("user.settings.autoSave"), "User's autoSave should not be overwritten")
+	assert.Equal(t, "zh", k.String("user.settings.language"), "User's language should not be overwritten")
+
+	// Verify missing fields were added with default values
+	assert.True(t, k.Bool("user.settings.newSetting"), "Missing field should be added")
+	assert.Equal(t, "value", k.String("user.settings.newSetting2"), "Missing field should be added")
+	assert.True(t, k.Bool("newSection.enabled"), "Missing section should be added")
+	assert.Equal(t, "new section", k.String("newSection.value"), "Missing section should be added")
+}
+
+// TestConfigMigrator_TypeMismatch tests handling of type mismatches (config structure evolution)
+func TestConfigMigrator_TypeMismatch(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_type_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create user config where some fields have different types
+	userConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":    "TestApp",
+			"version": "1.0.0",
+			"theme":   "dark",
+		},
+		"user": map[string]interface{}{
+			"name":     "Test User",
+			"email":    "test@example.com",
+			"settings": "simple_string", // This is a string, but default is an object
+		},
+		"newSection": 123, // This is a number, but default is an object
+	}
+
+	// Create config file
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	// Create migrator and load config
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create default config
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "dark"
+	defaultConfig.User.Name = "Test User"
+	defaultConfig.User.Email = "test@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true
+	defaultConfig.User.Settings.NewSetting2 = "value"
+	defaultConfig.NewSection.Enabled = true
+	defaultConfig.NewSection.Value = "new section"
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+
+	// Should detect missing fields and merge them, overriding type conflicts for config evolution
+	assert.True(t, result.Migrated, "Migration should be performed")
+	assert.Greater(t, len(result.MissingFields), 0, "Should detect missing fields with type mismatch")
+
+	// Verify that type-mismatched values are overwritten with new structure (config evolution)
+	// This is important for software upgrades where config structure changes
+	assert.NotEqual(t, "simple_string", k.String("user.settings"), "User's string should be overwritten with new structure")
+	assert.NotEqual(t, int64(123), k.Int64("newSection"), "User's number should be overwritten with new structure")
+
+	// Verify new structure is properly applied
+	assert.True(t, k.Bool("user.settings.autoSave"), "New settings structure should be applied")
+	assert.Equal(t, "en", k.String("user.settings.language"), "New settings structure should be applied")
+	assert.True(t, k.Bool("user.settings.newSetting"), "New settings structure should be applied")
+	assert.Equal(t, "value", k.String("user.settings.newSetting2"), "New settings structure should be applied")
+	assert.True(t, k.Bool("newSection.enabled"), "New section structure should be applied")
+	assert.Equal(t, "new section", k.String("newSection.value"), "New section structure should be applied")
+}
+
+// TestConfigMigrator_ConfigEvolution tests configuration structure evolution scenarios
+func TestConfigMigrator_ConfigEvolution(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_evolution_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Simulate old config format where "features" was a simple string
+	// but new version expects it to be an object
+	oldConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":     "MyApp",
+			"version":  "1.0.0",
+			"features": "plugin1,plugin2", // Old: simple comma-separated string
+		},
+		"database": "sqlite://data.db", // Old: simple string
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(oldConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// New config format where "features" and "database" are objects
+	type NewConfig struct {
+		App struct {
+			Name     string `json:"name"`
+			Version  string `json:"version"`
+			Features struct {
+				Enabled []string `json:"enabled"`
+				Config  string   `json:"config"`
+			} `json:"features"`
+		} `json:"app"`
+		Database struct {
+			Type string `json:"type"`
+			URL  string `json:"url"`
+		} `json:"database"`
+	}
+
+	defaultConfig := NewConfig{}
+	defaultConfig.App.Name = "DefaultApp" // Will be preserved from user
+	defaultConfig.App.Version = "2.0.0"   // Will be preserved from user
+	defaultConfig.App.Features.Enabled = []string{"newFeature"}
+	defaultConfig.App.Features.Config = "default.conf"
+	defaultConfig.Database.Type = "postgresql"
+	defaultConfig.Database.URL = "postgres://localhost:5432/db"
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// User's non-conflicting values should be preserved
+	assert.Equal(t, "MyApp", k.String("app.name"), "User's app name should be preserved")
+	assert.Equal(t, "1.0.0", k.String("app.version"), "User's version should be preserved")
+
+	// Conflicting structure should be evolved (old string → new object)
+	assert.NotEqual(t, "plugin1,plugin2", k.String("app.features"), "Old features string should be replaced")
+	assert.Equal(t, []string{"newFeature"}, k.Strings("app.features.enabled"), "New features structure should be applied")
+	assert.Equal(t, "default.conf", k.String("app.features.config"), "New features structure should be applied")
+
+	assert.NotEqual(t, "sqlite://data.db", k.String("database"), "Old database string should be replaced")
+	assert.Equal(t, "postgresql", k.String("database.type"), "New database structure should be applied")
+	assert.Equal(t, "postgres://localhost:5432/db", k.String("database.url"), "New database structure should be applied")
+
+	t.Logf("Successfully evolved config structure, fields migrated: %d", len(result.MissingFields))
+}
+
+// TestConfigMigrator_ComplexNested tests complex nested structure migration
+func TestConfigMigrator_ComplexNested(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_complex_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Complex user config with deep nesting
+	userConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":    "TestApp",
+			"version": "1.0.0",
+			"advanced": map[string]interface{}{
+				"logging": map[string]interface{}{
+					"level": "info",
+					"file":  "/var/log/app.log",
+					// Missing: format, rotation
+				},
+				"performance": map[string]interface{}{
+					"cache": true,
+					// Missing: timeout, maxConnections
+				},
+				// Missing: security section
+			},
+		},
+		"plugins": map[string]interface{}{
+			"enabled": []string{"plugin1", "plugin2"},
+			// Missing: config section
+		},
+		// Missing: monitoring section
+	}
+
+	// Default config with additional nested fields
+	type ComplexConfig struct {
+		App struct {
+			Name     string `json:"name"`
+			Version  string `json:"version"`
+			Advanced struct {
+				Logging struct {
+					Level    string `json:"level"`
+					File     string `json:"file"`
+					Format   string `json:"format"`
+					Rotation bool   `json:"rotation"`
+				} `json:"logging"`
+				Performance struct {
+					Cache          bool `json:"cache"`
+					Timeout        int  `json:"timeout"`
+					MaxConnections int  `json:"maxConnections"`
+				} `json:"performance"`
+				Security struct {
+					Enabled    bool   `json:"enabled"`
+					TokenType  string `json:"tokenType"`
+					ExpireTime int    `json:"expireTime"`
+				} `json:"security"`
+			} `json:"advanced"`
+		} `json:"app"`
+		Plugins struct {
+			Enabled []string `json:"enabled"`
+			Config  struct {
+				LoadOrder []string          `json:"loadOrder"`
+				Settings  map[string]string `json:"settings"`
+			} `json:"config"`
+		} `json:"plugins"`
+		Monitoring struct {
+			Enabled  bool   `json:"enabled"`
+			Endpoint string `json:"endpoint"`
+			Interval int    `json:"interval"`
+		} `json:"monitoring"`
+	}
+
+	// Create config file
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	// Create migrator and load config
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create complete default config
+	defaultConfig := ComplexConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Advanced.Logging.Level = "info"
+	defaultConfig.App.Advanced.Logging.File = "/var/log/app.log"
+	defaultConfig.App.Advanced.Logging.Format = "json"
+	defaultConfig.App.Advanced.Logging.Rotation = true
+	defaultConfig.App.Advanced.Performance.Cache = true
+	defaultConfig.App.Advanced.Performance.Timeout = 30
+	defaultConfig.App.Advanced.Performance.MaxConnections = 100
+	defaultConfig.App.Advanced.Security.Enabled = true
+	defaultConfig.App.Advanced.Security.TokenType = "JWT"
+	defaultConfig.App.Advanced.Security.ExpireTime = 3600
+	defaultConfig.Plugins.Enabled = []string{"plugin1", "plugin2"}
+	defaultConfig.Plugins.Config.LoadOrder = []string{"plugin1", "plugin2"}
+	defaultConfig.Plugins.Config.Settings = map[string]string{"key": "value"}
+	defaultConfig.Monitoring.Enabled = true
+	defaultConfig.Monitoring.Endpoint = "/metrics"
+	defaultConfig.Monitoring.Interval = 60
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// Verify user values are preserved
+	assert.Equal(t, "info", k.String("app.advanced.logging.level"))
+	assert.Equal(t, "/var/log/app.log", k.String("app.advanced.logging.file"))
+	assert.True(t, k.Bool("app.advanced.performance.cache"))
+
+	// Verify missing fields were added
+	assert.Equal(t, "json", k.String("app.advanced.logging.format"))
+	assert.True(t, k.Bool("app.advanced.logging.rotation"))
+	assert.Equal(t, 30, k.Int("app.advanced.performance.timeout"))
+	assert.Equal(t, 100, k.Int("app.advanced.performance.maxConnections"))
+	assert.True(t, k.Bool("app.advanced.security.enabled"))
+	assert.Equal(t, "JWT", k.String("app.advanced.security.tokenType"))
+	assert.Equal(t, 3600, k.Int("app.advanced.security.expireTime"))
+	assert.Equal(t, []string{"plugin1", "plugin2"}, k.Strings("plugins.config.loadOrder"))
+	assert.True(t, k.Bool("monitoring.enabled"))
+	assert.Equal(t, "/metrics", k.String("monitoring.endpoint"))
+	assert.Equal(t, 60, k.Int("monitoring.interval"))
+
+	t.Logf("Detected missing fields: %v", result.MissingFields)
+	// Should detect multiple missing fields
+	assert.Greater(t, len(result.MissingFields), 5, "Should detect multiple missing fields")
+}
+
+// TestConfigMigrator_MultipleMigrations tests running migration multiple times
+func TestConfigMigrator_MultipleMigrations(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_multiple_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create initial config
+	configPath := createTestConfig(t, tempDir)
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+
+	// Create default config
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "dark"
+	defaultConfig.User.Name = "Test User"
+	defaultConfig.User.Email = "test@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true
+	defaultConfig.User.Settings.NewSetting2 = "value"
+	defaultConfig.NewSection.Enabled = true
+	defaultConfig.NewSection.Value = "new section"
+
+	// First migration
+	k1 := koanf.New(".")
+	k1.Load(file.Provider(configPath), jsonparser.Parser())
+	result1, err := migrator.AutoMigrate(defaultConfig, k1)
+	assert.NoError(t, err)
+	assert.True(t, result1.Migrated, "First migration should be performed")
+
+	// Second migration - should detect no missing fields
+	k2 := koanf.New(".")
+	k2.Load(file.Provider(configPath), jsonparser.Parser())
+	result2, err := migrator.AutoMigrate(defaultConfig, k2)
+	assert.NoError(t, err)
+	assert.False(t, result2.Migrated, "Second migration should not be needed")
+	assert.Equal(t, 0, len(result2.MissingFields), "No fields should be missing in second migration")
+}
+
+// TestConfigMigrator_BackupHandling tests backup creation and cleanup
+func TestConfigMigrator_BackupHandling(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_backup_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	configPath := createTestConfig(t, tempDir)
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+
+	// Create default config
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "dark"
+	defaultConfig.User.Name = "Test User"
+	defaultConfig.User.Email = "test@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true
+	defaultConfig.User.Settings.NewSetting2 = "value"
+	defaultConfig.NewSection.Enabled = true
+	defaultConfig.NewSection.Value = "new section"
+
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// Backup should be cleaned up after successful migration
+	backupFiles, _ := filepath.Glob(filepath.Join(tempDir, "*.backup.*"))
+	assert.Equal(t, 0, len(backupFiles), "Backup should be cleaned up after successful migration")
+}
+
+// TestConfigMigrator_NoMigrationNeeded tests when no migration is needed
+func TestConfigMigrator_NoMigrationNeeded(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_no_migration_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create complete config (no missing fields)
+	completeConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":    "TestApp",
+			"version": "1.0.0",
+			"theme":   "dark",
+		},
+		"user": map[string]interface{}{
+			"name":  "Test User",
+			"email": "test@example.com",
+			"settings": map[string]interface{}{
+				"autoSave":    true,
+				"language":    "en",
+				"newSetting":  true,
+				"newSetting2": "value",
+			},
+		},
+		"newSection": map[string]interface{}{
+			"enabled": true,
+			"value":   "new section",
+		},
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(completeConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create matching default config
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "dark"
+	defaultConfig.User.Name = "Test User"
+	defaultConfig.User.Email = "test@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true
+	defaultConfig.User.Settings.NewSetting2 = "value"
+	defaultConfig.NewSection.Enabled = true
+	defaultConfig.NewSection.Value = "new section"
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.False(t, result.Migrated, "No migration should be needed")
+	assert.Equal(t, 0, len(result.MissingFields), "No fields should be missing")
+
+	// No backup should be created
+	backupFiles, _ := filepath.Glob(filepath.Join(tempDir, "*.backup.*"))
+	assert.Equal(t, 0, len(backupFiles), "No backup should be created when migration is not needed")
+}
+
+// TestConfigMigrator_PartialOverride tests partial user override scenarios
+func TestConfigMigrator_PartialOverride(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_partial_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Create user config with partial overrides
+	userConfig := map[string]interface{}{
+		"app": map[string]interface{}{
+			"name":    "CustomApp",
+			"version": "2.0.0", // User custom value
+			// Missing: theme (should use default)
+		},
+		"user": map[string]interface{}{
+			"name":  "Custom User",
+			"email": "custom@example.com",
+			"settings": map[string]interface{}{
+				"autoSave": false, // User custom value
+				"language": "zh",  // User custom value
+				// Missing: newSetting, newSetting2 (should use defaults)
+			},
+		},
+		// Missing: newSection (should use defaults)
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create complete default config
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "DefaultApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "light" // Should be added
+	defaultConfig.User.Name = "Default User"
+	defaultConfig.User.Email = "default@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true     // Should be added
+	defaultConfig.User.Settings.NewSetting2 = "value" // Should be added
+	defaultConfig.NewSection.Enabled = true           // Should be added
+	defaultConfig.NewSection.Value = "new section"    // Should be added
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// Verify user values are preserved
+	assert.Equal(t, "CustomApp", k.String("app.name"))
+	assert.Equal(t, "2.0.0", k.String("app.version"))
+	assert.Equal(t, "Custom User", k.String("user.name"))
+	assert.Equal(t, "custom@example.com", k.String("user.email"))
+	assert.False(t, k.Bool("user.settings.autoSave"))
+	assert.Equal(t, "zh", k.String("user.settings.language"))
+
+	// Verify missing fields were added with defaults
+	assert.Equal(t, "light", k.String("app.theme"))
+	assert.True(t, k.Bool("user.settings.newSetting"))
+	assert.Equal(t, "value", k.String("user.settings.newSetting2"))
+	assert.True(t, k.Bool("newSection.enabled"))
+	assert.Equal(t, "new section", k.String("newSection.value"))
+}
+
+// TestConfigMigrator_ArrayMerge tests array and slice handling
+func TestConfigMigrator_ArrayMerge(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_array_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Config with arrays
+	type ArrayConfig struct {
+		Plugins struct {
+			Enabled []string `json:"enabled"`
+			Config  struct {
+				LoadOrder []string          `json:"loadOrder"`
+				Settings  map[string]string `json:"settings"`
+			} `json:"config"`
+		} `json:"plugins"`
+		Database struct {
+			Hosts []string `json:"hosts"`
+			Ports []int    `json:"ports"`
+		} `json:"database"`
+	}
+
+	// User config with some arrays
+	userConfig := map[string]interface{}{
+		"plugins": map[string]interface{}{
+			"enabled": []string{"plugin1", "plugin2"}, // User's plugin list
+			// Missing: config section
+		},
+		// Missing: database section
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create default config with arrays
+	defaultConfig := ArrayConfig{}
+	defaultConfig.Plugins.Enabled = []string{"defaultPlugin1", "defaultPlugin2"}
+	defaultConfig.Plugins.Config.LoadOrder = []string{"plugin1", "plugin2"}
+	defaultConfig.Plugins.Config.Settings = map[string]string{"timeout": "30"}
+	defaultConfig.Database.Hosts = []string{"localhost", "backup.host"}
+	defaultConfig.Database.Ports = []int{5432, 5433}
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// User's array should be preserved
+	assert.Equal(t, []string{"plugin1", "plugin2"}, k.Strings("plugins.enabled"))
+
+	// Missing arrays should be added from defaults
+	assert.Equal(t, []string{"plugin1", "plugin2"}, k.Strings("plugins.config.loadOrder"))
+	assert.Equal(t, []string{"localhost", "backup.host"}, k.Strings("database.hosts"))
+	assert.Equal(t, []int{5432, 5433}, k.Ints("database.ports"))
+
+	expectedSettings := map[string]string{"timeout": "30"}
+	assert.Equal(t, expectedSettings, k.StringMap("plugins.config.settings"))
+}
+
+// TestConfigMigrator_DeepNesting tests very deep nested structures
+func TestConfigMigrator_DeepNesting(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_deep_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Deep nested config
+	type DeepConfig struct {
+		Level1 struct {
+			Level2 struct {
+				Level3 struct {
+					Level4 struct {
+						Level5 struct {
+							Value string `json:"value"`
+							Count int    `json:"count"`
+						} `json:"level5"`
+					} `json:"level4"`
+				} `json:"level3"`
+			} `json:"level2"`
+		} `json:"level1"`
+	}
+
+	// User config with partial deep nesting
+	userConfig := map[string]interface{}{
+		"level1": map[string]interface{}{
+			"level2": map[string]interface{}{
+				"level3": map[string]interface{}{
+					// Missing level4 completely
+				},
+			},
+		},
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Create default config with complete deep nesting
+	defaultConfig := DeepConfig{}
+	defaultConfig.Level1.Level2.Level3.Level4.Level5.Value = "deep_value"
+	defaultConfig.Level1.Level2.Level3.Level4.Level5.Count = 42
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+
+	// Verify deep nested values were added
+	assert.Equal(t, "deep_value", k.String("level1.level2.level3.level4.level5.value"))
+	assert.Equal(t, 42, k.Int("level1.level2.level3.level4.level5.count"))
+
+	t.Logf("Missing fields: %v", result.MissingFields)
+	assert.Equal(t, 2, len(result.MissingFields), "Should detect 2 missing deep nested fields")
+}
+
+// TestConfigMigrator_EdgeCases tests various edge cases
+func TestConfigMigrator_EdgeCases(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_edge_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Edge case config with various data types
+	userConfig := map[string]interface{}{
+		"string_empty":  "",
+		"string_spaces": "   ",
+		"number_zero":   0,
+		"number_float":  3.14,
+		"bool_false":    false,
+		"array_empty":   []interface{}{},
+		"map_empty":     map[string]interface{}{},
+		"null_value":    nil,
+	}
+
+	configPath := filepath.Join(tempDir, "config.json")
+	jsonData, _ := json.MarshalIndent(userConfig, "", "  ")
+	os.WriteFile(configPath, jsonData, 0644)
+
+	logger := log.New()
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+	k := koanf.New(".")
+	k.Load(file.Provider(configPath), jsonparser.Parser())
+
+	// Default config with different values
+	type EdgeConfig struct {
+		StringEmpty  string                 `json:"string_empty"`
+		StringSpaces string                 `json:"string_spaces"`
+		NumberZero   int                    `json:"number_zero"`
+		NumberFloat  float64                `json:"number_float"`
+		BoolFalse    bool                   `json:"bool_false"`
+		ArrayEmpty   []string               `json:"array_empty"`
+		MapEmpty     map[string]interface{} `json:"map_empty"`
+		NullValue    *string                `json:"null_value"`
+		NewField     string                 `json:"new_field"` // This should be added
+	}
+
+	defaultConfig := EdgeConfig{}
+	defaultConfig.StringEmpty = "default_string"
+	defaultConfig.StringSpaces = "default_spaces"
+	defaultConfig.NumberZero = 42
+	defaultConfig.NumberFloat = 2.71
+	defaultConfig.BoolFalse = true
+	defaultConfig.ArrayEmpty = []string{"default"}
+	defaultConfig.MapEmpty = map[string]interface{}{"key": "value"}
+	defaultValue := "default_null"
+	defaultConfig.NullValue = &defaultValue
+	defaultConfig.NewField = "new_field_value"
+
+	// Run migration
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+
+	// All user edge case values should be preserved (they exist, even if empty/zero/false)
+	assert.Equal(t, "", k.String("string_empty"))
+	assert.Equal(t, "   ", k.String("string_spaces"))
+	assert.Equal(t, 0, k.Int("number_zero"))
+	assert.Equal(t, 3.14, k.Float64("number_float"))
+	assert.False(t, k.Bool("bool_false"))
+	assert.Equal(t, []string{}, k.Strings("array_empty"))
+
+	// Only truly missing field should be added
+	assert.Equal(t, "new_field_value", k.String("new_field"))
+
+	// Should detect 2 missing fields: new_field and map_empty.key
+	// The user has an empty map, but default config has a key inside that map
+	assert.Equal(t, 2, len(result.MissingFields), "Should detect 2 missing fields: new_field and map_empty.key")
+	assert.Contains(t, result.MissingFields, "new_field")
+	assert.Contains(t, result.MissingFields, "map_empty.key")
+
+	// Verify that the key was added to the empty map
+	assert.Equal(t, "value", k.String("map_empty.key"))
+}
+
+// TestConfigMigrator_ErrorHandling tests error conditions
+func TestConfigMigrator_ErrorHandling(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_error_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	logger := log.New()
+	configPath := filepath.Join(tempDir, "nonexistent.json")
+	migrator := NewConfigMigrator(logger, tempDir, "config", configPath)
+
+	// Test with empty koanf (no config file loaded)
+	k := koanf.New(".")
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+
+	// This should still work (creates config from scratch)
+	result, err := migrator.AutoMigrate(defaultConfig, k)
+	assert.NoError(t, err)
+	assert.True(t, result.Migrated)
+	assert.Greater(t, len(result.MissingFields), 0)
+
+	// Test with corrupted config file
+	corruptedPath := filepath.Join(tempDir, "corrupted.json")
+	os.WriteFile(corruptedPath, []byte("{invalid json"), 0644)
+
+	k2 := koanf.New(".")
+	// This should fail gracefully when trying to load the corrupted file
+	err = k2.Load(file.Provider(corruptedPath), jsonparser.Parser())
+	assert.Error(t, err, "Should fail to load corrupted JSON")
+}
+
+// TestConfigMigrator_ConcurrentAccess tests concurrent migration access
+func TestConfigMigrator_ConcurrentAccess(t *testing.T) {
+	tempDir, err := os.MkdirTemp("", "config_migrator_concurrent_test")
+	if err != nil {
+		t.Fatalf("Failed to create temp directory: %v", err)
+	}
+	defer os.RemoveAll(tempDir)
+
+	configPath := createTestConfig(t, tempDir)
+	logger := log.New()
+
+	// Create multiple migrators
+	numWorkers := 5
+	results := make(chan *MigrationResult, numWorkers)
+	errors := make(chan error, numWorkers)
+
+	defaultConfig := TestConfig{}
+	defaultConfig.App.Name = "TestApp"
+	defaultConfig.App.Version = "1.0.0"
+	defaultConfig.App.Theme = "dark"
+	defaultConfig.User.Name = "Test User"
+	defaultConfig.User.Email = "test@example.com"
+	defaultConfig.User.Settings.AutoSave = true
+	defaultConfig.User.Settings.Language = "en"
+	defaultConfig.User.Settings.NewSetting = true
+	defaultConfig.User.Settings.NewSetting2 = "value"
+	defaultConfig.NewSection.Enabled = true
+	defaultConfig.NewSection.Value = "new section"
+
+	// Run concurrent migrations
+	for i := 0; i < numWorkers; i++ {
+		go func(workerID int) {
+			// Each worker gets its own config path to avoid file conflicts
+			workerConfigPath := filepath.Join(tempDir, fmt.Sprintf("config_%d.json", workerID))
+
+			// Copy the original config for this worker
+			originalData, _ := os.ReadFile(configPath)
+			os.WriteFile(workerConfigPath, originalData, 0644)
+
+			migrator := NewConfigMigrator(logger, tempDir, fmt.Sprintf("config_%d", workerID), workerConfigPath)
+			k := koanf.New(".")
+			k.Load(file.Provider(workerConfigPath), jsonparser.Parser())
+
+			result, err := migrator.AutoMigrate(defaultConfig, k)
+			if err != nil {
+				errors <- err
+				return
+			}
+			results <- result
+		}(i)
+	}
+
+	// Collect results
+	for i := 0; i < numWorkers; i++ {
+		select {
+		case result := <-results:
+			assert.True(t, result.Migrated, "Each worker should successfully migrate")
+			assert.Equal(t, 4, len(result.MissingFields), "Each worker should detect same missing fields")
+		case err := <-errors:
+			t.Errorf("Worker failed: %v", err)
+		}
+	}
 }

internal/services/config_service.go

@@ -109,9 +109,6 @@ func (cs *ConfigService) initConfig() error {
 		return cs.createDefaultConfig()
 	}
 
-	// 检查并自动迁移配置
-	cs.checkConfigMigration()
-
 	// 配置文件存在，直接加载现有配置
 	cs.fileProvider = file.Provider(cs.settingsPath)
 	if err := cs.koanf.Load(cs.fileProvider, jsonparser.Parser()); err != nil {
@@ -121,8 +118,8 @@ func (cs *ConfigService) initConfig() error {
 	return nil
 }
 
-// checkConfigMigration 检查配置迁移
-func (cs *ConfigService) checkConfigMigration() error {
+// MigrateConfig 执行配置迁移
+func (cs *ConfigService) MigrateConfig() error {
 	if cs.configMigrator == nil {
 		return nil
 	}

internal/services/hotkey_service.go

@@ -6,7 +6,7 @@ package services
 #cgo CFLAGS: -I../lib
 #cgo LDFLAGS: -luser32
 #include "../lib/hotkey_windows.c"
-#include "hotkey_windows.h"
+#include "../lib/hotkey_windows.h"
 */
 import "C"
 

internal/services/self_update_service.go

@@ -5,7 +5,9 @@ import (
 	"errors"
 	"fmt"
 	"github.com/creativeprojects/go-selfupdate"
+	"github.com/wailsapp/wails/v3/pkg/services/badge"
 	"github.com/wailsapp/wails/v3/pkg/services/log"
+	"github.com/wailsapp/wails/v3/pkg/services/notifications"
 	"os"
 	"runtime"
 	"time"
@@ -26,16 +28,18 @@ type SelfUpdateResult struct {
 
 // SelfUpdateService 自我更新服务
 type SelfUpdateService struct {
-	logger        *log.LogService
-	configService *ConfigService
-	config        *models.AppConfig
+	logger              *log.LogService
+	configService       *ConfigService
+	badgeService        *badge.BadgeService                // 直接使用Wails原生badge服务
+	notificationService *notifications.NotificationService // 通知服务
+	config              *models.AppConfig
 
 	// 状态管理
 	isUpdating bool
 }
 
 // NewSelfUpdateService 创建自我更新服务实例
-func NewSelfUpdateService(configService *ConfigService, logger *log.LogService) (*SelfUpdateService, error) {
+func NewSelfUpdateService(configService *ConfigService, badgeService *badge.BadgeService, notificationService *notifications.NotificationService, logger *log.LogService) (*SelfUpdateService, error) {
 	// 获取配置
 	appConfig, err := configService.GetConfig()
 	if err != nil {
@@ -43,10 +47,12 @@ func NewSelfUpdateService(configService *ConfigService, logger *log.LogService)
 	}
 
 	service := &SelfUpdateService{
-		logger:        logger,
-		configService: configService,
-		config:        appConfig,
-		isUpdating:    false,
+		logger:              logger,
+		configService:       configService,
+		badgeService:        badgeService,
+		notificationService: notificationService,
+		config:              appConfig,
+		isUpdating:          false,
 	}
 
 	return service, nil
@@ -63,6 +69,7 @@ func (s *SelfUpdateService) CheckForUpdates(ctx context.Context) (*SelfUpdateRes
 	// 首先尝试主要更新源
 	primaryResult, err := s.checkSourceForUpdates(ctx, s.config.Updates.PrimarySource)
 	if err == nil && primaryResult != nil {
+		s.handleUpdateBadge(primaryResult)
 		return primaryResult, nil
 	}
 
@@ -71,9 +78,12 @@ func (s *SelfUpdateService) CheckForUpdates(ctx context.Context) (*SelfUpdateRes
 	if backupErr != nil {
 		// 如果备用源也失败，返回主要源的错误信息
 		result.Error = fmt.Sprintf("Primary source error: %v; Backup source error: %v", err, backupErr)
+		// 确保在检查失败时也调用handleUpdateBadge来清除可能存在的badge
+		s.handleUpdateBadge(result)
 		return result, errors.New(result.Error)
 	}
 
+	s.handleUpdateBadge(backupResult)
 	return backupResult, nil
 }
 
@@ -251,7 +261,6 @@ func (s *SelfUpdateService) ApplyUpdate(ctx context.Context) (*SelfUpdateResult,
 
 	// 检查是否有可用更新
 	if !primaryRelease.GreaterThan(s.config.Updates.Version) {
-		s.logger.Info("Current version is up to date, no need to apply update")
 		result.LatestVersion = primaryRelease.Version()
 		return result, nil
 	}
@@ -310,6 +319,18 @@ func (s *SelfUpdateService) ApplyUpdate(ctx context.Context) (*SelfUpdateResult,
 		s.logger.Error("Failed to update config version", "error", err)
 	}
 
+	// 执行配置迁移
+	if err := s.configService.MigrateConfig(); err != nil {
+		s.logger.Error("Failed to migrate config after update", "error", err)
+	}
+
+	// 更新成功，移除badge
+	if s.badgeService != nil {
+		if err := s.badgeService.RemoveBadge(); err != nil {
+			s.logger.Error("failed to remove update badge after successful update", "error", err)
+		}
+	}
+
 	return result, nil
 }
 
@@ -365,7 +386,6 @@ func (s *SelfUpdateService) updateFromSource(ctx context.Context, sourceType mod
 	}
 
 	// 尝试下载并应用更新，不设置超时
-	s.logger.Info("Downloading update...", "source", sourceType)
 	err = updater.UpdateTo(ctx, release, exe)
 
 	if err != nil {
@@ -392,6 +412,13 @@ func (s *SelfUpdateService) updateFromSource(ctx context.Context, sourceType mod
 		s.logger.Error("Failed to update config version", "error", err)
 	}
 
+	// 更新成功，移除badge
+	if s.badgeService != nil {
+		if err := s.badgeService.RemoveBadge(); err != nil {
+			s.logger.Error("failed to remove update badge after successful update", "error", err)
+		}
+	}
+
 	return result, nil
 }
 
@@ -462,3 +489,63 @@ func (s *SelfUpdateService) cleanupBackup(backupPath string) error {
 	}
 	return nil
 }
+
+// handleUpdateBadge 处理更新通知badge和通知
+func (s *SelfUpdateService) handleUpdateBadge(result *SelfUpdateResult) {
+	if result != nil && result.HasUpdate {
+		// 有更新时显示更新badge
+		if s.badgeService != nil {
+			if err := s.badgeService.SetBadge("●"); err != nil {
+				s.logger.Error("failed to set update badge", "error", err)
+			}
+		}
+
+		// 发送简单通知
+		s.sendUpdateNotification(result)
+	} else {
+		// 没有更新或出错时移除badge
+		if s.badgeService != nil {
+			if err := s.badgeService.RemoveBadge(); err != nil {
+				s.logger.Error("failed to remove update badge", "error", err)
+			}
+		}
+	}
+}
+
+// sendUpdateNotification 发送更新通知
+func (s *SelfUpdateService) sendUpdateNotification(result *SelfUpdateResult) {
+	if s.notificationService == nil {
+		return
+	}
+
+	// 检查通知授权（macOS需要）
+	authorized, err := s.notificationService.CheckNotificationAuthorization()
+	if err != nil {
+		s.logger.Error("Failed to check notification authorization", "error", err)
+		return
+	}
+
+	if !authorized {
+		authorized, err = s.notificationService.RequestNotificationAuthorization()
+		if err != nil || !authorized {
+			s.logger.Error("Failed to get notification authorization", "error", err)
+			return
+		}
+	}
+
+	// 构建简单通知内容
+	title := "Voidraft Update Available"
+	body := fmt.Sprintf("New version %s available (current: %s)", result.LatestVersion, result.CurrentVersion)
+
+	// 发送简单通知
+	err = s.notificationService.SendNotification(notifications.NotificationOptions{
+		ID:       "update_available",
+		Title:    title,
+		Subtitle: "New version available",
+		Body:     body,
+	})
+	if err != nil {
+		s.logger.Error("Failed to send notification", "error", err)
+		return
+	}
+}