tova 0.2.7 → 0.2.9

package/bin/tova.js

@@ -352,7 +352,9 @@ async function runFile(filePath, options = {}) {
     // Execute the generated JavaScript (with stdlib)
     const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
     const stdlib = getRunStdlib();
-    const code = stdlib + '\n' + (output.shared || '') + '\n' + (output.server || output.client || '');
+    let code = stdlib + '\n' + (output.shared || '') + '\n' + (output.server || output.client || '');
+    // Strip 'export ' keywords — not valid inside AsyncFunction (used in tova build only)
+    code = code.replace(/^export /gm, '');
     const fn = new AsyncFunction(code);
     await fn();
   } catch (err) {
@@ -764,6 +766,18 @@ async function devServer(args) {
       processes.push({ child, label: 'server', port });
       rebuildPortOffset++;
     }
+
+    // Wait for server to be ready before triggering browser reload
+    if (processes.length > 0) {
+      const serverPort = processes[0].port;
+      for (let i = 0; i < 50; i++) {
+        try {
+          const res = await fetch(`http://localhost:${serverPort}/`);
+          if (res.ok || res.status === 404) break;
+        } catch {}
+        await new Promise(r => setTimeout(r, 100));
+      }
+    }
     console.log('  ✓ Rebuild complete');
     notifyReload();
   });
