tova 0.5.1 → 0.8.2

package/src/parser/{client-parser.js → browser-parser.js}

@@ -1,42 +1,55 @@
-// Client-specific parser methods for the Tova language
-// Extracted from parser.js for lazy loading — only loaded when client { } blocks are encountered.
+// Browser-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when browser { } blocks are encountered.
 
 import { TokenType, Keywords } from '../lexer/tokens.js';
 import * as AST from './ast.js';
+import { installFormParser } from './form-parser.js';
 
-export function installClientParser(ParserClass) {
-  if (ParserClass.prototype._clientParserInstalled) return;
-  ParserClass.prototype._clientParserInstalled = true;
+export function installBrowserParser(ParserClass) {
+  if (ParserClass.prototype._browserParserInstalled) return;
+  ParserClass.prototype._browserParserInstalled = true;
 
-  ParserClass.prototype.parseClientBlock = function() {
+  installFormParser(ParserClass);
+
+  ParserClass.prototype.parseBrowserBlock = function() {
     const l = this.loc();
-    this.expect(TokenType.CLIENT);
-    // Optional block name: client "admin" { }
+    // Capture the keyword value before consuming for deprecation warning
+    const keyword = this.current().value;
+    this.expect(TokenType.BROWSER);
+    if (keyword === 'client') {
+      this.warnings = this.warnings || [];
+      this.warnings.push({
+        message: "`client` block is deprecated, use `browser` instead",
+        loc: l,
+      });
+    }
+    // Optional block name: browser "admin" { }
     let name = null;
     if (this.check(TokenType.STRING)) {
       name = this.advance().value;
     }
-    this.expect(TokenType.LBRACE, "Expected '{' after 'client'");
+    this.expect(TokenType.LBRACE, "Expected '{' after 'browser'");
     const body = [];
     while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
       try {
-        const stmt = this.parseClientStatement();
+        const stmt = this.parseBrowserStatement();
         if (stmt) body.push(stmt);
       } catch (e) {
         this.errors.push(e);
         this._synchronizeBlock();
       }
     }
-    this.expect(TokenType.RBRACE, "Expected '}' to close client block");
-    return new AST.ClientBlock(body, l, name);
+    this.expect(TokenType.RBRACE, "Expected '}' to close browser block");
+    return new AST.BrowserBlock(body, l, name);
   };
 
-  ParserClass.prototype.parseClientStatement = function() {
+  ParserClass.prototype.parseBrowserStatement = function() {
     if (this.check(TokenType.STATE)) return this.parseState();
     if (this.check(TokenType.COMPUTED)) return this.parseComputed();
     if (this.check(TokenType.EFFECT)) return this.parseEffect();
     if (this.check(TokenType.COMPONENT)) return this.parseComponent();
     if (this.check(TokenType.STORE)) return this.parseStore();
+    if (this.check(TokenType.FORM)) return this.parseFormDeclaration();
     return this.parseStatement();
   };
 
@@ -125,6 +138,8 @@ export function installClientParser(ParserClass) {
         body.push(this.parseEffect());
       } else if (this.check(TokenType.COMPONENT)) {
         body.push(this.parseComponent());
+      } else if (this.check(TokenType.FORM)) {
+        body.push(this.parseFormDeclaration());
       } else {
         body.push(this.parseStatement());
       }
@@ -242,7 +257,13 @@ export function installClientParser(ParserClass) {
     const l = this.loc();
     this.expect(TokenType.LESS, "Expected '<'");
 
-    const tag = this.expect(TokenType.IDENTIFIER, "Expected tag name").value;
+    // Accept identifiers and keywords as JSX tag names (e.g., <form>, <label>)
+    let tag;
+    if (this.check(TokenType.IDENTIFIER) || (this.peek().value in Keywords)) {
+      tag = this.advance().value;
+    } else {
+      tag = this.expect(TokenType.IDENTIFIER, "Expected tag name").value;
+    }
 
     // Parse attributes (including spread: {...expr})
     const attributes = [];
@@ -330,7 +351,13 @@ export function installClientParser(ParserClass) {
       if (this.check(TokenType.LESS) && this.peek(1).type === TokenType.SLASH) {
         this.advance(); // <
         this.advance(); // /
-        const closeTag = this.expect(TokenType.IDENTIFIER, "Expected closing tag name").value;
+        // Accept identifiers and keywords as JSX closing tag names (e.g., </form>)
+        let closeTag;
+        if (this.check(TokenType.IDENTIFIER) || (this.peek().value in Keywords)) {
+          closeTag = this.advance().value;
+        } else {
+          closeTag = this.expect(TokenType.IDENTIFIER, "Expected closing tag name").value;
+        }
         if (closeTag !== parentTag) {
           this.error(`Mismatched closing tag: expected </${parentTag}>, got </${closeTag}>`);
         }

package/src/parser/concurrency-ast.js

@@ -0,0 +1,15 @@
+// Concurrency-specific AST Node definitions for the Tova language
+// Extracted for lazy loading -- only loaded when concurrent { } blocks are used.
+
+/**
+ * spawn foo(args)
+ * spawn fn() { ... }
+ */
+export class SpawnExpression {
+  constructor(callee, args, loc) {
+    this.type = 'SpawnExpression';
+    this.callee = callee;       // Expression (function name or lambda)
+    this.arguments = args;      // Array of Expression
+    this.loc = loc;
+  }
+}

package/src/parser/concurrency-parser.js

@@ -0,0 +1,236 @@
+// Concurrency-specific parser methods for the Tova language
+// Extracted for lazy loading — only loaded when concurrent { } blocks are used.
+
+import { TokenType } from '../lexer/tokens.js';
+import * as AST from './ast.js';
+import { SpawnExpression } from './concurrency-ast.js';
+import { SelectStatement, SelectCase } from './select-ast.js';
+
+const CONCURRENT_MODES = new Set(['cancel_on_error', 'first', 'timeout']);
+
+export function installConcurrencyParser(ParserClass) {
+  if (ParserClass.prototype._concurrencyParserInstalled) return;
+  ParserClass.prototype._concurrencyParserInstalled = true;
+
+  /**
+   * Parse: concurrent [mode] { body }
+   *
+   * Modes:
+   *   concurrent { ... }                  — mode "all" (default)
+   *   concurrent cancel_on_error { ... }  — cancel siblings on first error
+   *   concurrent first { ... }            — return first result, cancel rest
+   *   concurrent timeout(ms) { ... }      — timeout after ms milliseconds
+   */
+  ParserClass.prototype.parseConcurrentBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'concurrent'
+
+    let mode = 'all';
+    let timeout = null;
+
+    // Check for mode modifier
+    if (this.check(TokenType.IDENTIFIER) && CONCURRENT_MODES.has(this.current().value)) {
+      const modeName = this.advance().value;
+      if (modeName === 'timeout') {
+        this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+        timeout = this.parseExpression();
+        this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+        mode = 'timeout';
+      } else {
+        mode = modeName;
+      }
+    }
+
+    this.expect(TokenType.LBRACE, "Expected '{' after 'concurrent'");
+
+    const body = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseStatement();
+        if (stmt) body.push(stmt);
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close concurrent block");
+    return new AST.ConcurrentBlock(mode, timeout, body, l);
+  };
+
+  // Save the original parseUnary method to extend it with spawn support
+  const _originalParseUnary = ParserClass.prototype.parseUnary;
+
+  /**
+   * Extend parseUnary to handle `spawn` as a prefix expression.
+   * spawn foo(args) → SpawnExpression
+   * Works like `await` but for concurrent task spawning.
+   */
+  ParserClass.prototype.parseUnary = function() {
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'spawn') {
+      // Distinguish concurrency `spawn foo()` from stdlib function call `spawn("cmd", args)`.
+      // If `spawn` is followed by `(`, it's a regular function call, not a concurrency keyword.
+      const next = this.peek(1);
+      if (next && next.type === TokenType.LPAREN) {
+        return _originalParseUnary.call(this);
+      }
+
+      const l = this.loc();
+      this.advance(); // consume 'spawn'
+
+      // Parse the expression after spawn (function call, lambda, etc.)
+      const expr = this.parseUnary();
+
+      // If it's a call expression, split into callee + args
+      if (expr.type === 'CallExpression') {
+        return new SpawnExpression(expr.callee, expr.arguments, l);
+      }
+
+      // Otherwise treat the whole expression as the callee with no args
+      return new SpawnExpression(expr, [], l);
+    }
+
+    return _originalParseUnary.call(this);
+  };
+
+  // Also support concurrent as a statement inside function bodies
+  const _originalParseStatement = ParserClass.prototype.parseStatement;
+
+  ParserClass.prototype.parseStatement = function() {
+    // Check for 'concurrent' at statement level (inside function bodies)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'concurrent') {
+      return this.parseConcurrentBlock();
+    }
+    // Check for 'select {' at statement level (disambiguate from select() function call)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'select'
+        && this.peek(1).type === TokenType.LBRACE) {
+      return this.parseSelectStatement();
+    }
+    return _originalParseStatement.call(this);
+  };
+
+  /**
+   * Parse: select { case1  case2  ... }
+   *
+   * Each case is one of:
+   *   binding from channel => body
+   *   _ from channel => body
+   *   channel.send(value) => body
+   *   timeout(ms) => body
+   *   _ => body
+   */
+  ParserClass.prototype.parseSelectStatement = function() {
+    const l = this.loc();
+    this.advance(); // consume 'select'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'select'");
+
+    const cases = [];
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        cases.push(this.parseSelectCase());
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close select block");
+    return new SelectStatement(cases, l);
+  };
+
+  ParserClass.prototype.parseSelectCase = function() {
+    const l = this.loc();
+
+    // timeout(ms) => body
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === 'timeout'
+        && this.peek(1).type === TokenType.LPAREN) {
+      this.advance(); // consume 'timeout'
+      this.expect(TokenType.LPAREN, "Expected '(' after 'timeout'");
+      const ms = this.parseExpression();
+      this.expect(TokenType.RPAREN, "Expected ')' after timeout value");
+      this.expect(TokenType.ARROW, "Expected '=>' after timeout");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('timeout', null, null, ms, body, l);
+    }
+
+    // _ => body (default case) — must check before _ from channel
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.ARROW) {
+      this.advance(); // consume '_'
+      this.expect(TokenType.ARROW, "Expected '=>' after '_'");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('default', null, null, null, body, l);
+    }
+
+    // _ from channel => body (wildcard receive)
+    if (this.check(TokenType.IDENTIFIER) && this.current().value === '_'
+        && this.peek(1).type === TokenType.FROM) {
+      this.advance(); // consume '_'
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, null, null, body, l);
+    }
+
+    // binding from channel => body (named receive)
+    if (this.check(TokenType.IDENTIFIER) && this.peek(1).type === TokenType.FROM) {
+      const binding = this.advance().value; // consume binding name
+      this.advance(); // consume 'from'
+      const channel = this._parseSelectChannel();
+      this.expect(TokenType.ARROW, "Expected '=>' after channel");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('receive', channel, binding, null, body, l);
+    }
+
+    // channel.send(value) => body (send case)
+    // Parse as expression, then check if it's a send call
+    const expr = this.parseExpression();
+    if (expr.type === 'CallExpression' && expr.callee.type === 'MemberExpression'
+        && expr.callee.property === 'send') {
+      this.expect(TokenType.ARROW, "Expected '=>' after send");
+      const body = this.parseSelectCaseBody();
+      return new SelectCase('send', expr.callee.object, null, expr.arguments[0], body, l);
+    }
+
+    throw this.error("Expected select case: 'binding from channel =>', 'timeout(ms) =>', 'channel.send(val) =>', or '_ =>'", l);
+  };
+
+  /**
+   * Parse a channel expression in a select receive case.
+   * Handles identifiers and member access chains (e.g., ch, obj.ch)
+   * without consuming '=>' as a lambda arrow.
+   */
+  ParserClass.prototype._parseSelectChannel = function() {
+    const l = this.loc();
+    let expr = new AST.Identifier(this.advance().value, l);
+    // Follow member access chains: ch.sub, obj.channels, etc.
+    while (this.check(TokenType.DOT)) {
+      this.advance(); // consume '.'
+      const prop = this.advance().value;
+      expr = new AST.MemberExpression(expr, prop, false, this.loc());
+    }
+    return expr;
+  };
+
+  ParserClass.prototype.parseSelectCaseBody = function() {
+    if (this.check(TokenType.LBRACE)) {
+      this.advance(); // consume '{'
+      const body = [];
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        try {
+          const stmt = this.parseStatement();
+          if (stmt) body.push(stmt);
+        } catch (e) {
+          this.errors.push(e);
+          this._synchronizeBlock();
+        }
+      }
+      this.expect(TokenType.RBRACE, "Expected '}' to close select case body");
+      return body;
+    }
+    // Single statement
+    const stmt = this.parseStatement();
+    return stmt ? [stmt] : [];
+  };
+}

