arc-lang 0.5.0

package/dist/semantic.js

@@ -0,0 +1,327 @@
+// Arc Language Semantic Analyzer
+// Performs: name resolution, scope validation, mutability checking, arity checking, match exhaustiveness warnings
+class Scope {
+    parent;
+    symbols = new Map();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    define(name, info) {
+        // Allow redefinition in same scope (shadowing)
+        this.symbols.set(name, info);
+        return true;
+    }
+    lookup(name) {
+        const s = this.symbols.get(name);
+        if (s)
+            return s;
+        if (this.parent)
+            return this.parent.lookup(name);
+        return undefined;
+    }
+    lookupLocal(name) {
+        return this.symbols.get(name);
+    }
+}
+// Built-in names that are always available
+const BUILTINS = new Set([
+    "print", "println", "len", "push", "pop", "map", "filter", "reduce",
+    "range", "keys", "values", "entries", "type", "str", "int", "float",
+    "sort", "reverse", "join", "split", "trim", "contains", "starts_with",
+    "ends_with", "replace", "to_upper", "to_lower", "slice", "flat",
+    "flat_map", "zip", "enumerate", "sum", "min", "max", "abs",
+    "head", "tail", "take", "drop", "find", "any", "all", "count",
+    "unique", "group_by", "sort_by", "chunk", "window", "scan",
+    "assert", "assert_eq", "Some", "None", "Ok", "Err",
+    "Math", "String", "List", "Map", "JSON", "Error",
+    "true", "false", "nil",
+    "is_nil", "is_some", "unwrap", "unwrap_or",
+    "typeof", "chars", "char_at", "index_of", "last_index_of",
+    "parse_int", "parse_float", "to_string", "format",
+    "now", "sleep", "random", "floor", "ceil", "round", "sqrt", "pow", "log",
+    "read_file", "write_file", "http_get", "http_post",
+    "append", "prepend", "concat", "flatten", "each", "fold",
+    "first", "last", "rest", "init", "is_empty", "size",
+    "repeat", "pad_left", "pad_right", "upper", "lower",
+    "every", "some", "none", "includes",
+]);
+export function analyze(program) {
+    const diagnostics = [];
+    const globalScope = new Scope();
+    function error(loc, message) {
+        diagnostics.push({ level: "error", message, loc });
+    }
+    function warning(loc, message) {
+        diagnostics.push({ level: "warning", message, loc });
+    }
+    function analyzeExpr(expr, scope) {
+        switch (expr.kind) {
+            case "IntLiteral":
+            case "FloatLiteral":
+            case "BoolLiteral":
+            case "NilLiteral":
+            case "StringLiteral":
+                break;
+            case "StringInterp":
+                for (const part of expr.parts) {
+                    if (typeof part !== "string") {
+                        analyzeExpr(part, scope);
+                    }
+                }
+                break;
+            case "Identifier": {
+                const sym = scope.lookup(expr.name);
+                if (!sym && !BUILTINS.has(expr.name)) {
+                    error(expr.loc, `Undefined variable: '${expr.name}'`);
+                }
+                break;
+            }
+            case "BinaryExpr":
+                analyzeExpr(expr.left, scope);
+                analyzeExpr(expr.right, scope);
+                break;
+            case "UnaryExpr":
+                analyzeExpr(expr.operand, scope);
+                break;
+            case "CallExpr": {
+                analyzeExpr(expr.callee, scope);
+                for (const arg of expr.args) {
+                    analyzeExpr(arg, scope);
+                }
+                // Arity check for known functions
+                if (expr.callee.kind === "Identifier") {
+                    const sym = scope.lookup(expr.callee.name);
+                    if (sym && sym.kind === "function" && sym.arity !== undefined) {
+                        if (expr.args.length !== sym.arity) {
+                            error(expr.loc, `Function '${expr.callee.name}' expects ${sym.arity} argument(s), but got ${expr.args.length}`);
+                        }
+                    }
+                }
+                break;
+            }
+            case "MemberExpr":
+                analyzeExpr(expr.object, scope);
+                break;
+            case "IndexExpr":
+                analyzeExpr(expr.object, scope);
+                analyzeExpr(expr.index, scope);
+                break;
+            case "PipelineExpr":
+                analyzeExpr(expr.left, scope);
+                analyzeExpr(expr.right, scope);
+                break;
+            case "IfExpr":
+                analyzeExpr(expr.condition, scope);
+                analyzeExpr(expr.then, scope);
+                if (expr.else_)
+                    analyzeExpr(expr.else_, scope);
+                break;
+            case "MatchExpr":
+                analyzeExpr(expr.subject, scope);
+                analyzeMatchExhaustiveness(expr, scope);
+                for (const arm of expr.arms) {
+                    const armScope = new Scope(scope);
+                    analyzePattern(arm.pattern, armScope);
+                    if (arm.guard)
+                        analyzeExpr(arm.guard, armScope);
+                    analyzeExpr(arm.body, armScope);
+                }
+                break;
+            case "LambdaExpr": {
+                const lambdaScope = new Scope(scope);
+                for (const p of expr.params) {
+                    lambdaScope.define(p, { mutable: false, kind: "parameter" });
+                }
+                analyzeExpr(expr.body, lambdaScope);
+                break;
+            }
+            case "ListLiteral":
+                for (const el of expr.elements)
+                    analyzeExpr(el, scope);
+                break;
+            case "MapLiteral":
+                for (const entry of expr.entries) {
+                    if (typeof entry.key !== "string")
+                        analyzeExpr(entry.key, scope);
+                    analyzeExpr(entry.value, scope);
+                }
+                break;
+            case "ListComprehension": {
+                analyzeExpr(expr.iterable, scope);
+                const compScope = new Scope(scope);
+                compScope.define(expr.variable, { mutable: false, kind: "loop-var" });
+                analyzeExpr(expr.expr, compScope);
+                if (expr.filter)
+                    analyzeExpr(expr.filter, compScope);
+                break;
+            }
+            case "ToolCallExpr":
+                analyzeExpr(expr.arg, scope);
+                if (expr.body)
+                    analyzeExpr(expr.body, scope);
+                break;
+            case "RangeExpr":
+                analyzeExpr(expr.start, scope);
+                analyzeExpr(expr.end, scope);
+                break;
+            case "BlockExpr": {
+                const blockScope = new Scope(scope);
+                analyzeStmts(expr.stmts, blockScope);
+                break;
+            }
+            case "AsyncExpr":
+                analyzeExpr(expr.body, scope);
+                break;
+            case "AwaitExpr":
+                analyzeExpr(expr.expr, scope);
+                break;
+            case "FetchExpr":
+                for (const t of expr.targets)
+                    analyzeExpr(t, scope);
+                break;
+        }
+    }
+    function analyzePattern(pattern, scope) {
+        switch (pattern.kind) {
+            case "WildcardPattern":
+                break;
+            case "LiteralPattern":
+                break;
+            case "BindingPattern":
+                scope.define(pattern.name, { mutable: false, kind: "variable" });
+                break;
+            case "ArrayPattern":
+                for (const el of pattern.elements)
+                    analyzePattern(el, scope);
+                break;
+            case "OrPattern":
+                for (const p of pattern.patterns)
+                    analyzePattern(p, scope);
+                break;
+        }
+    }
+    function analyzeMatchExhaustiveness(expr, _scope) {
+        const arms = expr.arms;
+        if (arms.length === 0) {
+            warning(expr.loc, "Match expression has no arms");
+            return;
+        }
+        // Check if there's a wildcard or binding (catch-all) pattern without a guard
+        const hasCatchAll = arms.some(arm => !arm.guard && isCatchAllPattern(arm.pattern));
+        if (!hasCatchAll) {
+            warning(expr.loc, "Match expression may not be exhaustive — consider adding a wildcard '_' arm");
+        }
+        // Check for unreachable arms (arms after a catch-all without guard)
+        for (let i = 0; i < arms.length - 1; i++) {
+            if (!arms[i].guard && isCatchAllPattern(arms[i].pattern)) {
+                warning(arms[i + 1].body.loc, "Unreachable match arm — previous arm catches all patterns");
+                break;
+            }
+        }
+    }
+    function isCatchAllPattern(pattern) {
+        return pattern.kind === "WildcardPattern" || pattern.kind === "BindingPattern";
+    }
+    function analyzeStmts(stmts, scope) {
+        // First pass: register all function declarations (hoisting)
+        for (const stmt of stmts) {
+            if (stmt.kind === "FnStmt") {
+                scope.define(stmt.name, {
+                    mutable: false,
+                    kind: "function",
+                    arity: stmt.params.length,
+                });
+            }
+        }
+        for (const stmt of stmts) {
+            analyzeStmt(stmt, scope);
+        }
+    }
+    function analyzeStmt(stmt, scope) {
+        switch (stmt.kind) {
+            case "LetStmt": {
+                analyzeExpr(stmt.value, scope);
+                if (typeof stmt.name === "string") {
+                    scope.define(stmt.name, {
+                        mutable: stmt.mutable,
+                        kind: "variable",
+                    });
+                }
+                else {
+                    // DestructureTarget
+                    for (const n of stmt.name.names) {
+                        scope.define(n, {
+                            mutable: stmt.mutable,
+                            kind: "destructured",
+                        });
+                    }
+                }
+                break;
+            }
+            case "FnStmt": {
+                // Already registered in first pass; now analyze body
+                const fnScope = new Scope(scope);
+                for (const p of stmt.params) {
+                    fnScope.define(p, { mutable: false, kind: "parameter" });
+                }
+                analyzeExpr(stmt.body, fnScope);
+                break;
+            }
+            case "ForStmt": {
+                analyzeExpr(stmt.iterable, scope);
+                const forScope = new Scope(scope);
+                forScope.define(stmt.variable, { mutable: false, kind: "loop-var" });
+                analyzeExpr(stmt.body, forScope);
+                break;
+            }
+            case "DoStmt":
+                analyzeExpr(stmt.body, scope);
+                analyzeExpr(stmt.condition, scope);
+                break;
+            case "ExprStmt":
+                analyzeExpr(stmt.expr, scope);
+                break;
+            case "UseStmt":
+                // Register imported names
+                if (stmt.imports) {
+                    for (const imp of stmt.imports) {
+                        scope.define(imp, { mutable: false, kind: "import" });
+                    }
+                }
+                else if (stmt.wildcard) {
+                    // Wildcard import — can't track names statically
+                }
+                else {
+                    // Default: import the module name
+                    const moduleName = stmt.path[stmt.path.length - 1];
+                    scope.define(moduleName, { mutable: false, kind: "import" });
+                }
+                break;
+            case "TypeStmt":
+                scope.define(stmt.name, { mutable: false, kind: "type" });
+                break;
+            case "AssignStmt": {
+                const sym = scope.lookup(stmt.target);
+                if (!sym && !BUILTINS.has(stmt.target)) {
+                    error(stmt.loc, `Undefined variable: '${stmt.target}'`);
+                }
+                else if (sym && !sym.mutable) {
+                    error(stmt.loc, `Cannot reassign immutable variable: '${stmt.target}'`);
+                }
+                analyzeExpr(stmt.value, scope);
+                break;
+            }
+            case "MemberAssignStmt":
+                analyzeExpr(stmt.object, scope);
+                analyzeExpr(stmt.value, scope);
+                break;
+            case "IndexAssignStmt":
+                analyzeExpr(stmt.object, scope);
+                analyzeExpr(stmt.index, scope);
+                analyzeExpr(stmt.value, scope);
+                break;
+        }
+    }
+    analyzeStmts(program.stmts, globalScope);
+    return diagnostics;
+}

