@sheldev/oryn 0.0.0-stage → 0.1.0

package/dist/compiler.js

@@ -0,0 +1,89 @@
+import { readFile, writeFile, mkdir, readdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, dirname, relative, extname, basename } from "node:path";
+import { spawnSync } from "node:child_process";
+import { parse } from "./parser.js";
+import { transpile } from "./codegen.js";
+export function compileSource(source, options) {
+    const ast = parse(source);
+    return transpile(ast, options);
+}
+export async function transpileFile(inputPath, outputPath) {
+    const source = await readFile(inputPath, "utf8");
+    const odinCode = compileSource(source);
+    if (outputPath) {
+        await writeFile(outputPath, odinCode, "utf8");
+    }
+    return odinCode;
+}
+/**
+ * Recursively transpile every `.ory` file under `inputDir` into `outputDir`,
+ * preserving the relative directory layout and swapping the `.ory` extension
+ * for `.odin`.
+ */
+export async function transpileDirectory(inputDir, outputDir) {
+    const files = await collectOryFiles(inputDir);
+    for (const file of files) {
+        const rel = relative(inputDir, file);
+        const outFile = join(outputDir, rel.replace(/\.ory$/, ".odin"));
+        await mkdir(dirname(outFile), { recursive: true });
+        const source = await readFile(file, "utf8");
+        await writeFile(outFile, compileSource(source), "utf8");
+    }
+    return { count: files.length };
+}
+async function collectOryFiles(dir) {
+    const result = [];
+    for (const entry of await readdir(dir, { withFileTypes: true })) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === "node_modules" || entry.name.startsWith("."))
+                continue;
+            result.push(...(await collectOryFiles(full)));
+        }
+        else if (extname(entry.name) === ".ory") {
+            result.push(full);
+        }
+    }
+    return result;
+}
+/**
+ * Transpile `inputPath` and hand the generated Odin source to the native
+ * `odin` compiler. `-file` tells Odin to treat a single file as a
+ * self-contained package, which is exactly what we want for a single Oryn
+ * source file.
+ */
+export async function buildWithOdin(inputPath, options = {}) {
+    const source = await readFile(inputPath, "utf8");
+    const odinCode = compileSource(source);
+    // Odin requires a writable directory for intermediate artifacts; use a
+    // temp dir so we never clobber anything the user cares about.
+    const { mkdtemp, rm } = await import("node:fs/promises");
+    const tempDir = await mkdtemp(join(tmpdir(), "oryn-build-"));
+    const base = basename(inputPath, extname(inputPath));
+    const odinFile = join(tempDir, `${base}.odin`);
+    try {
+        await writeFile(odinFile, odinCode, "utf8");
+        const subcommand = options.run ? "run" : "build";
+        const args = [subcommand, odinFile, "-file"];
+        if (!options.run) {
+            const outPath = options.outputBinary ?? base;
+            args.push(`-out:${outPath}`);
+        }
+        const result = spawnSync("odin", args, { stdio: "inherit" });
+        if (result.error) {
+            if (result.error.code === "ENOENT") {
+                throw new Error("Native 'odin' compiler not found in PATH. " +
+                    "Install Odin to compile binaries; the transpiled Odin source is valid.");
+            }
+            throw result.error;
+        }
+        if (result.status !== 0) {
+            process.exitCode = result.status ?? 1;
+        }
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=compiler.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { Lexer, tokenize } from "./lexer.js";
+export { Parser, parse, ParserError } from "./parser.js";
+export { CodeGenerator, transpile, type CodegenOptions } from "./codegen.js";
+export { compileSource, transpileFile, buildWithOdin } from "./compiler.js";
+export * as AST from "./ast.js";
+export { LexerError, type SourcePosition, type Token, type TokenKind } from "./token.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Lexer, tokenize } from "./lexer.js";
+export { Parser, parse, ParserError } from "./parser.js";
+export { CodeGenerator, transpile } from "./codegen.js";
+export { compileSource, transpileFile, buildWithOdin } from "./compiler.js";
+export * as AST from "./ast.js";
+export { LexerError } from "./token.js";
+//# sourceMappingURL=index.js.map

package/dist/lexer.d.ts

@@ -0,0 +1,28 @@
+import { type Token } from "./token.js";
+export declare class Lexer {
+    private readonly source;
+    private offset;
+    private line;
+    private column;
+    private readonly tokens;
+    constructor(source: string);
+    tokenize(): Token[];
+    private atEnd;
+    private peek;
+    private peekNext;
+    private advance;
+    private position;
+    private emit;
+    private single;
+    private emitNewline;
+    private lineComment;
+    private blockComment;
+    private string;
+    private number;
+    private identifier;
+    private operator;
+    private isDigit;
+    private isIdentifierStart;
+    private isIdentifierContinue;
+}
+export declare function tokenize(source: string): Token[];

package/dist/lexer.js

@@ -0,0 +1,305 @@
+import { LexerError } from "./token.js";
+const KEYWORDS = new Set([
+    "import",
+    "proc",
+    "var",
+    "let",
+    "const",
+    "struct",
+    "enum",
+    "type",
+    "if",
+    "else",
+    "for",
+    "while",
+    "return",
+    "break",
+    "continue",
+    "defer",
+]);
+const OPERATORS = [
+    "...", "..=", "->", "=>", ":=", "==", "!=", "<=", ">=",
+    "&&", "||", "+=", "-=", "*=", "/=", "%=", "&=", "|=",
+    "<<", ">>", "..", "and", "or", "not",
+];
+const SINGLE_OPERATORS = new Set("+-*/%=<>!&|^~?=".split(""));
+const PUNCTUATION = new Set("(){}[],:;.".split(""));
+export class Lexer {
+    source;
+    offset = 0;
+    line = 1;
+    column = 1;
+    tokens = [];
+    constructor(source) {
+        this.source = source;
+    }
+    tokenize() {
+        while (!this.atEnd()) {
+            const char = this.peek();
+            if (char === " " || char === "\t" || char === "\r") {
+                this.advance();
+                continue;
+            }
+            if (char === "\n") {
+                this.emitNewline();
+                continue;
+            }
+            if (char === "/" && this.peekNext() === "/") {
+                this.lineComment();
+                continue;
+            }
+            if (char === "/" && this.peekNext() === "*") {
+                this.blockComment();
+                continue;
+            }
+            if (char === '"' || char === "'") {
+                this.string();
+                continue;
+            }
+            if (this.isDigit(char)) {
+                this.number();
+                continue;
+            }
+            if (this.isIdentifierStart(char)) {
+                this.identifier();
+                continue;
+            }
+            if (this.operator()) {
+                continue;
+            }
+            if (PUNCTUATION.has(char)) {
+                this.single("punctuation");
+                continue;
+            }
+            if (SINGLE_OPERATORS.has(char)) {
+                this.single("operator");
+                continue;
+            }
+            throw new LexerError(`Unexpected character ${JSON.stringify(char)}`, this.position());
+        }
+        const position = this.position();
+        this.tokens.push({
+            kind: "eof",
+            value: "",
+            start: position,
+            end: position,
+        });
+        return this.tokens;
+    }
+    atEnd() {
+        return this.offset >= this.source.length;
+    }
+    peek(distance = 0) {
+        return this.source[this.offset + distance] ?? "";
+    }
+    peekNext() {
+        return this.peek(1);
+    }
+    advance() {
+        const char = this.source[this.offset++] ?? "";
+        if (char === "\n") {
+            this.line++;
+            this.column = 1;
+        }
+        else {
+            this.column++;
+        }
+        return char;
+    }
+    position() {
+        return { offset: this.offset, line: this.line, column: this.column };
+    }
+    emit(kind, value, start) {
+        this.tokens.push({ kind, value, start, end: this.position() });
+    }
+    single(kind) {
+        const start = this.position();
+        const value = this.advance();
+        this.emit(kind, value, start);
+    }
+    emitNewline() {
+        const start = this.position();
+        this.advance();
+        this.emit("newline", "\n", start);
+    }
+    lineComment() {
+        while (!this.atEnd() && this.peek() !== "\n")
+            this.advance();
+    }
+    blockComment() {
+        const start = this.position();
+        this.advance();
+        this.advance();
+        while (!this.atEnd()) {
+            if (this.peek() === "*" && this.peekNext() === "/") {
+                this.advance();
+                this.advance();
+                return;
+            }
+            this.advance();
+        }
+        throw new LexerError("Unterminated block comment", start);
+    }
+    string() {
+        const start = this.position();
+        const quote = this.advance();
+        let value = quote;
+        while (!this.atEnd()) {
+            const char = this.advance();
+            value += char;
+            if (char === "\\") {
+                if (!this.atEnd())
+                    value += this.advance();
+                continue;
+            }
+            if (char === quote) {
+                this.emit("string", value, start);
+                return;
+            }
+            if (char === "\n") {
+                throw new LexerError("Unterminated string literal", start);
+            }
+        }
+        throw new LexerError("Unterminated string literal", start);
+    }
+    number() {
+        const start = this.position();
+        let value = "";
+        if (this.peek() === "0" && /[xXbBoO]/.test(this.peekNext())) {
+            value += this.advance();
+            const prefix = this.advance().toLowerCase();
+            value += prefix;
+            const isValidDigit = (c) => {
+                if (prefix === "x")
+                    return /[0-9a-fA-F]/.test(c);
+                if (prefix === "b")
+                    return /[01]/.test(c);
+                if (prefix === "o")
+                    return /[0-7]/.test(c);
+                return false;
+            };
+            if (!isValidDigit(this.peek())) {
+                throw new LexerError(`Malformed ${prefix === "x" ? "hexadecimal" : prefix === "b" ? "binary" : "octal"} literal`, start);
+            }
+            let lastWasUnderscore = false;
+            while (!this.atEnd()) {
+                const c = this.peek();
+                if (isValidDigit(c)) {
+                    value += this.advance();
+                    lastWasUnderscore = false;
+                }
+                else if (c === "_") {
+                    if (lastWasUnderscore) {
+                        throw new LexerError("Malformed numeric literal: consecutive underscores", start);
+                    }
+                    value += this.advance();
+                    lastWasUnderscore = true;
+                }
+                else if (this.isIdentifierContinue(c) || this.isDigit(c)) {
+                    throw new LexerError(`Malformed ${prefix === "x" ? "hexadecimal" : prefix === "b" ? "binary" : "octal"} literal`, start);
+                }
+                else {
+                    break;
+                }
+            }
+            if (lastWasUnderscore) {
+                throw new LexerError("Malformed numeric literal: trailing underscore", start);
+            }
+            this.emit("number", value, start);
+            return;
+        }
+        let lastWasUnderscore = false;
+        let hasDecimalPoint = false;
+        while (!this.atEnd()) {
+            const c = this.peek();
+            if (this.isDigit(c)) {
+                value += this.advance();
+                lastWasUnderscore = false;
+            }
+            else if (c === "_") {
+                if (lastWasUnderscore) {
+                    throw new LexerError("Malformed numeric literal: consecutive underscores", start);
+                }
+                value += this.advance();
+                lastWasUnderscore = true;
+            }
+            else if (c === ".") {
+                if (this.peek(1) === ".") {
+                    break;
+                }
+                if (hasDecimalPoint) {
+                    break;
+                }
+                if (!this.isDigit(this.peek(1))) {
+                    throw new LexerError("Malformed numeric literal: trailing decimal point", start);
+                }
+                hasDecimalPoint = true;
+                value += this.advance();
+                lastWasUnderscore = false;
+            }
+            else if (c.toLowerCase() === "e") {
+                value += this.advance();
+                if (this.peek() === "+" || this.peek() === "-") {
+                    value += this.advance();
+                }
+                if (!this.isDigit(this.peek())) {
+                    throw new LexerError("Malformed numeric exponent", start);
+                }
+                while (this.isDigit(this.peek()) || this.peek() === "_") {
+                    value += this.advance();
+                }
+                break;
+            }
+            else if (this.isIdentifierStart(c) || (this.isIdentifierContinue(c) && !this.isDigit(c))) {
+                throw new LexerError("Malformed numeric literal", start);
+            }
+            else {
+                break;
+            }
+        }
+        if (lastWasUnderscore) {
+            throw new LexerError("Malformed numeric literal: trailing underscore", start);
+        }
+        this.emit("number", value, start);
+    }
+    identifier() {
+        const start = this.position();
+        let value = this.advance();
+        while (this.isIdentifierContinue(this.peek())) {
+            value += this.advance();
+        }
+        const kind = KEYWORDS.has(value) ? "keyword" : "identifier";
+        this.emit(kind, value, start);
+    }
+    operator() {
+        for (const operator of OPERATORS) {
+            if (this.source.startsWith(operator, this.offset)) {
+                if (/^[a-zA-Z_]+$/.test(operator)) {
+                    const nextChar = this.source[this.offset + operator.length] ?? "";
+                    if (/[a-zA-Z0-9_]/.test(nextChar)) {
+                        continue;
+                    }
+                }
+                const start = this.position();
+                for (let i = 0; i < operator.length; i++)
+                    this.advance();
+                this.emit("operator", operator, start);
+                return true;
+            }
+        }
+        return false;
+    }
+    isDigit(char) {
+        return char >= "0" && char <= "9";
+    }
+    isIdentifierStart(char) {
+        return /[A-Za-z_]/.test(char);
+    }
+    isIdentifierContinue(char) {
+        return /[A-Za-z0-9_]/.test(char);
+    }
+}
+export function tokenize(source) {
+    return new Lexer(source).tokenize();
+}
+//# sourceMappingURL=lexer.js.map

package/dist/parser.d.ts

@@ -0,0 +1,52 @@
+import { type Token, type SourcePosition } from "./token.js";
+import * as AST from "./ast.js";
+export declare class ParserError extends Error {
+    readonly position: SourcePosition;
+    constructor(message: string, position: SourcePosition);
+}
+export declare class Parser {
+    private readonly tokens;
+    private current;
+    constructor(tokens: Token[]);
+    parse(): AST.Program;
+    private parseImport;
+    private parseStruct;
+    private parseEnum;
+    private parseTypeAnnotation;
+    private parseProc;
+    private parseVarDecl;
+    private parseBlock;
+    private parseStatement;
+    private parseReturn;
+    private parseIf;
+    private parseWhile;
+    private parseFor;
+    private parseExpression;
+    private parseOrHandling;
+    private parseLambda;
+    private parseLogicalOr;
+    private parseLogicalAnd;
+    private parseEquality;
+    private parseComparison;
+    private parseTerm;
+    private parseFactor;
+    private parseUnary;
+    private parseCallMember;
+    private finishCall;
+    private parsePrimary;
+    private peek;
+    private previous;
+    private isAtEnd;
+    private advance;
+    private match;
+    private matchKeyword;
+    private matchPunctuation;
+    private checkPunctuation;
+    private matchOperator;
+    private consume;
+    private consumePunctuation;
+    private isAssignmentOperator;
+    private isSeparator;
+    private skipSeparators;
+}
+export declare function parse(source: string): AST.Program;