package/src/parser/deploy-ast.js

@@ -0,0 +1,37 @@
+// Deploy-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when deploy { } blocks are used.
+
+export class DeployBlock {
+  constructor(body, loc, name = null) {
+    this.type = 'DeployBlock';
+    this.name = name;
+    this.body = body;
+    this.loc = loc;
+  }
+}
+
+export class DeployConfigField {
+  constructor(key, value, loc) {
+    this.type = 'DeployConfigField';
+    this.key = key;
+    this.value = value;
+    this.loc = loc;
+  }
+}
+
+export class DeployEnvBlock {
+  constructor(entries, loc) {
+    this.type = 'DeployEnvBlock';
+    this.entries = entries;
+    this.loc = loc;
+  }
+}
+
+export class DeployDbBlock {
+  constructor(engine, config, loc) {
+    this.type = 'DeployDbBlock';
+    this.engine = engine;
+    this.config = config;
+    this.loc = loc;
+  }
+}

package/src/parser/deploy-parser.js

@@ -0,0 +1,132 @@
+// Deploy-specific parser methods for the Tova language
+// Extracted from parser.js for lazy loading — only loaded when deploy { } blocks are encountered.
+
+import { TokenType } from '../lexer/tokens.js';
+import {
+  DeployBlock, DeployConfigField, DeployEnvBlock, DeployDbBlock,
+} from './deploy-ast.js';
+
+// Keywords that start sub-blocks (not config fields)
+const DEPLOY_SUB_BLOCK_KEYWORDS = new Set(['env', 'db']);
+
+export function installDeployParser(ParserClass) {
+  if (ParserClass.prototype._deployParserInstalled) return;
+  ParserClass.prototype._deployParserInstalled = true;
+
+  ParserClass.prototype.parseDeployBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'deploy'
+
+    // Deploy blocks REQUIRE a name
+    if (!this.check(TokenType.STRING)) {
+      throw this.error("Deploy block requires a name (e.g., deploy \"prod\" { })");
+    }
+    const name = this.advance().value;
+
+    this.expect(TokenType.LBRACE, "Expected '{' after deploy name");
+    const body = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      try {
+        const stmt = this.parseDeployStatement();
+        if (stmt) {
+          if (Array.isArray(stmt)) {
+            body.push(...stmt);
+          } else {
+            body.push(stmt);
+          }
+        }
+      } catch (e) {
+        this.errors.push(e);
+        this._synchronizeBlock();
+      }
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close deploy block");
+    return new DeployBlock(body, l, name);
+  };
+
+  ParserClass.prototype.parseDeployStatement = function() {
+    if (this.check(TokenType.IDENTIFIER)) {
+      const val = this.current().value;
+
+      // env { KEY: "value" }
+      if (val === 'env') {
+        return this.parseDeployEnvBlock();
+      }
+
+      // db { postgres { } redis { } }
+      if (val === 'db') {
+        return this.parseDeployDbBlock();
+      }
+
+      // Config field: identifier: value (e.g., domain: "myapp.com")
+      if (this.peek(1).type === TokenType.COLON && !DEPLOY_SUB_BLOCK_KEYWORDS.has(val)) {
+        return this.parseDeployConfigField();
+      }
+    }
+
+    // Handle keyword tokens used as config keys (e.g., server: "root@example.com")
+    // In deploy blocks, 'server' is lexed as TokenType.SERVER, not IDENTIFIER
+    if (this.check(TokenType.SERVER) && this.peek(1).type === TokenType.COLON) {
+      return this.parseDeployConfigField();
+    }
+
+    // Deploy blocks only contain config fields, env, and db sub-blocks
+    throw this.error(`Unexpected token in deploy block: "${this.current().value || this.current().type}"`);
+  };
+
+  ParserClass.prototype.parseDeployConfigField = function() {
+    const l = this.loc();
+    const key = this.advance().value; // consume identifier (e.g., 'server')
+    this.expect(TokenType.COLON, "Expected ':' after config key");
+    const value = this.parseExpression();
+    return new DeployConfigField(key, value, l);
+  };
+
+  ParserClass.prototype.parseDeployEnvBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'env'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'env'");
+    const entries = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const key = this.expect(TokenType.IDENTIFIER, "Expected env variable name").value;
+      this.expect(TokenType.COLON, "Expected ':' after env key");
+      const value = this.parseExpression();
+      entries.push({ key, value });
+      this.match(TokenType.COMMA);
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close env block");
+    return new DeployEnvBlock(entries, l);
+  };
+
+  ParserClass.prototype.parseDeployDbBlock = function() {
+    const l = this.loc();
+    this.advance(); // consume 'db'
+    this.expect(TokenType.LBRACE, "Expected '{' after 'db'");
+    const blocks = [];
+
+    while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+      const engineLoc = this.loc();
+      const engine = this.expect(TokenType.IDENTIFIER, "Expected database engine name (e.g., postgres, redis)").value;
+      this.expect(TokenType.LBRACE, `Expected '{' after '${engine}'`);
+      const config = {};
+
+      while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
+        const key = this.expect(TokenType.IDENTIFIER, "Expected config key").value;
+        this.expect(TokenType.COLON, "Expected ':' after config key");
+        const value = this.parseExpression();
+        config[key] = value;
+        this.match(TokenType.COMMA);
+      }
+
+      this.expect(TokenType.RBRACE, `Expected '}' to close ${engine} config`);
+      blocks.push(new DeployDbBlock(engine, config, engineLoc));
+    }
+
+    this.expect(TokenType.RBRACE, "Expected '}' to close db block");
+    return blocks;
+  };
+}