@@ -791,7 +805,16 @@ async function generateDevHTML(clientCode, srcDir, reloadPort = 0) {
     (function() {
       var es = new EventSource("http://localhost:${reloadPort}/__tova_reload");
       es.onmessage = function(e) { if (e.data === "reload") window.location.reload(); };
-      es.onerror = function() { setTimeout(function() { window.location.reload(); }, 1000); };
+      es.onerror = function() {
+        es.close();
+        // Server is rebuilding — poll until it's back, then reload
+        var check = setInterval(function() {
+          fetch(window.location.href, { mode: "no-cors" }).then(function() {
+            clearInterval(check);
+            window.location.reload();
+          }).catch(function() {});
+        }, 500);
+      };
     })();
   </script>` : '';
 
@@ -1456,6 +1479,8 @@ async function startRepl() {
     }
 
     if (trimmed === ':clear') {
+      for (const key of Object.keys(context)) delete context[key];
+      delete context.__mutable;
       initFn.call(context);
       console.log('  Context cleared.\n');
       rl.prompt();
@@ -1491,6 +1516,36 @@ async function startRepl() {
       const output = compileTova(input, '<repl>');
       const code = output.shared || '';
       if (code.trim()) {
+        // Extract function/const/let names from compiled code
+        const declaredInCode = new Set();
+        for (const m of code.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
+        for (const m of code.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
+        for (const m of code.matchAll(/\blet\s+([a-zA-Z_]\w*)/g)) {
+          declaredInCode.add(m[1]);
+          // Track mutable variables for proper let destructuring
+          if (!context.__mutable) context.__mutable = new Set();
+          context.__mutable.add(m[1]);
+        }
+
+        // Save declared variables back to context for persistence across inputs
+        const saveNewDecls = declaredInCode.size > 0
+          ? [...declaredInCode].map(n => `if(typeof ${n}!=='undefined')__ctx.${n}=${n};`).join('\n')
+          : '';
+        // Also save mutable variables that may have been modified (not newly declared)
+        const mutKeys = context.__mutable
+          ? [...context.__mutable].filter(n => !declaredInCode.has(n) && n in context)
+          : [];
+        const saveMut = mutKeys.map(n => `__ctx.${n}=${n};`).join('\n');
+        const allSave = [saveNewDecls, saveMut].filter(Boolean).join('\n');
+
+        // Context destructuring: use let for mutable, const for immutable
+        const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k) && k !== '__mutable');
+        const constKeys = ctxKeys.filter(k => !context.__mutable || !context.__mutable.has(k));
+        const letKeys = ctxKeys.filter(k => context.__mutable && context.__mutable.has(k));
+        const destructure =
+          (constKeys.length > 0 ? `const {${constKeys.join(',')}} = __ctx;\n` : '') +
+          (letKeys.length > 0 ? `let {${letKeys.join(',')}} = __ctx;\n` : '');
+
         // Try wrapping last expression statement as a return for value display
         const lines = code.trim().split('\n');
         const lastLine = lines[lines.length - 1].trim();
@@ -1501,28 +1556,25 @@ async function startRepl() {
           const allButLast = lines.slice(0, -1).join('\n');
           // Strip trailing semicolon from last line for the return
           const returnExpr = lastLine.endsWith(';') ? lastLine.slice(0, -1) : lastLine;
-          evalCode = allButLast + (allButLast ? '\n' : '') + `return (${returnExpr});`;
+          // Use try/finally so save runs after return expression evaluates (captures updated mutable values)
+          if (allSave) {
+            evalCode = `try {\n${allButLast}\nreturn (${returnExpr});\n} finally {\n${allSave}\n}`;
+          } else {
+            evalCode = allButLast + (allButLast ? '\n' : '') + `return (${returnExpr});`;
+          }
+        } else {
+          evalCode = code + (allSave ? '\n' + allSave : '');
         }
         try {
-          // Extract function/const names from compiled code to avoid shadowing conflicts
-          const declaredInCode = new Set();
-          for (const m of evalCode.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          for (const m of evalCode.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k));
-          const destructure = ctxKeys.length > 0 ? `const {${ctxKeys.join(',')}} = __ctx;` : '';
-          const fn = new Function('__ctx', `${destructure}\n${evalCode}`);
+          const fn = new Function('__ctx', `${destructure}${evalCode}`);
           const result = fn(context);
           if (result !== undefined) {
             console.log(' ', result);
           }
         } catch (e) {
           // If return-wrapping fails, fall back to plain execution
-          const declaredInCode = new Set();
-          for (const m of code.matchAll(/\bfunction\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          for (const m of code.matchAll(/\bconst\s+([a-zA-Z_]\w*)/g)) declaredInCode.add(m[1]);
-          const ctxKeys = Object.keys(context).filter(k => !declaredInCode.has(k));
-          const destructure = ctxKeys.length > 0 ? `const {${ctxKeys.join(',')}} = __ctx;` : '';
-          const fn = new Function('__ctx', `${destructure}\n${code}`);
+          const fallbackCode = code + (allSave ? '\n' + allSave : '');
+          const fn = new Function('__ctx', `${destructure}${fallbackCode}`);
           fn(context);
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tova",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "Tova — a modern programming language that transpiles to JavaScript, unifying frontend and backend",
   "type": "module",
   "main": "src/index.js",

package/src/analyzer/analyzer.js

@@ -2006,7 +2006,14 @@ export class Analyzer {
     const hasSpread = node.arguments.some(a => a.type === 'SpreadExpression');
     if (hasSpread) return;
 
-    const actualCount = node.arguments.length;
+    // Named arguments are collapsed into a single object at codegen
+    const hasNamedArgs = node.arguments.some(a => a.type === 'NamedArgument');
+    if (hasNamedArgs) {
+      const positionalCount = node.arguments.filter(a => a.type !== 'NamedArgument').length;
+      var actualCount = positionalCount + 1; // named args become one object
+    } else {
+      var actualCount = node.arguments.length;
+    }
     const name = node.callee.name;
 
     if (actualCount > fnSym._totalParamCount) {
@@ -2144,7 +2151,7 @@ export class Analyzer {
         name: m.name,
         paramTypes: (m.params || []).map(p => typeAnnotationToType(p.typeAnnotation)),
         returnType: typeAnnotationToType(m.returnType),
-        paramCount: (m.params || []).length,
+        paramCount: (m.params || []).filter(p => p.name !== 'self').length,
       }));
       this.currentScope.define(node.name, sym);
 

package/src/codegen/base-codegen.js

@@ -1462,6 +1462,9 @@ export class BaseCodegen {
 
   genObjectLiteral(node) {
     const props = node.properties.map(p => {
+      if (p.spread) {
+        return `...${this.genExpression(p.argument)}`;
+      }
       if (p.shorthand) {
         return this.genExpression(p.key);
       }
@@ -1590,7 +1593,7 @@ export class BaseCodegen {
       const fieldNames = node.variants.map(f => f.name);
       const params = fieldNames.join(', ');
       const obj = fieldNames.map(f => `${f}`).join(', ');
-      lines.push(`${this.i()}${exportPrefix}function ${node.name}(${params}) { return { ${obj} }; }`);
+      lines.push(`${this.i()}${exportPrefix}function ${node.name}(${params}) { return Object.assign(Object.create(${node.name}.prototype), { ${obj} }); }`);
     }
 
     // Derive clause: generate methods
@@ -1636,21 +1639,24 @@ export class BaseCodegen {
   genImplDeclaration(node) {
     const lines = [];
     for (const method of node.methods) {
+      const hasSelf = method.params.some(p => p.name === 'self');
       const params = method.params.filter(p => p.name !== 'self');
       const paramStr = this.genParams(params);
       const hasPropagate = this._containsPropagate(method.body);
       const asyncPrefix = method.isAsync ? 'async ' : '';
       this.pushScope();
+      if (hasSelf) this.declareVar('self');
       for (const p of params) {
         if (p.destructure) this._declareDestructureVars(p.destructure);
         else this.declareVar(p.name);
       }
       const body = this.genBlockBody(method.body);
       this.popScope();
+      const selfBinding = hasSelf ? `\n${this.i()}  const self = this;` : '';
       if (hasPropagate) {
-        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {\n${this.i()}  try {\n${body}\n${this.i()}  } catch (__e) {\n${this.i()}    if (__e && __e.__tova_propagate) return __e.value;\n${this.i()}    throw __e;\n${this.i()}  }\n${this.i()}};`);
+        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {${selfBinding}\n${this.i()}  try {\n${body}\n${this.i()}  } catch (__e) {\n${this.i()}    if (__e && __e.__tova_propagate) return __e.value;\n${this.i()}    throw __e;\n${this.i()}  }\n${this.i()}};`);
       } else {
-        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {\n${body}\n${this.i()}};`);
+        lines.push(`${this.i()}${node.typeName}.prototype.${method.name} = ${asyncPrefix}function(${paramStr}) {${selfBinding}\n${body}\n${this.i()}};`);
       }
     }
     return lines.join('\n');

