arc-lang 0.6.7 → 0.6.9

package/dist/ast.d.ts

@@ -2,7 +2,7 @@ export interface Loc {
     line: number;
     col: number;
 }
-export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr | SpreadExpr | OptionalMemberExpr | TryExpr | TryCatchExpr;
+export type Expr = IntLiteral | FloatLiteral | BoolLiteral | NilLiteral | StringLiteral | StringInterp | Identifier | BinaryExpr | UnaryExpr | CallExpr | MemberExpr | IndexExpr | PipelineExpr | IfExpr | MatchExpr | LambdaExpr | ListLiteral | MapLiteral | ListComprehension | ToolCallExpr | RangeExpr | BlockExpr | AsyncExpr | AwaitExpr | FetchExpr | SpreadExpr | OptionalMemberExpr | TryExpr | TryCatchExpr | GroupExpr;
 export interface IntLiteral {
     kind: "IntLiteral";
     value: number;
@@ -177,6 +177,11 @@ export interface TryCatchExpr {
     catchBody: Expr;
     loc: Loc;
 }
+export interface GroupExpr {
+    kind: "GroupExpr";
+    expr: Expr;
+    loc: Loc;
+}
 export type Pattern = WildcardPattern | LiteralPattern | BindingPattern | ArrayPattern | OrPattern | ConstructorPattern;
 export interface WildcardPattern {
     kind: "WildcardPattern";

package/dist/formatter.js

@@ -35,6 +35,16 @@ function extractComments(source) {
                 col++;
             }
         }
+        else if (source[i] === '/' && i + 1 < source.length && source[i + 1] === '/') {
+            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] === '#') {
             const startLine = line, startCol = col;
             let text = '';
@@ -98,7 +108,10 @@ export function format(source, options) {
     function formatExpr(expr, depth) {
         switch (expr.kind) {
             case "IntLiteral": return String(expr.value);
-            case "FloatLiteral": return String(expr.value);
+            case "FloatLiteral": {
+                const s = String(expr.value);
+                return s.includes('.') ? s : s + '.0';
+            }
             case "BoolLiteral": return expr.value ? "true" : "false";
             case "NilLiteral": return "nil";
             case "StringLiteral": {
@@ -244,6 +257,7 @@ export function format(source, options) {
                 const targets = expr.targets.map(t => formatExpr(t, depth)).join(", ");
                 return `fetch [${targets}]`;
             }
+            case "GroupExpr": return `(${formatExpr(expr.expr, depth)})`;
             case "SpreadExpr": return `...${formatExpr(expr.expr, depth)}`;
             case "OptionalMemberExpr": return `${formatExpr(expr.object, depth)}?.${expr.property}`;
             case "TryExpr": return `${formatExpr(expr.expr, depth)}?`;

package/dist/interpreter.js

@@ -20,6 +20,13 @@ class Env {
         if (this.parent)
             return this.parent.get(name);
         // Collect all known variable names for "did you mean?" suggestion
+        if (name === "mut" || name === "var") {
+            throw new ArcRuntimeError(`Undefined variable: ${name}`, {
+                code: ErrorCode.UNDEFINED_VARIABLE,
+                category: "RuntimeError",
+                suggestion: "Did you mean 'let mut' to declare a mutable variable?",
+            });
+        }
         const candidates = this.allNames();
         const closest = findClosestMatch(name, candidates);
         throw new ArcRuntimeError(`Undefined variable: ${name}`, {
@@ -2681,7 +2688,15 @@ function evalExpr(expr, env) {
             if (obj === null)
                 return null;
             if (obj && typeof obj === "object" && "__map" in obj) {
-                return obj.entries.get(expr.property) ?? null;
+                const mapObj = obj;
+                const val = mapObj.entries.get(expr.property);
+                if (val === undefined && "__module" in obj) {
+                    const modName = obj.__module;
+                    const candidates = [...mapObj.entries.keys()];
+                    const closest = findClosestMatch(expr.property, candidates);
+                    throw new ArcRuntimeError(`Module '${modName}' has no member '${expr.property}'${closest ? `. Did you mean '${closest}'?` : ""}`, { code: ErrorCode.PROPERTY_ACCESS, loc: expr.loc });
+                }
+                return val ?? null;
             }
             // Teaching error messages for common method-style access
             const prop = expr.property;
@@ -2956,6 +2971,8 @@ function evalExpr(expr, env) {
             }
             return result;
         }
+        case "GroupExpr":
+            return evalExpr(expr.expr, env);
         default:
             throw new Error(`Unknown expression kind: ${expr.kind}`);
     }

package/dist/linter.js

@@ -2,6 +2,16 @@
 // Checks for common code quality issues
 import { lex } from "./lexer.js";
 import { parse } from "./parser.js";
+/** Walk an expression to find the root variable name (e.g. `a[b].c` → "a") */
+function getRootVariable(expr) {
+    if (expr.kind === "Identifier")
+        return expr.name;
+    if (expr.kind === "MemberExpr" || expr.kind === "OptionalMemberExpr")
+        return getRootVariable(expr.object);
+    if (expr.kind === "IndexExpr")
+        return getRootVariable(expr.object);
+    return null;
+}
 const DEFAULT_OPTIONS = {
     maxLineLength: 100,
     file: "<stdin>",
@@ -212,6 +222,9 @@ export function lint(source, options) {
                 for (const t of expr.targets)
                     analyzeExpr(t, scope);
                 break;
+            case "GroupExpr":
+                analyzeExpr(expr.expr, scope);
+                break;
         }
     }
     function analyzePattern(pat, scope) {
@@ -399,15 +412,27 @@ export function lint(source, options) {
                 scope.markUsed(stmt.target);
                 analyzeExpr(stmt.value, scope);
                 break;
-            case "MemberAssignStmt":
+            case "MemberAssignStmt": {
                 analyzeExpr(stmt.object, scope);
                 analyzeExpr(stmt.value, scope);
+                const memberRoot = getRootVariable(stmt.object);
+                if (memberRoot) {
+                    scope.markMutated(memberRoot);
+                    scope.markUsed(memberRoot);
+                }
                 break;
-            case "IndexAssignStmt":
+            }
+            case "IndexAssignStmt": {
                 analyzeExpr(stmt.object, scope);
                 analyzeExpr(stmt.index, scope);
                 analyzeExpr(stmt.value, scope);
+                const indexRoot = getRootVariable(stmt.object);
+                if (indexRoot) {
+                    scope.markMutated(indexRoot);
+                    scope.markUsed(indexRoot);
+                }
                 break;
+            }
         }
     }
     const globalScope = new LintScope();

package/dist/modules.js

@@ -124,7 +124,7 @@ export function handleUse(stmt, env, currentFile) {
     for (const [name, value] of Object.entries(exports)) {
         entries.set(name, value);
     }
-    env.set(nsName, { __map: true, entries });
+    env.set(nsName, { __map: true, __module: nsName, entries });
 }
 /**
  * Create a UseHandler bound to a specific file path.

package/dist/parser.d.ts

@@ -37,6 +37,7 @@ export declare class Parser {
     private parsePrefix;
     private parseStringInterp;
     private parseListOrComprehension;
+    private isIdentOrKeyword;
     private isMapStart;
     private parseMapEntry;
     private parseMapOrBlock;

package/dist/parser.js

@@ -68,6 +68,10 @@ export class Parser {
             case TokenType.Type: return this.parseType();
             case TokenType.Ret: return this.parseRet();
             case TokenType.Try: return this.parseTryStmtOrExpr();
+            case TokenType.Mut: {
+                const loc = this.loc();
+                throw new ParseError(`'mut' is not a statement. Did you mean 'let mut' to declare a mutable variable?`, loc);
+            }
             default: {
                 const exprLoc = this.loc();
                 const expr = this.parseExpr();
@@ -696,7 +700,7 @@ export class Parser {
             this.pos = saved;
             const expr = this.parseExpr();
             this.expect(TokenType.RParen);
-            return expr;
+            return { kind: "GroupExpr", expr, loc };
         }
         // List literal or comprehension
         if (t.type === TokenType.LBracket) {
@@ -856,9 +860,13 @@ export class Parser {
         this.expect(TokenType.RBracket);
         return { kind: "ListLiteral", elements, loc };
     }
+    isIdentOrKeyword(t) {
+        const tt = t ?? this.peek().type;
+        return tt === TokenType.Ident || tt === TokenType.Match || tt === TokenType.Fn || tt === TokenType.Let || tt === TokenType.If || tt === TokenType.For || tt === TokenType.In || tt === TokenType.Do || tt === TokenType.While || tt === TokenType.Until || tt === TokenType.Use || tt === TokenType.Pub || tt === TokenType.Type || tt === TokenType.Ret || tt === TokenType.Where || tt === TokenType.Matching || tt === TokenType.Fetch || tt === TokenType.Async || tt === TokenType.Await || tt === TokenType.Try || tt === TokenType.Catch || tt === TokenType.Mut || tt === TokenType.True || tt === TokenType.False || tt === TokenType.NilKw || tt === TokenType.And || tt === TokenType.Or || tt === TokenType.Not || tt === TokenType.Break || tt === TokenType.Continue || tt === TokenType.El;
+    }
     isMapStart() {
         // Check if current position (after {) looks like a map entry
-        if (this.at(TokenType.Ident) && this.tokens[this.pos + 1]?.type === TokenType.Colon)
+        if (this.isIdentOrKeyword() && this.tokens[this.pos + 1]?.type === TokenType.Colon)
             return true;
         if (this.at(TokenType.String) && this.tokens[this.pos + 1]?.type === TokenType.Colon)
             return true;
@@ -912,7 +920,13 @@ export class Parser {
             const value = this.parseExpr();
             return { key, value };
         }
-        // Ident key: name: value
+        // Ident or keyword key: name: value
+        if (this.isIdentOrKeyword()) {
+            const key = this.advance().value;
+            this.expect(TokenType.Colon);
+            const value = this.parseExpr();
+            return { key, value };
+        }
         const key = this.expect(TokenType.Ident).value;
         this.expect(TokenType.Colon);
         const value = this.parseExpr();

package/dist/version.d.ts

@@ -1,4 +1,4 @@
-export declare const ARC_VERSION = "0.6.7";
+export declare const ARC_VERSION = "0.6.9";
 export declare const ARC_BUILD_DATE: string;
 export declare const ARC_PLATFORM: string;
 /** Print version info */

package/dist/version.js

@@ -1,5 +1,5 @@
 // Arc Version System
-export const ARC_VERSION = "0.6.7";
+export const ARC_VERSION = "0.6.9";
 export const ARC_BUILD_DATE = new Date().toISOString().split("T")[0];
 export const ARC_PLATFORM = `${process.platform}-${process.arch}`;
 /** Print version info */

package/package.json

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