arc-lang 0.5.0

package/dist/errors.js

@@ -0,0 +1,229 @@
+// Arc Language Error Reporting System - Rich, friendly error messages
+// Error codes
+export var ErrorCode;
+(function (ErrorCode) {
+    // Parse errors (ARC001-ARC099)
+    ErrorCode["UNEXPECTED_TOKEN"] = "ARC001";
+    ErrorCode["MISSING_CLOSING_PAREN"] = "ARC002";
+    ErrorCode["MISSING_CLOSING_BRACKET"] = "ARC003";
+    ErrorCode["MISSING_CLOSING_BRACE"] = "ARC004";
+    ErrorCode["EXPECTED_EXPRESSION"] = "ARC005";
+    ErrorCode["INVALID_ASSIGNMENT"] = "ARC006";
+    ErrorCode["UNTERMINATED_STRING"] = "ARC007";
+    ErrorCode["INVALID_NUMBER"] = "ARC008";
+    // Type errors (ARC100-ARC199)
+    ErrorCode["TYPE_MISMATCH"] = "ARC100";
+    ErrorCode["INVALID_OPERATOR"] = "ARC101";
+    ErrorCode["NOT_CALLABLE"] = "ARC102";
+    ErrorCode["WRONG_ARITY"] = "ARC103";
+    // Runtime errors (ARC200-ARC299)
+    ErrorCode["UNDEFINED_VARIABLE"] = "ARC200";
+    ErrorCode["IMMUTABLE_REASSIGN"] = "ARC201";
+    ErrorCode["INDEX_OUT_OF_BOUNDS"] = "ARC202";
+    ErrorCode["DIVISION_BY_ZERO"] = "ARC203";
+    ErrorCode["NOT_ITERABLE"] = "ARC204";
+    ErrorCode["ASSERTION_FAILED"] = "ARC205";
+    ErrorCode["PROPERTY_ACCESS"] = "ARC206";
+    // Import errors (ARC300-ARC399)
+    ErrorCode["MODULE_NOT_FOUND"] = "ARC300";
+    ErrorCode["CIRCULAR_IMPORT"] = "ARC301";
+    // Security errors (ARC400-ARC499)
+    ErrorCode["SOURCE_TOO_LARGE"] = "ARC400";
+    ErrorCode["NESTING_TOO_DEEP"] = "ARC401";
+    ErrorCode["EXECUTION_LIMIT"] = "ARC402";
+    ErrorCode["RECURSION_LIMIT"] = "ARC403";
+    ErrorCode["TOOL_CALL_BLOCKED"] = "ARC404";
+    ErrorCode["IMPORT_BLOCKED"] = "ARC405";
+    ErrorCode["TIMEOUT"] = "ARC406";
+})(ErrorCode || (ErrorCode = {}));
+// ANSI color codes
+const COLORS = {
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+    bold: "\x1b[1m",
+    reset: "\x1b[0m",
+    underline: "\x1b[4m",
+};
+function noColor(s) {
+    return s.replace(/\x1b\[\d+m/g, "");
+}
+// Levenshtein distance for "did you mean?" suggestions
+export function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    if (m === 0)
+        return n;
+    if (n === 0)
+        return m;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}
+// Find closest match from a list of candidates
+export function findClosestMatch(name, candidates, maxDistance = 3) {
+    let best = null;
+    let bestDist = maxDistance + 1;
+    for (const c of candidates) {
+        const d = levenshtein(name, c);
+        if (d < bestDist) {
+            bestDist = d;
+            best = c;
+        }
+    }
+    return best;
+}
+// Format a rich error message with source snippet
+export function formatError(error, useColor = true) {
+    const c = useColor ? COLORS : { red: "", yellow: "", cyan: "", gray: "", bold: "", reset: "", underline: "" };
+    const lines = [];
+    // Header: category[code]: message
+    lines.push(`${c.red}${c.bold}${error.category}[${error.code}]${c.reset}: ${c.bold}${error.message}${c.reset}`);
+    // Source snippet with error pointer
+    if (error.source && error.loc) {
+        const sourceLines = error.source.split("\n");
+        const lineIdx = error.loc.line - 1;
+        if (lineIdx >= 0 && lineIdx < sourceLines.length) {
+            const lineNum = error.loc.line;
+            const padding = String(lineNum).length;
+            // Line before (context)
+            if (lineIdx > 0) {
+                lines.push(`${c.gray}${String(lineNum - 1).padStart(padding)} │${c.reset} ${sourceLines[lineIdx - 1]}`);
+            }
+            // Error line
+            lines.push(`${c.cyan}${String(lineNum).padStart(padding)} │${c.reset} ${sourceLines[lineIdx]}`);
+            // Underline pointer
+            const col = Math.max(0, error.loc.col - 1);
+            const pointer = " ".repeat(padding) + " │ " + " ".repeat(col) + `${c.red}^^^${c.reset}`;
+            lines.push(pointer);
+            // Line after (context)
+            if (lineIdx + 1 < sourceLines.length) {
+                lines.push(`${c.gray}${String(lineNum + 1).padStart(padding)} │${c.reset} ${sourceLines[lineIdx + 1]}`);
+            }
+        }
+    }
+    // Suggestion
+    if (error.suggestion) {
+        lines.push(`${c.yellow}hint${c.reset}: ${error.suggestion}`);
+    }
+    return lines.join("\n");
+}
+// Create specific error constructors
+export function undefinedVariableError(name, candidates, loc, source) {
+    const suggestion = findClosestMatch(name, candidates);
+    return {
+        code: ErrorCode.UNDEFINED_VARIABLE,
+        category: "RuntimeError",
+        message: `Undefined variable '${name}'`,
+        loc,
+        source,
+        suggestion: suggestion ? `Did you mean '${suggestion}'?` : undefined,
+    };
+}
+export function parseError(message, loc, source, suggestion) {
+    // Auto-detect suggestion from message
+    if (!suggestion) {
+        if (message.includes("Expected RParen") || message.includes("Expected )")) {
+            suggestion = "Missing closing parenthesis ')'";
+        }
+        else if (message.includes("Expected RBracket") || message.includes("Expected ]")) {
+            suggestion = "Missing closing bracket ']'";
+        }
+        else if (message.includes("Expected RBrace") || message.includes("Expected }")) {
+            suggestion = "Missing closing brace '}'";
+        }
+    }
+    return {
+        code: ErrorCode.UNEXPECTED_TOKEN,
+        category: "ParseError",
+        message,
+        loc,
+        source,
+        suggestion,
+    };
+}
+export function typeError(message, loc, source) {
+    return {
+        code: ErrorCode.TYPE_MISMATCH,
+        category: "TypeError",
+        message,
+        loc,
+        source,
+    };
+}
+export function runtimeError(code, message, loc, source, suggestion) {
+    return {
+        code,
+        category: "RuntimeError",
+        message,
+        loc,
+        source,
+        suggestion,
+    };
+}
+export function importError(message, loc, source) {
+    return {
+        code: ErrorCode.MODULE_NOT_FOUND,
+        category: "ImportError",
+        message,
+        loc,
+        source,
+    };
+}
+export function securityError(code, message) {
+    return {
+        code,
+        category: "SecurityError",
+        message,
+    };
+}
+// Pretty-print an error that was caught during execution
+export function prettyPrintError(err, source, useColor = true) {
+    // Try to extract location from error message
+    const locMatch = err.message.match(/at line (\d+)(?:, col (\d+))?/);
+    const loc = locMatch ? { line: parseInt(locMatch[1]), col: parseInt(locMatch[2] || "1") } : undefined;
+    // Detect error category
+    let category = "RuntimeError";
+    let code = ErrorCode.UNDEFINED_VARIABLE;
+    let suggestion;
+    if (err.message.includes("Parse error")) {
+        category = "ParseError";
+        code = ErrorCode.UNEXPECTED_TOKEN;
+    }
+    else if (err.message.includes("Undefined variable")) {
+        code = ErrorCode.UNDEFINED_VARIABLE;
+        const nameMatch = err.message.match(/Undefined variable: (\w+)/);
+        if (nameMatch) {
+            suggestion = `Check that '${nameMatch[1]}' is defined before use`;
+        }
+    }
+    else if (err.message.includes("Cannot reassign immutable")) {
+        code = ErrorCode.IMMUTABLE_REASSIGN;
+        suggestion = "Use 'let mut' to declare a mutable variable";
+    }
+    else if (err.message.includes("Not callable")) {
+        code = ErrorCode.NOT_CALLABLE;
+    }
+    else if (err.message.includes("SecurityError") || err.name === "SecurityError") {
+        category = "SecurityError";
+        code = ErrorCode.EXECUTION_LIMIT;
+    }
+    return formatError({ code, category, message: err.message, loc, source, suggestion }, useColor);
+}
+let prettyErrorsEnabled = true;
+export function setPrettyErrors(enabled) {
+    prettyErrorsEnabled = enabled;
+}
+export function isPrettyErrorsEnabled() {
+    return prettyErrorsEnabled;
+}

