cluaupp 0.2.2 → 0.2.3

package/docs/syntax.md

@@ -2,16 +2,39 @@
 
 Cluaupp is not a full C++ compiler. It is a **subset** aimed at Roblox scripts, in the same spirit as roblox-ts (restricted TypeScript → Luau).
 
-Generated Luau follows the current language: [`local`](https://luau.org/getting-started), `const`, and `const function`. Injected `require` / `GetService` lines are `const`. `--!strict` is emitted only when the file has `#pragma strict` (or `"strict": true` in config).
+Live grid of every construct: **[Language reference](https://kartzrbx.github.io/Cluaupp/docs/reference.html)**.
 
-## Files
+Generated Luau follows the current language: [`local`](https://luau.org/getting-started), `const`, and `const function`. Injected `require` / `GetService` lines are `const`. `--!strict` is emitted only when the file has `#pragma strict` (or `"strict": true` in config). `#pragma nstrict` never emits it.
 
-- Extensions: `.cpp`, `.h`, `.hpp` (also `.cc`, `.hh`)
-- Quoted `#include "file.h"` becomes a Rojo `require` (or is inlined for a header that belongs to the same `.cpp`)
-- `#include <cluaupp/roblox.hpp>` and `<cluaupp/libs/*.hpp>` are IntelliSense only; library headers also inject `require(CluauppLibs.*)`
-- `#pragma once` is ignored
-- `#pragma strict` / `#pragma nstrict` control `--!strict` for that compilation unit
-- Function prototypes in a `.h` / `.hpp` become `export type` fields (`init: (self: Name) -> ()`). Only `.cpp` files emit function bodies.
+## Files and includes
+
+- Extensions: `.cpp`, `.cc`, `.cxx`, `.c`, `.h`, `.hpp`, `.hh`
+- Tags: `*.server.cpp` → Script, `*.client.cpp` → LocalScript, `*.plugin.cpp` → Plugin, `*.legacy*` → Legacy, untagged → ModuleScript
+- Quoted `#include "Own.h"` (same stem as the `.cpp`) is **inlined**. Other quoted includes become `require` (Rojo path)
+- `#include <cluaupp/roblox.hpp>` is IntelliSense only. `#include <cluaupp/libs/janitor.hpp>` also injects `require(CluauppLibs.Janitor)`
+- `#pragma once` is ignored. Other macros are not expanded. `//` and `/* */` comments are stripped
+- `using …;` is skipped. `namespace { }` is flattened. `enum` / `template` / `typedef` / `extern` declarations are skipped
+
+## Types
+
+| C++ | Luau |
+| --- | --- |
+| `int` / `float` / `double` | `number` |
+| `bool` | `boolean` |
+| `string` | `string` (not `std::string`) |
+| `void` | no return annotation |
+| `auto` / `auto*` | inferred from `new` / `GetService` / datatype ctor |
+| `Player*` / `Folder*` | `Player` / `Folder` (Instance handle, not a heap address) |
+| `LuaArray<T>` / `vector<T>` / `array<T>` / `span<T>` | `{T}` |
+| `optional<T>` | `T?` |
+| `const` / `static constexpr` | Luau `const` |
+| `nullptr` | `nil` |
+| `Vector3` `CFrame` `UDim2` `Color3` | same names (copied values) |
+| `Enum::Material::Plastic` | `Enum.Material.Plastic` |
+
+Always initialize: `int coins = 0;` not `int coins;` (uninitialized emits `nil`). There is no `delete`, no `*part`, no `&part`, no `int&`. Numbers copy; Instances mutate through `->`.
+
+`auto` infers when the value is `new Class(...)`, `GetService<T>()`, or a datatype constructor. Prefer explicit types on parameters and struct fields.
 
 ## Functions
 
@@ -35,28 +58,18 @@ const function doubleCoins(coins: number): number
 end
 ```
 
-`void` omits a return annotation. `int` / `float` / `double` → `number`. `bool` → `boolean`. Roblox types (`Player`, `Folder`) keep their name.
-
-If `void init()` exists, emit appends `init()` at the end of the file.
-
-## Locals and const
+- Only functions with a body are emitted from a `.cpp`. Prototypes in a `.h` become `export type` fields
+- No overloading — one name, one emit. No default arguments
+- If `void init()` exists, emit appends `init()` at the end of Scripts / LocalScripts. There is no `int main()`
+- Shared ModuleScripts should not define `init()` unless you want them to run on `require`
 
-Luau uses `local` for variables and `const` for constants. `const int` in C++ becomes `const` in Luau.
+## Scopes
 
-```cpp
-int coins = 10;
-const int STARTING_COINS = 0;
-auto* folder = new Folder(player);
-```
-
-```luau
-local coins: number = 10
-const STARTING_COINS: number = 0
-local folder: Folder = Instance.new("Folder")
-folder.Parent = player
-```
-
-`auto` infers the type when the value is `new Class(...)` or `GetService<Service>()`.
+- File-level decls become file `local` / `const`
+- Function decls become `local` from that line to the end of the block. Nested `{ }` can shadow
+- In `Class::Method`, `this` is `self`. Bare field names become `self.field`. Bare calls to other methods become `self:Method(...)`. Parameters and locals shadow fields
+- Globals stay bare: `print`, `game`, `workspace`, library types, Instance types, datatypes
+- Instances are not RAII. Leaving a block does not Destroy a Part — use Janitor
 
 ## Control flow
 
@@ -121,9 +134,9 @@ repeat
 until true
 ```
 
-`switch` evaluates the discriminant **once**, then becomes `if` / `elseif` / `else` inside `repeat … until true` so `break` still exits the switch (even from inside an `if`). Stacked `case` labels share a body (`case "buy": case "purchase":`). There is no C-style fall-through into the next case’s statements. C-style `for (int i = 0; i < n; i++)` is not supported yet.
+`switch` evaluates the discriminant **once**, then becomes `if` / `elseif` / `else` inside `repeat … until true` so `break` still exits the switch (even from inside an `if`). Stacked `case` labels share a body. There is no C-style fall-through. C-style `for (int i = 0; i < n; i++)` is not supported. No `continue`, no `do/while`, no ternary. `else if (x)` emits a nested `if` inside `else` (not Luau `elseif`).
 
-## Expressions
+## Expressions and operators
 
 | C++ | Luau |
 | --- | --- |
@@ -132,15 +145,20 @@ until true
 | `!=` | `~=` |
 | `&&` | `and` |
 | `\|\|` | `or` |
-| `==` `+` `-` `*` `/` `<` `>` `<=` `>=` | same |
+| `!` | `not` |
+| `==` `+` `-` `*` `/` `<` `>` `<=` `>=` | same (`*` is multiply) |
 | `"text"` | `"text"` |
+| `=` | assignment |
 | `obj->Prop` | `obj.Prop` |
-| `obj->Method(a)` | `obj:Method(a)` if the method is a Roblox API |
+| `obj->Method(a)` | `obj:Method(a)` if the method is a Roblox / library API |
 | `fn(a)` | `fn(a)` |
 | `signal.Connect(fn)` | `signal:Connect(fn)` |
 | `Type { .Field = value }` | `{ Field = value }` |
+| unary `-` | `-` |
+
+No `++` `--` `+=`. Write `n = n + 1`. Binary operators in this subset are left-associative — use parentheses when mixing.
 
-Designated initializers become Luau tables. Nested braces work the same way:
+Designated initializers become Luau tables:
 
 ```cpp
 DataService::Server.Init(DataServiceOptions {
@@ -158,48 +176,87 @@ DataService.Server:Init({
 })
 ```
 
+## Strings and string_concat
+
+Luau concatenates with `..`. Do not write `..` in a `.cpp`.
+
+- If either side of `+` is a string literal, another concat, or `.Name` / `.Text` / `.DisplayName`, `+` becomes `..`
+- `string_concat(a, b, c)` is variadic: zero args → `""`, one arg → that value, several → `(a .. b .. c)`
+- Declared in `datatypes.hpp` (via `roblox.hpp`)
+
+```cpp
+return player->Name + "_LeaderstatsJanitor";
+return string_concat(player->Name, "_", "LeaderstatsJanitor");
+```
+
+```luau
+return player.Name .. "_LeaderstatsJanitor"
+return (player.Name .. "_" .. "LeaderstatsJanitor")
+```
+
+## print / cout
+
+`print`, `warn`, and `error` work as in Luau. `cout << … << endl` is the C++ spelling — each `<<` is another argument, `endl` ends the line. `cout::warn` / `cout::error` / `cout::ping` pick the Roblox function. `cerr` is `warn`. Full table: [print and cout](print-cout.md).
+
 ## `new` and services
 
 ```cpp
 auto* coins = new IntValue(leaderstats);
 auto* players = GetService<Players>();
+auto* janitor = new Janitor();
+part->Size = Vector3(8, 1, 8);
+part->CFrame = CFrame::lookAt(from, look);
+part->Material = Enum::Material::Plastic;
 ```
 
 ```luau
 local coins: IntValue = Instance.new("IntValue")
 coins.Parent = leaderstats
 local players: Players = game:GetService("Players")
+local janitor = Janitor.new()
+part.Size = Vector3.new(8, 1, 8)
+part.CFrame = CFrame.lookAt(from, look)
+part.Material = Enum.Material.Plastic
 ```
 
-The first argument of `new Class(parent)` becomes `.Parent`. With no argument: `Instance.new("Class")` only.
+The first argument of `new Class(parent)` becomes `.Parent` for Instance classes. Libraries use `Janitor.new()`. Datatypes use `Vector3(...)`, not `new`.
 
-## print / cout
+## Casts
 
-`print`, `warn`, and `error` work as in Luau. `cout << … << endl` is the C++ spelling — each `<<` is another argument, `endl` ends the line. `cout::warn` / `cout::error` / `cout::ping` pick the Roblox function.
+`static_cast<T>(x)`, `const_cast`, `reinterpret_cast`, `dynamic_cast` emit the argument. `(void)x;` is omitted (silences unused for clangd). Luau has no casts — they do not check ClassName.
+
+## Callbacks (events and lambdas)
+
+Signals use `.Connect`. Callbacks may be **named functions** or **lambdas** (`[](Player* player) { ... }`, including `[&]` / `[=]` / `[coinsValue]`). Capture lists are accepted; Luau closures do not copy C++ captures — keep Instances alive with Janitor.
+
+Passing a method by name from inside `Class::` binds `self`: `function(...) self:OnPlayer(...) end`.
 
 ```cpp
-cout << "EnsureStat: " << name << " not found" << endl;
-cout::print << "EnsureStat: " << name << " not found" << endl;
-cerr << "failed";
-cout::print("ok");
-cout::warn("careful");
-cout::error("fail");
-cout::ping("here");
+players->PlayerAdded.Connect([&](Player* playerEntered) {
+	leaderstatsServer.PlayerEntered(playerEntered);
+});
+game->BindToClose([&]() {
+	leaderstatsServer.janitor->Cleanup();
+});
 ```
 
-```luau
-print("EnsureStat: ", name, " not found")
-warn("failed")
-print("ok")
-warn("careful")
-error("fail")
-print("here")
-```
+## OOP: structs, methods, singletons
+
+How you write a type: a `struct` (or `class`) in the sibling `.h`, `Class::Method` in the `.cpp`, `void init()` to boot.
+
+- `static constexpr` fields are `const`
+- Fields are `self.field`. `public:` / `private:` are ignored
+- Nested structs with defaults become nested tables (DataService Templates). `LuaArray<T>` fields stay on the table
+- `Class::` methods emit `function Class:Method(...)`
+- Construct **one** service table in `init()` (`LeaderstatsServer leaderstatsServer;`) and capture it in lambdas. That is the game singleton
+- Library singletons already exist: `DataService::Server` / `Client` — `Init` once from a boot script
+- Header-only field structs emit `const function Name()` returning defaults
+- Untagged files of only `Class::` methods `return` the table (ModuleScript)
 
-Full table and IntelliSense notes: [print and cout](print-cout.md).
+Stem must match: `LeaderstatsServer.h` next to `LeaderstatsServer.server.cpp`. A differently named include is a `require`, not the class body.
 
-## Not supported yet
+## Not supported
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`).
+Custom C++ classes as metatables, generic templates besides `GetService<T>` / `static_cast<T>` / `LuaArray<T>` / `string_concat`, pointer arithmetic, `std::` (except mapped aliases), overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`), JSX / XML UI tags, C-style `for`, `++` `--` `+=`, `continue`, ternary, `do/while`, `try/catch`, `goto`, `int&` references.
 
-If you need one of those patterns, open an issue with the C++ and the expected Luau.
+CLI forms: [CLI](cli.md). How to write a type: [OOP](oop/index.md). Full handbook: **[Docs](https://kartzrbx.github.io/Cluaupp/docs/)**.

package/examples/game/.vscode/extensions.json

@@ -1,5 +1,8 @@
 {
 	"recommendations": [
 		"llvm-vs-code-extensions.vscode-clangd"
+	],
+	"unwantedRecommendations": [
+		"ms-vscode.cpptools"
 	]
 }

package/examples/game/.vscode/settings.json

@@ -1,13 +1,4 @@
 {
-	"C_Cpp.intelliSenseEngine": "Disabled",
-	"C_Cpp.default.cppStandard": "c++20",
-	"C_Cpp.default.cStandard": "c17",
-	"C_Cpp.default.compilerPath": "clang++",
-	"C_Cpp.default.intelliSenseMode": "windows-clang-x64",
-	"C_Cpp.default.includePath": [
-		"${workspaceFolder}/include",
-		"${workspaceFolder}/src"
-	],
 	"clangd.enable": true,
 	"clangd.arguments": [
 		"--compile-commands-dir=${workspaceFolder}",

package/generated/api.js

@@ -43,9 +43,23 @@ function luauType(name) {
     if (!name) {
         return null;
     }
-    const cleaned = String(name).replace(/\*+$/, "").replace(/^const\s+/, "").replace(/^Enum::/, "Enum.");
+    const cleaned = String(name)
+        .replace(/\*+$/, "")
+        .replace(/^const\s+/, "")
+        .replace(/^Enum::/, "Enum.")
+        .replace(/\s+/g, " ")
+        .trim();
     if (cleaned in LUAU_TYPES) {
         return LUAU_TYPES[cleaned];
     }
+    const generic = cleaned.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
+    if (generic) {
+        const inner = luauType(generic[1]) || generic[1];
+        return `{${inner}}`;
+    }
+    const optional = cleaned.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
+    if (optional) {
+        return `${luauType(optional[1]) || optional[1]}?`;
+    }
     return cleaned;
 }

package/generated/emit.js

@@ -31,6 +31,7 @@ function emit(ast, options = {}) {
         }
     }
     const ownedFns = (ast.body || []).filter((decl) => decl.type === "function");
+    const hasOwnedMethods = ownedFns.some((decl) => Boolean(decl.owner));
     const classModule = ownedFns.length > 0 && ownedFns.every((decl) => Boolean(decl.owner));
     const nestedTypes = new Set();
     for (const decl of ast.body || []) {
@@ -131,6 +132,35 @@ function emit(ast, options = {}) {
         }
         return linesOut;
     };
+    const isStringConcatCall = (node) => node && node.type === "call" && !node.object && node.name === "string_concat";
+    const emitStringConcat = (args) => {
+        const parts = (args || []).map(emitExpr);
+        if (parts.length === 0) {
+            return `""`;
+        }
+        if (parts.length === 1) {
+            return parts[0];
+        }
+        return `(${parts.join(" .. ")})`;
+    };
+    const isStringExpr = (node) => {
+        if (!node) {
+            return false;
+        }
+        if (node.type === "string") {
+            return true;
+        }
+        if (isStringConcatCall(node)) {
+            return true;
+        }
+        if (node.type === "binary" && node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+            return true;
+        }
+        if (node.type === "member" && (node.name === "Name" || node.name === "Text" || node.name === "DisplayName")) {
+            return true;
+        }
+        return false;
+    };
     const emitExpr = (node) => {
         if (!node) {
             return "nil";
@@ -153,6 +183,28 @@ function emit(ast, options = {}) {
                 }
                 return `{ ${entries.join(", ")} }`;
             }
+            case "cast":
+                if (node.valueType === "void") {
+                    return emitExpr(node.argument);
+                }
+                return emitExpr(node.argument);
+            case "lambda": {
+                const params = (node.params || [])
+                    .map((param) => {
+                    if (typeof param === "string") {
+                        return param;
+                    }
+                    const typeAnn = (0, api_js_1.luauType)(param.valueType);
+                    return typeAnn ? `${param.name}: ${typeAnn}` : param.name;
+                })
+                    .join(", ");
+                const inner = [];
+                for (const stmt of node.body || []) {
+                    inner.push(...emitStmt(stmt, 1));
+                }
+                const body = inner.length > 0 ? `\n${inner.join("\n")}\n` : "\n";
+                return `function(${params})${body}end`;
+            }
             case "unary": {
                 const inner = emitExpr(node.argument);
                 if (node.op === "!") {
@@ -172,6 +224,9 @@ function emit(ast, options = {}) {
             case "member":
                 return `${emitExpr(node.object)}.${node.name}`;
             case "call": {
+                if (isStringConcatCall(node)) {
+                    return emitStringConcat(node.args);
+                }
                 const args = node.args.map(emitMethodArg).join(", ");
                 if (!node.object) {
                     if ((0, api_js_1.isDatatype)(node.name)) {
@@ -183,6 +238,9 @@ function emit(ast, options = {}) {
                     return `${node.name}(${args})`;
                 }
                 const obj = emitExpr(node.object);
+                if (classMethods.has(node.name) && !localNames.has(node.name)) {
+                    return `${obj}:${node.name}(${args})`;
+                }
                 if (node.access === "::" && node.object.type === "ident" && node.object.name === "cout") {
                     if (node.name === "endl") {
                         return "print()";
@@ -220,6 +278,9 @@ function emit(ast, options = {}) {
                         return printed.join("; ");
                     }
                 }
+                if (node.op === "+" && (isStringExpr(node.left) || isStringExpr(node.right))) {
+                    return `${emitExpr(node.left)} .. ${emitExpr(node.right)}`;
+                }
                 const ops = { "!=": "~=", "&&": "and", "||": "or" };
                 const op = ops[node.op] || node.op;
                 return `${emitExpr(node.left)} ${op} ${emitExpr(node.right)}`;
@@ -278,6 +339,9 @@ function emit(ast, options = {}) {
             return [`${prefix}${kind} ${node.name}${typed} = ${created.className}.new(${args})`];
         }
         const value = node.value ? emitExpr(node.value) : "nil";
+        if (!node.value && node.valueType && classOwners.has(node.valueType)) {
+            return [`${prefix}${kind} ${node.name}${typed} = ${node.valueType}`];
+        }
         return [`${prefix}${kind} ${node.name}${typed} = ${value}`];
     };
     const emitStmt = (node, indent) => {
@@ -290,6 +354,9 @@ function emit(ast, options = {}) {
                 return emitNewDecl(node, indent);
             case "expr": {
                 const expr = node.expr;
+                if (expr && expr.type === "cast" && expr.valueType === "void") {
+                    return [];
+                }
                 if (expr && expr.type === "binary" && expr.op === "<<") {
                     const printed = emitCout(expr);
                     if (printed) {
@@ -433,10 +500,8 @@ function emit(ast, options = {}) {
         lines.push("	}");
         lines.push("end");
         lines.push("");
-        lines.push(`return ${root}`);
-        lines.push("");
     };
-    if (classModule) {
+    if (hasOwnedMethods) {
         for (const owner of classOwners) {
             lines.push(`local ${owner} = {}`);
             lines.push("");
@@ -446,6 +511,17 @@ function emit(ast, options = {}) {
         for (const root of structRoots) {
             emitStructConstructor(root);
         }
+        if (structRoots.length === 1) {
+            lines.push(`return ${structRoots[0]}`);
+        }
+        else {
+            lines.push("return {");
+            for (const root of structRoots) {
+                lines.push(`	${root} = ${root},`);
+            }
+            lines.push("}");
+        }
+        lines.push("");
         return lines.join("\n");
     }
     for (const decl of ast.body) {

package/generated/intellisense.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.intelliSenseMode = intelliSenseMode;
 exports.clangPath = clangPath;
 exports.writeCompileCommands = writeCompileCommands;
 exports.writeClangd = writeClangd;
@@ -65,32 +64,6 @@ function compileCommandEntry(root, file) {
         arguments: [clangPath(), ...clangCompileArgs(root), "-c", absFile],
     };
 }
-function mergeJson(file, patch) {
-    let current = {};
-    if (node_fs_1.default.existsSync(file)) {
-        try {
-            current = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
-        }
-        catch {
-            current = {};
-        }
-    }
-    const next = { ...current, ...patch };
-    for (const key of Object.keys(patch)) {
-        const value = patch[key];
-        const existing = current[key];
-        if (value && typeof value === "object" && !Array.isArray(value) && existing && typeof existing === "object" && !Array.isArray(existing)) {
-            next[key] = { ...existing, ...value };
-        }
-    }
-    const json = `${JSON.stringify(next, null, "\t")}\n`;
-    if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, "utf8") === json) {
-        return false;
-    }
-    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
-    node_fs_1.default.writeFileSync(file, json, "utf8");
-    return true;
-}
 function copyDir(from, to) {
     node_fs_1.default.mkdirSync(to, { recursive: true });
     for (const entry of node_fs_1.default.readdirSync(from, { withFileTypes: true })) {
@@ -104,6 +77,55 @@ function copyDir(from, to) {
         }
     }
 }
+function uniqueStrings(...lists) {
+    const seen = new Set();
+    const out = [];
+    for (const list of lists) {
+        if (!Array.isArray(list)) {
+            continue;
+        }
+        for (const item of list) {
+            if (typeof item === "string" && item && !seen.has(item)) {
+                seen.add(item);
+                out.push(item);
+            }
+        }
+    }
+    return out;
+}
+function stripCppToolsSettings(current) {
+    const next = {};
+    for (const [key, value] of Object.entries(current)) {
+        if (key === "C_Cpp" || key.startsWith("C_Cpp.")) {
+            continue;
+        }
+        next[key] = value;
+    }
+    return next;
+}
+function readJsonObject(file) {
+    if (!node_fs_1.default.existsSync(file)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+    }
+    catch {
+        // ignore corrupt editor json
+    }
+    return {};
+}
+function writeJson(file, value) {
+    const json = `${JSON.stringify(value, null, "\t")}\n`;
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
+    if (node_fs_1.default.existsSync(file) && node_fs_1.default.readFileSync(file, "utf8") === json) {
+        return;
+    }
+    node_fs_1.default.writeFileSync(file, json, "utf8");
+}
 function clangdEditorArgs() {
     return [
         "--compile-commands-dir=${workspaceFolder}",
@@ -111,16 +133,6 @@ function clangdEditorArgs() {
         "--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe",
     ];
 }
-function intelliSenseMode() {
-    const arch = process.arch === "arm64" ? "arm64" : "x64";
-    if (process.platform === "win32") {
-        return `windows-clang-${arch}`;
-    }
-    if (process.platform === "darwin") {
-        return `macos-clang-${arch}`;
-    }
-    return `linux-clang-${arch}`;
-}
 function clangPath() {
     return (0, editor_install_js_1.findClangPlusPlus)() || "clang++";
 }
@@ -167,54 +179,37 @@ Index:
     return true;
 }
 function writeVscode(root) {
-    const settings = node_path_1.default.join(root, ".vscode", "settings.json");
-    mergeJson(settings, {
-        "C_Cpp.intelliSenseEngine": "Disabled",
-        "C_Cpp.default.cppStandard": "c++20",
-        "C_Cpp.default.cStandard": "c17",
-        "C_Cpp.default.compilerPath": clangPath(),
-        "C_Cpp.default.intelliSenseMode": intelliSenseMode(),
-        "C_Cpp.default.includePath": ["${workspaceFolder}/include", "${workspaceFolder}/src"],
+    const settingsPath = node_path_1.default.join(root, ".vscode", "settings.json");
+    const current = readJsonObject(settingsPath);
+    const associations = {
+        ...((current["files.associations"] && typeof current["files.associations"] === "object" && !Array.isArray(current["files.associations"]))
+            ? current["files.associations"]
+            : {}),
+        "*.hpp": "cpp",
+        "*.h": "cpp",
+        "*.server.cpp": "cpp",
+        "*.client.cpp": "cpp",
+        "*.plugin.cpp": "cpp",
+        "*.legacy.cpp": "cpp",
+        "*.legacy.server.cpp": "cpp",
+        "*.legacy.client.cpp": "cpp",
+    };
+    writeJson(settingsPath, {
+        ...stripCppToolsSettings(current),
         "clangd.enable": true,
         "clangd.arguments": clangdEditorArgs(),
-        "files.associations": {
-            "*.hpp": "cpp",
-            "*.h": "cpp",
-            "*.server.cpp": "cpp",
-            "*.client.cpp": "cpp",
-            "*.plugin.cpp": "cpp",
-            "*.legacy.cpp": "cpp",
-            "*.legacy.server.cpp": "cpp",
-            "*.legacy.client.cpp": "cpp",
-        },
+        "files.associations": associations,
     });
-    mergeJson(node_path_1.default.join(root, ".vscode", "extensions.json"), {
-        recommendations: ["llvm-vs-code-extensions.vscode-clangd"],
+    const extensionsPath = node_path_1.default.join(root, ".vscode", "extensions.json");
+    const extensions = readJsonObject(extensionsPath);
+    writeJson(extensionsPath, {
+        ...extensions,
+        recommendations: uniqueStrings(extensions.recommendations, ["llvm-vs-code-extensions.vscode-clangd"]),
+        unwantedRecommendations: uniqueStrings(extensions.unwantedRecommendations, ["ms-vscode.cpptools"]),
     });
     const props = node_path_1.default.join(root, ".vscode", "c_cpp_properties.json");
-    const nextProps = {
-        configurations: [
-            {
-                name: "Cluaupp",
-                compilerPath: clangPath(),
-                cStandard: "c17",
-                cppStandard: "c++20",
-                intelliSenseMode: intelliSenseMode(),
-                includePath: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-                forcedInclude: ["${workspaceFolder}/include/cluaupp/roblox.hpp"],
-                compileCommands: "${workspaceFolder}/compile_commands.json",
-                browse: {
-                    path: ["${workspaceFolder}/include", "${workspaceFolder}/src"],
-                    limitSymbolsToIncludedHeaders: true,
-                },
-            },
-        ],
-        version: 4,
-    };
-    const json = `${JSON.stringify(nextProps, null, "\t")}\n`;
-    node_fs_1.default.mkdirSync(node_path_1.default.dirname(props), { recursive: true });
-    if (!node_fs_1.default.existsSync(props) || node_fs_1.default.readFileSync(props, "utf8") !== json) {
-        node_fs_1.default.writeFileSync(props, json, "utf8");
+    if (node_fs_1.default.existsSync(props)) {
+        node_fs_1.default.unlinkSync(props);
     }
 }
 function diagnosticsFor(source, fileName, options = {}) {

package/generated/lex.js

@@ -33,6 +33,9 @@ const KEYWORDS = new Set([
     "case",
     "default",
     "break",
+    "static",
+    "constexpr",
+    "inline",
 ]);
 function tokenize(source) {
     const tokens = [];