📦 Optimized packaging

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

@@ -18,7 +18,6 @@ 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,
@@ -36,8 +35,7 @@ export {
     ThemeService,
     TranslationService,
     TrayService,
-    WindowService,
+    WindowService
-    WindowSnapService
 };
 
 export * from "./models.js";

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-lock.json

@@ -39,12 +39,16 @@
         "@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",
@@ -53,8 +57,10 @@
         "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.92.1",
+        "sh-syntax": "^0.5.8",
         "sql-formatter": "^15.6.9",
         "vue": "^3.5.21",
         "vue-i18n": "^11.1.12",
@@ -68,9 +74,11 @@
         "@types/remarkable": "^2.0.8",
         "@vitejs/plugin-vue": "^6.0.1",
         "@wailsio/runtime": "latest",
+        "cross-env": "^7.0.3",
         "eslint": "^9.35.0",
         "eslint-plugin-vue": "^10.4.0",
         "globals": "^16.4.0",
+        "rollup-plugin-visualizer": "^6.0.3",
         "typescript": "^5.9.2",
         "typescript-eslint": "^8.43.0",
         "unplugin-vue-components": "^29.0.0",
@@ -126,6 +134,45 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@chevrotain/cst-dts-gen": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.0.3.tgz",
+      "integrity": "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/gast": "11.0.3",
+        "@chevrotain/types": "11.0.3",
+        "lodash-es": "4.17.21"
+      }
+    },
+    "node_modules/@chevrotain/gast": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@chevrotain/gast/-/gast-11.0.3.tgz",
+      "integrity": "sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/types": "11.0.3",
+        "lodash-es": "4.17.21"
+      }
+    },
+    "node_modules/@chevrotain/regexp-to-ast": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.0.3.tgz",
+      "integrity": "sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@chevrotain/types": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@chevrotain/types/-/types-11.0.3.tgz",
+      "integrity": "sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/@chevrotain/utils": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/@chevrotain/utils/-/utils-11.0.3.tgz",
+      "integrity": "sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ==",
+      "license": "Apache-2.0"
+    },
     "node_modules/@codemirror/autocomplete": {
       "version": "6.18.7",
       "resolved": "https://registry.npmmirror.com/@codemirror/autocomplete/-/autocomplete-6.18.7.tgz",
@@ -1814,6 +1861,27 @@
         "url": "https://opencollective.com/popperjs"
       }
     },
+    "node_modules/@prettier/plugin-xml": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmmirror.com/@prettier/plugin-xml/-/plugin-xml-3.4.2.tgz",
+      "integrity": "sha512-/UyNlHfkuLXG6Ed85KB0WBF283xn2yavR+UtRibBRUcvEJId2DSLdGXwJ/cDa1X++SWDPzq3+GSFniHjkNy7yg==",
+      "license": "MIT",
+      "dependencies": {
+        "@xml-tools/parser": "^1.0.11"
+      },
+      "peerDependencies": {
+        "prettier": "^3.0.0"
+      }
+    },
+    "node_modules/@reteps/dockerfmt": {
+      "version": "0.3.6",
+      "resolved": "https://registry.npmmirror.com/@reteps/dockerfmt/-/dockerfmt-0.3.6.tgz",
+      "integrity": "sha512-Tb5wIMvBf/nLejTQ61krK644/CEMB/cpiaIFXqGApfGqO3GwcR3qnI0DbmkFVCl2OyEp8LnLX3EkucoL0+tbFg==",
+      "license": "MIT",
+      "engines": {
+        "node": "^v12.20.0 || ^14.13.0 || >=16.0.0"
+      }
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-beta.29",
       "resolved": "https://registry.npmmirror.com/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.29.tgz",
@@ -2160,6 +2228,21 @@
         "win32"
       ]
     },
