tova 0.8.2 → 0.9.4

package/src/analyzer/browser-analyzer.js

@@ -12,7 +12,23 @@ export function installBrowserAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitBrowserBlock = function(node) {
     const prevScope = this.currentScope;
-    this.currentScope = this.currentScope.child('browser');
+    let browserScope = null;
+    for (const ch of this.currentScope.children) {
+      if (ch.context === 'browser') { browserScope = ch; break; }
+    }
+    const isFirst = !browserScope;
+    this.currentScope = browserScope || this.currentScope.child('browser');
+
+    // On first browser block, pre-register state/computed/function names from ALL
+    // browser blocks so cross-file references resolve regardless of file order.
+    if (isFirst && this.ast && this.ast.body) {
+      for (const topNode of this.ast.body) {
+        if (topNode.type === 'BrowserBlock') {
+          this._preRegisterBrowserDecls(topNode.body);
+        }
+      }
+    }
+
     try {
       for (const stmt of node.body) {
         this.visitNode(stmt);
@@ -22,9 +38,26 @@ export function installBrowserAnalyzer(AnalyzerClass) {
     }
   };
 
+  AnalyzerClass.prototype._preRegisterBrowserDecls = function(stmts) {
+    for (const stmt of stmts) {
+      const name = stmt.name;
+      if (!name) continue;
+      let kind = null;
+      if (stmt.type === 'StateDeclaration') kind = 'state';
+      else if (stmt.type === 'ComputedDeclaration') kind = 'computed';
+      else if (stmt.type === 'FunctionDeclaration') kind = 'function';
+      else if (stmt.type === 'ComponentDeclaration') kind = 'component';
+      if (kind && !this.currentScope.symbols.has(name)) {
+        const sym = new Symbol(name, kind, stmt.typeAnnotation || null, kind === 'state', stmt.loc);
+        sym._forward = true;
+        try { this.currentScope.define(name, sym); } catch (e) { /* ignore */ }
+      }
+    }
+  };
+
   AnalyzerClass.prototype.visitStateDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'browser') {
+    if (ctx !== 'browser' && !this._inPubComponent) {
       this.error(`'state' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
@@ -38,7 +71,7 @@ export function installBrowserAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitComputedDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'browser') {
+    if (ctx !== 'browser' && !this._inPubComponent) {
       this.error(`'computed' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
@@ -52,7 +85,7 @@ export function installBrowserAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitEffectDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'browser') {
+    if (ctx !== 'browser' && !this._inPubComponent) {
       this.error(`'effect' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this.visitNode(node.body);
@@ -60,19 +93,32 @@ export function installBrowserAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitComponentDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'browser') {
+    if (ctx !== 'browser' && !node.isPublic) {
       this.error(`'component' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
-    this._checkNamingConvention(node.name, 'component', node.loc);
+    // Skip naming convention check for compound components (e.g. Dialog.Title)
+    // since "Dialog.Title" isn't a single PascalCase identifier
+    if (!node.parent) {
+      this._checkNamingConvention(node.name, 'component', node.loc);
+    }
+    // For compound components, register with the parent name (already defined)
+    // and use the full name for the symbol definition
+    const symbolName = node.name;
     try {
-      this.currentScope.define(node.name,
-        new Symbol(node.name, 'component', null, false, node.loc));
+      this.currentScope.define(symbolName,
+        new Symbol(symbolName, 'component', null, false, node.loc));
     } catch (e) {
       this.error(e.message);
     }
 
     const prevScope = this.currentScope;
     this.currentScope = this.currentScope.child('function');
+    // Store component prop names for variant() validation in style blocks
+    const prevComponentProps = this._currentComponentProps;
+    this._currentComponentProps = node.params.map(p => p.name);
+    // Track pub component context so state/computed/effect are allowed inside
+    const prevInPubComponent = this._inPubComponent;
+    if (node.isPublic) this._inPubComponent = true;
     for (const param of node.params) {
       try {
         this.currentScope.define(param.name,
@@ -86,6 +132,8 @@ export function installBrowserAnalyzer(AnalyzerClass) {
         this.visitNode(child);
       }
     } finally {
+      this._currentComponentProps = prevComponentProps;
+      this._inPubComponent = prevInPubComponent;
       this.currentScope = prevScope;
     }
   };

package/src/analyzer/scope.js

@@ -28,6 +28,13 @@ export class Scope {
       const existing = this.symbols.get(name);
       // Allow user code to shadow builtins
       if (existing.kind === 'builtin') {
+        if (existing.used) symbol.used = true;
+        this.symbols.set(name, symbol);
+        return;
+      }
+      // Allow real definitions to overwrite forward-declared symbols
+      if (existing._forward) {
+        if (existing.used) symbol.used = true;
         this.symbols.set(name, symbol);
         return;
       }

package/src/analyzer/server-analyzer.js

@@ -37,7 +37,22 @@ export function installServerAnalyzer(AnalyzerClass) {
     const prevScope = this.currentScope;
     const prevServerBlockName = this._currentServerBlockName;
     this._currentServerBlockName = node.name || null;
-    this.currentScope = this.currentScope.child('server');
+    let serverScope = null;
+    for (const ch of this.currentScope.children) {
+      if (ch.context === 'server') { serverScope = ch; break; }
+    }
+    const isFirst = !serverScope;
+    this.currentScope = serverScope || this.currentScope.child('server');
+
+    // On first server block, pre-register function/var/type names from ALL
+    // server blocks so cross-file references resolve regardless of file order.
+    if (isFirst && this.ast && this.ast.body) {
+      for (const topNode of this.ast.body) {
+        if (topNode.type === 'ServerBlock') {
+          this._preRegisterServerDecls(topNode.body);
+        }
+      }
+    }
 
     try {
       // Register peer server block names as valid identifiers in this scope
@@ -76,6 +91,23 @@ export function installServerAnalyzer(AnalyzerClass) {
     }
   };
 
+  AnalyzerClass.prototype._preRegisterServerDecls = function(stmts) {
+    for (const stmt of stmts) {
+      const name = stmt.name;
+      if (!name) continue;
+      let kind = null;
+      if (stmt.type === 'FunctionDeclaration') kind = 'function';
+      else if (stmt.type === 'VarDeclaration') kind = 'variable';
+      else if (stmt.type === 'TypeDeclaration') kind = 'type';
+      else if (stmt.type === 'ModelDeclaration') kind = 'type';
+      if (kind && !this.currentScope.symbols.has(name)) {
+        const sym = new Symbol(name, kind, stmt.typeAnnotation || null, kind === 'variable', stmt.loc);
+        sym._forward = true;
+        try { this.currentScope.define(name, sym); } catch (e) { /* ignore */ }
+      }
+    }
+  };
+
   AnalyzerClass.prototype.visitRouteDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
     if (ctx !== 'server') {

package/src/codegen/base-codegen.js

@@ -189,10 +189,25 @@ export class BaseCodegen {
   // Track a builtin and its transitive dependencies from the stdlib dependency graph
   _trackBuiltin(name) {
     this._usedBuiltins.add(name);
-    const deps = STDLIB_DEPS[name];
-    if (deps) {
-      for (const dep of deps) {
-        this._usedBuiltins.add(dep);
+    // Check if this name or any transitive dependency requires Result/Option
+    if (name === 'Ok' || name === 'Err' || name === 'Some' || name === 'None') {
+      this._needsResultOption = true;
+    }
+    // Resolve transitive deps using a queue (e.g., iter -> Seq -> Some/None)
+    const queue = [name];
+    while (queue.length > 0) {
+      const current = queue.pop();
+      const deps = STDLIB_DEPS[current];
+      if (deps) {
+        for (const dep of deps) {
+          if (!this._usedBuiltins.has(dep)) {
+            this._usedBuiltins.add(dep);
+            queue.push(dep); // resolve further transitive deps
+          }
+          if (dep === 'Ok' || dep === 'Err' || dep === 'Some' || dep === 'None') {
+            this._needsResultOption = true;
+          }
+        }
       }
     }
   }
@@ -316,9 +331,12 @@ export class BaseCodegen {
           return this._paramSubstitutions.get(node.name);
         }
         // Track builtin identifier usage (e.g., None used without call)
+        // Use _trackBuiltin to resolve transitive deps (including Result/Option)
         if (BUILTIN_NAMES.has(node.name)) {
-          this._usedBuiltins.add(node.name);
+          this._trackBuiltin(node.name);
         }
+        // Ok/Err/Some/None are in RESULT_OPTION, not BUILTIN_FUNCTIONS,
+        // so they need a separate check for _needsResultOption
         if (node.name === 'Ok' || node.name === 'Err' || node.name === 'Some' || node.name === 'None') {
           this._needsResultOption = true;
         }
@@ -619,7 +637,14 @@ export class BaseCodegen {
     }).join(', ');
   }
 
+  _rewriteImportSource(node) {
+    if (node.source.startsWith('tova:')) {
+      node.source = './runtime/' + node.source.slice(5) + '.js';
+    }
+  }
+
   genImport(node) {
+    this._rewriteImportSource(node);
     for (const s of node.specifiers) this.declareVar(s.local);
     const specs = node.specifiers.map(s => {
       if (s.imported !== s.local) return `${s.imported} as ${s.local}`;
@@ -629,11 +654,13 @@ export class BaseCodegen {
   }
 
   genImportDefault(node) {
+    this._rewriteImportSource(node);
     this.declareVar(node.local);
     return `${this.i()}import ${node.local} from ${JSON.stringify(node.source)};`;
   }
 
   genImportWildcard(node) {
+    this._rewriteImportSource(node);
     this.declareVar(node.local);
     return `${this.i()}import * as ${node.local} from ${JSON.stringify(node.source)};`;
   }
@@ -1522,6 +1549,10 @@ export class BaseCodegen {
       if (node.callee.name === 'iter') {
         this._needsResultOption = true; // Seq.first()/find() return Option
       }
+      // LRUCache.get() returns Option — needs Result/Option
+      if (node.callee.name === 'LRUCache') {
+        this._needsResultOption = true;
+      }
 
       // Inline string/collection builtins to direct method calls
       const inlined = this._tryInlineBuiltin(node);
@@ -1534,19 +1565,24 @@ export class BaseCodegen {
         BUILTIN_NAMES.has(node.callee.object.name)) {
       const ns = node.callee.object.name;
       this._trackBuiltin(ns);
-      // Namespaces that depend on Ok/Err need Result/Option
+      // Namespaces that depend on Ok/Err/Some/None need Result/Option
       const deps = STDLIB_DEPS[ns];
-      if (deps && (deps.includes('Ok') || deps.includes('Err'))) {
+      if (deps && (deps.includes('Ok') || deps.includes('Err') || deps.includes('Some') || deps.includes('None'))) {
         this._needsResultOption = true;
       }
     }
 
     // Check for table operation calls with column expressions
     const hasColumnExprs = node.arguments.some(a => this._containsColumnExpr(a));
-    if (hasColumnExprs || (node.callee.type === 'Identifier' && ['agg', 'table_agg'].includes(node.callee.name))) {
+    if (hasColumnExprs || (node.callee.type === 'Identifier' && ['agg', 'table_agg', 'window', 'table_window'].includes(node.callee.name))) {
       const tableArgs = this._genTableCallArgs(node);
       if (tableArgs) {
-        const callee = this.genExpression(node.callee);
+        let callee = this.genExpression(node.callee);
+        // Remap window → table_window to avoid browser global conflict
+        if (node.callee.type === 'Identifier' && node.callee.name === 'window') {
+          callee = 'table_window';
+          this._usedBuiltins.add('table_window');
+        }
         return `${callee}(${tableArgs.join(', ')})`;
       }
     }
@@ -1555,6 +1591,15 @@ export class BaseCodegen {
     const hasNamedArgs = node.arguments.some(a => a.type === 'NamedArgument');
 
     if (hasNamedArgs) {
+      // Check if callee is a type/variant constructor — reorder named args to positional
+      const calleeName = node.callee.type === 'Identifier' ? node.callee.name : null;
+      const fieldOrder = calleeName ? this._variantFields[calleeName] : null;
+
+      if (fieldOrder) {
+        const result = this._reorderNamedArgsToPositional(node.arguments, fieldOrder);
+        return `${callee}(${result.join(', ')})`;
+      }
+
       const allNamed = node.arguments.every(a => a.type === 'NamedArgument');
       if (allNamed) {
         // All named args → single object argument
@@ -1970,13 +2015,18 @@ export class BaseCodegen {
     if (right.type === 'CallExpression') {
       // Check for table operations with column expressions
       const hasColumnExprs = right.arguments.some(a => this._containsColumnExpr(a));
-      if (hasColumnExprs || (right.callee.type === 'Identifier' && ['agg', 'table_agg'].includes(right.callee.name))) {
+      if (hasColumnExprs || (right.callee.type === 'Identifier' && ['agg', 'table_agg', 'window', 'table_window'].includes(right.callee.name))) {
         const tableArgs = this._genTableCallArgs(right);
         if (tableArgs) {
-          const callee = this.genExpression(right.callee);
-          // Track builtin usage
+          let callee = this.genExpression(right.callee);
+          // Remap window → table_window to avoid browser global conflict
+          if (right.callee.type === 'Identifier' && right.callee.name === 'window') {
+            callee = 'table_window';
+            this._usedBuiltins.add('table_window');
+          }
+          // Track builtin usage (with dependency resolution)
           if (right.callee.type === 'Identifier' && BUILTIN_NAMES.has(right.callee.name)) {
-            this._usedBuiltins.add(right.callee.name);
+            this._trackBuiltin(right.callee.name);
           }
           return `${callee}(${[left, ...tableArgs].join(', ')})`;
         }
@@ -2128,6 +2178,33 @@ export class BaseCodegen {
     return this.genExpression(node);
   }
 
+  // Reorder named args to positional order for type/variant constructors
+  _reorderNamedArgsToPositional(args, fieldOrder) {
+    const slots = new Array(fieldOrder.length);
+    let positionalIndex = 0;
+    // First pass: place positional args in order
+    for (const arg of args) {
+      if (arg.type !== 'NamedArgument') {
+        slots[positionalIndex] = this.genExpression(arg);
+        positionalIndex++;
+      }
+    }
+    // Second pass: place named args in their field's slot
+    for (const arg of args) {
+      if (arg.type === 'NamedArgument') {
+        const idx = fieldOrder.indexOf(arg.name);
+        if (idx !== -1) {
+          slots[idx] = this.genExpression(arg.value);
+        } else {
+          // Unknown field — emit as-is (analyzer will warn)
+          slots[positionalIndex] = this.genExpression(arg.value);
+          positionalIndex++;
+        }
+      }
+    }
+    return slots.filter(s => s !== undefined);
+  }
+
   // Override genCallExpression to handle table operations with column expressions
   _genTableCallArgs(node) {
     const calleeName = node.callee.type === 'Identifier' ? node.callee.name : null;
@@ -2226,6 +2303,52 @@ export class BaseCodegen {
       return parts;
     }
 
+    // window() / table_window() — partition_by/order_by/desc are meta, rest are window fns
+    if (calleeName === 'window' || calleeName === 'table_window') {
+      const META_KEYS = new Set(['partition_by', 'order_by', 'desc']);
+      const optParts = [];
+      const winParts = [];
+      for (const a of node.arguments) {
+        if (a.type === 'NamedArgument') {
+          if (META_KEYS.has(a.name)) {
+            // Meta keys: partition_by → partition, order_by → order
+            const key = a.name === 'partition_by' ? 'partition' : a.name === 'order_by' ? 'order' : a.name;
+            if (a.name === 'desc') {
+              optParts.push(`desc: ${this.genExpression(a.value)}`);
+            } else if (this._containsColumnExpr(a.value)) {
+              optParts.push(`${key}: (__row) => ${this._genColumnBody(a.value)}`);
+            } else {
+              optParts.push(`${key}: ${this.genExpression(a.value)}`);
+            }
+          } else {
+            // Window function column
+            const val = a.value;
+            if (val.type === 'CallExpression' && val.callee.type === 'Identifier') {
+              const fnName = val.callee.name;
+              const winFn = `win_${fnName}`;
+              const WIN_FNS = ['row_number', 'rank', 'dense_rank', 'percent_rank', 'ntile',
+                'lag', 'lead', 'first_value', 'last_value',
+                'running_sum', 'running_count', 'running_avg', 'running_min', 'running_max',
+                'moving_avg'];
+              if (WIN_FNS.includes(fnName)) {
+                this._usedBuiltins.add(winFn);
+                const innerArgs = val.arguments.map(ia => {
+                  if (this._containsColumnExpr(ia)) {
+                    return `(__row) => ${this._genColumnBody(ia)}`;
+                  }
+                  return this.genExpression(ia);
+                });
+                winParts.push(`${a.name}: ${winFn}(${innerArgs.join(', ')})`);
+                continue;
+              }
+            }
+            winParts.push(`${a.name}: ${this.genExpression(a.value)}`);
+          }
+        }
+      }
+      return [`{ ${optParts.join(', ')} }`, `{ ${winParts.join(', ')} }`];
+    }
+
     // drop_nil/fill_nil — column expression compiles to string or lambda
     if (calleeName === 'drop_nil' || calleeName === 'fill_nil') {
       return node.arguments.map(a => {
@@ -3138,6 +3261,7 @@ export class BaseCodegen {
     } else {
       this.declareVar(node.name);
       const fieldNames = node.variants.map(f => f.name);
+      this._variantFields[node.name] = fieldNames;
       const params = fieldNames.join(', ');
       const obj = fieldNames.map(f => `${f}`).join(', ');
       lines.push(`${this.i()}${exportPrefix}function ${node.name}(${params}) { return Object.assign(Object.create(${node.name}.prototype), { ${obj} }); }`);