tova 0.3.0 → 0.3.1

package/src/codegen/base-codegen.js

@@ -1,5 +1,5 @@
 // Base code generation utilities shared across all codegen targets
-import { RESULT_OPTION, PROPAGATE, BUILTIN_NAMES } from '../stdlib/inline.js';
+import { RESULT_OPTION, PROPAGATE, BUILTIN_NAMES, STDLIB_DEPS } from '../stdlib/inline.js';
 import { PIPE_TARGET } from '../parser/ast.js';
 
 export class BaseCodegen {
@@ -12,15 +12,35 @@ export class BaseCodegen {
     this._usedBuiltins = new Set(); // track which stdlib builtins are actually used
     this._needsResultOption = false; // track if Ok/Err/Some/None are used
     this._variantFields = { 'Ok': ['value'], 'Err': ['error'], 'Some': ['value'] }; // map variant name -> [field names] for pattern destructuring
+    this._traitDecls = new Map(); // traitName -> { methods: [...] }
+    this._traitImpls = new Map(); // "TraitName:TypeName" -> ImplDeclaration node
     // Source map tracking
-    this._sourceMappings = []; // {sourceLine, sourceCol, outputLine, outputCol}
+    this._sourceMappings = []; // {sourceLine, sourceCol, outputLine, outputCol, sourceFile?}
     this._outputLineCount = 0;
+    this._sourceFile = null; // current source file for multi-file source maps
   }
 
   _uid() {
     return this._counter++;
   }
 
+  // Returns true for AST nodes with no side effects that are safe to evaluate multiple times
+  _isSimpleExpression(node) {
+    if (!node) return false;
+    switch (node.type) {
+      case 'Identifier':
+      case 'NumberLiteral':
+      case 'StringLiteral':
+      case 'BooleanLiteral':
+      case 'NilLiteral':
+        return true;
+      case 'MemberExpression':
+        return !node.computed && this._isSimpleExpression(node.object);
+      default:
+        return false;
+    }
+  }
+
   // Known void/side-effect-only calls that shouldn't be implicitly returned
   _isVoidCall(expr) {
     if (expr.type !== 'CallExpression') return false;
@@ -58,18 +78,35 @@ export class BaseCodegen {
     return '  '.repeat(this.indent);
   }
 
+  // Set current source file for multi-file source map tracking
+  setSourceFile(filename) {
+    this._sourceFile = filename;
+  }
+
   // Source map: record a mapping from source location to output line
   _addMapping(node, outputLine) {
     if (node && node.loc && node.loc.line) {
-      this._sourceMappings.push({
+      const mapping = {
         sourceLine: node.loc.line - 1, // 0-based
         sourceCol: (node.loc.column || 1) - 1, // 0-based
         outputLine,
         outputCol: this.indent * 2, // approximate column from indent
-      });
+      };
+      if (this._sourceFile) mapping.sourceFile = this._sourceFile;
+      this._sourceMappings.push(mapping);
     }
   }
 
+  // Count newlines in a generated string to update output line tracking
+  _countLines(code) {
+    if (!code) return 0;
+    let count = 0;
+    for (let i = 0; i < code.length; i++) {
+      if (code.charCodeAt(i) === 10) count++;
+    }
+    return count;
+  }
+
   // Get collected source mappings
   getSourceMappings() {
     return this._sourceMappings;
@@ -79,13 +116,26 @@ export class BaseCodegen {
     return this._usedBuiltins;
   }
 
+  // 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);
+      }
+    }
+  }
+
   getContainsHelper() {
-    return 'function __contains(col, val) {\n' +
-      '  if (Array.isArray(col) || typeof col === \'string\') return col.includes(val);\n' +
-      '  if (col instanceof Set || col instanceof Map) return col.has(val);\n' +
-      '  if (typeof col === \'object\' && col !== null) return val in col;\n' +
-      '  return false;\n' +
-      '}';
+    return [
+      'function __contains(col, val) {',
+      '  if (Array.isArray(col) || typeof col === \'string\') return col.includes(val);',
+      '  if (col instanceof Set || col instanceof Map) return col.has(val);',
+      '  if (typeof col === \'object\' && col !== null) return val in col;',
+      '  return false;',
+      '}',
+    ].join('\n');
   }
 
   genPropagateExpression(node) {
@@ -143,19 +193,21 @@ export class BaseCodegen {
       case 'IfStatement': result = this.genIfStatement(node); break;
       case 'ForStatement': result = this.genForStatement(node); break;
       case 'WhileStatement': result = this.genWhileStatement(node); break;
+      case 'LoopStatement': result = this.genLoopStatement(node); break;
       case 'TryCatchStatement': result = this.genTryCatchStatement(node); break;
       case 'ReturnStatement': result = this.genReturnStatement(node); break;
       case 'ExpressionStatement': result = `${this.i()}${this.genExpression(node.expression)};`; break;
       case 'BlockStatement': result = this.genBlock(node); break;
       case 'CompoundAssignment': result = this.genCompoundAssignment(node); break;
-      case 'BreakStatement': result = `${this.i()}break;`; break;
-      case 'ContinueStatement': result = `${this.i()}continue;`; break;
+      case 'BreakStatement': result = node.label ? `${this.i()}break ${node.label};` : `${this.i()}break;`; break;
+      case 'ContinueStatement': result = node.label ? `${this.i()}continue ${node.label};` : `${this.i()}continue;`; break;
       case 'GuardStatement': result = this.genGuardStatement(node); break;
       case 'InterfaceDeclaration': result = this.genInterfaceDeclaration(node); break;
       case 'ImplDeclaration': result = this.genImplDeclaration(node); break;
       case 'TraitDeclaration': result = this.genTraitDeclaration(node); break;
       case 'TypeAlias': result = this.genTypeAlias(node); break;
       case 'DeferStatement': result = this.genDeferStatement(node); break;
+      case 'WithStatement': result = this.genWithStatement(node); break;
       case 'ExternDeclaration': result = `${this.i()}// extern: ${node.name}`; break;
       // Config declarations handled at block level — emit nothing in statement context
       case 'AiConfigDeclaration': result = ''; break;
@@ -169,10 +221,9 @@ export class BaseCodegen {
         result = `${this.i()}${this.genExpression(node)};`;
     }
 
-    // Track output line count
+    // Track output line count using fast character scan
     if (result) {
-      const newlines = result.split('\n').length - 1;
-      this._outputLineCount += newlines + 1; // +1 for the line itself (join with \n)
+      this._outputLineCount += this._countLines(result) + 1; // +1 for the join newline
     }
 
     return result;
@@ -202,6 +253,7 @@ export class BaseCodegen {
       case 'LogicalExpression': return this.genLogicalExpression(node);
       case 'ChainedComparison': return this.genChainedComparison(node);
       case 'MembershipExpression': return this.genMembershipExpression(node);
+      case 'IsExpression': return this.genIsExpression(node);
       case 'CallExpression': return this.genCallExpression(node);
       case 'MemberExpression': return this.genMemberExpression(node);
       case 'OptionalChain': return this.genOptionalChain(node);
@@ -334,10 +386,20 @@ export class BaseCodegen {
     }
     const body = this.genBlockBody(node.body);
     this.popScope();
+    const p = [];
+    p.push(`${this.i()}${exportPrefix}${asyncPrefix}function${genStar} ${node.name}(${params}) {`);
     if (hasPropagate) {
-      return `${this.i()}${exportPrefix}${asyncPrefix}function${genStar} ${node.name}(${params}) {\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()}}`;
+      p.push(`${this.i()}  try {`);
+      p.push(body);
+      p.push(`${this.i()}  } catch (__e) {`);
+      p.push(`${this.i()}    if (__e && __e.__tova_propagate) return __e.value;`);
+      p.push(`${this.i()}    throw __e;`);
+      p.push(`${this.i()}  }`);
+    } else {
+      p.push(body);
     }
-    return `${this.i()}${exportPrefix}${asyncPrefix}function${genStar} ${node.name}(${params}) {\n${body}\n${this.i()}}`;
+    p.push(`${this.i()}}`);
+    return p.join('\n');
   }
 
   genParams(params) {
@@ -383,145 +445,171 @@ export class BaseCodegen {
   }
 
   genIfStatement(node) {
-    let code = `${this.i()}if (${this.genExpression(node.condition)}) {\n`;
+    const p = [];
+    p.push(`${this.i()}if (${this.genExpression(node.condition)}) {\n`);
     this.indent++;
     this.pushScope();
-    code += this.genBlockStatements(node.consequent);
+    p.push(this.genBlockStatements(node.consequent));
     this.popScope();
     this.indent--;
-    code += `\n${this.i()}}`;
+    p.push(`\n${this.i()}}`);
 
     for (const alt of node.alternates) {
-      code += ` else if (${this.genExpression(alt.condition)}) {\n`;
+      p.push(` else if (${this.genExpression(alt.condition)}) {\n`);
       this.indent++;
       this.pushScope();
-      code += this.genBlockStatements(alt.body);
+      p.push(this.genBlockStatements(alt.body));
       this.popScope();
       this.indent--;
-      code += `\n${this.i()}}`;
+      p.push(`\n${this.i()}}`);
     }
 
     if (node.elseBody) {
-      code += ` else {\n`;
+      p.push(` else {\n`);
       this.indent++;
       this.pushScope();
-      code += this.genBlockStatements(node.elseBody);
+      p.push(this.genBlockStatements(node.elseBody));
       this.popScope();
       this.indent--;
-      code += `\n${this.i()}}`;
+      p.push(`\n${this.i()}}`);
     }
 
-    return code;
+    return p.join('');
   }
 
   genForStatement(node) {
     const vars = Array.isArray(node.variable) ? node.variable : [node.variable];
     const iterExpr = this.genExpression(node.iterable);
+    const labelPrefix = node.label ? `${node.label}: ` : '';
+    const awaitKeyword = node.isAsync ? ' await' : '';
 
     if (node.elseBody) {
       // for-else: run else if iterable was empty
       const tempVar = `__iter_${this._uid()}`;
       const enteredVar = `__entered_${this._uid()}`;
-      let code = `${this.i()}{\n`;
+      const p = [];
+      p.push(`${this.i()}{\n`);
       this.indent++;
-      code += `${this.i()}const ${tempVar} = ${iterExpr};\n`;
-      code += `${this.i()}let ${enteredVar} = false;\n`;
+      p.push(`${this.i()}const ${tempVar} = ${iterExpr};\n`);
+      p.push(`${this.i()}let ${enteredVar} = false;\n`);
       this.pushScope();
       for (const v of vars) this.declareVar(v);
       if (vars.length === 2) {
-        code += `${this.i()}for (const [${vars[0]}, ${vars[1]}] of ${tempVar}) {\n`;
+        p.push(`${this.i()}${labelPrefix}for${awaitKeyword} (const [${vars[0]}, ${vars[1]}] of ${tempVar}) {\n`);
       } else {
-        code += `${this.i()}for (const ${vars[0]} of ${tempVar}) {\n`;
+        p.push(`${this.i()}${labelPrefix}for${awaitKeyword} (const ${vars[0]} of ${tempVar}) {\n`);
       }
       this.indent++;
-      code += `${this.i()}${enteredVar} = true;\n`;
-      code += this.genBlockStatements(node.body);
+      p.push(`${this.i()}${enteredVar} = true;\n`);
+      if (node.guard) {
+        p.push(`${this.i()}if (!(${this.genExpression(node.guard)})) continue;\n`);
+      }
+      p.push(this.genBlockStatements(node.body));
       this.indent--;
-      code += `\n${this.i()}}\n`;
+      p.push(`\n${this.i()}}\n`);
       this.popScope();
       this.pushScope();
-      code += `${this.i()}if (!${enteredVar}) {\n`;
+      p.push(`${this.i()}if (!${enteredVar}) {\n`);
       this.indent++;
-      code += this.genBlockStatements(node.elseBody);
+      p.push(this.genBlockStatements(node.elseBody));
       this.indent--;
-      code += `\n${this.i()}}\n`;
+      p.push(`\n${this.i()}}\n`);
       this.popScope();
       this.indent--;
-      code += `${this.i()}}`;
-      return code;
+      p.push(`${this.i()}}`);
+      return p.join('');
     }
 
     this.pushScope();
     for (const v of vars) this.declareVar(v);
-    let code;
+    const p = [];
     if (vars.length === 2) {
-      code = `${this.i()}for (const [${vars[0]}, ${vars[1]}] of ${iterExpr}) {\n`;
+      p.push(`${this.i()}${labelPrefix}for${awaitKeyword} (const [${vars[0]}, ${vars[1]}] of ${iterExpr}) {\n`);
     } else {
-      code = `${this.i()}for (const ${vars[0]} of ${iterExpr}) {\n`;
+      p.push(`${this.i()}${labelPrefix}for${awaitKeyword} (const ${vars[0]} of ${iterExpr}) {\n`);
     }
     this.indent++;
-    code += this.genBlockStatements(node.body);
+    if (node.guard) {
+      p.push(`${this.i()}if (!(${this.genExpression(node.guard)})) continue;\n`);
+    }
+    p.push(this.genBlockStatements(node.body));
     this.indent--;
-    code += `\n${this.i()}}`;
+    p.push(`\n${this.i()}}`);
     this.popScope();
 
-    return code;
+    return p.join('');
   }
 
   genWhileStatement(node) {
-    let code = `${this.i()}while (${this.genExpression(node.condition)}) {\n`;
+    const labelPrefix = node.label ? `${node.label}: ` : '';
+    const p = [];
+    p.push(`${this.i()}${labelPrefix}while (${this.genExpression(node.condition)}) {\n`);
     this.indent++;
     this.pushScope();
-    code += this.genBlockStatements(node.body);
+    p.push(this.genBlockStatements(node.body));
     this.popScope();
     this.indent--;
-    code += `\n${this.i()}}`;
-    return code;
+    p.push(`\n${this.i()}}`);
+    return p.join('');
+  }
+
+  genLoopStatement(node) {
+    const labelPrefix = node.label ? `${node.label}: ` : '';
+    const p = [];
+    p.push(`${this.i()}${labelPrefix}while (true) {\n`);
+    this.indent++;
+    this.pushScope();
+    p.push(this.genBlockStatements(node.body));
+    this.popScope();
+    this.indent--;
+    p.push(`\n${this.i()}}`);
+    return p.join('');
   }
 
   genTryCatchStatement(node) {
-    let code = `${this.i()}try {\n`;
+    const p = [];
+    p.push(`${this.i()}try {\n`);
     this.indent++;
     this.pushScope();
     for (const stmt of node.tryBody) {
-      code += this.generateStatement(stmt) + '\n';
+      p.push(this.generateStatement(stmt) + '\n');
     }
     this.popScope();
     this.indent--;
 
     if (node.catchBody) {
       const catchVar = node.catchParam || '__err';
-      code += `${this.i()}} catch (${catchVar}) {\n`;
+      p.push(`${this.i()}} catch (${catchVar}) {\n`);
       this.pushScope();
       this.declareVar(catchVar);
       this.indent++;
       // Re-throw propagation sentinels so ? operator works through user try/catch
-      code += `${this.i()}if (${catchVar} && ${catchVar}.__tova_propagate) throw ${catchVar};\n`;
+      p.push(`${this.i()}if (${catchVar} && ${catchVar}.__tova_propagate) throw ${catchVar};\n`);
       for (const stmt of node.catchBody) {
-        code += this.generateStatement(stmt) + '\n';
+        p.push(this.generateStatement(stmt) + '\n');
       }
       this.popScope();
       this.indent--;
-      code += `${this.i()}}`;
+      p.push(`${this.i()}}`);
     }
 
     if (node.finallyBody) {
       if (!node.catchBody) {
         // try/finally without catch
-        code += `${this.i()}}`;
+        p.push(`${this.i()}}`);
       }
-      code += ` finally {\n`;
+      p.push(` finally {\n`);
       this.indent++;
       this.pushScope();
       for (const stmt of node.finallyBody) {
-        code += this.generateStatement(stmt) + '\n';
+        p.push(this.generateStatement(stmt) + '\n');
       }
       this.popScope();
       this.indent--;
-      code += `${this.i()}}`;
+      p.push(`${this.i()}}`);
     }
 
-    return code;
+    return p.join('');
   }
 
   genReturnStatement(node) {
@@ -536,14 +624,15 @@ export class BaseCodegen {
   }
 
   genBlock(node) {
-    let code = `{\n`;
+    const p = [];
+    p.push(`{\n`);
     this.indent++;
     this.pushScope();
-    code += this.genBlockStatements(node);
+    p.push(this.genBlockStatements(node));
     this.popScope();
     this.indent--;
-    code += `\n${this.i()}}`;
-    return code;
+    p.push(`\n${this.i()}}`);
+    return p.join('');
   }
 
   genBlockBody(block) {
@@ -614,23 +703,24 @@ export class BaseCodegen {
   }
 
   _genIfStatementWithReturns(node) {
-    let code = `${this.i()}if (${this.genExpression(node.condition)}) {\n`;
-    code += this._genBlockBodyReturns(node.consequent);
-    code += `\n${this.i()}}`;
+    const p = [];
+    p.push(`${this.i()}if (${this.genExpression(node.condition)}) {\n`);
+    p.push(this._genBlockBodyReturns(node.consequent));
+    p.push(`\n${this.i()}}`);
 
     for (const alt of node.alternates) {
-      code += ` else if (${this.genExpression(alt.condition)}) {\n`;
-      code += this._genBlockBodyReturns(alt.body);
-      code += `\n${this.i()}}`;
+      p.push(` else if (${this.genExpression(alt.condition)}) {\n`);
+      p.push(this._genBlockBodyReturns(alt.body));
+      p.push(`\n${this.i()}}`);
     }
 
     if (node.elseBody) {
-      code += ` else {\n`;
-      code += this._genBlockBodyReturns(node.elseBody);
-      code += `\n${this.i()}}`;
+      p.push(` else {\n`);
+      p.push(this._genBlockBodyReturns(node.elseBody));
+      p.push(`\n${this.i()}}`);
     }
 
-    return code;
+    return p.join('');
   }
 
   _genBlockBodyReturns(block) {
@@ -691,6 +781,9 @@ export class BaseCodegen {
 
     // Tova ?? is NaN-safe: catches null, undefined, AND NaN
     if (op === '??') {
+      if (this._isSimpleExpression(node.left)) {
+        return `((${left} != null && ${left} === ${left}) ? ${left} : ${right})`;
+      }
       return `((__tova_v) => (__tova_v != null && __tova_v === __tova_v) ? __tova_v : ${right})(${left})`;
     }
 
@@ -719,6 +812,21 @@ export class BaseCodegen {
       const right = this.genExpression(node.operands[1]);
       return `(${left} ${node.operators[0]} ${right})`;
     }
+    // Optimization: if all intermediate operands are simple (no side effects),
+    // we can inline them without temp vars or IIFE
+    const intermediateOperands = node.operands.slice(1, -1);
+    const allSimple = intermediateOperands.every(op => this._isSimpleExpression(op));
+
+    if (allSimple) {
+      const parts = [];
+      for (let idx = 0; idx < node.operators.length; idx++) {
+        const left = this.genExpression(node.operands[idx]);
+        const right = this.genExpression(node.operands[idx + 1]);
+        parts.push(`(${left} ${node.operators[idx]} ${right})`);
+      }
+      return `(${parts.join(' && ')})`;
+    }
+
     const temps = [];
     const parts = [];
     for (let idx = 0; idx < node.operators.length; idx++) {
@@ -744,9 +852,45 @@ export class BaseCodegen {
     return `(${parts.join(' && ')})`;
   }
 
+  // Try to specialize `in` checks based on the collection's AST type
+  _specializeContains(collectionNode, colCode, valCode) {
+    switch (collectionNode.type) {
+      case 'ArrayLiteral':
+        return `${colCode}.includes(${valCode})`;
+      case 'StringLiteral':
+      case 'TemplateLiteral':
+        return `${colCode}.includes(${valCode})`;
+      case 'CallExpression':
+        if (collectionNode.callee.type === 'MemberExpression' &&
+            !collectionNode.callee.computed &&
+            collectionNode.callee.property === 'new') {
+          const objName = collectionNode.callee.object.type === 'Identifier'
+            ? collectionNode.callee.object.name : null;
+          if (objName === 'Set' || objName === 'Map') {
+            return `${colCode}.has(${valCode})`;
+          }
+        }
+        return null;
+      case 'ObjectLiteral':
+        return `(${valCode} in ${colCode})`;
+      default:
+        return null;
+    }
+  }
+
   genMembershipExpression(node) {
     const val = this.genExpression(node.value);
     const col = this.genExpression(node.collection);
+
+    // Try specialized check based on collection type
+    const specialized = this._specializeContains(node.collection, col, val);
+    if (specialized) {
+      if (node.negated) {
+        return `(!${specialized})`;
+      }
+      return specialized;
+    }
+
     this._needsContainsHelper = true;
     if (node.negated) {
       return `(!__contains(${col}, ${val}))`;
@@ -754,6 +898,41 @@ export class BaseCodegen {
     return `__contains(${col}, ${val})`;
   }
 
+  genIsExpression(node) {
+    const val = this.genExpression(node.value);
+    const op = node.negated ? '!==' : '===';
+    const notOp = node.negated ? '!' : '';
+
+    // Map Tova type names to JS runtime checks
+    switch (node.typeName) {
+      case 'String':
+        return `(typeof ${val} ${op} 'string')`;
+      case 'Int':
+        return node.negated
+          ? `(typeof ${val} !== 'number' || !Number.isInteger(${val}))`
+          : `(typeof ${val} === 'number' && Number.isInteger(${val}))`;
+      case 'Float':
+        return node.negated
+          ? `(typeof ${val} !== 'number' || Number.isInteger(${val}))`
+          : `(typeof ${val} === 'number' && !Number.isInteger(${val}))`;
+      case 'Bool':
+        return `(typeof ${val} ${op} 'boolean')`;
+      case 'Nil':
+        return `(${val} ${op} null)`;
+      case 'Array':
+        return `(${notOp}Array.isArray(${val}))`;
+      case 'Function':
+        return `(typeof ${val} ${op} 'function')`;
+      case 'Number':
+        return `(typeof ${val} ${op} 'number')`;
+      default:
+        // For ADT variants, check __tag; for classes, use instanceof
+        return node.negated
+          ? `(!(${val} != null && (${val}.__tag === '${node.typeName}' || ${val} instanceof (typeof ${node.typeName} !== 'undefined' ? ${node.typeName} : function(){}))))`
+          : `(${val} != null && (${val}.__tag === '${node.typeName}' || ${val} instanceof (typeof ${node.typeName} !== 'undefined' ? ${node.typeName} : function(){})))`;
+    }
+  }
+
   genCallExpression(node) {
     // Transform Foo.new(...) → new Foo(...)
     if (node.callee.type === 'MemberExpression' && !node.callee.computed && node.callee.property === 'new') {
@@ -762,20 +941,37 @@ export class BaseCodegen {
       return `new ${obj}(${args})`;
     }
 
-    // Track builtin usage for tree-shaking
+    // Track builtin usage for tree-shaking (with dependency resolution)
     if (node.callee.type === 'Identifier') {
       if (BUILTIN_NAMES.has(node.callee.name)) {
-        this._usedBuiltins.add(node.callee.name);
+        this._trackBuiltin(node.callee.name);
       }
       if (node.callee.name === 'Ok' || node.callee.name === 'Err' || node.callee.name === 'Some') {
         this._needsResultOption = true;
       }
+      // Seq is a dependency of iter — handled by _trackBuiltin via STDLIB_DEPS
+      if (node.callee.name === 'iter') {
+        this._needsResultOption = true; // Seq.first()/find() return Option
+      }
 
       // Inline string/collection builtins to direct method calls
       const inlined = this._tryInlineBuiltin(node);
       if (inlined !== null) return inlined;
     }
 
+    // Track namespace builtin usage: math.sin() → include 'math' namespace + deps
+    if (node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        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
+      const deps = STDLIB_DEPS[ns];
+      if (deps && (deps.includes('Ok') || deps.includes('Err'))) {
+        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))) {
@@ -893,6 +1089,10 @@ export class BaseCodegen {
   }
 
   genMemberExpression(node) {
+    // Track namespace builtin usage: math.PI → include 'math' namespace + deps
+    if (node.object.type === 'Identifier' && BUILTIN_NAMES.has(node.object.name)) {
+      this._trackBuiltin(node.object.name);
+    }
     const obj = this.genExpression(node.object);
     if (node.computed) {
       return `${obj}[${this.genExpression(node.property)}]`;
@@ -941,7 +1141,14 @@ export class BaseCodegen {
       if (placeholderCount > 0) {
         const callee = this.genExpression(right.callee);
         if (placeholderCount > 1) {
-          // Multiple placeholders: evaluate left once via IIFE temp var
+          // Multiple placeholders: inline if left is simple, otherwise IIFE temp var
+          if (this._isSimpleExpression(node.left)) {
+            const args = right.arguments.map(a => {
+              if (a.type === 'Identifier' && a.name === '_') return left;
+              return this.genExpression(a);
+            }).join(', ');
+            return `${callee}(${args})`;
+          }
           const tmp = `__pipe_${this._uid()}`;
           const args = right.arguments.map(a => {
             if (a.type === 'Identifier' && a.name === '_') return tmp;
@@ -1227,9 +1434,18 @@ export class BaseCodegen {
       const body = this.genBlockBody(node.body);
       this.popScope();
       if (hasPropagate) {
-        return `${asyncPrefix}(${params}) => {\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()}}`;
+        const p = [];
+        p.push(`${asyncPrefix}(${params}) => {`);
+        p.push(`${this.i()}  try {`);
+        p.push(body);
+        p.push(`${this.i()}  } catch (__e) {`);
+        p.push(`${this.i()}    if (__e && __e.__tova_propagate) return __e.value;`);
+        p.push(`${this.i()}    throw __e;`);
+        p.push(`${this.i()}  }`);
+        p.push(`${this.i()}}`);
+        return p.join('\n');
       }
-      return `${asyncPrefix}(${params}) => {\n${body}\n${this.i()}}`;
+      return [`${asyncPrefix}(${params}) => {`, body, `${this.i()}}`].join('\n');
     }
 
     // Statement bodies (compound assignment, assignment in lambda)
@@ -1249,12 +1465,73 @@ export class BaseCodegen {
     return `${asyncPrefix}(${params}) => ${this.genExpression(node.body)}`;
   }
 
+  // Check if a match can be emitted as a ternary chain instead of IIFE
+  _isSimpleMatch(node) {
+    if (!this._isSimpleExpression(node.subject)) return false;
+    for (const arm of node.arms) {
+      // All bodies must be expressions (not block statements)
+      if (arm.body.type === 'BlockStatement') return false;
+      // No patterns that need variable bindings
+      if (this._patternNeedsBindings(arm.pattern)) return false;
+      // Guards with BindingPattern need IIFE for binding
+      if (arm.guard && arm.pattern.type === 'BindingPattern') return false;
+    }
+    return true;
+  }
+
+  // Check recursively whether a pattern requires const bindings
+  _patternNeedsBindings(pattern) {
+    switch (pattern.type) {
+      case 'LiteralPattern':
+      case 'WildcardPattern':
+      case 'RangePattern':
+        return false;
+      case 'BindingPattern':
+        return true;
+      case 'VariantPattern':
+        return pattern.fields.some(f => typeof f === 'string' || (f && this._patternNeedsBindings(f)));
+      case 'ArrayPattern':
+      case 'TuplePattern':
+        return pattern.elements.some(el => el && this._patternNeedsBindings(el));
+      default:
+        return true; // Conservative: unknown patterns may need bindings
+    }
+  }
+
+  // Generate a simple match as nested ternary
+  _genSimpleMatch(node) {
+    const subject = this.genExpression(node.subject);
+    let result = '';
+    for (let idx = 0; idx < node.arms.length; idx++) {
+      const arm = node.arms[idx];
+      const body = this.genExpression(arm.body);
+      // Last arm with wildcard → else branch
+      if ((arm.pattern.type === 'WildcardPattern' || arm.pattern.type === 'BindingPattern') && !arm.guard) {
+        result += body;
+        break;
+      }
+      const condition = this.genPatternCondition(arm.pattern, subject, arm.guard);
+      result += `(${condition}) ? ${body} : `;
+      // If this is the last arm and not a wildcard, add undefined as fallback
+      if (idx === node.arms.length - 1) {
+        result += 'undefined';
+      }
+    }
+    return `(${result})`;
+  }
+
   genMatchExpression(node) {
+    // Optimization: simple matches emit ternary chain instead of IIFE
+    if (this._isSimpleMatch(node)) {
+      return this._genSimpleMatch(node);
+    }
+
     // Generate as IIFE with if-else chain
     const subject = this.genExpression(node.subject);
     const tempVar = '__match';
 
-    let code = `((${tempVar}) => {\n`;
+    const p = [];
+    p.push(`((${tempVar}) => {\n`);
     this.indent++;
 
     for (let idx = 0; idx < node.arms.length; idx++) {
@@ -1265,36 +1542,36 @@ export class BaseCodegen {
         if (idx === node.arms.length - 1 && !arm.guard) {
           // Default case
           if (arm.pattern.type === 'BindingPattern') {
-            code += `${this.i()}const ${arm.pattern.name} = ${tempVar};\n`;
+            p.push(`${this.i()}const ${arm.pattern.name} = ${tempVar};\n`);
           }
           if (arm.body.type === 'BlockStatement') {
-            code += this.genBlockBody(arm.body) + '\n';
+            p.push(this.genBlockBody(arm.body) + '\n');
           } else {
-            code += `${this.i()}return ${this.genExpression(arm.body)};\n`;
+            p.push(`${this.i()}return ${this.genExpression(arm.body)};\n`);
           }
           break;
         }
       }
 
       const keyword = idx === 0 ? 'if' : 'else if';
-      code += `${this.i()}${keyword} (${condition}) {\n`;
+      p.push(`${this.i()}${keyword} (${condition}) {\n`);
       this.indent++;
 
       // Bind variables from pattern
-      code += this.genPatternBindings(arm.pattern, tempVar);
+      p.push(this.genPatternBindings(arm.pattern, tempVar));
 
       if (arm.body.type === 'BlockStatement') {
-        code += this.genBlockBody(arm.body) + '\n';
+        p.push(this.genBlockBody(arm.body) + '\n');
       } else {
-        code += `${this.i()}return ${this.genExpression(arm.body)};\n`;
+        p.push(`${this.i()}return ${this.genExpression(arm.body)};\n`);
       }
       this.indent--;
-      code += `${this.i()}}\n`;
+      p.push(`${this.i()}}\n`);
     }
 
     this.indent--;
-    code += `${this.i()}})(${subject})`;
-    return code;
+    p.push(`${this.i()}})(${subject})`);
+    return p.join('');
   }
 
   genIfExpression(node) {
@@ -1309,27 +1586,40 @@ export class BaseCodegen {
       return `((${cond}) ? (${thenExpr}) : (${elseExpr}))`;
     }
 
+    // Extended optimization: if/elif/else where ALL branches are single expressions → nested ternary
+    if (node.alternates.length > 0 && node.elseBody &&
+        isSingleExpr(node.consequent) && isSingleExpr(node.elseBody) &&
+        node.alternates.every(alt => isSingleExpr(alt.body))) {
+      let result = `((${this.genExpression(node.condition)}) ? (${this.genExpression(node.consequent.body[0].expression)})`;
+      for (const alt of node.alternates) {
+        result += ` : (${this.genExpression(alt.condition)}) ? (${this.genExpression(alt.body.body[0].expression)})`;
+      }
+      result += ` : (${this.genExpression(node.elseBody.body[0].expression)}))`;
+      return result;
+    }
+
     // Full IIFE for multi-statement branches
-    let code = `(() => {\n`;
+    const p = [];
+    p.push(`(() => {\n`);
     this.indent++;
 
-    code += `${this.i()}if (${this.genExpression(node.condition)}) {\n`;
-    code += this.genBlockBody(node.consequent);
-    code += `\n${this.i()}}`;
+    p.push(`${this.i()}if (${this.genExpression(node.condition)}) {\n`);
+    p.push(this.genBlockBody(node.consequent));
+    p.push(`\n${this.i()}}`);
 
     for (const alt of node.alternates) {
-      code += ` else if (${this.genExpression(alt.condition)}) {\n`;
-      code += this.genBlockBody(alt.body);
-      code += `\n${this.i()}}`;
+      p.push(` else if (${this.genExpression(alt.condition)}) {\n`);
+      p.push(this.genBlockBody(alt.body));
+      p.push(`\n${this.i()}}`);
     }
 
-    code += ` else {\n`;
-    code += this.genBlockBody(node.elseBody);
-    code += `\n${this.i()}}`;
+    p.push(` else {\n`);
+    p.push(this.genBlockBody(node.elseBody));
+    p.push(`\n${this.i()}}`);
 
     this.indent--;
-    code += `\n${this.i()}})()`;
-    return code;
+    p.push(`\n${this.i()}})()`);
+    return p.join('');
   }
 
   genPatternCondition(pattern, subject, guard) {
@@ -1546,14 +1836,15 @@ export class BaseCodegen {
   }
 
   genGuardStatement(node) {
-    let code = `${this.i()}if (!(${this.genExpression(node.condition)})) {\n`;
+    const p = [];
+    p.push(`${this.i()}if (!(${this.genExpression(node.condition)})) {\n`);
     this.indent++;
     this.pushScope();
-    code += this.genBlockStatements(node.elseBody);
+    p.push(this.genBlockStatements(node.elseBody));
     this.popScope();
     this.indent--;
-    code += `\n${this.i()}}`;
-    return code;
+    p.push(`\n${this.i()}}`);
+    return p.join('');
   }
 
   genInterfaceDeclaration(node) {
@@ -1605,6 +1896,7 @@ export class BaseCodegen {
       const targetName = hasVariants ? null : node.name;
       const fieldNames = hasVariants ? [] : node.variants.map(f => f.name);
 
+      const builtinTraits = new Set(['Eq', 'Show', 'JSON']);
       for (const trait of node.derive) {
         if (trait === 'Eq' && targetName) {
           // Deep equality: compare all fields
@@ -1619,6 +1911,19 @@ export class BaseCodegen {
           lines.push(`${this.i()}${targetName}.toJSON = function(obj) { return JSON.stringify(obj); };`);
           lines.push(`${this.i()}${targetName}.fromJSON = function(str) { const d = JSON.parse(str); return ${targetName}(${fieldNames.map(f => `d.${f}`).join(', ')}); };`);
         }
+
+        // Extensible derive: user-defined traits
+        if (!builtinTraits.has(trait) && targetName) {
+          const traitDecl = this._traitDecls.get(trait);
+          if (traitDecl) {
+            for (const method of traitDecl.methods) {
+              if (method.body) {
+                // Trait has a default implementation — use it
+                lines.push(`${this.i()}${targetName}.prototype.${method.name} = __trait_${trait}_${method.name};`);
+              }
+            }
+          }
+        }
       }
 
       // For variant types with derive
@@ -1641,6 +1946,11 @@ export class BaseCodegen {
   }
 
   genImplDeclaration(node) {
+    // Register trait impl for extensible derive
+    if (node.traitName) {
+      this._traitImpls.set(`${node.traitName}:${node.typeName}`, node);
+    }
+
     const lines = [];
     for (const method of node.methods) {
       const hasSelf = method.params.some(p => p.name === 'self');
@@ -1667,6 +1977,9 @@ export class BaseCodegen {
   }
 
   genTraitDeclaration(node) {
+    // Register trait for extensible derive
+    this._traitDecls.set(node.name, { methods: node.methods });
+
     // Traits are mostly compile-time, but generate default implementations as functions
     const lines = [];
     const defaultMethods = node.methods.filter(m => m.body);
@@ -1692,8 +2005,31 @@ export class BaseCodegen {
   genTypeAlias(node) {
     // Type aliases are compile-time only
     const exportStr = node.isPublic ? 'export ' : '';
-    const typeStr = node.typeExpr.name || 'any';
-    return `${this.i()}/* ${exportStr}type alias: ${node.name} = ${typeStr} */`;
+    const typeParams = node.typeParams && node.typeParams.length > 0 ? `<${node.typeParams.join(', ')}>` : '';
+    const typeStr = this._typeAnnotationToString(node.typeExpr);
+    return `${this.i()}/* ${exportStr}type alias: ${node.name}${typeParams} = ${typeStr} */`;
+  }
+
+  _typeAnnotationToString(ann) {
+    if (!ann) return 'any';
+    if (ann.type === 'UnionTypeAnnotation') {
+      return ann.members.map(m => this._typeAnnotationToString(m)).join(' | ');
+    }
+    if (ann.type === 'ArrayTypeAnnotation') {
+      return `[${this._typeAnnotationToString(ann.elementType)}]`;
+    }
+    if (ann.type === 'TupleTypeAnnotation') {
+      return `(${ann.elementTypes.map(t => this._typeAnnotationToString(t)).join(', ')})`;
+    }
+    if (ann.type === 'FunctionTypeAnnotation') {
+      const params = ann.paramTypes.map(t => this._typeAnnotationToString(t)).join(', ');
+      return `(${params}) -> ${this._typeAnnotationToString(ann.returnType)}`;
+    }
+    if (ann.typeParams && ann.typeParams.length > 0) {
+      const params = ann.typeParams.map(t => this._typeAnnotationToString(t)).join(', ');
+      return `${ann.name}<${params}>`;
+    }
+    return ann.name || 'any';
   }
 
   genRefinementType(node) {
@@ -1711,6 +2047,28 @@ export class BaseCodegen {
     return `${this.i()}/* defer */`;
   }
 
+  genWithStatement(node) {
+    const expr = this.genExpression(node.expression);
+    const name = node.name;
+    this.declareVar(name);
+    const p = [];
+    p.push(`${this.i()}const ${name} = ${expr};`);
+    p.push(`${this.i()}try {`);
+    this.indent++;
+    this.pushScope();
+    p.push(this.genBlockStatements(node.body));
+    this.popScope();
+    this.indent--;
+    p.push(`${this.i()}} finally {`);
+    this.indent++;
+    p.push(`${this.i()}if (${name} != null && typeof ${name}.close === 'function') ${name}.close();`);
+    p.push(`${this.i()}else if (${name} != null && typeof ${name}.dispose === 'function') ${name}.dispose();`);
+    p.push(`${this.i()}else if (${name} != null && typeof ${name}[Symbol.dispose] === 'function') ${name}[Symbol.dispose]();`);
+    this.indent--;
+    p.push(`${this.i()}}`);
+    return p.join('\n');
+  }
+
   // Check if a function body contains yield expressions (for generator detection)
   _containsYield(node) {
     if (!node) return false;