+    "node_modules/@taplo/core": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmmirror.com/@taplo/core/-/core-0.2.0.tgz",
+      "integrity": "sha512-r8bl54Zj1In3QLkiW/ex694bVzpPJ9EhwqT9xkcUVODnVUGirdB1JTsmiIv0o1uwqZiwhi8xNnTOQBRQCpizrQ==",
+      "license": "MIT"
+    },
+    "node_modules/@taplo/lib": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmmirror.com/@taplo/lib/-/lib-0.5.0.tgz",
+      "integrity": "sha512-+xIqpQXJco3T+VGaTTwmhxLa51qpkQxCjRwezjFZgr+l21ExlywJFcDfTrNmL6lG6tqb0h8GyJKO3UPGPtSCWg==",
+      "license": "MIT",
+      "dependencies": {
+        "@taplo/core": "^0.2.0"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.8",
       "resolved": "https://registry.npmmirror.com/@types/estree/-/estree-1.0.8.tgz",
@@ -2690,6 +2773,24 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@xml-tools/parser": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmmirror.com/@xml-tools/parser/-/parser-1.0.11.tgz",
+      "integrity": "sha512-aKqQ077XnR+oQtHJlrAflaZaL7qZsulWc/i/ZEooar5JiWj1eLt0+Wg28cpa+XLney107wXqneC+oG1IZvxkTA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "chevrotain": "7.1.1"
+      }
+    },
+    "node_modules/@xml-tools/parser/node_modules/chevrotain": {
+      "version": "7.1.1",
+      "resolved": "https://registry.npmmirror.com/chevrotain/-/chevrotain-7.1.1.tgz",
+      "integrity": "sha512-wy3mC1x4ye+O+QkEinVJkPf5u2vsrDIYW9G7ZuwFl6v/Yu0LwUuT2POsb+NUWApebyxfkQq6+yDfRExbnI5rcw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "regexp-to-ast": "0.5.0"
+      }
+    },
     "node_modules/acorn": {
       "version": "8.15.0",
       "resolved": "https://registry.npmmirror.com/acorn/-/acorn-8.15.0.tgz",
@@ -2737,6 +2838,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/ansi-styles": {
       "version": "4.3.0",
       "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz",
@@ -3225,6 +3336,32 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/chevrotain": {
+      "version": "11.0.3",
+      "resolved": "https://registry.npmmirror.com/chevrotain/-/chevrotain-11.0.3.tgz",
+      "integrity": "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@chevrotain/cst-dts-gen": "11.0.3",
+        "@chevrotain/gast": "11.0.3",
+        "@chevrotain/regexp-to-ast": "11.0.3",
+        "@chevrotain/types": "11.0.3",
+        "@chevrotain/utils": "11.0.3",
+        "lodash-es": "4.17.21"
+      }
+    },
+    "node_modules/chevrotain-allstar": {
+      "version": "0.3.1",
+      "resolved": "https://registry.npmmirror.com/chevrotain-allstar/-/chevrotain-allstar-0.3.1.tgz",
+      "integrity": "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==",
+      "license": "MIT",
+      "dependencies": {
+        "lodash-es": "^4.17.21"
+      },
+      "peerDependencies": {
+        "chevrotain": "^11.0.0"
+      }
+    },
     "node_modules/chokidar": {
       "version": "4.0.3",
       "resolved": "https://registry.npmmirror.com/chokidar/-/chokidar-4.0.3.tgz",
@@ -3265,6 +3402,21 @@
         "consola": "^3.2.3"
       }
     },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmmirror.com/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/codemirror": {
       "version": "6.0.2",
       "resolved": "https://registry.npmmirror.com/codemirror/-/codemirror-6.0.2.tgz",
@@ -3469,6 +3621,25 @@
       "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
       "license": "MIT"
     },
+    "node_modules/cross-env": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmmirror.com/cross-env/-/cross-env-7.0.3.tgz",
+      "integrity": "sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cross-spawn": "^7.0.1"
+      },
+      "bin": {
+        "cross-env": "src/bin/cross-env.js",
+        "cross-env-shell": "src/bin/cross-env-shell.js"
+      },
+      "engines": {
+        "node": ">=10.14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmmirror.com/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -3586,6 +3757,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/define-lazy-prop": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/define-lazy-prop/-/define-lazy-prop-2.0.0.tgz",
+      "integrity": "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/define-properties": {
       "version": "1.2.1",
       "resolved": "https://registry.npmmirror.com/define-properties/-/define-properties-1.2.1.tgz",
@@ -3730,6 +3911,13 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/entities": {
       "version": "4.5.0",
       "resolved": "https://registry.npmmirror.com/entities/-/entities-4.5.0.tgz",
@@ -3824,6 +4012,16 @@
         "@esbuild/win32-x64": "0.25.2"
       }
     },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/escape-string-regexp": {
       "version": "4.0.0",
       "resolved": "https://registry.npmmirror.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
