kopscript 0.1.0

package/dist/lexer.js

@@ -0,0 +1,301 @@
+import { TokenKind } from "./tokens.js";
+const KEYWORDS = {
+    using: TokenKind.Using,
+    extern: TokenKind.Extern,
+    from: TokenKind.From,
+    as: TokenKind.As,
+    const: TokenKind.Const,
+    class: TokenKind.Class,
+    interface: TokenKind.Interface,
+    enum: TokenKind.Enum,
+    constructor: TokenKind.Constructor,
+    public: TokenKind.Public,
+    private: TokenKind.Private,
+    protected: TokenKind.Protected,
+    static: TokenKind.Static,
+    virtual: TokenKind.Virtual,
+    override: TokenKind.Override,
+    get: TokenKind.Get,
+    set: TokenKind.Set,
+    return: TokenKind.Return,
+    if: TokenKind.If,
+    else: TokenKind.Else,
+    while: TokenKind.While,
+    for: TokenKind.For,
+    foreach: TokenKind.Foreach,
+    in: TokenKind.In,
+    break: TokenKind.Break,
+    continue: TokenKind.Continue,
+    match: TokenKind.Match,
+    this: TokenKind.This,
+    base: TokenKind.Base,
+    new: TokenKind.New,
+    void: TokenKind.Void,
+    true: TokenKind.True,
+    false: TokenKind.False,
+    task: TokenKind.Task,
+    state: TokenKind.State,
+    async: TokenKind.Async,
+    await: TokenKind.Await,
+    try: TokenKind.Try,
+    catch: TokenKind.Catch,
+    finally: TokenKind.Finally,
+    throw: TokenKind.Throw,
+};
+export class Lexer {
+    constructor(source, diagnostics) {
+        this.source = source;
+        this.diagnostics = diagnostics;
+        this.pos = 0;
+        this.line = 1;
+        this.col = 1;
+    }
+    tokenize() {
+        const tokens = [];
+        for (;;) {
+            const token = this.next();
+            tokens.push(token);
+            if (token.kind === TokenKind.EOF)
+                break;
+        }
+        return tokens;
+    }
+    next() {
+        this.skipTrivia();
+        const line = this.line;
+        const col = this.col;
+        if (this.isAtEnd())
+            return this.make(TokenKind.EOF, "", line, col);
+        const c = this.peek();
+        if (c === '"')
+            return this.readString(line, col);
+        if (c === "$" && this.peek(1) === '"')
+            return this.readInterpolatedString(line, col);
+        if (c === "r" && this.peek(1) === '"')
+            return this.readRegexLiteral(line, col);
+        if (this.isDigit(c))
+            return this.readNumber(line, col);
+        if (this.isIdentStart(c))
+            return this.readIdentifier(line, col);
+        return this.readOperator(line, col);
+    }
+    skipTrivia() {
+        for (;;) {
+            const c = this.peek();
+            if (c === " " || c === "\t" || c === "\r") {
+                this.advance();
+            }
+            else if (c === "\n") {
+                this.advance();
+            }
+            else if (c === "/" && this.peek(1) === "/") {
+                while (!this.isAtEnd() && this.peek() !== "\n")
+                    this.advance();
+            }
+            else {
+                break;
+            }
+        }
+    }
+    readString(line, col) {
+        this.advance(); // opening quote
+        let value = "";
+        while (!this.isAtEnd() && this.peek() !== '"') {
+            value += this.readStringChar();
+        }
+        if (this.isAtEnd()) {
+            this.diagnostics.error("Unterminated string literal", line, col);
+        }
+        else {
+            this.advance(); // closing quote
+        }
+        return this.make(TokenKind.String, value, line, col);
+    }
+    readInterpolatedString(line, col) {
+        this.advance(); // '$'
+        this.advance(); // opening quote
+        let raw = "";
+        let depth = 0;
+        while (!this.isAtEnd() && !(this.peek() === '"' && depth === 0)) {
+            if (this.peek() === "{")
+                depth++;
+            if (this.peek() === "}")
+                depth--;
+            raw += this.advance();
+        }
+        if (this.isAtEnd()) {
+            this.diagnostics.error("Unterminated interpolated string literal", line, col);
+        }
+        else {
+            this.advance(); // closing quote
+        }
+        return this.make(TokenKind.InterpolatedString, raw, line, col);
+    }
+    readRegexLiteral(line, col) {
+        this.advance(); // 'r'
+        this.advance(); // opening quote
+        let value = "";
+        while (!this.isAtEnd() && this.peek() !== '"') {
+            value += this.readStringChar();
+        }
+        if (this.isAtEnd()) {
+            this.diagnostics.error("Unterminated regex literal", line, col);
+        }
+        else {
+            this.advance(); // closing quote
+        }
+        return this.make(TokenKind.RegexLiteral, value, line, col);
+    }
+    readStringChar() {
+        const c = this.advance();
+        if (c !== "\\")
+            return c;
+        const esc = this.advance();
+        switch (esc) {
+            case "n":
+                return "\n";
+            case "t":
+                return "\t";
+            case "r":
+                return "\r";
+            case "\\":
+                return "\\";
+            case '"':
+                return '"';
+            case "{":
+                return "{";
+            case "}":
+                return "}";
+            default:
+                return esc;
+        }
+    }
+    readNumber(line, col) {
+        let value = "";
+        while (this.isDigit(this.peek()))
+            value += this.advance();
+        if (this.peek() === "." && this.isDigit(this.peek(1))) {
+            value += this.advance();
+            while (this.isDigit(this.peek()))
+                value += this.advance();
+        }
+        return this.make(TokenKind.Number, value, line, col);
+    }
+    readIdentifier(line, col) {
+        let value = "";
+        while (this.isIdentPart(this.peek()))
+            value += this.advance();
+        if (value === "_")
+            return this.make(TokenKind.Underscore, value, line, col);
+        const kind = KEYWORDS[value] ?? TokenKind.Identifier;
+        return this.make(kind, value, line, col);
+    }
+    readOperator(line, col) {
+        const c = this.advance();
+        switch (c) {
+            case "(":
+                return this.make(TokenKind.LParen, c, line, col);
+            case ")":
+                return this.make(TokenKind.RParen, c, line, col);
+            case "{":
+                return this.make(TokenKind.LBrace, c, line, col);
+            case "}":
+                return this.make(TokenKind.RBrace, c, line, col);
+            case "[":
+                return this.make(TokenKind.LBracket, c, line, col);
+            case "]":
+                return this.make(TokenKind.RBracket, c, line, col);
+            case ",":
+                return this.make(TokenKind.Comma, c, line, col);
+            case ":":
+                return this.make(TokenKind.Colon, c, line, col);
+            case ";":
+                return this.make(TokenKind.Semicolon, c, line, col);
+            case ".":
+                return this.make(TokenKind.Dot, c, line, col);
+            case "+":
+                return this.make(TokenKind.Plus, c, line, col);
+            case "-":
+                return this.make(TokenKind.Minus, c, line, col);
+            case "*":
+                return this.make(TokenKind.Star, c, line, col);
+            case "/":
+                return this.make(TokenKind.Slash, c, line, col);
+            case "%":
+                return this.make(TokenKind.Percent, c, line, col);
+            case "!":
+                if (this.peek() === "=") {
+                    this.advance();
+                    return this.make(TokenKind.NotEq, "!=", line, col);
+                }
+                return this.make(TokenKind.Not, c, line, col);
+            case "=":
+                if (this.peek() === "=") {
+                    this.advance();
+                    return this.make(TokenKind.Eq, "==", line, col);
+                }
+                if (this.peek() === ">") {
+                    this.advance();
+                    return this.make(TokenKind.Arrow, "=>", line, col);
+                }
+                return this.make(TokenKind.Assign, c, line, col);
+            case "<":
+                if (this.peek() === "=") {
+                    this.advance();
+                    return this.make(TokenKind.LtEq, "<=", line, col);
+                }
+                return this.make(TokenKind.Lt, c, line, col);
+            case ">":
+                if (this.peek() === "=") {
+                    this.advance();
+                    return this.make(TokenKind.GtEq, ">=", line, col);
+                }
+                return this.make(TokenKind.Gt, c, line, col);
+            case "&":
+                if (this.peek() === "&") {
+                    this.advance();
+                    return this.make(TokenKind.AndAnd, "&&", line, col);
+                }
+                break;
+            case "|":
+                if (this.peek() === "|") {
+                    this.advance();
+                    return this.make(TokenKind.OrOr, "||", line, col);
+                }
+                break;
+        }
+        this.diagnostics.error(`Unexpected character '${c}'`, line, col);
+        return this.next();
+    }
+    make(kind, lexeme, line, col) {
+        return { kind, lexeme, line, col };
+    }
+    isAtEnd() {
+        return this.pos >= this.source.length;
+    }
+    peek(offset = 0) {
+        const i = this.pos + offset;
+        return i < this.source.length ? this.source[i] : "\0";
+    }
+    advance() {
+        const c = this.source[this.pos];
+        this.pos++;
+        if (c === "\n") {
+            this.line++;
+            this.col = 1;
+        }
+        else {
+            this.col++;
+        }
+        return c;
+    }
+    isDigit(c) {
+        return c >= "0" && c <= "9";
+    }
+    isIdentStart(c) {
+        return c === "_" || (c >= "a" && c <= "z") || (c >= "A" && c <= "Z");
+    }
+    isIdentPart(c) {
+        return this.isIdentStart(c) || this.isDigit(c);
+    }
+}

