kopscript 0.1.0

package/dist/cli.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import { writeFileSync, watch as fsWatch } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { resolve, basename, join } from "node:path";
+import { compileGraph } from "./modules.js";
+function outputPathFor(filePath) {
+    const name = basename(filePath, ".ks");
+    return join(resolve(filePath, ".."), `${name}.js`);
+}
+// Compiles the whole module graph reachable from `filePath`, writing one
+// .js file next to each .ks source.
+function build(filePath) {
+    const result = compileGraph(filePath);
+    if (result.entryMissing) {
+        console.error(`ks: cannot find file '${filePath}'`);
+        process.exitCode = 1;
+        return { outPath: null, watchFiles: [] };
+    }
+    if (!result.success) {
+        for (const absPath of result.order) {
+            const mod = result.modules.get(absPath);
+            if (mod.diagnostics.hasErrors) {
+                console.error(mod.diagnostics.format(mod.source, absPath));
+                console.error("");
+            }
+        }
+        process.exitCode = 1;
+        return { outPath: null, watchFiles: result.order };
+    }
+    for (const absPath of result.order) {
+        writeFileSync(outputPathFor(absPath), result.outputs.get(absPath), "utf-8");
+    }
+    return { outPath: outputPathFor(filePath), watchFiles: result.order };
+}
+function run(filePath) {
+    const { outPath } = build(filePath);
+    if (!outPath)
+        return;
+    const result = spawnSync(process.execPath, [outPath], { stdio: "inherit" });
+    process.exitCode = result.status ?? 0;
+}
+// Rebuilds on every save of any file in the graph (not just the entry —
+// editing a `using`'d dependency triggers a rebuild too). Watchers are torn
+// down and re-established after each rebuild, since the dependency set
+// itself can change (a `using` added or removed). Multiple change events
+// from one save (common with editors that write-then-rename) are
+// debounced into a single rebuild.
+function watchCommand(filePath) {
+    let watchers = [];
+    let debounceTimer = null;
+    const clearWatchers = () => {
+        for (const w of watchers)
+            w.close();
+        watchers = [];
+    };
+    const rebuild = () => {
+        clearWatchers();
+        const timestamp = new Date().toLocaleTimeString();
+        process.exitCode = 0; // each rebuild gets a clean slate; a fixed error shouldn't leave the process pre-marked failed
+        const { outPath, watchFiles } = build(filePath);
+        console.log(outPath ? `[${timestamp}] Wrote ${outPath}` : `[${timestamp}] Build failed`);
+        const filesToWatch = watchFiles.length > 0 ? watchFiles : [filePath];
+        for (const f of filesToWatch) {
+            try {
+                watchers.push(fsWatch(f, () => scheduleRebuild()));
+            }
+            catch {
+                // Missing file (e.g. a typo'd entry path) — nothing to watch until it exists.
+            }
+        }
+    };
+    const scheduleRebuild = () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(rebuild, 80);
+    };
+    console.log(`[watch] ${filePath} — watching for changes. Press Ctrl+C to stop.`);
+    rebuild();
+}
+function main() {
+    const [, , command, file] = process.argv;
+    if (!command || !file || (command !== "build" && command !== "run" && command !== "watch")) {
+        console.error("Usage: ks <build|run|watch> <file.ks>");
+        process.exitCode = 1;
+        return;
+    }
+    const filePath = resolve(file);
+    if (command === "build") {
+        const { outPath } = build(filePath);
+        if (outPath)
+            console.log(`Wrote ${outPath}`);
+    }
+    else if (command === "watch") {
+        watchCommand(filePath);
+    }
+    else {
+        run(filePath);
+    }
+}
+main();

package/dist/codegen.js