package/src/parser/edge-ast.js

@@ -0,0 +1,83 @@
+// Edge/serverless-specific AST Node definitions for the Tova language
+// Extracted for lazy loading — only loaded when edge { } blocks are used.
+
+export class EdgeConfigField {
+  constructor(key, value, loc) {
+    this.type = 'EdgeConfigField';
+    this.key = key;       // string — "target", "name", etc.
+    this.value = value;   // Expression (StringLiteral, etc.)
+    this.loc = loc;
+  }
+}
+
+export class EdgeKVDeclaration {
+  constructor(name, config, loc) {
+    this.type = 'EdgeKVDeclaration';
+    this.name = name;       // string — binding name (e.g., "CACHE")
+    this.config = config;   // object or null — { ttl: Expression } etc.
+    this.loc = loc;
+  }
+}
+
+export class EdgeSQLDeclaration {
+  constructor(name, config, loc) {
+    this.type = 'EdgeSQLDeclaration';
+    this.name = name;       // string — binding name (e.g., "DB")
+    this.config = config;   // object or null
+    this.loc = loc;
+  }
+}
+
+export class EdgeStorageDeclaration {
+  constructor(name, config, loc) {
+    this.type = 'EdgeStorageDeclaration';
+    this.name = name;       // string — binding name (e.g., "UPLOADS")
+    this.config = config;   // object or null
+    this.loc = loc;
+  }
+}
+
+export class EdgeQueueDeclaration {
+  constructor(name, config, loc) {
+    this.type = 'EdgeQueueDeclaration';
+    this.name = name;       // string — binding name (e.g., "EMAILS")
+    this.config = config;   // object or null
+    this.loc = loc;
+  }
+}
+
+export class EdgeEnvDeclaration {
+  constructor(name, defaultValue, loc) {
+    this.type = 'EdgeEnvDeclaration';
+    this.name = name;             // string — env var name
+    this.defaultValue = defaultValue; // Expression or null
+    this.loc = loc;
+  }
+}
+
+export class EdgeSecretDeclaration {
+  constructor(name, loc) {
+    this.type = 'EdgeSecretDeclaration';
+    this.name = name;       // string — secret name
+    this.loc = loc;
+  }
+}
+
+export class EdgeScheduleDeclaration {
+  constructor(name, cron, body, loc) {
+    this.type = 'EdgeScheduleDeclaration';
+    this.name = name;       // string — schedule name
+    this.cron = cron;       // string — cron expression
+    this.body = body;       // BlockStatement
+    this.loc = loc;
+  }
+}
+
+export class EdgeConsumeDeclaration {
+  constructor(queue, handler, loc) {
+    this.type = 'EdgeConsumeDeclaration';
+    this.queue = queue;     // string — queue binding name
+    this.handler = handler; // FunctionDeclaration or LambdaExpression
+    this.loc = loc;
+  }
+}