tova 0.7.0 → 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/deploy-analyzer.js

@@ -0,0 +1,44 @@
+// Deploy-specific analyzer methods for the Tova language
+// Extracted from analyzer.js for lazy loading — only loaded when deploy { } blocks are encountered.
+
+const KNOWN_DEPLOY_FIELDS = new Set([
+  'server', 'domain', 'instances', 'memory', 'branch',
+  'health', 'health_interval', 'health_timeout',
+  'restart_on_failure', 'keep_releases',
+]);
+
+const REQUIRED_DEPLOY_FIELDS = ['server', 'domain'];
+
+export function installDeployAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._deployAnalyzerInstalled) return;
+  AnalyzerClass.prototype._deployAnalyzerInstalled = true;
+
+  AnalyzerClass.prototype.visitDeployBlock = function(node) {
+    // Collect config field keys present in the deploy block body
+    const presentFields = new Set();
+    for (const stmt of node.body) {
+      if (stmt.type === 'DeployConfigField') {
+        // Validate unknown fields
+        if (!KNOWN_DEPLOY_FIELDS.has(stmt.key)) {
+          this.error(
+            `Unknown deploy config field "${stmt.key}"`,
+            stmt.loc,
+            `Known fields: ${[...KNOWN_DEPLOY_FIELDS].join(', ')}`
+          );
+        }
+        presentFields.add(stmt.key);
+      }
+      // DeployEnvBlock and DeployDbBlock are valid sub-blocks — no additional validation needed
+    }
+
+    // Validate required fields
+    for (const required of REQUIRED_DEPLOY_FIELDS) {
+      if (!presentFields.has(required)) {
+        this.error(
+          `Deploy block "${node.name}" is missing required field "${required}"`,
+          node.loc
+        );
+      }
+    }
+  };
+}

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') {