arc-lang 0.5.2 → 0.5.3

package/dist/ast.d.ts

@@ -177,7 +177,7 @@ export interface OrPattern {
     patterns: Pattern[];
     loc: Loc;
 }
-export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt;
+export type Stmt = LetStmt | FnStmt | ForStmt | DoStmt | ExprStmt | UseStmt | TypeStmt | AssignStmt | MemberAssignStmt | IndexAssignStmt | RetStmt;
 export interface AssignStmt {
     kind: "AssignStmt";
     target: string;
@@ -198,6 +198,11 @@ export interface IndexAssignStmt {
     value: Expr;
     loc: Loc;
 }
+export interface RetStmt {
+    kind: "RetStmt";
+    value?: Expr;
+    loc: Loc;
+}
 export interface LetStmt {
     kind: "LetStmt";
     name: string | DestructureTarget;

package/dist/build.js

@@ -127,8 +127,8 @@ export function newProject(name, parentDir) {
         "dev-dependencies": {},
     };
     writeFileSync(resolve(projectDir, "arc.toml"), serializeArcToml(toml));
-    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() do\n  let msg = "Hello from ${name}!"\nend\n`);
-    writeFileSync(resolve(projectDir, "tests", "main.test.arc"), `fn test_main() do\n  let x = 1 + 1\nend\n`);
+    writeFileSync(resolve(projectDir, "src", "main.arc"), `fn main() {\n  let msg = "Hello from ${name}!"\n  print(msg)\n}\n`);
+    writeFileSync(resolve(projectDir, "tests", "main.test.arc"), `fn test_main() {\n  let x = 1 + 1\n  print(x)\n}\n`);
     writeFileSync(resolve(projectDir, "README.md"), `# ${name}\n\nAn Arc project.\n\n## Getting Started\n\n\`\`\`bash\narc build\narc run\n\`\`\`\n`);
     console.log(`Created project '${name}'`);
     console.log(`  ${name}/arc.toml`);

package/dist/codegen-js.js

@@ -74,9 +74,71 @@ function emitFunction(fn, baseIndent = "") {
 }
 function emitBlock(block, indent) {
     const lines = [];
-    for (const instr of block.instrs) {
-        lines.push(indent + emitInstr(instr));
+    const instrs = block.instrs;
+    const sections = [];
+    let currentSection = { label: "__start", instrs: [] };
+    sections.push(currentSection);
+    for (const instr of instrs) {
+        if (instr.op === "label") {
+            currentSection = { label: instr.name, instrs: [] };
+            sections.push(currentSection);
+        }
+        else {
+            currentSection.instrs.push(instr);
+        }
     }
+    // If no labels exist, emit linearly (simple case)
+    if (sections.length === 1) {
+        for (const instr of instrs) {
+            lines.push(indent + emitInstr(instr));
+        }
+        return lines;
+    }
+    // Use a state-machine approach with a __pc variable and a while/switch loop
+    // to properly handle branches and jumps
+    const labelToIdx = new Map();
+    for (let i = 0; i < sections.length; i++) {
+        labelToIdx.set(sections[i].label, i);
+    }
+    lines.push(`${indent}var __pc = 0;`);
+    lines.push(`${indent}__control: while (true) {`);
+    lines.push(`${indent}  switch (__pc) {`);
+    for (let i = 0; i < sections.length; i++) {
+        const section = sections[i];
+        lines.push(`${indent}    case ${i}: /* ${section.label} */`);
+        for (const instr of section.instrs) {
+            if (instr.op === "jump") {
+                const target = labelToIdx.get(instr.target);
+                if (target !== undefined) {
+                    lines.push(`${indent}      __pc = ${target}; continue __control;`);
+                }
+            }
+            else if (instr.op === "branch") {
+                const ifTrue = labelToIdx.get(instr.ifTrue);
+                const ifFalse = labelToIdx.get(instr.ifFalse);
+                lines.push(`${indent}      if (${S(instr.cond)}) { __pc = ${ifTrue}; } else { __pc = ${ifFalse}; } continue __control;`);
+            }
+            else if (instr.op === "ret") {
+                lines.push(`${indent}      ` + emitInstr(instr));
+            }
+            else {
+                lines.push(`${indent}      ` + emitInstr(instr));
+            }
+        }
+        // Fall through to next section if no jump/branch/ret at end
+        const lastInstr = section.instrs[section.instrs.length - 1];
+        if (!lastInstr || (lastInstr.op !== "jump" && lastInstr.op !== "branch" && lastInstr.op !== "ret")) {
+            if (i + 1 < sections.length) {
+                lines.push(`${indent}      __pc = ${i + 1}; continue __control;`);
+            }
+            else {
+                lines.push(`${indent}      break __control;`);
+            }
+        }
+    }
+    lines.push(`${indent}    default: break __control;`);
+    lines.push(`${indent}  }`);
+    lines.push(`${indent}}`);
     return lines;
 }
 function emitInstr(instr) {

package/dist/formatter.js

@@ -141,15 +141,39 @@ export function format(source, options) {
             }
             case "IfExpr": {
                 const cond = formatExpr(expr.condition, depth);
-                const then = formatBlockExpr(expr.then, depth);
+                const thenInline = formatBlockExpr(expr.then, depth);
                 if (expr.else_) {
+                    let elInline;
                     if (expr.else_.kind === "IfExpr") {
-                        return `if ${cond} ${then} el ${formatExpr(expr.else_, depth)}`;
+                        elInline = formatExpr(expr.else_, depth);
                     }
-                    const el = formatBlockExpr(expr.else_, depth);
-                    return `if ${cond} ${then} el ${el}`;
+                    else {
+                        elInline = formatBlockExpr(expr.else_, depth);
+                    }
+                    const single = `if ${cond} ${thenInline} el ${elInline}`;
+                    if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
+                        return single;
+                    }
+                    // Force multi-line blocks when single-line is too long
+                    const thenMulti = expr.then.kind === "BlockExpr"
+                        ? formatBlockMultiline(expr.then, depth)
+                        : thenInline;
+                    if (expr.else_.kind === "IfExpr") {
+                        return `if ${cond} ${thenMulti} el ${formatExpr(expr.else_, depth)}`;
+                    }
+                    const elMulti = expr.else_.kind === "BlockExpr"
+                        ? formatBlockMultiline(expr.else_, depth)
+                        : elInline;
+                    return `if ${cond} ${thenMulti} el ${elMulti}`;
+                }
+                const single = `if ${cond} ${thenInline}`;
+                if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
+                    return single;
                 }
-                return `if ${cond} ${then}`;
+                const thenMulti = expr.then.kind === "BlockExpr"
+                    ? formatBlockMultiline(expr.then, depth)
+                    : thenInline;
+                return `if ${cond} ${thenMulti}`;
             }
             case "MatchExpr": {
                 const subject = formatExpr(expr.subject, depth);
@@ -218,6 +242,12 @@ export function format(source, options) {
             return formatBlockInline(expr, depth);
         return formatExpr(expr, depth);
     }
+    function formatBlockMultiline(block, depth) {
+        if (block.stmts.length === 0)
+            return "{}";
+        const body = block.stmts.map(s => `${indent(depth + 1)}${formatStmtStr(s, depth + 1)}`).join('\n');
+        return `{\n${body}\n${indent(depth)}}`;
+    }
     function formatBlockInline(block, depth) {
         if (block.stmts.length === 0)
             return "{}";
@@ -315,6 +345,8 @@ export function format(source, options) {
                 return `${formatExpr(stmt.object, depth)}.${stmt.property} = ${formatExpr(stmt.value, depth)}`;
             case "IndexAssignStmt":
                 return `${formatExpr(stmt.object, depth)}[${formatExpr(stmt.index, depth)}] = ${formatExpr(stmt.value, depth)}`;
+            default:
+                return `/* unknown stmt: ${stmt.kind} */`;
         }
     }
     // Emit top-level statements with comments and blank lines between declarations

package/dist/interpreter.js

@@ -243,6 +243,13 @@ function makePrelude(env) {
         env.set(name, fn);
     }
 }
+// Return signal — thrown to unwind the stack on `ret`
+class ReturnSignal {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
 // Evaluate expression in tail position — returns TCOSignal for self-recursive tail calls
 function evalExprTCO(expr, env, fnName) {
     // Only handle tail-position expressions specially
@@ -317,8 +324,16 @@ function evalExpr(expr, env) {
                 case "+": return left + right;
                 case "-": return left - right;
                 case "*": return left * right;
-                case "/": return left / right;
-                case "%": return left % right;
+                case "/": {
+                    if (right === 0)
+                        throw new Error(`Division by zero at line ${expr.loc.line}`);
+                    return left / right;
+                }
+                case "%": {
+                    if (right === 0)
+                        throw new Error(`Modulo by zero at line ${expr.loc.line}`);
+                    return left % right;
+                }
                 case "**": return Math.pow(left, right);
                 case "==": return left === right;
                 case "!=": return left !== right;
@@ -353,18 +368,28 @@ function evalExpr(expr, env) {
                 let fn = callee;
                 // Tail call optimization loop: if the function body resolves to
                 // a tail call back to itself, reuse the frame instead of recursing
-                tailLoop: while (true) {
-                    const fnEnv = new Env(fn.closure);
-                    fn.params.forEach((p, i) => fnEnv.set(p, args[i] ?? null));
-                    const bodyResult = evalExprTCO(fn.body, fnEnv, fn.name);
-                    if (bodyResult && typeof bodyResult === "object" && "__tco" in bodyResult) {
-                        const tco = bodyResult;
-                        args = tco.args;
-                        // fn stays the same — it's a self-recursive tail call
-                        continue tailLoop;
+                try {
+                    tailLoop: while (true) {
+                        const fnEnv = new Env(fn.closure);
+                        fn.params.forEach((p, i) => fnEnv.set(p, args[i] ?? null));
+                        const bodyResult = evalExprTCO(fn.body, fnEnv, fn.name);
+                        if (bodyResult && typeof bodyResult === "object" && "__tco" in bodyResult) {
+                            const tco = bodyResult;
+                            args = tco.args;
+                            // fn stays the same — it's a self-recursive tail call
+                            continue tailLoop;
+                        }
+                        result = bodyResult;
+                        break;
+                    }
+                }
+                catch (e) {
+                    if (e instanceof ReturnSignal) {
+                        result = e.value;
+                    }
+                    else {
+                        throw e;
                     }
-                    result = bodyResult;
-                    break;
                 }
             }
             else {
@@ -615,6 +640,10 @@ function evalStmt(stmt, env) {
             }
             throw new Error(`Cannot assign index on ${toStr(obj)}`);
         }
+        case "RetStmt": {
+            const value = stmt.value ? evalExpr(stmt.value, env) : null;
+            throw new ReturnSignal(value);
+        }
         case "ExprStmt": return evalExpr(stmt.expr, env);
         case "UseStmt": {
             // Module imports handled by interpretWithFile; no-op if no file context

package/dist/lexer.js

@@ -135,6 +135,10 @@ export function lex(source) {
             const parts = [];
             let hasInterp = false;
             while (i < source.length && peek() !== '"') {
+                if (peek() === "\n") {
+                    // Unterminated string - newline before closing quote
+                    throw new Error(`Unterminated string literal at line ${sl}, col ${sc}`);
+                }
                 if (peek() === "{") {
                     hasInterp = true;
                     if (str.length > 0 || parts.length === 0) {
@@ -162,6 +166,9 @@ export function lex(source) {
                 }
                 if (peek() === "\\") {
                     advance();
+                    if (i >= source.length) {
+                        throw new Error(`Unterminated string literal (escape at end of file) at line ${sl}, col ${sc}`);
+                    }
                     const esc = advance();
                     if (esc === "n")
                         str += "\n";
@@ -177,6 +184,9 @@ export function lex(source) {
                 }
                 str += advance();
             }
+            if (i >= source.length) {
+                throw new Error(`Unterminated string literal at line ${sl}, col ${sc}`);
+            }
             if (peek() === '"')
                 advance(); // skip closing quote
             if (hasInterp) {

package/dist/parser.d.ts

@@ -24,6 +24,7 @@ export declare class Parser {
     private parseDo;
     private parseUse;
     private parseType;
+    private parseRet;
     private parseTypeExpr;
     private parseTypeAtom;
     private parseBlock;

package/dist/parser.js

@@ -55,6 +55,7 @@ export class Parser {
             case TokenType.Do: return this.parseDo();
             case TokenType.Use: return this.parseUse();
             case TokenType.Type: return this.parseType();
+            case TokenType.Ret: return this.parseRet();
             default: {
                 const exprLoc = this.loc();
                 const expr = this.parseExpr();
@@ -226,6 +227,16 @@ export class Parser {
         const def = this.parseTypeExpr();
         return { kind: "TypeStmt", name, pub, def, loc };
     }
+    parseRet() {
+        const loc = this.loc();
+        this.expect(TokenType.Ret);
+        let value;
+        // If the next token could start an expression, parse it
+        if (!this.at(TokenType.EOF) && !this.at(TokenType.RBrace) && !this.at(TokenType.Semicolon)) {
+            value = this.parseExpr();
+        }
+        return { kind: "RetStmt", value, loc };
+    }
     parseTypeExpr() {
         let typeExpr = this.parseTypeAtom();
         // Check for enum/union: Type | Type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arc-lang",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
   "type": "module",
   "bin": {