cluaupp 0.2.2 → 1.0.0

package/docs/syntax.md

@@ -1,205 +1,80 @@
-# C++ → Luau syntax
+# CL++ syntax (Cluaupp)
 
-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).
+Cluaupp does **not** define the language. Write CL++ (`.clpp` / `.clp` / `.clh`); `clpp` emits Luau. Full course and reference: **[kartzrbx.github.io/CLPP](https://kartzrbx.github.io/CLPP/)**.
 
 ## Files
 
-- 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.
-
-## Functions
-
-```cpp
-void CreateLeaderstats(Player* player) {
-	return;
-}
-
-int doubleCoins(int coins) {
-	return coins;
-}
-```
-
-```luau
-const function CreateLeaderstats(player: Player)
-	return
-end
-
-const function doubleCoins(coins: number): number
-	return coins
-end
-```
+| Source | Rojo |
+| --- | --- |
+| `*.server.clpp` | Script |
+| `*.client.clpp` | LocalScript |
+| `*.plugin.clpp` | Plugin Script |
+| `*.clp` / untagged `.clpp` | ModuleScript |
+| `*.clh` | ModuleScript (types / structs) |
 
-`void` omits a return annotation. `int` / `float` / `double` → `number`. `bool` → `boolean`. Roblox types (`Player`, `Folder`) keep their name.
+`void init()` is the script entry. There is no `int main()`.
 
-If `void init()` exists, emit appends `init()` at the end of the file.
+## Accessors
 
-## Locals and const
+CL++ does **not** use `->`.
 
-Luau uses `local` for variables and `const` for constants. `const int` in C++ becomes `const` in Luau.
+| Write | Meaning | Luau |
+| --- | --- | --- |
+| `player.Name` | property | `.` |
+| `player::FindFirstChild("x")` | method | `:` |
+| `DataService:Server` | table key | `.` |
+| `"hi " .: name` | concat | `..` |
+| `signal~>Connect(fn)` | janitor Connect | `janitor:Add(..., "Disconnect")` |
+| `signal~>Once(fn)` | one-shot | `Once` + janitor |
 
-```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
-```
+`post` / `warn` / `report` → `print` / `warn` / `error`. `null` is `nil`.
 
-`auto` infers the type when the value is `new Class(...)` or `GetService<Service>()`.
+## Exclusive CL++ (compiled by `clpp`)
 
-## Control flow
-
-```cpp
-if (player->FindFirstChild("leaderstats") != nullptr) {
+```clpp
+guard (player != null) else {
+	warn("Invalid player");
 	return;
-} else {
-	print("ok");
-}
-
-while (true) {
-	print("tick");
-}
-
-for (auto* player : players->GetPlayers()) {
-	CreateLeaderstats(player);
-}
-
-switch (action) {
-case "buy":
-case "purchase":
-	Grant(player);
-	break;
-case "sell":
-	if (amount <= 0) {
-		break;
-	}
-	Take(player);
-	break;
-default:
-	warn("unknown");
-	break;
 }
-```
-
-```luau
-if player:FindFirstChild("leaderstats") ~= nil then
-	return
-else
-	print("ok")
-end
-
-while true do
-	print("tick")
-end
-
-for _, player in players:GetPlayers() do
-	CreateLeaderstats(player)
-end
-
-repeat
-	if action == "buy" or action == "purchase" then
-		Grant(player)
-	elseif action == "sell" then
-		if amount <= 0 then
-			break
-		end
-		Take(player)
-	else
-		warn("unknown")
-	end
-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.
 
-## Expressions
+match (child) {
+	BasePart* p => BindPart(p),
+	Model* m => post("model spawned " .: m.Name),
+	_ => warn("ignored instance")
+};
 
-| C++ | Luau |
-| --- | --- |
-| `nullptr` | `nil` |
-| `true` / `false` | `true` / `false` |
-| `!=` | `~=` |
-| `&&` | `and` |
-| `\|\|` | `or` |
-| `==` `+` `-` `*` `/` `<` `>` `<=` `>=` | same |
-| `"text"` | `"text"` |
-| `obj->Prop` | `obj.Prop` |
-| `obj->Method(a)` | `obj:Method(a)` if the method is a Roblox API |
-| `fn(a)` | `fn(a)` |
-| `signal.Connect(fn)` | `signal:Connect(fn)` |
-| `Type { .Field = value }` | `{ Field = value }` |
-
-Designated initializers become Luau tables. Nested braces work the same way:
-
-```cpp
-DataService::Server.Init(DataServiceOptions {
-	.Template = playerData,
-	.StoreName = "PlayerData",
-	.UseMock = true,
+observable int wallet = 100;
+wallet.OnChange(func [](int newValue) {
+	post("Coins changed to: " .: newValue);
 });
-```
 
-```luau
-DataService.Server:Init({
-	Template = playerData,
-	StoreName = "PlayerData",
-	UseMock = true,
-})
-```
-
-## `new` and services
-
-```cpp
-auto* coins = new IntValue(leaderstats);
-auto* players = GetService<Players>();
-```
-
-```luau
-local coins: IntValue = Instance.new("IntValue")
-coins.Parent = leaderstats
-local players: Players = game:GetService("Players")
-```
+signal<Player*, int> OnHit;
+OnHit~>Connect(func [](Player* player, int amount) {
+	post(player.Name .: " dmg " .: amount);
+});
+OnHit::Fire(player, 10);
 
-The first argument of `new Class(parent)` becomes `.Parent`. With no argument: `Instance.new("Class")` only.
+array<string> names = {"Kartz", "Player1"};
+dictionary<string, int> stats = { {"Coins", 100}, {"Gems", 50} };
 
-## print / cout
+spawn { task::wait(1); post("ready"); };
+parallel { post("desync"); };
 
-`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.
+async Data* FetchData(Player* player) {
+	return await DataService:Server::WaitFor(player);
+}
 
-```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");
-```
+[[server]]
+void SaveData(Player* player) { post(player.Name); }
 
-```luau
-print("EnsureStat: ", name, " not found")
-warn("failed")
-print("ok")
-warn("careful")
-error("fail")
-print("here")
+[[client]]
+void UpdateUI() { post("ui"); }
 ```
 
-Full table and IntelliSense notes: [print and cout](print-cout.md).
-
-## Not supported yet
+Fusion HUD uses `Fusion:scoped`, `Fusion:Value`, `Fusion:Computed`, `Fusion:New`. See [`examples/game`](../examples/game) (`combat.server.clpp`, `hud.client.clpp`, `features.clp`, `PlayerData.clh`).
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`).
+## What Cluaupp adds after `clpp`
 