package/dist/typechecker.d.ts

@@ -0,0 +1,7 @@
+import * as AST from "./ast.js";
+export interface Diagnostic {
+    level: "error" | "warning";
+    message: string;
+    loc?: AST.Loc;
+}
+export declare function typecheck(program: AST.Program): Diagnostic[];

package/dist/typechecker.js

@@ -0,0 +1,132 @@
+// Arc Language Type Checker (basic)
+export function typecheck(program) {
+    const diagnostics = [];
+    const typeDefinitions = new Map();
+    const knownBaseTypes = new Set(["Int", "Float", "String", "Bool", "Nil", "Any"]);
+    // First pass: collect type definitions
+    for (const stmt of program.stmts) {
+        if (stmt.kind === "TypeStmt") {
+            typeDefinitions.set(stmt.name, stmt.def);
+        }
+    }
+    // Second pass: validate type definitions
+    for (const [name, def] of typeDefinitions) {
+        validateTypeExpr(def, name);
+    }
+    // Third pass: check match exhaustiveness
+    for (const stmt of program.stmts) {
+        walkStmt(stmt);
+    }
+    function validateTypeExpr(typeExpr, context) {
+        switch (typeExpr.kind) {
+            case "NamedType":
+                if (!knownBaseTypes.has(typeExpr.name) && !typeDefinitions.has(typeExpr.name)) {
+                    // Could be a type parameter, so just warn
+                    // Don't warn for single-letter names (type params)
+                    if (typeExpr.name.length > 1) {
+                        diagnostics.push({
+                            level: "warning",
+                            message: `Unknown type '${typeExpr.name}' in definition of '${context}'`,
+                        });
+                    }
+                }
+                break;
+            case "ConstrainedType":
+                validateTypeExpr(typeExpr.base, context);
+                if (typeExpr.base.kind === "NamedType") {
+                    const baseName = typeExpr.base.name;
+                    if (typeExpr.constraint === "matching" && baseName !== "String") {
+                        diagnostics.push({
+                            level: "error",
+                            message: `'matching' constraint can only be applied to String type, got '${baseName}' in '${context}'`,
+                        });
+                    }
+                    if (typeExpr.constraint === "where" && !knownBaseTypes.has(baseName) && !typeDefinitions.has(baseName)) {
+                        diagnostics.push({
+                            level: "warning",
+                            message: `'where' constraint on unknown base type '${baseName}' in '${context}'`,
+                        });
+                    }
+                }
+                break;
+            case "RecordType":
+                for (const field of typeExpr.fields) {
+                    validateTypeExpr(field.type, context);
+                }
+                break;
+            case "FunctionType":
+                for (const param of typeExpr.params) {
+                    validateTypeExpr(param, context);
+                }
+                validateTypeExpr(typeExpr.ret, context);
+                break;
+            case "EnumType":
+                for (const variant of typeExpr.variants) {
+                    if (variant.params) {
+                        for (const p of variant.params) {
+                            validateTypeExpr(p, context);
+                        }
+                    }
+                }
+                break;
+            case "GenericType":
+                for (const p of typeExpr.params) {
+                    validateTypeExpr(p, context);
+                }
+                break;
+            case "UnionType":
+                for (const v of typeExpr.variants) {
+                    validateTypeExpr(v, context);
+                }
+                break;
+        }
+    }
+    function walkStmt(stmt) {
+        if (stmt.kind === "ExprStmt") {
+            walkExpr(stmt.expr);
+        }
+        else if (stmt.kind === "LetStmt") {
+            walkExpr(stmt.value);
+        }
+        else if (stmt.kind === "FnStmt") {
+            walkExpr(stmt.body);
+        }
+        else if (stmt.kind === "ForStmt") {
+            walkExpr(stmt.iterable);
+            walkExpr(stmt.body);
+        }
+    }
+    function walkExpr(expr) {
+        if (expr.kind === "MatchExpr") {
+            checkMatchExhaustiveness(expr);
+            for (const arm of expr.arms) {
+                walkExpr(arm.body);
+            }
+        }
+        else if (expr.kind === "BlockExpr") {
+            for (const s of expr.stmts) {
+                walkStmt(s);
+            }
+        }
+        else if (expr.kind === "IfExpr") {
+            walkExpr(expr.then);
+            if (expr.else_)
+                walkExpr(expr.else_);
+        }
+    }
+    function checkMatchExhaustiveness(matchExpr) {
+        const hasWildcard = matchExpr.arms.some(a => a.pattern.kind === "WildcardPattern");
+        if (!hasWildcard) {
+            // Check if subject is a known enum type
+            if (matchExpr.subject.kind === "Identifier") {
+                // Can't easily determine type without full type inference, so just warn
+                diagnostics.push({
+                    level: "warning",
+                    message: `Match expression may not be exhaustive (no wildcard pattern)`,
+                    loc: matchExpr.loc,
+                });
+            }
+        }
+    }
+    return diagnostics;
+}