@@ -4233,6 +4431,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
     "node_modules/get-intrinsic": {
       "version": "1.3.0",
       "resolved": "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
@@ -4604,6 +4812,22 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-docker": {
+      "version": "2.2.1",
+      "resolved": "https://registry.npmmirror.com/is-docker/-/is-docker-2.2.1.tgz",
+      "integrity": "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "is-docker": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-extglob": {
       "version": "2.1.1",
       "resolved": "https://registry.npmmirror.com/is-extglob/-/is-extglob-2.1.1.tgz",
@@ -4614,6 +4838,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-generator-function": {
       "version": "1.1.0",
       "resolved": "https://registry.npmmirror.com/is-generator-function/-/is-generator-function-1.1.0.tgz",
@@ -4720,6 +4954,19 @@
         "url": "https://github.com/sponsors/mesqueeb"
       }
     },
+    "node_modules/is-wsl": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmmirror.com/is-wsl/-/is-wsl-2.2.0.tgz",
+      "integrity": "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-docker": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/isarray": {
       "version": "2.0.5",
       "resolved": "https://registry.npmmirror.com/isarray/-/isarray-2.0.5.tgz",
@@ -4744,6 +4991,23 @@
         "node": ">=10"
       }
     },
+    "node_modules/java-parser": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmmirror.com/java-parser/-/java-parser-3.0.1.tgz",
+      "integrity": "sha512-sDIR7u9b7O2JViNUxiZRhnRz7URII/eE7g2B+BmGxDeS6Ex3OYAcCyz5oh0H4LQ+hL/BS8OJTz8apMy9xtGmrQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "chevrotain": "11.0.3",
+        "chevrotain-allstar": "0.3.1",
+        "lodash": "4.17.21"
+      }
+    },
+    "node_modules/jinx-rust": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmmirror.com/jinx-rust/-/jinx-rust-0.1.6.tgz",
+      "integrity": "sha512-qP+wtQL1PrDDFwtPKhNGtjWOmijCrKdfUHWTV2G/ikxfjrh+cjdvkQTmny9RAsVF0jiui9m+F0INWu4cuRcZeQ==",
+      "license": "MIT"
+    },
     "node_modules/jiti": {
       "version": "2.4.2",
       "resolved": "https://registry.npmmirror.com/jiti/-/jiti-2.4.2.tgz",
@@ -4915,6 +5179,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/lodash": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmmirror.com/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
+      "license": "MIT"
+    },
+    "node_modules/lodash-es": {
+      "version": "4.17.21",
+      "resolved": "https://registry.npmmirror.com/lodash-es/-/lodash-es-4.17.21.tgz",
+      "integrity": "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==",
+      "license": "MIT"
+    },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
       "resolved": "https://registry.npmmirror.com/lodash.merge/-/lodash.merge-4.6.2.tgz",
@@ -5327,6 +5603,24 @@
       "optional": true,
       "peer": true
     },
+    "node_modules/open": {
+      "version": "8.4.2",
+      "resolved": "https://registry.npmmirror.com/open/-/open-8.4.2.tgz",
+      "integrity": "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-lazy-prop": "^2.0.0",
+        "is-docker": "^2.1.1",
+        "is-wsl": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.9.4",
       "resolved": "https://registry.npmmirror.com/optionator/-/optionator-0.9.4.tgz",
@@ -5696,6 +5990,24 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
+    "node_modules/prettier-plugin-toml": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmmirror.com/prettier-plugin-toml/-/prettier-plugin-toml-2.0.6.tgz",
+      "integrity": "sha512-12N/wBuHa9jd/KVy9pRP20NMKxQfQLMseQCt66lIbLaPLItvGUcSIryE1eZZMJ7loSws6Ig3M2Elc2EreNh76w==",
+      "license": "MIT",
+      "dependencies": {
+        "@taplo/lib": "^0.5.0"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/unts"
+      },
+      "peerDependencies": {
+        "prettier": "^3.0.3"
+      }
+    },
     "node_modules/process": {
       "version": "0.11.10",
       "resolved": "https://registry.npmmirror.com/process/-/process-0.11.10.tgz",
@@ -5888,6 +6200,12 @@
         "url": "https://paulmillr.com/funding/"
       }
     },
+    "node_modules/regexp-to-ast": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmmirror.com/regexp-to-ast/-/regexp-to-ast-0.5.0.tgz",
+      "integrity": "sha512-tlbJqcMHnPKI9zSrystikWKwHkBqu2a/Sgw01h3zFjvYrMxEDYHzzoMZnUrbIfpTFEsoRnnviOXNCzFiSc54Qw==",
+      "license": "MIT"
+    },
     "node_modules/remarkable": {
       "version": "2.0.1",
       "resolved": "https://registry.npmmirror.com/remarkable/-/remarkable-2.0.1.tgz",
@@ -5913,6 +6231,16 @@
         "sprintf-js": "~1.0.2"
       }
     },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.10",
       "resolved": "https://registry.npmmirror.com/resolve/-/resolve-1.22.10.tgz",
