cluaupp 0.1.4 → 0.2.0

package/generated/emitter/translators.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateCppType = translateCppType;
+exports.translateGetService = translateGetService;
+exports.translateConstant = translateConstant;
+exports.translateAlias = translateAlias;
+exports.translateStruct = translateStruct;
+exports.translateFunction = translateFunction;
+const compile_js_1 = require("../compile.js");
+const TYPE_MAP = {
+    "std::string": "string",
+    "std::string_view": "string",
+    string: "string",
+    string_view: "string",
+    bool: "boolean",
+    int: "number",
+    int8_t: "number",
+    int16_t: "number",
+    int32_t: "number",
+    int64_t: "number",
+    uint8_t: "number",
+    uint16_t: "number",
+    uint32_t: "number",
+    uint64_t: "number",
+    float: "number",
+    double: "number",
+    size_t: "number",
+    void: "()",
+    auto: "any",
+};
+function translateCppType(cppType) {
+    const trimmed = cppType
+        .replace(/\b(?:const|constexpr|volatile|static|inline|restrict)\b/g, "")
+        .replace(/\s+/g, " ")
+        .replace(/&/g, "")
+        .replace(/\*/g, "")
+        .trim();
+    if (!trimmed) {
+        return "any";
+    }
+    if (TYPE_MAP[trimmed]) {
+        return TYPE_MAP[trimmed];
+    }
+    const generic = trimmed.match(/^(?:std::)?(?:vector|array|span|LuaArray)\s*<\s*([^>]+)\s*>$/);
+    if (generic) {
+        return `{${translateCppType(generic[1])}}`;
+    }
+    const optional = trimmed.match(/^(?:std::)?optional\s*<\s*([^>]+)\s*>$/);
+    if (optional) {
+        return `${translateCppType(optional[1])}?`;
+    }
+    return trimmed.replace(/^::/, "");
+}
+function translateGetService(node) {
+    const functionNode = node.childForFieldName("function") || node.namedChildren[0];
+    if (!functionNode) {
+        return null;
+    }
+    const text = functionNode.text.replace(/\s+/g, "");
+    const generic = text.match(/GetService<(\w+)>/);
+    if (generic) {
+        return generic[1];
+    }
+    if (!text.includes("GetService")) {
+        return null;
+    }
+    const args = functionNode.namedChildren.find((child) => child.type === "template_argument_list");
+    if (args) {
+        const ident = args.namedChildren.find((child) => child.type === "type_identifier" || child.type === "identifier");
+        if (ident) {
+            return ident.text;
+        }
+    }
+    const callText = node.text.replace(/\s+/g, "");
+    const match = callText.match(/GetService<(\w+)>/);
+    return match ? match[1] : null;
+}
+function translateConstant(node) {
+    const declarator = node.childForFieldName("declarator");
+    if (!declarator) {
+        return null;
+    }
+    const name = identifierOf(declarator);
+    const valueNode = node.childForFieldName("value") ||
+        declarator.childForFieldName("value") ||
+        namedOf(declarator, "initializer") ||
+        node.namedChildren[node.namedChildren.length - 1];
+    if (!name || !valueNode || valueNode === declarator) {
+        return null;
+    }
+    let value = valueNode.text.replace(/;$/, "").trim();
+    if (value.startsWith("=")) {
+        value = value.slice(1).trim();
+    }
+    if (!value) {
+        return null;
+    }
+    return `const ${name} = ${value}`;
+}
+function translateAlias(node, mapType) {
+    const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier") || node.namedChildren[1];
+    const typeNode = node.childForFieldName("type") || namedOf(node, "type_descriptor") || node.namedChildren[0];
+    if (!nameNode || !typeNode) {
+        return null;
+    }
+    return `type ${nameNode.text} = ${mapType(typeNode.text)}`;
+}
+function translateStruct(node, mapType) {
+    const nameNode = node.childForFieldName("name") || namedOf(node, "type_identifier");
+    const body = node.childForFieldName("body") || namedOf(node, "field_declaration_list");
+    if (!nameNode) {
+        return null;
+    }
+    if (!body) {
+        return `type ${nameNode.text} = {}`;
+    }
+    const fields = [];
+    for (const field of body.namedChildren) {
+        if (field.type !== "field_declaration") {
+            continue;
+        }
+        const fieldType = field.childForFieldName("type");
+        const fieldDecl = field.childForFieldName("declarator");
+        const fieldName = fieldDecl ? identifierOf(fieldDecl) : namedOf(field, "field_identifier")?.text;
+        if (!fieldName) {
+            continue;
+        }
+        fields.push(`\t${fieldName}: ${mapType(fieldType?.text || "any")},`);
+    }
+    if (fields.length === 0) {
+        return `type ${nameNode.text} = {}`;
+    }
+    return `type ${nameNode.text} = {\n${fields.join("\n")}\n}`;
+}
+function translateFunction(node, fileName) {
+    try {
+        const luau = (0, compile_js_1.compileSource)(node.text, fileName, { skipHeader: true });
+        const trimmed = String(luau || "").trim();
+        return trimmed || null;
+    }
+    catch {
+        const name = identifierOf(node.childForFieldName("declarator") || node) || "fn";
+        return `-- function ${name} (não traduzida)`;
+    }
+}
+function identifierOf(node) {
+    if (node.type === "identifier" || node.type === "field_identifier" || node.type === "type_identifier") {
+        return node.text;
+    }
+    const direct = node.childForFieldName("declarator") || namedOf(node, "identifier") || namedOf(node, "field_identifier");
+    if (direct) {
+        return identifierOf(direct);
+    }
+    for (const child of node.namedChildren) {
+        const found = identifierOf(child);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function namedOf(node, type) {
+    return node.namedChildren.find((child) => child.type === type) || null;
+}

package/generated/headers.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitHeaderModule = emitHeaderModule;
+exports.primaryHeaderName = primaryHeaderName;
+exports.collectHeaderShape = collectHeaderShape;
+// @ts-nocheck
+const node_path_1 = __importDefault(require("node:path"));
+const api_js_1 = require("./api.js");
+function fileStem(fileName) {
+    return node_path_1.default.basename(String(fileName || "module")).replace(/\.(h|hpp|hh|cpp|cc|cxx|c)$/i, "");
+}
+function emitValue(node) {
+    if (!node) {
+        return "nil";
+    }
+    if (node.type === "number") {
+        return node.value;
+    }
+    if (node.type === "string") {
+        return `"${node.value}"`;
+    }
+    if (node.type === "bool") {
+        return node.value ? "true" : "false";
+    }
+    if (node.type === "null") {
+        return "nil";
+    }
+    if (node.type === "initlist") {
+        const inner = (node.fields || []).map((field) => `${field.name} = ${emitValue(field.value)}`).join(", ");
+        return `{ ${inner} }`;
+    }
+    return "nil";
+}
+function collectHeaderShape(ast, fileName) {
+    const owners = new Map();
+    const ensure = (name) => {
+        if (!owners.has(name)) {
+            owners.set(name, { fields: [], methods: [] });
+        }
+        return owners.get(name);
+    };
+    const freeProtos = [];
+    const consts = [];
+    for (const decl of ast.body || []) {
+        if (decl.type === "decl" && decl.owner) {
+            ensure(decl.owner).fields.push(decl);
+            continue;
+        }
+        if (decl.type === "decl") {
+            consts.push(decl);
+            continue;
+        }
+        if ((decl.type === "proto" || decl.type === "function") && decl.owner) {
+            ensure(decl.owner).methods.push(decl);
+            continue;
+        }
+        if (decl.type === "proto") {
+            freeProtos.push(decl);
+        }
+    }
+    const nested = new Set();
+    for (const [ownerName, spec] of owners) {
+        for (const field of spec.fields) {
+            if (field.valueType && owners.has(field.valueType) && field.valueType !== ownerName) {
+                nested.add(field.valueType);
+            }
+        }
+    }
+    const roots = [...owners.keys()].filter((name) => !nested.has(name));
+    const withMethods = roots.filter((name) => ensure(name).methods.length > 0);
+    const stem = fileStem(fileName);
+    let primary = withMethods[0] || (freeProtos.length ? stem : roots[0] || stem);
+    return { owners, nested, roots, freeProtos, consts, primary, stem };
+}
+function primaryHeaderName(ast, fileName) {
+    return collectHeaderShape(ast, fileName).primary;
+}
+function methodType(fn, owner) {
+    const params = [];
+    if (owner) {
+        params.push(`self: ${owner}`);
+    }
+    for (const param of fn.params || []) {
+        if (typeof param === "string") {
+            params.push(param);
+            continue;
+        }
+        const typeAnn = (0, api_js_1.luauType)(param.valueType);
+        params.push(typeAnn ? `${param.name}: ${typeAnn}` : param.name);
+    }
+    const ret = (0, api_js_1.luauType)(fn.returnType);
+    const retAnn = !ret || ret === "()" ? "()" : ret;
+    return `(${params.join(", ")}) -> ${retAnn}`;
+}
+function fieldType(field, owners) {
+    if (field.valueType && owners.has(field.valueType)) {
+        return field.valueType;
+    }
+    return (0, api_js_1.luauType)(field.valueType) || "any";
+}
+function emitExportType(lines, name, spec, owners, extraMethods, extraFields) {
+    lines.push(`export type ${name} = {`);
+    const seen = new Set();
+    for (const field of [...((spec && spec.fields) || []), ...(extraFields || [])]) {
+        if (!field.name || seen.has(field.name)) {
+            continue;
+        }
+        seen.add(field.name);
+        lines.push(`	${field.name}: ${fieldType(field, owners)},`);
+    }
+    for (const method of (spec && spec.methods) || []) {
+        if (!method.name || seen.has(method.name)) {
+            continue;
+        }
+        seen.add(method.name);
+        lines.push(`	${method.name}: ${methodType(method, name)},`);
+    }
+    for (const method of extraMethods || []) {
+        if (!method.name || seen.has(method.name)) {
+            continue;
+        }
+        seen.add(method.name);
+        lines.push(`	${method.name}: ${methodType(method, null)},`);
+    }
+    lines.push("}");
+    lines.push("");
+}
+function emitDataConstructor(lines, name, spec, owners) {
+    const emitField = (field) => {
+        if (field.valueType && owners.has(field.valueType)) {
+            const nested = owners.get(field.valueType);
+            const inner = nested.fields.map((item) => `${item.name} = ${emitValue(item.value)}`).join(", ");
+            return `{ ${inner} }`;
+        }
+        if (field.value && field.value.type === "initlist") {
+            return emitValue(field.value);
+        }
+        return emitValue(field.value);
+    };
+    lines.push(`const function ${name}(): ${name}`);
+    lines.push("	return {");
+    for (const field of spec.fields) {
+        lines.push(`		${field.name} = ${emitField(field)},`);
+    }
+    lines.push("	}");
+    lines.push("end");
+    lines.push("");
+}
+function emitHeaderModule(ast, options = {}) {
+    const strict = options.strict === true;
+    const fileName = options.relativeName || options.filePath || "header.h";
+    const shape = collectHeaderShape(ast, fileName);
+    const lines = [];
+    if (strict) {
+        lines.push("--!strict");
+    }
+    lines.push("-- Compiled by Cluaupp — C++ × Luau");
+    lines.push("");
+    const typeOrder = [...shape.nested, ...shape.roots];
+    for (const name of typeOrder) {
+        const extra = name === shape.primary ? shape.freeProtos : [];
+        emitExportType(lines, name, shape.owners.get(name), shape.owners, extra);
+    }
+    if (shape.freeProtos.length && !shape.owners.has(shape.primary)) {
+        emitExportType(lines, shape.primary, { fields: [], methods: [] }, shape.owners, shape.freeProtos, shape.consts);
+    }
+    for (const decl of shape.consts) {
+        const typeAnn = (0, api_js_1.luauType)(decl.valueType);
+        const typed = typeAnn ? `: ${typeAnn}` : "";
+        lines.push(`const ${decl.name}${typed} = ${emitValue(decl.value)}`);
+    }
+    if (shape.consts.length) {
+        lines.push("");
+    }
+    const hasMethods = shape.roots.some((name) => shape.owners.get(name).methods.length > 0) || shape.freeProtos.length > 0;
+    const implName = hasMethods ? options.headerImplName : null;
+    if (!hasMethods && shape.roots.length > 0) {
+        for (const name of shape.roots) {
+            emitDataConstructor(lines, name, shape.owners.get(name), shape.owners);
+        }
+        lines.push(`return ${shape.primary}`);
+        lines.push("");
+        return lines.join("\n");
+    }
+    if (!hasMethods && shape.consts.length > 0) {
+        lines.push("return {");
+        for (const decl of shape.consts) {
+            lines.push(`	${decl.name} = ${decl.name},`);
+        }
+        lines.push("}");
+        lines.push("");
+        return lines.join("\n");
+    }
+    const tableName = shape.primary;
+    const spec = shape.owners.get(tableName) || { fields: [], methods: [] };
+    const methods = [...spec.methods, ...shape.freeProtos];
+    lines.push(`const ${tableName}: ${tableName} = {`);
+    if (implName) {
+        for (const field of spec.fields) {
+            if (field.valueType && shape.owners.has(field.valueType) && field.valueType !== tableName) {
+                continue;
+            }
+            lines.push(`	${field.name} = ${implName}.${field.name},`);
+        }
+        for (const method of methods) {
+            lines.push(`	${method.name} = ${implName}.${method.name},`);
+        }
+    }
+    for (const decl of shape.consts) {
+        lines.push(`	${decl.name} = ${decl.name},`);
+    }
+    lines.push("}");
+    lines.push("");
+    lines.push(`return ${tableName}`);
+    lines.push("");
+    return lines.join("\n");
+}

package/generated/index.html

@@ -0,0 +1,49 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Docs · Cluaupp V2 Specification</title>
+    <style>
+        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; background-color: #0f0f14; color: #c9d1d9; padding: 40px; line-height: 1.6; }
+        h1, h2, h3 { color: #58a6ff; border-bottom: 1px solid #21262d; padding-bottom: 8px; }
+        code { background-color: #161b22; padding: 4px 8px; border-radius: 4px; font-family: 'Courier New', Courier, monospace; color: #ff7b72; }
+        pre { background-color: #161b22; padding: 16px; border-radius: 8px; border: 1px solid #30363d; overflow-x: auto; }
+        .grid { display: grid; grid-template-columns: 1fr 1fr; gap: 20px; }
+        .card { background: #1f242c; border: 1px solid #30363d; padding: 20px; border-radius: 8px; }
+        .badge { background-color: #238636; color: white; padding: 4px 8px; border-radius: 12px; font-size: 12px; font-weight: bold; }
+    </style>
+</head>
+<body>
+    <h1>Cluaupp Compiler Core V2 <span class="badge">TypeScript Migration</span></h1>
+    <p>Documentação da API atualizada para o novo Pipeline de Transpilação baseado em Coletores Estruturados.</p>
+
+    <h2>A Nova Ordem Crítica do Output</h2>
+    <p>O compilador Cluaupp agora garante deterministicamente um arquivo Luau limpo, agrupado por blocos ordenados:</p>
+    <pre>1. game:GetService() Clientes Automatizados
+2. Módulos Locais Resolvidos via require() do Rojo
+3. Definições e Aliases de Tipos Estritos
+4. Declarações Globais de Constantes Imutáveis
+5. Lógica das Funções e Ciclos do Script</pre>
+
+    <h2>Mudanças Importantes na Tabela de Tipos</h2>
+    <div class="grid">
+        <div class="card">
+            <h3>Como era (Cluaupp V1)</h3>
+            <ul>
+                <li>Uso de tipos primitivos crus: <code>string</code></li>
+                <li>Injeção manual de variáveis de serviço globais</li>
+                <li>Geração de código procedural inline desordenada</li>
+            </ul>
+        </div>
+        <div class="card">
+            <h3>Como é Agora (Cluaupp V2)</h3>
+            <ul>
+                <li>Suporte a tipos idiomáticos: <code>std::string</code> e <code>std::string_view</code> viram <code>string</code></li>
+                <li>Injeção automática pelo analisador ao ler <code>GetService&lt;T&gt;()</code></li>
+                <li>Pós-processamento automático nativo com <code>StyLua</code> e <code>Luau-Analyze</code></li>
+            </ul>
+        </div>
+    </div>
+</body>
+</html>