package/dist/modules.js

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { Lexer } from "./lexer.js";
+import { Parser } from "./parser.js";
+import { Checker, emptyModuleExports } from "./checker.js";
+import { CodeGenerator } from "./codegen.js";
+import { DiagnosticBag } from "./diagnostics.js";
+function displayPath(absPath) {
+    return relative(process.cwd(), absPath);
+}
+// Parses the entry file and every file it transitively `using`s, in
+// dependency-first (topological) order. Each module's own DiagnosticBag
+// carries any parse errors and any problems with its `using` directives
+// (missing file, non-relative path, circular dependency) — a missing or
+// cyclic dependency is reported on the referencing `using` statement and
+// simply isn't added to that file's dependency list, so the rest of the
+// graph can still be explored and reported on in one pass.
+export function loadModuleGraph(entryAbsPath) {
+    const modules = new Map();
+    const order = [];
+    const stack = [];
+    if (!existsSync(entryAbsPath)) {
+        return { modules, order, entryMissing: true };
+    }
+    function visit(absPath) {
+        if (modules.has(absPath))
+            return;
+        const source = readFileSync(absPath, "utf-8");
+        const diagnostics = new DiagnosticBag();
+        const tokens = new Lexer(source, diagnostics).tokenize();
+        const program = new Parser(tokens, diagnostics).parseProgram();
+        const record = { absPath, source, program, diagnostics, dependencies: [] };
+        modules.set(absPath, record);
+        stack.push(absPath);
+        for (const u of program.usings) {
+            if (!u.path.startsWith("./") && !u.path.startsWith("../")) {
+                diagnostics.error(`'using' path '${u.path}' must be relative (start with './' or '../')`, u.line, u.col);
+                continue;
+            }
+            const depPath = resolve(dirname(absPath), u.path) + ".ks";
+            if (!existsSync(depPath)) {
+                diagnostics.error(`Cannot find module '${u.path}' (looked for '${displayPath(depPath)}')`, u.line, u.col);
+                continue;
+            }
+            if (stack.includes(depPath)) {
+                diagnostics.error(`Circular 'using' dependency: ${[...stack, depPath].map(displayPath).join(" -> ")}`, u.line, u.col);
+                continue;
+            }
+            record.dependencies.push(depPath);
+            visit(depPath);
+        }
+        stack.pop();
+        order.push(absPath);
+    }
+    visit(entryAbsPath);
+    return { modules, order, entryMissing: false };
+}
+// Compiles the whole module graph reachable from entryAbsPath: parses every
+// file, type-checks each in dependency order (seeding each module's checker
+// with its direct dependencies' merged exports), and — only if the entire
+// graph is error-free — generates one JS file's contents per module, with
+// real ES `import`/`export` statements wiring them together.
+export function compileGraph(entryAbsPath) {
+    const { modules, order, entryMissing } = loadModuleGraph(entryAbsPath);
+    if (entryMissing) {
+        return { success: false, entryMissing: true, modules, order, outputs: new Map() };
+    }
+    const exportsByModule = new Map();
+    let hasErrors = false;
+    for (const absPath of order) {
+        const mod = modules.get(absPath);
+        if (mod.diagnostics.hasErrors) {
+            hasErrors = true;
+            continue; // parse/using errors already recorded; skip semantic checking
+        }
+        const merged = emptyModuleExports();
+        const importedFrom = new Map();
+        for (const u of mod.program.usings) {
+            if (!u.path.startsWith("./") && !u.path.startsWith("../"))
+                continue; // already reported
+            const depPath = resolve(dirname(absPath), u.path) + ".ks";
+            const depExports = exportsByModule.get(depPath);
+            if (!depExports)
+                continue; // dependency missing/cyclic/failed; already reported
+            const mergeOne = (name, apply) => {
+                const existingFrom = importedFrom.get(name);
+                if (existingFrom && existingFrom !== depPath) {
+                    mod.diagnostics.error(`'${name}' is exported by both '${displayPath(existingFrom)}' and '${displayPath(depPath)}' — ambiguous 'using'`, u.line, u.col);
+                    return;
+                }
+                importedFrom.set(name, depPath);
+                apply();
+            };
+            for (const [name, kind] of depExports.namedTypes)
+                mergeOne(name, () => merged.namedTypes.set(name, kind));
+            for (const [name, info] of depExports.functions)
+                mergeOne(name, () => merged.functions.set(name, info));
+            for (const [name, type] of depExports.externValues)
+                mergeOne(name, () => merged.externValues.set(name, type));
+            for (const [name, info] of depExports.classes)
+                merged.classes.set(name, info);
+            for (const [name, info] of depExports.interfaces)
+                merged.interfaces.set(name, info);
+            for (const [name, info] of depExports.enums)
+                merged.enums.set(name, info);
+        }
+        const checker = new Checker(mod.program, mod.diagnostics, merged);
+        checker.check();
+        if (mod.diagnostics.hasErrors)
+            hasErrors = true;
+        exportsByModule.set(absPath, checker.getExports());
+    }
+    if (hasErrors) {
+        return { success: false, entryMissing: false, modules, order, outputs: new Map() };
+    }
+    const outputs = new Map();
+    for (const absPath of order) {
+        const mod = modules.get(absPath);
+        const usingExports = new Map();
+        for (const u of mod.program.usings) {
+            const depPath = resolve(dirname(absPath), u.path) + ".ks";
+            const depExports = exportsByModule.get(depPath);
+            if (depExports) {
+                // Interfaces are compile-time only and never produce a JS `export` —
+                // they'd make an invalid import specifier if listed here.
+                const importableTypeNames = [...depExports.namedTypes.entries()].filter(([, kind]) => kind !== "interface").map(([name]) => name);
+                usingExports.set(u.path, [...importableTypeNames, ...depExports.functions.keys(), ...depExports.externValues.keys()]);
+            }
+        }
+        outputs.set(absPath, new CodeGenerator().generate(mod.program, usingExports));
+    }
+    return { success: true, entryMissing: false, modules, order, outputs };
+}