@@ -6021,6 +6349,50 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/rollup-plugin-visualizer": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmmirror.com/rollup-plugin-visualizer/-/rollup-plugin-visualizer-6.0.3.tgz",
+      "integrity": "sha512-ZU41GwrkDcCpVoffviuM9Clwjy5fcUxlz0oMoTXTYsK+tcIFzbdacnrr2n8TXcHxbGKKXtOdjxM2HUS4HjkwIw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "open": "^8.0.0",
+        "picomatch": "^4.0.2",
+        "source-map": "^0.7.4",
+        "yargs": "^17.5.1"
+      },
+      "bin": {
+        "rollup-plugin-visualizer": "dist/bin/cli.js"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "rolldown": "1.x || ^1.0.0-beta",
+        "rollup": "2.x || 3.x || 4.x"
+      },
+      "peerDependenciesMeta": {
+        "rolldown": {
+          "optional": true
+        },
+        "rollup": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/rollup-plugin-visualizer/node_modules/picomatch": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmmirror.com/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "resolved": "https://registry.npmmirror.com/run-parallel/-/run-parallel-1.2.0.tgz",
@@ -6150,6 +6522,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/sh-syntax": {
+      "version": "0.5.8",
+      "resolved": "https://registry.npmmirror.com/sh-syntax/-/sh-syntax-0.5.8.tgz",
+      "integrity": "sha512-JfVoxf4FxQI5qpsPbkHhZo+n6N9YMJobyl4oGEUBb/31oQYlgTjkXQD8PBiafS2UbWoxrTO0Z5PJUBXEPAG1Zw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/sh-syntax"
+      }
+    },
     "node_modules/sha.js": {
       "version": "2.4.12",
       "resolved": "https://registry.npmmirror.com/sha.js/-/sha.js-2.4.12.tgz",
@@ -6270,6 +6657,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/source-map": {
+      "version": "0.7.6",
+      "resolved": "https://registry.npmmirror.com/source-map/-/source-map-0.7.6.tgz",
+      "integrity": "sha512-i5uvt8C3ikiWeNZSVZNWcfZPItFQOsYTUAOkcUPGd8DqDy1uOUikjt5dG+uRlwyvR108Fb9DOd4GvXfT0N2/uQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
     "node_modules/source-map-js": {
       "version": "1.2.1",
       "resolved": "https://registry.npmmirror.com/source-map-js/-/source-map-js-1.2.1.tgz",
@@ -6349,6 +6746,34 @@
         "safe-buffer": "~5.2.0"
       }
     },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmmirror.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -7263,6 +7688,24 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
     "node_modules/xml-name-validator": {
       "version": "4.0.0",
       "resolved": "https://registry.npmmirror.com/xml-name-validator/-/xml-name-validator-4.0.0.tgz",
@@ -7283,6 +7726,45 @@
         "node": ">=0.4"
       }
     },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmmirror.com/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmmirror.com/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmmirror.com/yocto-queue/-/yocto-queue-0.1.0.tgz",

frontend/package.json

