@sheldev/oryn 0.0.0-stage → 0.1.0

package/dist/parser.js

@@ -0,0 +1,518 @@
+import { tokenize } from "./lexer.js";
+export class ParserError extends Error {
+    position;
+    constructor(message, position) {
+        super(`${message} at ${position.line}:${position.column}`);
+        this.position = position;
+        this.name = "ParserError";
+    }
+}
+export class Parser {
+    tokens;
+    current = 0;
+    constructor(tokens) {
+        this.tokens = tokens;
+    }
+    parse() {
+        const imports = [];
+        const body = [];
+        this.skipSeparators();
+        while (!this.isAtEnd()) {
+            if (this.matchKeyword("import")) {
+                imports.push(this.parseImport());
+            }
+            else if (this.matchKeyword("proc")) {
+                body.push(this.parseProc());
+            }
+            else if (this.matchKeyword("struct")) {
+                body.push(this.parseStruct());
+            }
+            else if (this.matchKeyword("enum")) {
+                body.push(this.parseEnum());
+            }
+            else if (this.matchKeyword("var") || this.matchKeyword("let") || this.matchKeyword("const")) {
+                body.push(this.parseVarDecl());
+            }
+            else {
+                const token = this.peek();
+                throw new ParserError(`Unexpected token ${JSON.stringify(token.value)}`, token.start);
+            }
+            this.skipSeparators();
+        }
+        return {
+            kind: "Program",
+            imports,
+            body,
+        };
+    }
+    parseImport() {
+        const token = this.consume("string", "Expected string literal after import");
+        return {
+            kind: "ImportDecl",
+            path: token.value,
+        };
+    }
+    parseStruct() {
+        const name = this.consume("identifier", "Expected struct name").value;
+        this.consumePunctuation("{");
+        this.skipSeparators();
+        const fields = [];
+        while (!this.checkPunctuation("}") && !this.isAtEnd()) {
+            const fieldName = this.consume("identifier", "Expected field name").value;
+            this.consumePunctuation(":");
+            const fieldType = this.parseTypeAnnotation();
+            fields.push({ name: fieldName, type: fieldType });
+            this.matchPunctuation(",");
+            this.skipSeparators();
+        }
+        this.consumePunctuation("}");
+        return { kind: "StructDecl", name, fields };
+    }
+    parseEnum() {
+        const name = this.consume("identifier", "Expected enum name").value;
+        this.consumePunctuation("{");
+        this.skipSeparators();
+        const members = [];
+        while (!this.checkPunctuation("}") && !this.isAtEnd()) {
+            const memberName = this.consume("identifier", "Expected enum member name").value;
+            let value;
+            if (this.matchOperator("=")) {
+                value = this.parseExpression();
+            }
+            members.push({ name: memberName, value });
+            this.matchPunctuation(",");
+            this.skipSeparators();
+        }
+        this.consumePunctuation("}");
+        return { kind: "EnumDecl", name, members };
+    }
+    parseTypeAnnotation() {
+        let typeStr = "";
+        if (this.matchOperator("^")) {
+            typeStr += "^";
+        }
+        const token = this.consume("identifier", "Expected type name");
+        typeStr += token.value;
+        return typeStr;
+    }
+    parseProc() {
+        const nameToken = this.consume("identifier", "Expected procedure name");
+        this.consumePunctuation("(");
+        const params = [];
+        if (!this.checkPunctuation(")")) {
+            do {
+                const pName = this.consume("identifier", "Expected parameter name").value;
+                this.consumePunctuation(":");
+                const pType = this.parseTypeAnnotation();
+                params.push({ name: pName, type: pType });
+            } while (this.matchPunctuation(","));
+        }
+        this.consumePunctuation(")");
+        const returnTypes = [];
+        if (this.matchOperator("->")) {
+            if (this.matchPunctuation("(")) {
+                if (!this.checkPunctuation(")")) {
+                    do {
+                        returnTypes.push(this.parseTypeAnnotation());
+                    } while (this.matchPunctuation(","));
+                }
+                this.consumePunctuation(")");
+            }
+            else {
+                returnTypes.push(this.parseTypeAnnotation());
+            }
+        }
+        const body = this.parseBlock();
+        return {
+            kind: "ProcDecl",
+            name: nameToken.value,
+            params,
+            returnTypes,
+            body,
+        };
+    }
+    parseVarDecl() {
+        const keywordToken = this.previous();
+        const mutable = keywordToken.value !== "const";
+        const name = this.consume("identifier", "Expected variable name").value;
+        let type;
+        if (this.matchPunctuation(":")) {
+            type = this.parseTypeAnnotation();
+        }
+        let initializer;
+        if (this.matchOperator("=")) {
+            initializer = this.parseExpression();
+        }
+        return {
+            kind: "VarDecl",
+            name,
+            type,
+            initializer,
+            mutable,
+        };
+    }
+    parseBlock() {
+        this.consumePunctuation("{");
+        this.skipSeparators();
+        const statements = [];
+        while (!this.checkPunctuation("}") && !this.isAtEnd()) {
+            statements.push(this.parseStatement());
+            this.skipSeparators();
+        }
+        this.consumePunctuation("}");
+        return {
+            kind: "BlockStmt",
+            statements,
+        };
+    }
+    parseStatement() {
+        if (this.matchKeyword("var") || this.matchKeyword("let") || this.matchKeyword("const")) {
+            return this.parseVarDecl();
+        }
+        if (this.matchKeyword("return")) {
+            return this.parseReturn();
+        }
+        if (this.matchKeyword("if")) {
+            return this.parseIf();
+        }
+        if (this.matchKeyword("while")) {
+            return this.parseWhile();
+        }
+        if (this.matchKeyword("for")) {
+            return this.parseFor();
+        }
+        const expr = this.parseExpression();
+        if (this.isAssignmentOperator(this.peek().value)) {
+            const opToken = this.advance();
+            const value = this.parseExpression();
+            return {
+                kind: "AssignStmt",
+                target: expr,
+                operator: opToken.value,
+                value,
+            };
+        }
+        return expr;
+    }
+    parseReturn() {
+        const argumentsList = [];
+        if (!this.isSeparator() && !this.checkPunctuation("}")) {
+            do {
+                argumentsList.push(this.parseExpression());
+            } while (this.matchPunctuation(","));
+        }
+        return {
+            kind: "ReturnStmt",
+            arguments: argumentsList,
+        };
+    }
+    parseIf() {
+        const condition = this.parseExpression();
+        const consequent = this.parseBlock();
+        let alternate;
+        if (this.matchKeyword("else")) {
+            if (this.matchKeyword("if")) {
+                alternate = this.parseIf();
+            }
+            else {
+                alternate = this.parseBlock();
+            }
+        }
+        return {
+            kind: "IfStmt",
+            condition,
+            consequent,
+            alternate,
+        };
+    }
+    parseWhile() {
+        const condition = this.parseExpression();
+        const body = this.parseBlock();
+        return {
+            kind: "WhileStmt",
+            condition,
+            body,
+        };
+    }
+    parseFor() {
+        const condition = this.parseExpression();
+        const body = this.parseBlock();
+        return {
+            kind: "ForStmt",
+            condition,
+            body,
+        };
+    }
+    parseExpression() {
+        return this.parseOrHandling();
+    }
+    parseOrHandling() {
+        let expr = this.parseLambda();
+        while (this.matchKeyword("or_return") ||
+            this.matchKeyword("or_else") ||
+            this.matchKeyword("or_break")) {
+            const op = this.previous().value;
+            let fallback;
+            if (op === "or_else") {
+                fallback = this.parseLambda();
+            }
+            expr = {
+                kind: "OrHandleExpr",
+                expression: expr,
+                operator: op,
+                fallback,
+            };
+        }
+        return expr;
+    }
+    parseLambda() {
+        // Check for arrow lambda: (params) => body
+        if (this.checkPunctuation("(")) {
+            const saved = this.current;
+            try {
+                this.advance(); // consume '('
+                const params = [];
+                if (!this.checkPunctuation(")")) {
+                    do {
+                        const pName = this.consume("identifier", "Expected parameter name").value;
+                        this.consumePunctuation(":");
+                        const pType = this.parseTypeAnnotation();
+                        params.push({ name: pName, type: pType });
+                    } while (this.matchPunctuation(","));
+                }
+                this.consumePunctuation(")");
+                if (this.matchOperator("=>")) {
+                    const body = this.parseExpression();
+                    return { kind: "LambdaExpr", params, body };
+                }
+            }
+            catch {
+                // backtrack if not a lambda
+            }
+            this.current = saved;
+        }
+        return this.parseLogicalOr();
+    }
+    parseLogicalOr() {
+        let expr = this.parseLogicalAnd();
+        while (this.matchOperator("||") || this.matchKeyword("or")) {
+            const op = this.previous().value;
+            const right = this.parseLogicalAnd();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseLogicalAnd() {
+        let expr = this.parseEquality();
+        while (this.matchOperator("&&") || this.matchKeyword("and")) {
+            const op = this.previous().value;
+            const right = this.parseEquality();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseEquality() {
+        let expr = this.parseComparison();
+        while (this.matchOperator("==") || this.matchOperator("!=")) {
+            const op = this.previous().value;
+            const right = this.parseComparison();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseComparison() {
+        let expr = this.parseTerm();
+        while (this.matchOperator("<") ||
+            this.matchOperator(">") ||
+            this.matchOperator("<=") ||
+            this.matchOperator(">=")) {
+            const op = this.previous().value;
+            const right = this.parseTerm();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseTerm() {
+        let expr = this.parseFactor();
+        while (this.matchOperator("+") || this.matchOperator("-")) {
+            const op = this.previous().value;
+            const right = this.parseFactor();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseFactor() {
+        let expr = this.parseUnary();
+        while (this.matchOperator("*") ||
+            this.matchOperator("/") ||
+            this.matchOperator("%")) {
+            const op = this.previous().value;
+            const right = this.parseUnary();
+            expr = { kind: "BinaryExpr", left: expr, operator: op, right };
+        }
+        return expr;
+    }
+    parseUnary() {
+        if (this.matchOperator("-") || this.matchOperator("!") || this.matchKeyword("not") || this.matchOperator("^")) {
+            const op = this.previous().value;
+            const argument = this.parseUnary();
+            return { kind: "UnaryExpr", operator: op, argument };
+        }
+        return this.parseCallMember();
+    }
+    parseCallMember() {
+        let expr = this.parsePrimary();
+        while (true) {
+            if (this.matchPunctuation("(")) {
+                expr = this.finishCall(expr);
+            }
+            else if (this.matchPunctuation(".")) {
+                const prop = this.consume("identifier", "Expected property name after '.'").value;
+                expr = {
+                    kind: "MemberExpr",
+                    object: expr,
+                    property: prop,
+                };
+            }
+            else {
+                break;
+            }
+        }
+        return expr;
+    }
+    finishCall(callee) {
+        const args = [];
+        if (!this.checkPunctuation(")")) {
+            do {
+                args.push(this.parseExpression());
+            } while (this.matchPunctuation(","));
+        }
+        this.consumePunctuation(")");
+        return {
+            kind: "CallExpr",
+            callee,
+            args,
+        };
+    }
+    parsePrimary() {
+        if (this.match("number")) {
+            const token = this.previous();
+            return {
+                kind: "LiteralExpr",
+                value: Number(token.value.replace(/_/g, "")),
+                raw: token.value,
+                type: "number",
+            };
+        }
+        if (this.match("string")) {
+            const token = this.previous();
+            return {
+                kind: "LiteralExpr",
+                value: token.value.slice(1, -1),
+                raw: token.value,
+                type: "string",
+            };
+        }
+        if (this.peek().kind === "identifier" && (this.peek().value === "true" || this.peek().value === "false")) {
+            const token = this.advance();
+            return {
+                kind: "LiteralExpr",
+                value: token.value === "true",
+                raw: token.value,
+                type: "boolean",
+            };
+        }
+        if (this.match("identifier")) {
+            return {
+                kind: "IdentifierExpr",
+                name: this.previous().value,
+            };
+        }
+        if (this.matchPunctuation("(")) {
+            const expr = this.parseExpression();
+            this.consumePunctuation(")");
+            return expr;
+        }
+        const token = this.peek();
+        throw new ParserError(`Unexpected token ${JSON.stringify(token.value)}`, token.start);
+    }
+    peek() {
+        return this.tokens[this.current] ?? { kind: "eof", value: "", start: { offset: 0, line: 0, column: 0 }, end: { offset: 0, line: 0, column: 0 } };
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    isAtEnd() {
+        return this.peek().kind === "eof";
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
+    }
+    match(kind) {
+        if (this.peek().kind === kind) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    matchKeyword(kw) {
+        const token = this.peek();
+        if ((token.kind === "keyword" || token.kind === "identifier") && token.value === kw) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    matchPunctuation(p) {
+        const token = this.peek();
+        if (token.kind === "punctuation" && token.value === p) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    checkPunctuation(p) {
+        const token = this.peek();
+        return token.kind === "punctuation" && token.value === p;
+    }
+    matchOperator(op) {
+        const token = this.peek();
+        if (token.kind === "operator" && token.value === op) {
+            this.advance();
+            return true;
+        }
+        return false;
+    }
+    consume(kind, message) {
+        if (this.peek().kind === kind) {
+            return this.advance();
+        }
+        const token = this.peek();
+        throw new ParserError(message, token.start);
+    }
+    consumePunctuation(p) {
+        if (this.checkPunctuation(p)) {
+            return this.advance();
+        }
+        const token = this.peek();
+        throw new ParserError(`Expected '${p}'`, token.start);
+    }
+    isAssignmentOperator(op) {
+        return ["=", "+=", "-=", "*=", "/=", "%="].includes(op);
+    }
+    isSeparator() {
+        return this.peek().kind === "newline" || this.peek().value === ";";
+    }
+    skipSeparators() {
+        while (!this.isAtEnd() && (this.peek().kind === "newline" || this.peek().value === ";")) {
+            this.advance();
+        }
+    }
+}
+export function parse(source) {
+    const tokens = tokenize(source);
+    return new Parser(tokens).parse();
+}
+//# sourceMappingURL=parser.js.map

package/dist/token.d.ts

@@ -0,0 +1,16 @@
+export type TokenKind = "keyword" | "identifier" | "number" | "string" | "operator" | "punctuation" | "newline" | "eof";
+export interface SourcePosition {
+    offset: number;
+    line: number;
+    column: number;
+}
+export interface Token {
+    kind: TokenKind;
+    value: string;
+    start: SourcePosition;
+    end: SourcePosition;
+}
+export declare class LexerError extends Error {
+    readonly position: SourcePosition;
+    constructor(message: string, position: SourcePosition);
+}

package/dist/token.js

@@ -0,0 +1,9 @@
+export class LexerError extends Error {
+    position;
+    constructor(message, position) {
+        super(`${message} at ${position.line}:${position.column}`);
+        this.position = position;
+        this.name = "LexerError";
+    }
+}
+//# sourceMappingURL=token.js.map

package/package.json

@@ -1,6 +1,37 @@
 {
   "name": "@sheldev/oryn",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Oryn-to-Odin transpiler CLI",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Sheldevv/oryn.git"
+  },
+  "homepage": "https://github.com/Sheldevv/oryn#readme",
+  "keywords": ["oryn", "odin", "transpiler", "compiler", "language"],
+  "bugs": { "url": "https://github.com/Sheldevv/oryn/issues" },
+  "bin": {
+    "oryn": "dist/cli.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "SPEC.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/postbuild.mjs",
+    "dev": "tsx src/cli.ts",
+    "test": "tsx --test test/*.test.ts",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.3"
+  }
+}