package/src/lexer/lexer.js

@@ -435,6 +435,7 @@ export class Lexer {
           case '\\': current += '\\'; break;
           case '"': current += '"'; break;
           case '{': current += '{'; break;
+          case '}': current += '}'; break;
           default: current += '\\' + esc;
         }
         continue;

package/src/parser/parser.js

@@ -5,7 +5,7 @@ export class Parser {
   static MAX_EXPRESSION_DEPTH = 200;
 
   constructor(tokens, filename = '<stdin>') {
-    this.tokens = tokens.filter(t => t.type !== TokenType.NEWLINE && t.type !== TokenType.DOCSTRING);
+    this.tokens = tokens.filter(t => t.type !== TokenType.NEWLINE && t.type !== TokenType.DOCSTRING && t.type !== TokenType.SEMICOLON);
     this.rawTokens = tokens;
     this.filename = filename;
     this.pos = 0;
@@ -2846,6 +2846,25 @@ export class Parser {
     return new AST.ArrayLiteral(elements, l);
   }
 
+  _parseObjectProperty() {
+    // Spread property: ...expr
+    if (this.check(TokenType.SPREAD)) {
+      const sl = this.loc();
+      this.advance();
+      const argument = this.parseUnary();
+      return { spread: true, argument };
+    }
+    const key = this.parseExpression();
+    if (this.match(TokenType.COLON)) {
+      const value = this.parseExpression();
+      return { key, value, shorthand: false };
+    }
+    if (key.type === 'Identifier') {
+      return { key, value: key, shorthand: true };
+    }
+    this.error("Expected ':' in object literal");
+  }
+
   parseObjectOrDictComprehension() {
     const l = this.loc();
     this.expect(TokenType.LBRACE);
@@ -2855,6 +2874,17 @@ export class Parser {
       return new AST.ObjectLiteral([], l);
     }
 
+    // Check for spread as first element — always an object literal
+    if (this.check(TokenType.SPREAD)) {
+      const properties = [this._parseObjectProperty()];
+      while (this.match(TokenType.COMMA)) {
+        if (this.check(TokenType.RBRACE)) break;
+        properties.push(this._parseObjectProperty());
+      }
+      this.expect(TokenType.RBRACE, "Expected '}'");
+      return new AST.ObjectLiteral(properties, l);
+    }
+
     // Try to parse first key: value pair
     const firstKey = this.parseExpression();
 
@@ -2883,10 +2913,7 @@ export class Parser {
       const properties = [{ key: firstKey, value: firstValue, shorthand: false }];
       while (this.match(TokenType.COMMA)) {
         if (this.check(TokenType.RBRACE)) break;
-        const key = this.parseExpression();
-        this.expect(TokenType.COLON, "Expected ':' in object literal");
-        const value = this.parseExpression();
-        properties.push({ key, value, shorthand: false });
+        properties.push(this._parseObjectProperty());
       }
 
       this.expect(TokenType.RBRACE, "Expected '}'");
@@ -2898,15 +2925,7 @@ export class Parser {
       const properties = [{ key: firstKey, value: firstKey, shorthand: true }];
       while (this.match(TokenType.COMMA)) {
         if (this.check(TokenType.RBRACE)) break;
-        const key = this.parseExpression();
-        if (this.match(TokenType.COLON)) {
-          // Colon property: y: 10
-          const value = this.parseExpression();
-          properties.push({ key, value, shorthand: false });
-        } else {
-          // Shorthand property: y
-          properties.push({ key, value: key, shorthand: true });
-        }
+        properties.push(this._parseObjectProperty());
       }
       this.expect(TokenType.RBRACE, "Expected '}'");
       return new AST.ObjectLiteral(properties, l);

package/src/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-runtime.js — do not edit
-export const VERSION = "0.2.7";
+export const VERSION = "0.2.9";