cluaupp 0.1.2 → 0.1.4

package/docs/syntax.md

@@ -2,7 +2,7 @@
 
 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: [`--!strict`](https://luau.org/getting-started), `local`, and `const`.
+Generated Luau follows the current language: [`--!strict`](https://luau.org/getting-started), `local`, `const`, and `const function`. Injected `require` / `GetService` lines are `const`.
 
 ## Files
 
@@ -25,11 +25,11 @@ int doubleCoins(int coins) {
 ```
 
 ```luau
-local function CreateLeaderstats(player: Player)
+const function CreateLeaderstats(player: Player)
 	return
 end
 
-local function doubleCoins(coins: number): number
+const function doubleCoins(coins: number): number
 	return coins
 end
 ```
@@ -73,6 +73,22 @@ while (true) {
 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
@@ -89,9 +105,22 @@ 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
 ```
 
-The only `for` accepted today is **range-for**: `for (auto* x : list)`. 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 (`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
 
@@ -143,8 +172,33 @@ local players: Players = game:GetService("Players")
 
 The first argument of `new Class(parent)` becomes `.Parent`. With no argument: `Instance.new("Class")` only.
 
+## 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.
+
+```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");
+```
+
+```luau
+print("EnsureStat: ", name, " not found")
+warn("failed")
+print("ok")
+warn("careful")
+error("fail")
+print("here")
+```
+
+Full table and IntelliSense notes: [print and cout](print-cout.md).
+
 ## Not supported yet
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `switch`, `std::`, overloading, macros (except skipping `#` lines).
+Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except skipping `#` lines).
 
 If you need one of those patterns, open an issue with the C++ and the expected Luau.

package/editors/vscode/extension.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const vscode = require("vscode");
+
+function loadEngine(context) {
+	const folders = vscode.workspace.workspaceFolders || [];
+	const workspaceFolder = folders[0] ? folders[0].uri.fsPath : null;
+	const rootFile = path.join(context.extensionPath, "cluaupp.root");
+	const roots = [];
+	if (fs.existsSync(rootFile)) {
+		roots.push(fs.readFileSync(rootFile, "utf8").trim());
+	}
+	if (workspaceFolder) {
+		roots.push(path.join(workspaceFolder, "..", "Cluaupp"));
+		roots.push(path.join(workspaceFolder, "node_modules", "cluaupp"));
+	}
+	roots.push(path.join(context.extensionPath, "..", ".."));
+	for (const root of roots) {
+		const engine = path.join(root, "src", "intellisense.js");
+		if (fs.existsSync(engine)) {
+			return { engine: require(engine), root, workspaceFolder };
+		}
+	}
+	throw new Error("Cluaupp IntelliSense engine not found. Run `cluaupp intellisense` in the game folder.");
+}
+
+function kindOf(kind) {
+	const map = {
+		method: vscode.CompletionItemKind.Method,
+		function: vscode.CompletionItemKind.Function,
+		constructor: vscode.CompletionItemKind.Constructor,
+		property: vscode.CompletionItemKind.Property,
+		variable: vscode.CompletionItemKind.Variable,
+		class: vscode.CompletionItemKind.Class,
+		enum: vscode.CompletionItemKind.Enum,
+		keyword: vscode.CompletionItemKind.Keyword,
+		event: vscode.CompletionItemKind.Event,
+		file: vscode.CompletionItemKind.File,
+	};
+	return map[kind] || vscode.CompletionItemKind.Text;
+}
+
+function activate(context) {
+	let loaded;
+	try {
+		loaded = loadEngine(context);
+	} catch (err) {
+		vscode.window.showWarningMessage(String(err.message || err));
+		return;
+	}
+
+	const selector = { language: "cpp", scheme: "file" };
+	const diagnostics = vscode.languages.createDiagnosticCollection("cluaupp");
+	context.subscriptions.push(diagnostics);
+
+	const optionsFor = (document) => ({
+		projectRoot: loaded.workspaceFolder || path.dirname(document.uri.fsPath),
+		file: document.uri.fsPath,
+		filePath: document.uri.fsPath,
+		includeDirs: [
+			path.dirname(document.uri.fsPath),
+			path.join(loaded.workspaceFolder || "", "src"),
+			path.join(loaded.workspaceFolder || "", "include"),
+		],
+	});
+
+	const refreshDiagnostics = (document) => {
+		if (!document || document.languageId !== "cpp") {
+			return;
+		}
+		const items = loaded.engine.diagnosticsFor(document.getText(), document.uri.fsPath, optionsFor(document));
+		diagnostics.set(
+			document.uri,
+			items.map((item) => {
+				const line = Math.max(0, (item.line || 1) - 1);
+				const col = Math.max(0, (item.col || 1) - 1);
+				const range = new vscode.Range(line, col, line, col + 1);
+				return new vscode.Diagnostic(range, item.message, vscode.DiagnosticSeverity.Error);
+			}),
+		);
+	};
+
+	context.subscriptions.push(
+		vscode.languages.registerCompletionItemProvider(
+			selector,
+			{
+				provideCompletionItems(document, position) {
+					const offset = document.offsetAt(position);
+					const items = loaded.engine.completeAt(document.getText(), offset, optionsFor(document));
+					return items.map((item) => {
+						const completion = new vscode.CompletionItem(item.name, kindOf(item.kind));
+						completion.detail = item.detail || item.type || "";
+						completion.sortText = `${item.kind === "keyword" ? "2" : "0"}_${item.name}`;
+						completion.insertText = item.name;
+						return completion;
+					});
+				},
+			},
+			".",
+			":",
+			">",
+			"<",
+			'"',
+			"/",
+		),
+		vscode.languages.registerHoverProvider(selector, {
+			provideHover(document, position) {
+				const hover = loaded.engine.hoverAt(document.getText(), document.offsetAt(position), optionsFor(document));
+				if (!hover) {
+					return null;
+				}
+				return new vscode.Hover(new vscode.MarkdownString(`**${hover.name}**\n\n\`${hover.detail || hover.type || ""}\``));
+			},
+		}),
+		vscode.languages.registerDefinitionProvider(selector, {
+			provideDefinition(document, position) {
+				const def = loaded.engine.definitionAt(document.getText(), document.offsetAt(position), optionsFor(document));
+				if (!def || !def.file) {
+					return null;
+				}
+				return new vscode.Location(vscode.Uri.file(def.file), new vscode.Position(Math.max(0, (def.line || 1) - 1), 0));
+			},
+		}),
+		vscode.workspace.onDidChangeTextDocument((event) => refreshDiagnostics(event.document)),
+		vscode.workspace.onDidOpenTextDocument(refreshDiagnostics),
+		vscode.commands.registerCommand("cluaupp.restartIntelliSense", () => {
+			try {
+				delete require.cache[require.resolve(path.join(loaded.root, "src", "intellisense.js"))];
+				loaded = loadEngine(context);
+				vscode.window.showInformationMessage("Cluaupp IntelliSense reloaded.");
+			} catch (err) {
+				vscode.window.showErrorMessage(String(err.message || err));
+			}
+		}),
+	);
+
+	for (const document of vscode.workspace.textDocuments) {
+		refreshDiagnostics(document);
+	}
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate };

package/editors/vscode/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "cluaupp-intellisense",
+	"displayName": "Cluaupp IntelliSense",
+	"description": "Completions, hover, and go-to-definition for Cluaupp C++ (Roblox APIs, DataService paths, project structs).",
+	"version": "0.1.4",
+	"publisher": "kartzdev",
+	"engines": {
+		"vscode": "^1.74.0"
+	},
+	"categories": [
+		"Programming Languages"
+	],
+	"activationEvents": [
+		"onLanguage:cpp"
+	],
+	"main": "./extension.js",
+	"contributes": {
+		"commands": [
+			{
+				"command": "cluaupp.restartIntelliSense",
+				"title": "Cluaupp: Restart IntelliSense"
+			}
+		]
+	}
+}

package/include/cluaupp/libs/janitor.hpp

@@ -10,6 +10,8 @@ public:
 	template <typename T>
 	T Add(T object);
 	template <typename T>
+	T Add(T object, bool callDirectly);
+	template <typename T>
 	T Add(T object, string methodName);
 	template <typename T>
 	T Add(T object, string methodName, string index);
@@ -17,14 +19,15 @@ public:
 	T AddObject(T constructor);
 	template <typename P>
 	P AddPromise(P promise);
+	template <typename P>
+	P AddPromise(P promise, string index);
 	Janitor* Remove(string index);
 	Janitor* RemoveNoClean(string index);
 	Janitor* RemoveList(string index);
+	Janitor* RemoveListNoClean(string index);
 	template <typename T>
 	T Get(string index);
-	template <typename T>
-	T GetAll();
-	bool Has(string index);
+	void GetAll();
 	void Cleanup();
 	void Destroy();
 	RBXScriptConnection LinkToInstance(Instance* object);
@@ -32,4 +35,5 @@ public:
 	Janitor* LinkToInstances(Instance* object);
 	static bool Is(Instance* value);
 	static bool Is(string value);
+	static bool instanceof(Instance* value);
 };

package/include/cluaupp/roblox.hpp

@@ -21,6 +21,25 @@ extern LuaSourceContainer* script;
 void print(string message);
 void warn(string message);
 void error(string message);
+
+struct cout {
+	static void print(string message);
+	static void warn(string message);
+	static void error(string message);
+	static void ping(string message);
+	static void endl();
+	cout& operator<<(string value);
+	cout& operator<<(int value);
+	cout& operator<<(double value);
+	cout& operator<<(bool value);
+} cout;
+
+struct cerr {
+	cerr& operator<<(string value);
+	cerr& operator<<(int value);
+} cerr;
+
+const int endl = 0;
 double tick();
 double time();
 void wait(double seconds = 0);

package/package.json

@@ -1,65 +1,66 @@
-{
-	"name": "cluaupp",
-	"version": "0.1.2",
-	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
-	"author": "KartzDev",
-	"license": "MIT",
-	"bin": {
-		"cluaupp": "bin/cluaupp.js",
-		"cluau": "bin/cluaupp.js"
-	},
-	"main": "src/compile.js",
-	"exports": {
-		".": "./src/compile.js",
-		"./package.json": "./package.json"
-	},
-	"files": [
-		"bin",
-		"src",
-		"include",
-		"templates",
-		"runtime",
-		"README.md",
-		"LICENSE",
-		"CHANGELOG.md",
-		"docs"
-	],
-	"scripts": {
-		"cluaupp": "node bin/cluaupp.js",
-		"cluau": "node bin/cluaupp.js",
-		"build": "node bin/cluaupp.js build",
-		"watch": "node bin/cluaupp.js watch",
-		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js && node test/dataservice.test.js && node test/prune.test.js && node test/hold.test.js",
-		"generate-api": "node scripts/generate-api.js",
-		"check-highlight": "node scripts/check-highlight.js",
-		"vendor-libs": "node scripts/vendor-libs.js",
-		"docs": "moonwave dev",
-		"docs:build": "moonwave build",
-		"site": "node scripts/generate-api.js && node scripts/check-highlight.js",
-		"dev": "node scripts/dev.js",
-		"stop": "node scripts/stop.js",
-		"prepublishOnly": "npm test"
-	},
-	"engines": {
-		"node": ">=18"
-	},
-	"keywords": [
-		"luau",
-		"roblox",
-		"cpp",
-		"c++",
-		"transpiler",
-		"compiler",
-		"rojo",
-		"cluaupp",
-		"cluau"
-	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/KartzRbx/Cluaupp.git"
-	},
-	"bugs": {
-		"url": "https://github.com/KartzRbx/Cluaupp/issues"
-	},
-	"homepage": "https://github.com/KartzRbx/Cluaupp#readme"
-}
+{
+	"name": "cluaupp",
+	"version": "0.1.4",
+	"description": "Cluaupp — the definitive merge of C++ and modern Luau. Source-to-source transpiler with first-class Roblox APIs.",
+	"author": "KartzDev",
+	"license": "MIT",
+	"bin": {
+		"cluaupp": "bin/cluaupp.js",
+		"cluau": "bin/cluaupp.js"
+	},
+	"main": "src/compile.js",
+	"exports": {
+		".": "./src/compile.js",
+		"./package.json": "./package.json"
+	},
+	"files": [
+		"bin",
+		"src",
+		"include",
+		"templates",
+		"editors",
+		"runtime",
+		"README.md",
+		"LICENSE",
+		"CHANGELOG.md",
+		"docs"
+	],
+	"scripts": {
+		"cluaupp": "node bin/cluaupp.js",
+		"cluau": "node bin/cluaupp.js",
+		"build": "node bin/cluaupp.js build",
+		"watch": "node bin/cluaupp.js watch",
+		"test": "node test/leaderstats.test.js && node test/understand.test.js && node test/datatypes.test.js && node test/headers.test.js && node test/libs.test.js && node test/runtime-libs.test.js && node test/intellisense.test.js && node test/intellisense-complete.test.js && node test/dataservice.test.js && node test/datacontroller-signal.test.js && node test/cout.test.js && node test/prune.test.js && node test/hold.test.js && node test/vendor-stable.test.js && node test/switch.test.js && node test/qualified.test.js && node test/module-require.test.js",
+		"generate-api": "node scripts/generate-api.js",
+		"check-highlight": "node scripts/check-highlight.js",
+		"vendor-libs": "node scripts/vendor-libs.js",
+		"docs": "moonwave dev",
+		"docs:build": "moonwave build",
+		"site": "node scripts/generate-api.js && node scripts/check-highlight.js",
+		"dev": "node scripts/dev.js",
+		"stop": "node scripts/stop.js",
+		"prepublishOnly": "npm test"
+	},
+	"engines": {
+		"node": ">=18"
+	},
+	"keywords": [
+		"luau",
+		"roblox",
+		"cpp",
+		"c++",
+		"transpiler",
+		"compiler",
+		"rojo",
+		"cluaupp",
+		"cluau"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/KartzRbx/Cluaupp.git"
+	},
+	"bugs": {
+		"url": "https://github.com/KartzRbx/Cluaupp/issues"
+	},
+	"homepage": "https://github.com/KartzRbx/Cluaupp#readme"
+}

package/runtime/Janitor/init.luau

@@ -1,45 +1,15 @@
 --!strict
 -- Cluaupp Janitor — typed border. Engine: howmanysmall/Janitor (_impl).
--- Requires the sibling CluauppLibs.Promise module, never a nested stub.
+-- Public type and return value are the implementation. Promise is required
+-- inside _impl as CluauppLibs.Promise (`script.Parent.Parent.Promise`).
 
 --[=[
 	@class Janitor
 	Cleans up connections, instances, promises, and threads.
 ]=]
 
-local PromiseMod = require(script.Parent.Promise)
-type Promise<T...> = PromiseMod.Promise<T...>
-
 local Impl = require(script._impl)
 
-export type Janitor = {
-	CurrentlyCleaning: boolean,
-	SuppressInstanceReDestroy: boolean,
-	UnsafeThreadCleanup: boolean,
-	Add: <T>(self: Janitor, object: T, methodName: (boolean | string)?, index: string?) -> T,
-	AddObject: <T, A...>(
-		self: Janitor,
-		constructor: { new: (A...) -> T },
-		methodName: (boolean | string)?,
-		index: string?,
-		A...
-	) -> T,
-	AddPromise: <T...>(self: Janitor, promiseObject: Promise<T...>, index: string?) -> Promise<T...>,
-	Remove: (self: Janitor, index: string) -> Janitor,
-	RemoveNoClean: (self: Janitor, index: string) -> Janitor,
-	RemoveList: (self: Janitor, ...string) -> Janitor,
-	Get: <T>(self: Janitor, index: string) -> T?,
-	GetAll: (self: Janitor) -> { [string]: unknown },
-	Has: (self: Janitor, index: string) -> boolean,
-	Cleanup: (self: Janitor) -> (),
-	Destroy: (self: Janitor) -> (),
-	LinkToInstance: (self: Janitor, object: Instance, allowMultiple: boolean?) -> RBXScriptConnection,
-	LinkToInstances: (self: Janitor, ...Instance) -> Janitor,
-}
-
-type JanitorStatic = {
-	new: () -> Janitor,
-	Is: (value: unknown) -> boolean,
-}
+export type Janitor = Impl.Janitor
 
-return Impl :: JanitorStatic
+return Impl