package/dist/formatter.d.ts

@@ -0,0 +1,5 @@
+export interface FormatOptions {
+    indentSize: number;
+    maxLineLength: number;
+}
+export declare function format(source: string, options?: Partial<FormatOptions>): string;

package/dist/formatter.js

@@ -0,0 +1,361 @@
+// Arc Language Code Formatter
+// Pretty-prints Arc source with consistent style
+import { lex } from "./lexer.js";
+import { parse } from "./parser.js";
+const DEFAULT_OPTIONS = {
+    indentSize: 2,
+    maxLineLength: 100,
+};
+// Extract comments from source (lexer skips them)
+function extractComments(source) {
+    const comments = [];
+    let line = 1, col = 1;
+    let i = 0;
+    while (i < source.length) {
+        if (source[i] === '"') {
+            i++;
+            col++;
+            while (i < source.length && source[i] !== '"') {
+                if (source[i] === '\\') {
+                    i++;
+                    col++;
+                }
+                if (source[i] === '\n') {
+                    line++;
+                    col = 1;
+                }
+                else {
+                    col++;
+                }
+                i++;
+            }
+            if (i < source.length) {
+                i++;
+                col++;
+            }
+        }
+        else if (source[i] === '#') {
+            const startLine = line, startCol = col;
+            let text = '';
+            while (i < source.length && source[i] !== '\n') {
+                text += source[i];
+                i++;
+                col++;
+            }
+            comments.push({ text, line: startLine, col: startCol });
+        }
+        else {
+            if (source[i] === '\n') {
+                line++;
+                col = 1;
+            }
+            else {
+                col++;
+            }
+            i++;
+        }
+    }
+    return comments;
+}
+// Map comments to the nearest following AST node line
+function buildCommentMap(comments, stmts) {
+    // Map: stmtIndex -> comments that appear before it
+    const map = new Map();
+    if (comments.length === 0 || stmts.length === 0)
+        return map;
+    let ci = 0;
+    for (let si = 0; si < stmts.length; si++) {
+        const stmtLine = stmts[si].loc.line;
+        const before = [];
+        while (ci < comments.length && comments[ci].line <= stmtLine) {
+            before.push(comments[ci]);
+            ci++;
+        }
+        if (before.length > 0)
+            map.set(si, before);
+    }
+    // Trailing comments (after last stmt)
+    if (ci < comments.length) {
+        const trailing = [];
+        while (ci < comments.length) {
+            trailing.push(comments[ci]);
+            ci++;
+        }
+        map.set(stmts.length, trailing);
+    }
+    return map;
+}
+export function format(source, options) {
+    const opts = { ...DEFAULT_OPTIONS, ...options };
+    const comments = extractComments(source);
+    const tokens = lex(source);
+    const ast = parse(tokens);
+    const commentMap = buildCommentMap(comments, ast.stmts);
+    const lines = [];
+    function emit(line) { lines.push(line); }
+    function indent(depth) { return ' '.repeat(depth * opts.indentSize); }
+    function formatExpr(expr, depth) {
+        switch (expr.kind) {
+            case "IntLiteral": return String(expr.value);
+            case "FloatLiteral": return String(expr.value);
+            case "BoolLiteral": return expr.value ? "true" : "false";
+            case "NilLiteral": return "nil";
+            case "StringLiteral": return `"${escapeString(expr.value)}"`;
+            case "StringInterp": {
+                let s = '"';
+                for (const part of expr.parts) {
+                    if (typeof part === "string")
+                        s += escapeString(part);
+                    else
+                        s += `{${formatExpr(part, depth)}}`;
+                }
+                return s + '"';
+            }
+            case "Identifier": return expr.name;
+            case "BinaryExpr": {
+                const l = formatExpr(expr.left, depth);
+                const r = formatExpr(expr.right, depth);
+                return `${l} ${expr.op} ${r}`;
+            }
+            case "UnaryExpr": {
+                const operand = formatExpr(expr.operand, depth);
+                return expr.op === "not" ? `not ${operand}` : `${expr.op}${operand}`;
+            }
+            case "CallExpr": {
+                const callee = formatExpr(expr.callee, depth);
+                const args = expr.args.map(a => formatExpr(a, depth)).join(", ");
+                return `${callee}(${args})`;
+            }
+            case "MemberExpr":
+                return `${formatExpr(expr.object, depth)}.${expr.property}`;
+            case "IndexExpr":
+                return `${formatExpr(expr.object, depth)}[${formatExpr(expr.index, depth)}]`;
+            case "PipelineExpr": {
+                const l = formatExpr(expr.left, depth);
+                const r = formatExpr(expr.right, depth);
+                const single = `${l} |> ${r}`;
+                if (single.length + depth * opts.indentSize <= opts.maxLineLength) {
+                    return single;
+                }
+                return `${l}\n${indent(depth + 1)}|> ${r}`;
+            }
+            case "IfExpr": {
+                const cond = formatExpr(expr.condition, depth);
+                const then = formatBlockExpr(expr.then, depth);
+                if (expr.else_) {
+                    if (expr.else_.kind === "IfExpr") {
+                        return `if ${cond} ${then} el ${formatExpr(expr.else_, depth)}`;
+                    }
+                    const el = formatBlockExpr(expr.else_, depth);
+                    return `if ${cond} ${then} el ${el}`;
+                }
+                return `if ${cond} ${then}`;
+            }
+            case "MatchExpr": {
+                const subject = formatExpr(expr.subject, depth);
+                const armsStr = expr.arms.map(arm => {
+                    const pat = formatPattern(arm.pattern);
+                    const guard = arm.guard ? ` if ${formatExpr(arm.guard, depth + 1)}` : '';
+                    const body = formatExpr(arm.body, depth + 1);
+                    return `${indent(depth + 1)}${pat}${guard} => ${body}`;
+                }).join(',\n');
+                return `match ${subject} {\n${armsStr}\n${indent(depth)}}`;
+            }
+            case "LambdaExpr": {
+                const params = expr.params.length === 1
+                    ? expr.params[0]
+                    : `(${expr.params.join(", ")})`;
+                return `${params} => ${formatExpr(expr.body, depth)}`;
+            }
+            case "ListLiteral": {
+                if (expr.elements.length === 0)
+                    return "[]";
+                const elems = expr.elements.map(e => formatExpr(e, depth));
+                const single = `[${elems.join(", ")}]`;
+                if (single.length + depth * opts.indentSize <= opts.maxLineLength)
+                    return single;
+                return `[\n${elems.map(e => `${indent(depth + 1)}${e}`).join(',\n')}\n${indent(depth)}]`;
+            }
+            case "MapLiteral": {
+                if (expr.entries.length === 0)
+                    return "{}";
+                const entries = expr.entries.map(e => {
+                    const key = typeof e.key === "string" ? e.key : formatExpr(e.key, depth + 1);
+                    return `${key}: ${formatExpr(e.value, depth + 1)}`;
+                });
+                const single = `{ ${entries.join(", ")} }`;
+                if (single.length + depth * opts.indentSize <= opts.maxLineLength)
+                    return single;
+                return `{\n${entries.map(e => `${indent(depth + 1)}${e}`).join(',\n')}\n${indent(depth)}}`;
+            }
+            case "ListComprehension": {
+                const ex = formatExpr(expr.expr, depth);
+                const iter = formatExpr(expr.iterable, depth);
+                const filter = expr.filter ? ` if ${formatExpr(expr.filter, depth)}` : '';
+                return `[${ex} for ${expr.variable} in ${iter}${filter}]`;
+            }
+            case "ToolCallExpr": {
+                const arg = formatExpr(expr.arg, depth);
+                const body = expr.body ? ` ${formatBlockExpr(expr.body, depth)}` : '';
+                return `@${expr.method} ${arg}${body}`;
+            }
+            case "RangeExpr":
+                return `${formatExpr(expr.start, depth)}..${formatExpr(expr.end, depth)}`;
+            case "BlockExpr":
+                return formatBlockInline(expr, depth);
+            case "AsyncExpr":
+                return `async ${formatBlockExpr(expr.body, depth)}`;
+            case "AwaitExpr":
+                return `await ${formatExpr(expr.expr, depth)}`;
+            case "FetchExpr": {
+                const targets = expr.targets.map(t => formatExpr(t, depth)).join(", ");
+                return `fetch [${targets}]`;
+            }
+        }
+    }
+    function formatBlockExpr(expr, depth) {
+        if (expr.kind === "BlockExpr")
+            return formatBlockInline(expr, depth);
+        return formatExpr(expr, depth);
+    }
+    function formatBlockInline(block, depth) {
+        if (block.stmts.length === 0)
+            return "{}";
+        if (block.stmts.length === 1) {
+            const s = formatStmtStr(block.stmts[0], depth + 1);
+            const single = `{ ${s} }`;
+            if (single.length + depth * opts.indentSize <= opts.maxLineLength)
+                return single;
+        }
+        const body = block.stmts.map(s => `${indent(depth + 1)}${formatStmtStr(s, depth + 1)}`).join('\n');
+        return `{\n${body}\n${indent(depth)}}`;
+    }
+    function formatPattern(pat) {
+        switch (pat.kind) {
+            case "WildcardPattern": return "_";
+            case "LiteralPattern":
+                if (pat.value === null)
+                    return "nil";
+                if (typeof pat.value === "string")
+                    return `"${escapeString(pat.value)}"`;
+                return String(pat.value);
+            case "BindingPattern": return pat.name;
+            case "ArrayPattern": return `[${pat.elements.map(formatPattern).join(", ")}]`;
+            case "OrPattern": return pat.patterns.map(formatPattern).join(" | ");
+        }
+    }
+    function formatTypeExpr(t) {
+        switch (t.kind) {
+            case "NamedType": return t.name;
+            case "RecordType": {
+                const fields = t.fields.map(f => `${f.name}: ${formatTypeExpr(f.type)}`).join(", ");
+                return `{ ${fields} }`;
+            }
+            case "UnionType": return t.variants.map(formatTypeExpr).join(" | ");
+            case "FunctionType": {
+                const params = t.params.map(formatTypeExpr).join(", ");
+                return `(${params}) -> ${formatTypeExpr(t.ret)}`;
+            }
+            case "ConstrainedType":
+                return `${formatTypeExpr(t.base)} ${t.constraint} ${formatExpr(t.predicate, 0)}`;
+            case "EnumType":
+                return t.variants.map(v => {
+                    if (v.params)
+                        return `${v.name}(${v.params.map(formatTypeExpr).join(", ")})`;
+                    return v.name;
+                }).join(" | ");
+            case "GenericType":
+                return `${t.name}<${t.params.map(formatTypeExpr).join(", ")}>`;
+        }
+    }
+    function formatStmtStr(stmt, depth) {
+        switch (stmt.kind) {
+            case "LetStmt": {
+                const pub = stmt.pub ? "pub " : "";
+                const mut = stmt.mutable ? "mut " : "";
+                const name = typeof stmt.name === "string"
+                    ? stmt.name
+                    : stmt.name.type === "object"
+                        ? `{ ${stmt.name.names.join(", ")} }`
+                        : `[${stmt.name.names.join(", ")}]`;
+                return `${pub}let ${mut}${name} = ${formatExpr(stmt.value, depth)}`;
+            }
+            case "FnStmt": {
+                const pub = stmt.pub ? "pub " : "";
+                const async_ = stmt.isAsync ? "async " : "";
+                const params = stmt.params.join(", ");
+                if (stmt.body.kind === "BlockExpr") {
+                    return `${pub}${async_}fn ${stmt.name}(${params}) ${formatBlockInline(stmt.body, depth)}`;
+                }
+                return `${pub}${async_}fn ${stmt.name}(${params}) => ${formatExpr(stmt.body, depth)}`;
+            }
+            case "ForStmt":
+                return `for ${stmt.variable} in ${formatExpr(stmt.iterable, depth)} ${formatBlockExpr(stmt.body, depth)}`;
+            case "DoStmt": {
+                const kw = stmt.isWhile ? "while" : "until";
+                return `do ${formatBlockExpr(stmt.body, depth)} ${kw} ${formatExpr(stmt.condition, depth)}`;
+            }
+            case "ExprStmt":
+                return formatExpr(stmt.expr, depth);
+            case "UseStmt": {
+                const path = stmt.path.join("/");
+                if (stmt.wildcard)
+                    return `use ${path}: *`;
+                if (stmt.imports)
+                    return `use ${path}: ${stmt.imports.join(", ")}`;
+                return `use ${path}`;
+            }
+            case "TypeStmt": {
+                const pub = stmt.pub ? "pub " : "";
+                return `${pub}type ${stmt.name} = ${formatTypeExpr(stmt.def)}`;
+            }
+            case "AssignStmt":
+                return `${stmt.target} = ${formatExpr(stmt.value, depth)}`;
+            case "MemberAssignStmt":
+                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)}`;
+        }
+    }
+    // Emit top-level statements with comments and blank lines between declarations
+    let prevKind = '';
+    for (let i = 0; i < ast.stmts.length; i++) {
+        const stmtComments = commentMap.get(i);
+        if (stmtComments) {
+            for (const c of stmtComments) {
+                // If comment is on same line as previous stmt, it was inline — but we can't detect easily
+                // so emit as standalone line
+                emit(c.text);
+            }
+        }
+        const stmt = ast.stmts[i];
+        const isDecl = stmt.kind === "FnStmt" || stmt.kind === "TypeStmt";
+        const prevIsDecl = prevKind === "FnStmt" || prevKind === "TypeStmt";
+        // Blank line between top-level declarations
+        if (i > 0 && (isDecl || prevIsDecl)) {
+            // Only add if there isn't already a blank line from comments
+            if (!stmtComments || stmtComments.length === 0) {
+                emit('');
+            }
+        }
+        emit(formatStmtStr(stmt, 0));
+        prevKind = stmt.kind;
+    }
+    // Trailing comments
+    const trailingComments = commentMap.get(ast.stmts.length);
+    if (trailingComments) {
+        for (const c of trailingComments)
+            emit(c.text);
+    }
+    // Normalize trailing newline
+    let result = lines.join('\n');
+    result = result.replace(/\n+$/, '') + '\n';
+    return result;
+}
+function escapeString(s) {
+    return s
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, '\\n')
+        .replace(/\t/g, '\\t');
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};