package/dist/version.d.ts

@@ -0,0 +1,26 @@
+export declare const ARC_VERSION = "0.5.0";
+export declare const ARC_BUILD_DATE: string;
+export declare const ARC_PLATFORM: string;
+/** Print version info */
+export declare function printVersion(): void;
+/** Semver comparison: returns -1, 0, or 1 */
+export declare function compareSemver(a: string, b: string): number;
+/** Check if a manifest's arc version requirement is compatible */
+export declare function checkVersionCompatibility(required: string): {
+    compatible: boolean;
+    message: string;
+};
+/** Deprecation registry */
+interface DeprecationEntry {
+    feature: string;
+    since: string;
+    removeIn: string;
+    migration: string;
+}
+/** Register a deprecated feature */
+export declare function deprecate(feature: string, since: string, removeIn: string, migration: string): void;
+/** Emit a deprecation warning (once per feature per session) */
+export declare function emitDeprecationWarning(feature: string): void;
+/** Get all registered deprecations */
+export declare function getDeprecations(): readonly DeprecationEntry[];
+export {};

package/dist/version.js

@@ -0,0 +1,71 @@
+// Arc Version System
+export const ARC_VERSION = "0.5.0";
+export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
+export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
+/** Print version info */
+export function printVersion() {
+    console.log(`Arc ${ARC_VERSION}`);
+    console.log(`Build date: ${ARC_BUILD_DATE}`);
+    console.log(`Platform:   ${ARC_PLATFORM}`);
+    console.log(`Node.js:    ${process.version}`);
+}
+/** Semver comparison: returns -1, 0, or 1 */
+export function compareSemver(a, b) {
+    const pa = a.split(".").map(Number);
+    const pb = b.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] < pb[i])
+            return -1;
+        if (pa[i] > pb[i])
+            return 1;
+    }
+    return 0;
+}
+/** Check if a manifest's arc version requirement is compatible */
+export function checkVersionCompatibility(required) {
+    // Support formats: "0.5.0", ">=0.4.0", "^0.5.0", "~0.5.0"
+    const current = ARC_VERSION;
+    if (required.startsWith(">=")) {
+        const min = required.slice(2);
+        const ok = compareSemver(current, min) >= 0;
+        return { compatible: ok, message: ok ? "Compatible" : `Requires Arc >=${min}, current is ${current}` };
+    }
+    if (required.startsWith("^")) {
+        const base = required.slice(1);
+        const [major] = base.split(".").map(Number);
+        const [curMajor] = current.split(".").map(Number);
+        const ok = curMajor === major && compareSemver(current, base) >= 0;
+        return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
+    }
+    if (required.startsWith("~")) {
+        const base = required.slice(1);
+        const parts = base.split(".").map(Number);
+        const curParts = current.split(".").map(Number);
+        const ok = curParts[0] === parts[0] && curParts[1] === parts[1] && compareSemver(current, base) >= 0;
+        return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
+    }
+    // Exact match
+    const ok = compareSemver(current, required) >= 0;
+    return { compatible: ok, message: ok ? "Compatible" : `Requires Arc ${required}, current is ${current}` };
+}
+const deprecations = [];
+const emittedWarnings = new Set();
+/** Register a deprecated feature */
+export function deprecate(feature, since, removeIn, migration) {
+    deprecations.push({ feature, since, removeIn, migration });
+}
+/** Emit a deprecation warning (once per feature per session) */
+export function emitDeprecationWarning(feature) {
+    if (emittedWarnings.has(feature))
+        return;
+    const entry = deprecations.find(d => d.feature === feature);
+    if (!entry)
+        return;
+    emittedWarnings.add(feature);
+    console.warn(`⚠ DEPRECATED: '${feature}' was deprecated in v${entry.since} and will be removed in v${entry.removeIn}.`);
+    console.warn(`  Migration: ${entry.migration}`);
+}
+/** Get all registered deprecations */
+export function getDeprecations() {
+    return deprecations;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "arc-lang",
+  "version": "0.5.0",
+  "description": "Arc ⚡ — A programming language designed by AI agents, for AI agents. 27-63% fewer tokens than JavaScript.",
+  "type": "module",
+  "bin": {
+    "arc": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "run": "tsx src/index.ts run",
+    "parse": "tsx src/index.ts parse"
+  },
+  "keywords": [
+    "arc",
+    "programming-language",
+    "ai",
+    "ai-agents",
+    "compiler",
+    "token-efficient",
+    "language",
+    "interpreter",
+    "repl"
+  ],
+  "author": "Kai <nebula7458@proton.me> (https://arclang.dev)",
+  "license": "MIT",
+  "homepage": "https://arclang.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kai-builds-ai/arc-lang.git"
+  },
+  "bugs": {
+    "url": "https://github.com/kai-builds-ai/arc-lang/issues"
+  },
+  "dependencies": {
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3"
+  }
+}