tova 0.5.1 → 0.8.2

package/src/analyzer/analyzer.js

@@ -97,7 +97,7 @@ function levenshtein(a, b) {
 
 const _TOVA_RUNTIME = new Set([
   'Ok', 'Err', 'Some', 'None', 'Result', 'Option',
-  'db', 'server', 'client', 'shared',
+  'db', 'server', 'browser', 'client', 'shared',
 ]);
 
 // Pre-built static candidate set for Levenshtein suggestions (N1 optimization)
@@ -776,9 +776,9 @@ export class Analyzer {
     return this[methodName](node);
   }
 
-  _visitClientNode(node) {
-    // Ensure client analyzer is installed (may be called from visitExpression for JSX)
-    const plugin = BlockRegistry.get('client');
+  _visitBrowserNode(node) {
+    // Ensure browser analyzer is installed (may be called from visitExpression for JSX)
+    const plugin = BlockRegistry.get('browser');
     return plugin.analyzer.visit(this, node);
   }
 
@@ -900,6 +900,19 @@ export class Analyzer {
         }
         this.visitExpression(node.argument);
         return;
+      case 'SpawnExpression':
+        if (!this._concurrentDepth) {
+          this.warn("'spawn' should be used inside a 'concurrent' block", node.loc, null, {
+            code: 'W_SPAWN_OUTSIDE_CONCURRENT',
+          });
+        }
+        if (node.callee) this.visitExpression(node.callee);
+        if (node.arguments) {
+          for (const arg of node.arguments) {
+            this.visitExpression(arg);
+          }
+        }
+        return;
       case 'YieldExpression':
         if (node.argument) this.visitExpression(node.argument);
         return;
@@ -917,7 +930,7 @@ export class Analyzer {
         return;
       case 'JSXElement':
       case 'JSXFragment':
-        return this._visitClientNode(node);
+        return this._visitBrowserNode(node);
       // Column expressions (for table operations) — no semantic analysis needed
       case 'ColumnExpression':
         return;
@@ -1019,6 +1032,123 @@ export class Analyzer {
     }
   }
 
+  visitConcurrentBlock(node) {
+    // Validate mode
+    const validModes = new Set(['all', 'cancel_on_error', 'first', 'timeout']);
+    if (!validModes.has(node.mode)) {
+      this.warn(`Unknown concurrent block mode '${node.mode}'`, node.loc, null, {
+        code: 'W_UNKNOWN_CONCURRENT_MODE',
+      });
+    }
+
+    // Validate timeout
+    if (node.mode === 'timeout' && !node.timeout) {
+      this.warn("concurrent timeout mode requires a timeout value", node.loc, null, {
+        code: 'W_MISSING_TIMEOUT',
+      });
+    }
+
+    // Warn on empty block
+    if (node.body.length === 0) {
+      this.warn("Empty concurrent block", node.loc, null, {
+        code: 'W_EMPTY_CONCURRENT',
+      });
+    }
+
+    // Track concurrent depth for spawn validation
+    this._concurrentDepth = (this._concurrentDepth || 0) + 1;
+
+    // Visit body statements (concurrent block does NOT create a new scope —
+    // variables assigned inside should be visible after the block)
+    for (const stmt of node.body) {
+      this.visitNode(stmt);
+    }
+
+    // Check spawned functions for WASM compatibility — warn if mixed WASM/non-WASM
+    let hasWasm = false;
+    let hasNonWasm = false;
+    for (const stmt of node.body) {
+      const spawn = (stmt.type === 'Assignment' && stmt.values && stmt.values[0] && stmt.values[0].type === 'SpawnExpression')
+        ? stmt.values[0]
+        : (stmt.type === 'ExpressionStatement' && stmt.expression && stmt.expression.type === 'SpawnExpression')
+          ? stmt.expression
+          : null;
+      if (!spawn) continue;
+      const calleeName = spawn.callee && spawn.callee.type === 'Identifier' ? spawn.callee.name : null;
+      if (calleeName) {
+        const sym = this.currentScope.lookup(calleeName);
+        if (sym && sym.isWasm) {
+          hasWasm = true;
+        } else {
+          hasNonWasm = true;
+        }
+      } else {
+        // Lambda or complex expression — always non-WASM
+        hasNonWasm = true;
+      }
+    }
+    if (hasWasm && hasNonWasm) {
+      this.warn(
+        "concurrent block mixes @wasm and non-WASM tasks — non-WASM tasks will fall back to async JS execution",
+        node.loc, null, { code: 'W_SPAWN_WASM_FALLBACK' }
+      );
+    }
+
+    this._concurrentDepth--;
+  }
+
+  visitSelectStatement(node) {
+    if (node.cases.length === 0) {
+      this.warn("Empty select block", node.loc, null, {
+        code: 'W_EMPTY_SELECT',
+      });
+    }
+
+    let defaultCount = 0;
+    let timeoutCount = 0;
+    for (const c of node.cases) {
+      if (c.kind === 'default') defaultCount++;
+      if (c.kind === 'timeout') timeoutCount++;
+    }
+
+    if (defaultCount > 1) {
+      this.warn("select block has multiple default cases", node.loc, null, {
+        code: 'W_DUPLICATE_SELECT_DEFAULT',
+      });
+    }
+    if (timeoutCount > 1) {
+      this.warn("select block has multiple timeout cases", node.loc, null, {
+        code: 'W_DUPLICATE_SELECT_TIMEOUT',
+      });
+    }
+    if (defaultCount > 0 && timeoutCount > 0) {
+      this.warn("select block has both default and timeout — default makes timeout unreachable", node.loc, null, {
+        code: 'W_SELECT_DEFAULT_TIMEOUT',
+      });
+    }
+
+    // Visit each case's expressions and body
+    for (const c of node.cases) {
+      if (c.channel) this.visitNode(c.channel);
+      if (c.value) this.visitNode(c.value);
+
+      if (c.kind === 'receive' && c.binding) {
+        // Create scope for the binding variable
+        this.pushScope('select-case');
+        this.currentScope.define(c.binding,
+          new Symbol(c.binding, 'variable', null, false, c.loc));
+        for (const stmt of c.body) {
+          this.visitNode(stmt);
+        }
+        this.popScope();
+      } else {
+        for (const stmt of c.body) {
+          this.visitNode(stmt);
+        }
+      }
+    }
+  }
+
   _validateCliCrossBlock() {
     const cliBlocks = this.ast.body.filter(n => n.type === 'CliBlock');
     if (cliBlocks.length === 0) return;
@@ -1049,6 +1179,214 @@ export class Analyzer {
     }
   }
 
+  visitEdgeBlock(node) {
+    const validTargets = new Set(['cloudflare', 'deno', 'vercel', 'lambda', 'bun']);
+    const validConfigKeys = new Set(['target']);
+    const bindingNames = new Set();
+
+    // Binding support matrix per target
+    const BINDING_SUPPORT = {
+      cloudflare: { kv: true, sql: true, storage: true, queue: true },
+      deno:       { kv: true, sql: false, storage: false, queue: false },
+      vercel:     { kv: false, sql: false, storage: false, queue: false },
+      lambda:     { kv: false, sql: false, storage: false, queue: false },
+      bun:        { kv: false, sql: true, storage: false, queue: false },
+    };
+
+    // Targets that support schedule/consume/middleware
+    const SCHEDULE_TARGETS = new Set(['cloudflare', 'deno']);
+    const CONSUME_TARGETS = new Set(['cloudflare']);
+
+    // Determine target from config fields
+    let target = 'cloudflare';
+    for (const stmt of node.body) {
+      if (stmt.type === 'EdgeConfigField' && stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+        target = stmt.value.value;
+      }
+    }
+
+    this.pushScope('edge');
+
+    let kvCount = 0;
+    const queueNames = new Set();
+    const consumers = [];
+
+    for (const stmt of node.body) {
+      // Validate config fields
+      if (stmt.type === 'EdgeConfigField') {
+        if (!validConfigKeys.has(stmt.key)) {
+          this.warnings.push({
+            message: `Unknown edge config key '${stmt.key}' — valid keys are: ${[...validConfigKeys].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNKNOWN_EDGE_CONFIG',
+          });
+        }
+        if (stmt.key === 'target' && stmt.value.type === 'StringLiteral') {
+          if (!validTargets.has(stmt.value.value)) {
+            this.warnings.push({
+              message: `Unknown edge target '${stmt.value.value}' — valid targets are: ${[...validTargets].join(', ')}`,
+              loc: stmt.loc,
+              code: 'W_UNKNOWN_EDGE_TARGET',
+            });
+          }
+        }
+        continue;
+      }
+
+      // Check for duplicate binding names
+      if (stmt.type === 'EdgeKVDeclaration' || stmt.type === 'EdgeSQLDeclaration' ||
+          stmt.type === 'EdgeStorageDeclaration' || stmt.type === 'EdgeQueueDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Track queue names for consume validation
+      if (stmt.type === 'EdgeQueueDeclaration') {
+        queueNames.add(stmt.name);
+      }
+
+      // Check for duplicate env/secret names
+      if (stmt.type === 'EdgeEnvDeclaration' || stmt.type === 'EdgeSecretDeclaration') {
+        if (bindingNames.has(stmt.name)) {
+          this.warnings.push({
+            message: `Duplicate edge binding '${stmt.name}'`,
+            loc: stmt.loc,
+            code: 'W_DUPLICATE_EDGE_BINDING',
+          });
+        }
+        bindingNames.add(stmt.name);
+      }
+
+      // Unsupported binding warnings (per target)
+      const support = BINDING_SUPPORT[target] || BINDING_SUPPORT.cloudflare;
+      if (stmt.type === 'EdgeKVDeclaration' && !support.kv) {
+        this.warnings.push({
+          message: `KV binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_KV',
+        });
+      }
+      if (stmt.type === 'EdgeSQLDeclaration' && !support.sql) {
+        this.warnings.push({
+          message: `SQL binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_SQL',
+        });
+      }
+      if (stmt.type === 'EdgeStorageDeclaration' && !support.storage) {
+        this.warnings.push({
+          message: `Storage binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_STORAGE',
+        });
+      }
+      if (stmt.type === 'EdgeQueueDeclaration' && !support.queue) {
+        this.warnings.push({
+          message: `Queue binding '${stmt.name}' is not supported on target '${target}' — it will be stubbed as null`,
+          loc: stmt.loc,
+          code: 'W_UNSUPPORTED_QUEUE',
+        });
+      }
+
+      // Deno multi-KV warning
+      if (stmt.type === 'EdgeKVDeclaration') {
+        kvCount++;
+        if (kvCount > 1 && target === 'deno') {
+          this.warnings.push({
+            message: `Deno Deploy supports only one KV store — '${stmt.name}' will share the same store as the first KV binding`,
+            loc: stmt.loc,
+            code: 'W_DENO_MULTI_KV',
+          });
+        }
+      }
+
+      // Validate schedule cron expressions + target support
+      if (stmt.type === 'EdgeScheduleDeclaration') {
+        const parts = stmt.cron.split(/\s+/);
+        if (parts.length < 5 || parts.length > 6) {
+          this.warnings.push({
+            message: `Invalid cron expression '${stmt.cron}' — expected 5 or 6 space-separated fields`,
+            loc: stmt.loc,
+            code: 'W_INVALID_CRON',
+          });
+        }
+        if (!SCHEDULE_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Scheduled tasks are not supported on target '${target}' — schedule '${stmt.name}' will be ignored. Supported targets: ${[...SCHEDULE_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_SCHEDULE',
+          });
+        }
+      }
+
+      // Collect consume declarations for post-loop validation
+      if (stmt.type === 'EdgeConsumeDeclaration') {
+        consumers.push(stmt);
+        if (!CONSUME_TARGETS.has(target)) {
+          this.warnings.push({
+            message: `Queue consumers are not supported on target '${target}' — consume '${stmt.queue}' will be ignored. Supported targets: ${[...CONSUME_TARGETS].join(', ')}`,
+            loc: stmt.loc,
+            code: 'W_UNSUPPORTED_CONSUME',
+          });
+        }
+      }
+
+      // Visit child nodes — edge-specific types are noop in the registry,
+      // so explicitly visit bodies that contain statements
+      if (stmt.type === 'EdgeScheduleDeclaration' && stmt.body) {
+        for (const s of stmt.body.body || []) this.visitNode(s);
+      } else if (stmt.type === 'FunctionDeclaration' || stmt.type === 'RouteDeclaration') {
+        this.visitNode(stmt);
+      }
+    }
+
+    // Post-loop: validate consume references a declared queue
+    for (const consumer of consumers) {
+      if (!queueNames.has(consumer.queue)) {
+        this.warnings.push({
+          message: `consume '${consumer.queue}' references undeclared queue binding — add 'queue ${consumer.queue}' to the edge block`,
+          loc: consumer.loc,
+          code: 'W_CONSUME_UNKNOWN_QUEUE',
+        });
+      }
+    }
+
+    // Warn if edge block has no route or schedule handlers
+    const hasRoutes = node.body.some(s => s.type === 'RouteDeclaration');
+    const hasSchedules = node.body.some(s => s.type === 'EdgeScheduleDeclaration');
+    const hasConsumers = consumers.length > 0;
+    if (!hasRoutes && !hasSchedules && !hasConsumers) {
+      this.warnings.push({
+        message: 'edge block has no routes, schedules, or consumers — it will produce no handlers',
+        loc: node.loc,
+        code: 'W_EDGE_NO_HANDLERS',
+      });
+    }
+
+    this.popScope();
+  }
+
+  _validateEdgeCrossBlock() {
+    const edgeBlocks = this.ast.body.filter(n => n.type === 'EdgeBlock');
+    if (edgeBlocks.length === 0) return;
+
+    // Warn if edge + cli coexist (cli takes over with earlyReturn)
+    const hasCli = this.ast.body.some(n => n.type === 'CliBlock');
+    if (hasCli) {
+      this.warnings.push({
+        message: 'edge {} and cli {} blocks in the same file — cli produces a standalone executable, edge block will be ignored',
+        loc: edgeBlocks[0].loc,
+        code: 'W_EDGE_WITH_CLI',
+      });
+    }
+  }
+
   _validateSecurityCrossBlock() {
     // Collect ALL security declarations across ALL security blocks in the AST
     const allRoles = new Set();
@@ -1287,7 +1625,7 @@ export class Analyzer {
     }
   }
 
-  // visitClientBlock and other client visitors are in client-analyzer.js (lazy-loaded)
+  // visitBrowserBlock and other browser visitors are in browser-analyzer.js (lazy-loaded)
 
   visitSharedBlock(node) {
     const prevScope = this.currentScope;
@@ -1406,9 +1744,10 @@ export class Analyzer {
     } else if (node.pattern.type === 'ArrayPattern' || node.pattern.type === 'TuplePattern') {
       for (const el of node.pattern.elements) {
         if (el) {
+          const varName = el.startsWith('...') ? el.slice(3) : el;
           try {
-            this.currentScope.define(el,
-              new Symbol(el, 'variable', null, false, node.loc));
+            this.currentScope.define(varName,
+              new Symbol(varName, 'variable', null, false, node.loc));
           } catch (e) {
             this.error(e.message);
           }
@@ -1426,6 +1765,7 @@ export class Analyzer {
       sym._paramTypes = node.params.map(p => p.typeAnnotation || null);
       sym._typeParams = node.typeParams || [];
       sym.isPublic = node.isPublic || false;
+      sym.isWasm = !!(node.decorators && node.decorators.some(d => d.name === 'wasm'));
       this.currentScope.define(node.name, sym);
     } catch (e) {
       this.error(e.message);
@@ -1987,7 +2327,7 @@ export class Analyzer {
     this.visitExpression(node.value);
   }
 
-  // Client-specific visitors (visitState, visitComputed, etc.) are in client-analyzer.js (lazy-loaded)
+  // Browser-specific visitors (visitState, visitComputed, etc.) are in browser-analyzer.js (lazy-loaded)
 
   visitTestBlock(node) {
     const prevScope = this.currentScope;
@@ -2352,7 +2692,7 @@ export class Analyzer {
           candidates.push([node.name, typeVariants]);
         }
       }
-      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'ClientBlock') {
+      if (node.type === 'SharedBlock' || node.type === 'ServerBlock' || node.type === 'BrowserBlock') {
         this._collectTypeCandidates(node.body, coveredVariants, candidates);
       }
     }
@@ -2447,7 +2787,7 @@ export class Analyzer {
     }
   }
 
-  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in client-analyzer.js (lazy-loaded)
+  // visitJSXElement, visitJSXFragment, visitJSXFor, visitJSXIf are in browser-analyzer.js (lazy-loaded)
 
   // ─── New feature visitors ─────────────────────────────────
 

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

@@ -1,15 +1,18 @@
-// Client-specific analyzer methods for the Tova language
-// Extracted from analyzer.js for lazy loading — only loaded when client { } blocks are encountered.
+// Browser-specific analyzer methods for the Tova language
+// Extracted from analyzer.js for lazy loading — only loaded when browser { } blocks are encountered.
 
 import { Symbol } from './scope.js';
+import { installFormAnalyzer } from './form-analyzer.js';
 
-export function installClientAnalyzer(AnalyzerClass) {
-  if (AnalyzerClass.prototype._clientAnalyzerInstalled) return;
-  AnalyzerClass.prototype._clientAnalyzerInstalled = true;
+export function installBrowserAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._browserAnalyzerInstalled) return;
+  AnalyzerClass.prototype._browserAnalyzerInstalled = true;
 
-  AnalyzerClass.prototype.visitClientBlock = function(node) {
+  installFormAnalyzer(AnalyzerClass);
+
+  AnalyzerClass.prototype.visitBrowserBlock = function(node) {
     const prevScope = this.currentScope;
-    this.currentScope = this.currentScope.child('client');
+    this.currentScope = this.currentScope.child('browser');
     try {
       for (const stmt of node.body) {
         this.visitNode(stmt);
@@ -21,8 +24,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStateDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'state' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'state' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -35,8 +38,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitComputedDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'computed' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'computed' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     try {
       this.currentScope.define(node.name,
@@ -49,16 +52,16 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitEffectDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'effect' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      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);
   };
 
   AnalyzerClass.prototype.visitComponentDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'component' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      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);
     try {
@@ -89,8 +92,8 @@ export function installClientAnalyzer(AnalyzerClass) {
 
   AnalyzerClass.prototype.visitStoreDeclaration = function(node) {
     const ctx = this.currentScope.getContext();
-    if (ctx !== 'client') {
-      this.error(`'store' can only be used inside a client block`, node.loc, "move this inside a client { } block", { code: 'E302' });
+    if (ctx !== 'browser') {
+      this.error(`'store' can only be used inside a browser block`, node.loc, "move this inside a browser { } block", { code: 'E302' });
     }
     this._checkNamingConvention(node.name, 'store', node.loc);
     try {

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/form-analyzer.js

@@ -0,0 +1,113 @@
+// Form-specific analyzer methods for the Tova language
+// Extracted for lazy loading — only loaded when form { } blocks are encountered.
+
+import { Symbol } from './scope.js';
+
+export function installFormAnalyzer(AnalyzerClass) {
+  if (AnalyzerClass.prototype._formAnalyzerInstalled) return;
+  AnalyzerClass.prototype._formAnalyzerInstalled = true;
+
+  const KNOWN_VALIDATORS = new Set([
+    'required', 'minLength', 'maxLength', 'min', 'max',
+    'pattern', 'email', 'matches', 'oneOf', 'validate',
+  ]);
+
+  AnalyzerClass.prototype.visitFormDeclaration = function(node) {
+    const ctx = this.currentScope.getContext();
+    if (ctx !== 'browser') {
+      this.error(`'form' can only be used inside a browser block or component`, node.loc,
+        "move this inside a browser { } block", { code: 'E310' });
+    }
+
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'form', node.typeAnnotation, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('form');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+      for (const group of node.groups) { this._visitFormGroup(group); }
+      for (const arr of node.arrays) { this._visitFormArray(arr); }
+      for (const comp of node.computeds) { this.visitNode(comp); }
+      if (node.steps) { this._visitFormSteps(node, node.steps); }
+      if (node.onSubmit) { this.visitNode(node.onSubmit); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormField = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formField', node.typeAnnotation, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    if (node.initialValue) {
+      this.visitExpression(node.initialValue);
+    }
+    for (const v of node.validators) {
+      if (!KNOWN_VALIDATORS.has(v.name)) {
+        this.warn(`Unknown validator '${v.name}'`, v.loc, null, { code: 'W_UNKNOWN_VALIDATOR' });
+      }
+      for (const arg of v.args) {
+        this.visitExpression(arg);
+      }
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormGroup = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formGroup', null, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    if (node.condition) {
+      this.visitExpression(node.condition);
+    }
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('block');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+      for (const group of node.groups) { this._visitFormGroup(group); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormArray = function(node) {
+    try {
+      this.currentScope.define(node.name,
+        new Symbol(node.name, 'formArray', null, false, node.loc));
+    } catch (e) {
+      this.error(e.message);
+    }
+    const prevScope = this.currentScope;
+    this.currentScope = this.currentScope.child('block');
+    try {
+      for (const field of node.fields) { this._visitFormField(field); }
+    } finally {
+      this.currentScope = prevScope;
+    }
+  };
+
+  AnalyzerClass.prototype._visitFormSteps = function(formNode, stepsNode) {
+    const knownMembers = new Set();
+    for (const f of formNode.fields) knownMembers.add(f.name);
+    for (const g of formNode.groups) knownMembers.add(g.name);
+    for (const a of formNode.arrays) knownMembers.add(a.name);
+
+    for (const step of stepsNode.steps) {
+      for (const member of step.members) {
+        if (!knownMembers.has(member)) {
+          this.warn(`Step '${step.label}' references unknown member '${member}'`, step.loc, null, { code: 'W_STEP_UNKNOWN_MEMBER' });
+        }
+      }
+    }
+  };
+}