@@ -0,0 +1,339 @@
+// KopScript's PascalCase stdlib member names, mapped to their real JS names — a
+// blind syntactic rename (codegen has no type information, so this fires on
+// any member access with a matching name, string/array/user-class alike;
+// same pre-existing risk as any of the entries below, going back to the
+// original string stdlib). Map/Filter/ForEach need nothing beyond the
+// rename — the callback and everything else already codegens generically.
+// Push is handled separately in genCall, since it's non-mutating in KopScript
+// (unlike JS's own Array.push) and needs a different call shape entirely.
+const MEMBER_METHOD_MAP = {
+    Contains: "includes",
+    StartsWith: "startsWith",
+    EndsWith: "endsWith",
+    Replace: "replaceAll",
+    Split: "split",
+    Trim: "trim",
+    ToUpper: "toUpperCase",
+    ToLower: "toLowerCase",
+    Map: "map",
+    Filter: "filter",
+    ForEach: "forEach",
+};
+const BINARY_OP_MAP = {
+    "+": "+",
+    "-": "-",
+    "*": "*",
+    "/": "/",
+    "%": "%",
+    "==": "===",
+    "!=": "!==",
+    "<": "<",
+    ">": ">",
+    "<=": "<=",
+    ">=": ">=",
+};
+// Runtime backing for `state<T>`: a value plus its change listeners. Emitted
+// inline (once per file) rather than pulled from a shared runtime package —
+// consistent with the rest of codegen producing self-contained JS with no
+// external dependency of its own.
+const STATE_PRELUDE = `class __KopState {
+  constructor(value) {
+    this._value = value;
+    this._listeners = [];
+  }
+  get Value() { return this._value; }
+  set Value(v) {
+    this._value = v;
+    for (const listener of this._listeners) listener(v);
+  }
+  Subscribe(listener) {
+    this._listeners.push(listener);
+  }
+}`;
+export class CodeGenerator {
+    constructor() {
+        this.matchCounter = 0;
+        this.interfaceNames = new Set();
+        this.usesState = false;
+    }
+    // `usingExports` maps each `using "<path>"` path (as written in source) to
+    // the list of names that module exports — resolved by the caller from that
+    // module's own checked Program, since a bare `using` brings everything
+    // `public` into scope without naming it explicitly.
+    generate(program, usingExports = new Map()) {
+        this.interfaceNames = new Set(program.statements.filter((s) => s.kind === "InterfaceDecl").map((s) => s.name));
+        const importLines = program.usings
+            .map((u) => {
+            const names = usingExports.get(u.path) ?? [];
+            return names.length > 0 ? `import { ${names.join(", ")} } from "${u.path}.js";` : null;
+        })
+            .filter((line) => line !== null);
+        const lines = [];
+        for (const stmt of program.statements) {
+            if (stmt.kind === "InterfaceDecl")
+                continue; // compile-time only, no runtime representation
+            if (stmt.kind === "ExternFunctionDecl" || stmt.kind === "ExternClassDecl" || stmt.kind === "ExternValueDecl") {
+                // Extern class members need no codegen of their own — a call like
+                // `el.addEventListener(...)` is just an ordinary member call against
+                // whatever the class's own binding resolves to at runtime; only the
+                // binding itself (import / ambient alias / re-export) needs emitting.
+                const binding = this.genExternBinding(stmt.name, stmt.jsName, stmt.modulePath, stmt.isExported);
+                if (binding)
+                    lines.push(binding);
+                continue;
+            }
+            let code = this.genStatement(stmt, 0);
+            if ((stmt.kind === "ClassDecl" || stmt.kind === "EnumDecl" || stmt.kind === "FunctionDecl") && stmt.isExported) {
+                code = `export ${code}`;
+            }
+            lines.push(code);
+        }
+        const body = lines.join("\n") + "\n";
+        const sections = [importLines.join("\n"), this.usesState ? STATE_PRELUDE : "", body].filter((s) => s.length > 0);
+        return sections.join("\n\n");
+    }
+    // Builds the code (if any) that creates the local `name` binding for an
+    // extern declaration, wiring in `export` when needed:
+    //  - imported (modulePath set): a real `import`, plus a plain re-export if exported
+    //  - ambient + no rename: nothing at all — the bare global just resolves at runtime
+    //  - ambient + renamed, or ambient + exported: an explicit `const` alias off
+    //    `globalThis` (needed either way: to rebind the name, or because a bare
+    //    ambient reference has no local binding to `export` in the first place)
+    genExternBinding(name, jsName, modulePath, isExported) {
+        if (modulePath) {
+            const importClause = jsName === name ? name : `${jsName} as ${name}`;
+            const importLine = `import { ${importClause} } from "${modulePath}";`;
+            return isExported ? `${importLine}\nexport { ${name} };` : importLine;
+        }
+        if (jsName === name && !isExported)
+            return null;
+        return `${isExported ? "export const" : "const"} ${name} = globalThis.${jsName};`;
+    }
+    // ---------- statements ----------
+    indentStr(indent) {
+        return "  ".repeat(indent);
+    }
+    genStatement(stmt, indent) {
+        const pad = this.indentStr(indent);
+        switch (stmt.kind) {
+            case "VarDecl":
+                return `${pad}${stmt.isConst ? "const" : "let"} ${stmt.name} = ${this.genExpr(stmt.init)};`;
+            case "FunctionDecl":
+                return this.genFunction(stmt, indent);
+            case "ClassDecl":
+                return this.genClass(stmt, indent);
+            case "InterfaceDecl":
+            case "ExternFunctionDecl":
+            case "ExternClassDecl":
+            case "ExternValueDecl":
+                return ""; // handled directly in generate(); unreachable here except via a nested-decl error path
+            case "EnumDecl": {
+                const entries = stmt.members.map((m, i) => `${m}: ${i}`).join(", ");
+                return `${pad}const ${stmt.name} = Object.freeze({ ${entries} });`;
+            }
+            case "Block":
+                return this.genBlock(stmt, indent);
+            case "IfStatement":
+                return this.genIf(stmt, indent);
+            case "WhileStatement":
+                return `${pad}while (${this.genExpr(stmt.condition)}) ${this.genBlock(stmt.body, indent).trimStart()}`;
+            case "ForStatement": {
+                const init = stmt.init
+                    ? stmt.init.kind === "VarDecl"
+                        ? `${stmt.init.isConst ? "const" : "let"} ${stmt.init.name} = ${this.genExpr(stmt.init.init)}`
+                        : this.genExpr(stmt.init.expression)
+                    : "";
+                const cond = stmt.condition ? this.genExpr(stmt.condition) : "";
+                const update = stmt.update ? this.genExpr(stmt.update) : "";
+                return `${pad}for (${init}; ${cond}; ${update}) ${this.genBlock(stmt.body, indent).trimStart()}`;
+            }
+            case "ForInStatement":
+                return `${pad}for (const ${stmt.varName} of ${this.genExpr(stmt.iterable)}) ${this.genBlock(stmt.body, indent).trimStart()}`;
+            case "ReturnStatement":
+                return stmt.value ? `${pad}return ${this.genExpr(stmt.value)};` : `${pad}return;`;
+            case "BreakStatement":
+                return `${pad}break;`;
+            case "ContinueStatement":
+                return `${pad}continue;`;
+            case "ExpressionStatement":
+                return `${pad}${this.genExpr(stmt.expression)};`;
+            case "TryStatement":
+                return this.genTry(stmt, indent);
+            case "ThrowStatement":
+                return `${pad}throw ${this.genExpr(stmt.expression)};`;
+        }
+    }
+    genTry(stmt, indent) {
+        let code = `${this.indentStr(indent)}try ${this.genBlock(stmt.tryBlock, indent).trimStart()}`;
+        if (stmt.catchBlock && stmt.catchParam) {
+            code += ` catch (${stmt.catchParam.name}) ${this.genBlock(stmt.catchBlock, indent).trimStart()}`;
+        }
+        if (stmt.finallyBlock) {
+            code += ` finally ${this.genBlock(stmt.finallyBlock, indent).trimStart()}`;
+        }
+        return code;
+    }
+    genBlock(block, indent) {
+        const pad = this.indentStr(indent);
+        if (block.statements.length === 0)
+            return `{\n${pad}}`;
+        const body = block.statements.map((s) => this.genStatement(s, indent + 1)).join("\n");
+        return `{\n${body}\n${pad}}`;
+    }
+    genIf(stmt, indent) {
+        const pad = this.indentStr(indent);
+        let code = `${pad}if (${this.genExpr(stmt.condition)}) ${this.genBlock(stmt.thenBranch, indent).trimStart()}`;
+        if (stmt.elseBranch) {
+            if (stmt.elseBranch.kind === "IfStatement") {
+                code += ` else ${this.genIf(stmt.elseBranch, indent).trimStart()}`;
+            }
+            else {
+                code += ` else ${this.genBlock(stmt.elseBranch, indent).trimStart()}`;
+            }
+        }
+        return code;
+    }
+    genFunction(decl, indent) {
+        const pad = this.indentStr(indent);
+        const params = decl.params.map((p) => p.name).join(", ");
+        const prefix = decl.isAsync ? "async function" : "function";
+        return `${pad}${prefix} ${decl.name}(${params}) ${this.genBlock(decl.body, indent).trimStart()}`;
+    }
+    genClass(decl, indent) {
+        const pad = this.indentStr(indent);
+        // The base list mixes an optional superclass with interface names (checker-validated);
+        // only the non-interface entry, if any, becomes a JS `extends` clause.
+        const superclass = decl.baseList.find((n) => !this.interfaceNames.has(n)) ?? null;
+        const header = superclass ? `class ${decl.name} extends ${superclass} {` : `class ${decl.name} {`;
+        const parts = [];
+        const memberPad = this.indentStr(indent + 1);
+        for (const field of decl.fields) {
+            if (field.isStatic)
+                parts.push(`${memberPad}static ${field.name} = ${this.genExpr(field.initializer)};`);
+        }
+        if (decl.constructor) {
+            parts.push(this.genConstructor(decl.constructor, indent + 1));
+        }
+        for (const method of decl.methods) {
+            const params = method.params.map((p) => p.name).join(", ");
+            const prefix = `${method.isStatic ? "static " : ""}${method.isAsync ? "async " : ""}`;
+            parts.push(`${memberPad}${prefix}${method.name}(${params}) ${this.genBlock(method.body, indent + 1).trimStart()}`);
+        }
+        const body = parts.join("\n\n");
+        return `${pad}${header}\n${body}\n${pad}}`;
+    }
+    // `: base(...)` compiles to `super(...)` as the literal first statement in
+    // the constructor body — required by real JS semantics (super() must run
+    // before `this` is touched), which is exactly the rule the checker already
+    // enforces, so this can't fail here.
+    genConstructor(ctor, indent) {
+        const pad = this.indentStr(indent);
+        const bodyPad = this.indentStr(indent + 1);
+        const params = ctor.params.map((p) => p.name).join(", ");
+        const lines = [];
+        if (ctor.baseArgs) {
+            lines.push(`${bodyPad}super(${ctor.baseArgs.map((a) => this.genExpr(a)).join(", ")});`);
+        }
+        lines.push(...ctor.body.statements.map((s) => this.genStatement(s, indent + 1)));
+        const bodyStr = lines.length > 0 ? `{\n${lines.join("\n")}\n${pad}}` : `{\n${pad}}`;
+        return `${pad}constructor(${params}) ${bodyStr}`;
+    }
+    // ---------- expressions ----------
+    genExpr(expr) {
+        switch (expr.kind) {
+            case "NumberLiteral":
+                return String(expr.value);
+            case "StringLiteral":
+                return JSON.stringify(expr.value);
+            case "BoolLiteral":
+                return String(expr.value);
+            case "InterpolatedStringLiteral":
+                return this.genInterpolatedString(expr);
+            case "ArrayLiteral":
+                return `[${expr.elements.map((e) => this.genExpr(e)).join(", ")}]`;
+            case "Identifier":
+                return expr.name;
+            case "ThisExpr":
+                return "this";
+            case "UnaryExpr":
+                return `${expr.op}${this.genExpr(expr.operand)}`;
+            case "BinaryExpr":
+                return `(${this.genExpr(expr.left)} ${BINARY_OP_MAP[expr.op]} ${this.genExpr(expr.right)})`;
+            case "LogicalExpr":
+                return `(${this.genExpr(expr.left)} ${expr.op} ${this.genExpr(expr.right)})`;
+            case "AssignExpr":
+                return `(${this.genExpr(expr.target)} = ${this.genExpr(expr.value)})`;
+            case "CallExpr":
+                return this.genCall(expr);
+            case "NewExpr":
+                return `new ${expr.className}(${expr.args.map((a) => this.genExpr(a)).join(", ")})`;
+            case "MemberExpr":
+                return this.genMember(expr);
+            case "IndexExpr":
+                return `${this.genExpr(expr.object)}[${this.genExpr(expr.index)}]`;
+            case "MatchExpr":
+                return this.genMatch(expr);
+            case "LambdaExpr":
+                return this.genLambda(expr);
+            case "AwaitExpr":
+                return `await ${this.genExpr(expr.operand)}`;
+            case "StateExpr":
+                this.usesState = true;
+                return `new __KopState(${this.genExpr(expr.initializer)})`;
+        }
+    }
+    genLambda(expr) {
+        const params = expr.params.map((p) => p.name).join(", ");
+        if (expr.body.kind === "Block") {
+            return `(${params}) => ${this.genBlock(expr.body, 0).trimStart()}`;
+        }
+        return `(${params}) => (${this.genExpr(expr.body)})`;
+    }
+    genInterpolatedString(expr) {
+        const escapeText = (text) => text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+        const body = expr.parts
+            .map((part) => (part.kind === "Text" ? escapeText(part.text) : `\${${this.genExpr(part.expression)}}`))
+            .join("");
+        return `\`${body}\``;
+    }
+    genCall(expr) {
+        if (expr.callee.kind === "Identifier" && expr.callee.name === "print") {
+            return `console.log(${expr.args.map((a) => this.genExpr(a)).join(", ")})`;
+        }
+        // Array.Push is non-mutating in KopScript, unlike JS's own (mutating,
+        // length-returning) Array.prototype.push — so it can't just be a member
+        // rename like Map/Filter/ForEach; it needs an entirely different call
+        // shape (a spread into a fresh array).
+        if (expr.callee.kind === "MemberExpr" && expr.callee.property === "Push" && expr.args.length === 1) {
+            return `[...${this.genExpr(expr.callee.object)}, ${this.genExpr(expr.args[0])}]`;
+        }
+        return `${this.genExpr(expr.callee)}(${expr.args.map((a) => this.genExpr(a)).join(", ")})`;
+    }
+    genMember(expr) {
+        const jsProperty = expr.property === "Length" ? "length" : MEMBER_METHOD_MAP[expr.property] ?? expr.property;
+        return `${this.genExpr(expr.object)}.${jsProperty}`;
+    }
+    genMatch(expr) {
+        const subjectVar = `__subject${this.matchCounter++}`;
+        const lines = [`(() => {`, `  const ${subjectVar} = ${this.genExpr(expr.subject)};`];
+        let emittedIf = false;
+        expr.arms.forEach((arm) => {
+            if (arm.pattern.kind === "WildcardPattern") {
+                lines.push(emittedIf ? `  else {` : `  if (true) {`);
+                lines.push(`    return ${this.genExpr(arm.result)};`);
+                lines.push(`  }`);
+                emittedIf = true;
+                return;
+            }
+            const condition = arm.pattern.kind === "RegexPattern"
+                ? `new RegExp(${JSON.stringify(arm.pattern.source)}).test(${subjectVar})`
+                : arm.pattern.values.map((v) => `${subjectVar} === ${this.genExpr(v)}`).join(" || ");
+            lines.push(`  ${emittedIf ? "else if" : "if"} (${condition}) {`);
+            lines.push(`    return ${this.genExpr(arm.result)};`);
+            lines.push(`  }`);
+            emittedIf = true;
+        });
+        lines.push(`})()`);
+        return lines.join("\n");
+    }
+}

package/dist/diagnostics.js

@@ -0,0 +1,26 @@
+export class DiagnosticBag {
+    constructor() {
+        this.diagnostics = [];
+    }
+    error(message, line, col) {
+        this.diagnostics.push({ severity: "error", message, line, col });
+    }
+    warning(message, line, col) {
+        this.diagnostics.push({ severity: "warning", message, line, col });
+    }
+    get hasErrors() {
+        return this.diagnostics.some((d) => d.severity === "error");
+    }
+    format(source, fileName) {
+        const lines = source.split("\n");
+        return this.diagnostics
+            .map((d) => {
+            const sourceLine = lines[d.line - 1] ?? "";
+            const pointer = " ".repeat(Math.max(0, d.col - 1)) + "^";
+            return (`${fileName}:${d.line}:${d.col} - ${d.severity}: ${d.message}\n` +
+                `  ${sourceLine}\n` +
+                `  ${pointer}`);
+        })
+            .join("\n\n");
+    }
+}