-If you need one of those patterns, open an issue with the C++ and the expected Luau.
+- `require(ClppLibs.X)` → `require(ReplicatedStorage.CluauppLibs.X)`
+- `--!strict` from `cluaupp.config.json` / `#pragma strict`
+- `out/` layout for Rojo (`init`, `build`, `watch`)

package/editors/vscode/extension.js

@@ -55,7 +55,7 @@ function activate(context) {
 	});
 
 	const refreshDiagnostics = (document) => {
-		if (!document || document.languageId !== "cpp") {
+		if (!document || (document.languageId !== "clpp" && document.languageId !== "cpp")) {
 			return;
 		}
 		if (typeof loaded.engine.diagnosticsFor !== "function") {

package/editors/vscode/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "cluaupp-diagnostics",
 	"displayName": "Cluaupp",
-	"description": "Cluaupp subset parse errors. C++ completion, hover, and go-to-definition come from clangd + include/cluaupp/roblox.hpp.",
-	"version": "0.2.2",
+	"description": "Cluaupp project diagnostics. Language highlighting and IntelliSense come from clpp install (CL++).",
+	"version": "1.0.0",
 	"publisher": "kartzdev",
 	"engines": {
 		"vscode": "^1.74.0"
@@ -11,14 +11,14 @@
 		"Linters"
 	],
 	"activationEvents": [
-		"onLanguage:cpp"
+		"onLanguage:clpp"
 	],
 	"main": "./extension.js",
 	"contributes": {
 		"commands": [
 			{
 				"command": "cluaupp.restartIntelliSense",
-				"title": "Cluaupp: Reload subset diagnostics"
+				"title": "Cluaupp: Reload CL++ diagnostics"
 			}
 		]
 	}

package/examples/README.md

@@ -1,18 +1,16 @@
 # Sample game
 
-This is the C++ a Cluaupp game looks like — **not** the compiler.
+CL++ sources for a Cluaupp project — **not** the compiler. Language samples: [CL++ examples](https://github.com/KartzRbx/CLPP/tree/main/examples).
 
 | Folder | Rojo | Tag |
 | --- | --- | --- |
-| `src/server/*.server.cpp` | Script | server |
-| `src/client/*.client.cpp` | LocalScript | client |
-| `src/shared/*` | ModuleScript | none |
-
-`src/` of **this repo** is the TypeScript CLI ([roblox-ts](https://github.com/roblox-ts/roblox-ts) does the same). The sample scripts live here so they never mix with `understand.ts`.
+| `src/server/*.server.clpp` | Script | server |
+| `src/client/*.client.clpp` | LocalScript | client |
+| `src/shared/*.clp` / `*.clh` | ModuleScript | none |
 
 ```bash
 cd examples/game
 npx cluaupp build .
 ```
 
-`cluaupp init` copies `templates/game` (the slim scaffold). This folder adds combat / HUD so `SystemUnderstander` has real tokens to score.
+`cluaupp init` copies `templates/game`. This folder adds combat (`guard` / `match` / `signal` / `observable` / `spawn`), a Fusion HUD, `features.clp`, and `PlayerData.clh`.

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

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

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

@@ -1,27 +1,10 @@
 {
-	"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}",
-		"--header-insertion=never",
-		"--query-driver=**/clang++*,**/clang++.exe,**/g++*,**/g++.exe"
-	],
 	"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"
+		"*.clpp": "clpp",
+		"*.clp": "clpp",
+		"*.clh": "clpp",
+		"*.server.clpp": "clpp",
+		"*.client.clpp": "clpp",
+		"*.plugin.clpp": "clpp"
 	}
 }

package/examples/game/src/client/hud.client.clpp

@@ -0,0 +1,54 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/fusion.clh>
+
+[[client]]
+void init() {
+	Players* players = GetService<Players>();
+	Player* localPlayer = players.LocalPlayer;
+	guard (localPlayer != null) else {
+		report("LocalPlayer missing");
+		return;
+	}
+
+	Instance* playerGui = localPlayer::WaitForChild("PlayerGui");
+	auto scope = Fusion:scoped();
+	auto Children = Fusion:Children;
+
+	auto coins = Fusion:Value(scope, 0);
+	auto title = Fusion:Computed(scope, func []() {
+		return "Coins: " .: coins();
+	});
+
+	auto newScreenGui = Fusion:New(scope, "ScreenGui");
+	auto newFrame = Fusion:New(scope, "Frame");
+	auto newLabel = Fusion:New(scope, "TextLabel");
+
+	auto label = newLabel({
+		{"Name", "Amount"},
+		{"BackgroundTransparency", 1},
+		{"Size", UDim2.fromScale(1, 1)},
+		{"Text", title},
+		{"TextColor3", Color3.fromRGB(255, 255, 255)},
+		{"TextScaled", true}
+	});
+
+	auto frame = newFrame({
+		{"Name", "Hud"},
+		{"AnchorPoint", Vector2(0, 1)},
+		{"Position", UDim2.fromScale(0, 1)},
+		{"Size", UDim2.fromOffset(220, 64)},
+		{"BackgroundColor3", Color3.fromRGB(28, 18, 48)},
+		{Children, label}
+	});
+
+	newScreenGui({
+		{"Name", "CoinsHud"},
+		{"ResetOnSpawn", false},
+		{"Parent", playerGui},
+		{Children, frame}
+	});
+
+	coins(100);
+	post("hud ready");
+}

package/examples/game/src/client/init.client.clpp

@@ -0,0 +1,6 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void init() {
+	post("Cluaupp client ok");
+}

package/examples/game/src/server/combat.server.clpp

@@ -0,0 +1,85 @@
+#pragma strict
+#include <clpp/roblox.clh>
+#include <clpp/libs/janitor.clh>
+
+struct CombatServer {
+	Janitor* janitor;
+	signal<Player*, int> OnHit;
+	void PlayerEntered(Player* player);
+	void BindPart(BasePart* part);
+	void WatchWorkspace();
+};
+
+void CombatServer::BindPart(BasePart* part) {
+	guard (part != null) else {
+		return;
+	}
+
+	part.Touched~>Once(func [](BasePart* other) {
+		Instance* character = other.Parent;
+		guard (character != null) else {
+			return;
+		}
+
+		match (character::FindFirstChild("Humanoid")) {
+			Humanoid* humanoid => {
+				guard (humanoid.Health > 0) else {
+					return;
+				}
+				Players* players = GetService<Players>();
+				Player* player = players::GetPlayerFromCharacter(character);
+				guard (player != null) else {
+					return;
+				}
+				OnHit::Fire(player, 10);
+				part::Destroy();
+			},
+			_ => warn("touch without humanoid")
+		};
+	});
+}
+
+void CombatServer::PlayerEntered(Player* player) {
+	guard (player != null) else {
+		return;
+	}
+
+	observable int combo = 0;
+	OnHit~>Connect(func [](Player* victim, int amount) {
+		guard (victim == player) else {
+			return;
+		}
+		combo = combo + 1;
+		post(player.Name .: " combo " .: combo .: " dmg " .: amount);
+	});
+}
+
+[[server]]
+void CombatServer::WatchWorkspace() {
+	workspace.ChildAdded~>Connect(func [](Instance* child) {
+		match (child) {
+			BasePart* p => BindPart(p),
+			Model* m => post("model spawned " .: m.Name),
+			_ => warn("ignored instance")
+		};
+	});
+}
+
+void init() {
+	CombatServer combat;
+	combat.janitor = new Janitor();
+
+	spawn {
+		task::wait(1);
+		post("combat ready");
+	};
+
+	Players* players = GetService<Players>();
+	for (Player* player : players::GetPlayers()) {
+		combat::PlayerEntered(player);
+	}
+	players::PlayerAdded~>Connect(func [](Player* p) {
+		combat::PlayerEntered(p);
+	});
+	combat::WatchWorkspace();
+}

package/examples/game/src/server/leaderstats.server.clpp

@@ -0,0 +1,28 @@
+#pragma strict
+#include <clpp/roblox.clh>
+
+void CreateLeaderstats(Player* player) {
+	if (player::FindFirstChild("leaderstats") != null) {
+		return;
+	}
+
+	Folder* leaderstats = new Folder(player);
+	leaderstats.Name = "leaderstats";
+
+	IntValue* coins = new IntValue(leaderstats);
+	coins.Name = "Coins";
+	coins.Value = 0;
+
+	IntValue* level = new IntValue(leaderstats);
+	level.Name = "Level";
+	level.Value = 0;
+}
+
+void init() {
+	Players* players = GetService<Players>();
+	for (Player* player : players::GetPlayers()) {
+		CreateLeaderstats(player);
+	}
+
+	players::PlayerAdded::Connect(CreateLeaderstats);
+}

package/examples/game/src/shared/PlayerData.clh

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <clpp/datatypes.clh>
+
+struct PlayerDataCurrencies {
+	int Coins = 0;
+	int Rebirths = 0;
+};
+
+struct PlayerDataInventory {
+	array<int> HotBar;
+	array<int> Storage;
+
+	int MaxStorage = 90;
+};
+
+struct PlayerData {
+	PlayerDataCurrencies Currencies;
+	PlayerDataInventory Inventory;
+};

package/examples/game/src/shared/config.clp

@@ -0,0 +1,6 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+const int STARTING_COINS = 0;
+const string REMOTE_COINS = "Coins";
+const string LEADERSTATS_FOLDER = "leaderstats";

package/examples/game/src/shared/features.clp

@@ -0,0 +1,88 @@
+#pragma once
+#include <clpp/roblox.clh>
+
+void ShowcaseFeatures(int coins, Player* playerRef) {
+	int n = 100;
+	float speed = 16.5;
+	string name = "Kartz";
+	bool isActive = true;
+	func callback = []() {};
+	(void)speed;
+	(void)isActive;
+	(void)callback;
+
+	array<string> names = {"Kartz", "Player1"};
+	dictionary<string, int> stats = {
+		{"Coins", 100},
+		{"Gems", 50}
+	};
+	(void)names;
+	(void)stats;
+
+	if (coins > 50) {
+		post("Enough balance!");
+	} else if (coins == 0) {
+		warn("No coins!");
+	} else {
+		report("Balance sync error.");
+	}
+
+	for (int i = 0; i < 10; i++) {
+		post("Count: " .: i);
+	}
+
+	n += 1;
+
+	observable int wallet = 100;
+	wallet.OnChange(func [](int newValue) {
+		post("Coins changed to: " .: newValue);
+	});
+
+	signal<Player*, int> OnCoinsUpdated;
+	OnCoinsUpdated~>Connect(func [](Player* player, int newAmount) {
+		post("New coins for " .: player.Name .: ": " .: newAmount);
+	});
+	OnCoinsUpdated~>Once(func [](Player* player, int newAmount) {
+		(void)newAmount;
+		post("First coins for " .: player.Name);
+	});
+	OnCoinsUpdated::Fire(playerRef, wallet);
+
+	guard (playerRef != null) else {
+		warn("Invalid player");
+		return;
+	}
+
+	playerRef::GetPropertyChangedSignal("Name")~>Connect(func []() {
+		post("Name changed");
+	});
+
+	auto [success, result] = pcall(func []() {
+		return 1;
+	});
+	(void)result;
+
+	const int moeda = 4;
+	match (moeda) {
+		int a => post(a),
+		_ => post("Not found")
+	};
+
+	if (success) {
+		post("Data loaded successfully!");
+	}
+
+	spawn {
+		task::wait(2);
+		post("Delay finished!");
+	};
+
+	parallel {
+		post("desync");
+	};
+
+	match (name) {
+		string s => post(s),
+		_ => warn("Instance not supported")
+	};
+}