@@ -5,8 +5,8 @@
   "type": "module",
   "scripts": {
     "dev": "vite --host --mode development",
-    "build:dev": "vue-tsc && vite build --minify false --mode development",
+    "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": "vue-tsc && vite build --mode production",
+    "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"
@@ -43,12 +43,16 @@
     "@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",
@@ -57,8 +61,10 @@
     "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.92.1",
+    "sh-syntax": "^0.5.8",
     "sql-formatter": "^15.6.9",
     "vue": "^3.5.21",
     "vue-i18n": "^11.1.12",
@@ -72,9 +78,11 @@
     "@types/remarkable": "^2.0.8",
     "@vitejs/plugin-vue": "^6.0.1",
     "@wailsio/runtime": "latest",
+    "cross-env": "^7.0.3",
     "eslint": "^9.35.0",
     "eslint-plugin-vue": "^10.4.0",
     "globals": "^16.4.0",
+    "rollup-plugin-visualizer": "^6.0.3",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.43.0",
     "unplugin-vue-components": "^29.0.0",

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/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/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/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) {
+      if (themes[ThemeType.ThemeTypeDark]) {
-        Object.assign(themeColors.darkTheme, themes.dark.colors);
+        Object.assign(themeColors.darkTheme, themes[ThemeType.ThemeTypeDark].colors);
       }
-      if (themes.light) {
+      if (themes[ThemeType.ThemeTypeLight]) {
-        Object.assign(themeColors.lightTheme, themes.light.colors);
+        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

@@ -36,9 +36,14 @@ 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 "@/utils/prettier/plugins/go/go"
+import goPrettierPlugin from "@/common/prettier/plugins/go/go"
-import sqlPrettierPlugin from "@/utils/prettier/plugins/sql/sql"
+import sqlPrettierPlugin from "@/common/prettier/plugins/sql/sql"
-import phpPrettierPlugin from "@/utils/prettier/plugins/php"
+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";
 
 /**
@@ -78,7 +83,10 @@ export const LANGUAGES: LanguageInfo[] = [
         parser: "markdown",
         plugins: [markdownPrettierPlugin]
     }),
-    new LanguageInfo("java", "Java", javaLanguage.parser),
+    new LanguageInfo("java", "Java", javaLanguage.parser,{
+        parser: "java",
+        plugins: [javaPrettierPlugin]
+    }),
     new LanguageInfo("php", "PHP", phpLanguage.configure({top: "Program"}).parser, {
         parser: "php",
         plugins: [phpPrettierPlugin]
@@ -87,17 +95,29 @@ export const LANGUAGES: LanguageInfo[] = [
         parser: "css",
         plugins: [cssPrettierPlugin]
     }),
-    new LanguageInfo("xml", "XML", xmlLanguage.parser),
+    new LanguageInfo("xml", "XML", xmlLanguage.parser,{
+        parser: "xml",
+        plugins: [xmlPrettierPlugin]
+    }),
     new LanguageInfo("cpp", "C++", cppLanguage.parser),
-    new LanguageInfo("rs", "Rust", rustLanguage.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),
+    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),
+    new LanguageInfo("toml", "TOML", StreamLanguage.define(toml).parser,{
+        parser: "toml",
+        plugins: [tomlPrettierPlugin]
+    }),
     new LanguageInfo("go", "Go", StreamLanguage.define(go).parser, {
         parser: "go",
         plugins: [goPrettierPlugin]

frontend/vite.config.ts

@@ -2,7 +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 {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());
@@ -17,6 +18,9 @@ export default defineConfig(({mode}: { mode: string }): object => {
         plugins: [
             vue(),
             nodePolyfills(),
+            visualizer({open: false,
+                filename: 'visualizer.html',
+                }),
             Components({
                 dts: true,
                 dirs: ['src/components'],
@@ -29,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,
+            brotliSize: false, // 跳过 brotli 压缩分析
-            chunkSizeWarningLimit: 2000,
+            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';
+                        }
+                    }
                 },
             }
         }

internal/services/service_manager.go

@@ -142,7 +142,6 @@ func NewServiceManager() *ServiceManager {
 		databaseService:     databaseService,
 		documentService:     documentService,
 		windowService:       windowService,
-		windowSnapService:   windowSnapService,
 		migrationService:    migrationService,
 		systemService:       systemService,
 		hotkeyService:       hotkeyService,
@@ -169,7 +168,6 @@ func (sm *ServiceManager) GetServices() []application.Service {
 		application.NewService(sm.databaseService),
 		application.NewService(sm.documentService),
 		application.NewService(sm.windowService),
-		application.NewService(sm.windowSnapService),
 		application.NewService(sm.keyBindingService),
 		application.NewService(sm.extensionService),
 		application.NewService(sm.migrationService),
@@ -183,7 +181,7 @@ func (sm *ServiceManager) GetServices() []application.Service {
 		application.NewService(sm.themeService),
 		application.NewService(sm.badgeService),
 		application.NewService(sm.notificationService),
-		application.NewService(sm.testService), // 注册测试服务
+		application.NewService(sm.testService),
 		application.NewService(sm.BackupService),
 	}
 	return services
@@ -259,11 +257,6 @@ func (sm *ServiceManager) GetThemeService() *ThemeService {
 	return sm.themeService
 }
 
-// GetWindowSnapService 获取窗口吸附服务实例
-func (sm *ServiceManager) GetWindowSnapService() *WindowSnapService {
-	return sm.windowSnapService
-}
-
 // GetBadgeService 获取badge服务实例
 func (sm *ServiceManager) GetBadgeService() *badge.BadgeService {
 	return sm.badgeService