From 01580f2fbca7c06f2e376aae29d08f30cd276a97 Mon Sep 17 00:00:00 2001
From: Mathieu Duckerts-Antoine <mathieuduckerts@gmail.com>
Date: Tue, 7 Oct 2025 15:30:54 +0200
Subject: [PATCH 1/2] [IMP] qweb: Make t-call parametric, enable lazy XML
 evaluation

The goal is to apply to OWL the same type of changes that were made in odoo/odoo#197296.
Note that we have a stricter version here. In case some attrs are found
on a t-call, the only parameters given to the template called are the
one listed or found in the t-call-context.
---
 src/compiler/code_generator.ts                |   67 +-
 src/compiler/parser.ts                        |   39 +-
 .../compiler/__snapshots__/misc.test.ts.snap  |    4 +-
 .../__snapshots__/t_call.test.ts.snap         |   54 +-
 .../__snapshots__/t_call2.test.ts.snap        | 1395 +++++++++++++++++
 .../compiler/__snapshots__/t_esc.test.ts.snap |    4 +-
 .../compiler/__snapshots__/t_out.test.ts.snap |   10 +-
 tests/compiler/parser.test.ts                 |   25 +-
 tests/compiler/t_call2.test.ts                |  560 +++++++
 .../__snapshots__/t_call.test.ts.snap         |    2 +-
 10 files changed, 2098 insertions(+), 62 deletions(-)
 create mode 100644 tests/compiler/__snapshots__/t_call2.test.ts.snap
 create mode 100644 tests/compiler/t_call2.test.ts

diff --git a/src/compiler/code_generator.ts b/src/compiler/code_generator.ts
index 8c696e940..22b4d4284 100644
--- a/src/compiler/code_generator.ts
+++ b/src/compiler/code_generator.ts
@@ -32,6 +32,8 @@ import {
 } from "./parser";
 import { OwlError } from "../common/owl_error";
 
+const zero = Symbol("zero");
+
 type BlockType = "block" | "text" | "multi" | "list" | "html" | "comment";
 const whitespaceRE = /\s+/g;
 
@@ -279,7 +281,7 @@ export class CodeGenerator {
   translatableAttributes: string[] = TRANSLATABLE_ATTRS;
   ast: AST;
   staticDefs: { id: string; expr: string }[] = [];
-  slotNames: Set<String> = new Set();
+  slotNames: Set<String | Symbol> = new Set();
   helpers: Set<string> = new Set();
 
   constructor(ast: AST, options: CodeGenOptions) {
@@ -791,12 +793,22 @@ export class CodeGenerator {
     return block!.varName;
   }
 
+  compileZero() {
+    this.helpers.add("zero");
+    const isMultiple = this.slotNames.has(zero);
+    this.slotNames.add(zero);
+    let key = this.target.loopLevel ? `key${this.target.loopLevel}` : "key";
+    if (isMultiple) {
+      key = this.generateComponentKey(key);
+    }
+    return `ctx[zero]?.(node, ${key})`;
+  }
+
   compileTEsc(ast: ASTTEsc, ctx: Context): string {
     let { block, forceNewBlock } = ctx;
     let expr: string;
     if (ast.expr === "0") {
-      this.helpers.add("zero");
-      expr = `ctx[zero]`;
+      expr = this.compileZero();
     } else {
       expr = compileExpr(ast.expr);
       if (ast.defaultValue) {
@@ -824,8 +836,7 @@ export class CodeGenerator {
     block = this.createBlock(block, "html", ctx);
     let blockStr;
     if (ast.expr === "0") {
-      this.helpers.add("zero");
-      blockStr = `ctx[zero]`;
+      blockStr = this.compileZero();
     } else if (ast.body) {
       let bodyValue = null;
       bodyValue = BlockDescription.nextBlockId;
@@ -1044,8 +1055,12 @@ export class CodeGenerator {
 
   compileTCall(ast: ASTTCall, ctx: Context): string {
     let { block, forceNewBlock } = ctx;
+
+    const attrs: string[] = ast.attrs
+      ? this.formatPropObject(ast.attrs, ast.attrsTranslationCtx, ctx.translationCtx)
+      : [];
     let ctxVar = ctx.ctxVar || "ctx";
-    if (ast.context) {
+    if (!ast.attrs && ast.context) {
       ctxVar = generateId("ctx");
       this.addLine(`let ${ctxVar} = ${compileExpr(ast.context)};`);
     }
@@ -1056,17 +1071,35 @@ export class CodeGenerator {
     }
     block = this.createBlock(block, "multi", ctx);
     if (ast.body) {
-      this.addLine(`${ctxVar} = Object.create(${ctxVar});`);
-      this.addLine(`${ctxVar}[isBoundary] = 1;`);
-      this.helpers.add("isBoundary");
-      const subCtx = createContext(ctx, { ctxVar });
-      const bl = this.compileMulti({ type: ASTType.Multi, content: ast.body }, subCtx);
-      if (bl) {
+      if (ast.attrs) {
+        const ctxStr = generateId("ctx");
+        this.helpers.add("capture");
+        this.define(ctxStr, `capture(ctx)`);
+        const name = this.compileInNewTarget("callBody", ast.body, ctx);
+        const zeroStr = generateId("lazyBlock");
+        this.define(zeroStr, `${name}.bind(this, Object.create(${ctxStr}))`);
         this.helpers.add("zero");
-        this.addLine(`${ctxVar}[zero] = ${bl};`);
+        attrs.push(`[zero]: ${zeroStr}`);
+      } else {
+        this.addLine(`${ctxVar} = Object.create(${ctxVar});`);
+        this.addLine(`${ctxVar}[isBoundary] = 1;`);
+        this.helpers.add("isBoundary");
+        const subCtx = createContext(ctx, { ctxVar });
+        const bl = this.compileAST(ast.body, subCtx);
+        if (bl) {
+          this.helpers.add("zero");
+          this.addLine(`${ctxVar}[zero] = () => ${bl};`);
+        }
       }
     }
 
+    let ctxString = `{${attrs.join(", ")}}`;
+    if (ast.attrs && ast.context) {
+      const dynCtxVar = generateId("ctx");
+      this.addLine(`const ${dynCtxVar} = ${compileExpr(ast.context)};`);
+      ctxString = `Object.assign({}, ${dynCtxVar}${attrs.length ? ", " + ctxString : ""})`;
+    }
+    const ctxExpr = ast.attrs ? ctxString : ctxVar;
     const key = this.generateComponentKey();
     if (isDynamic) {
       const templateVar = generateId("template");
@@ -1074,20 +1107,20 @@ export class CodeGenerator {
         this.staticDefs.push({ id: "call", expr: `app.callTemplate.bind(app)` });
       }
       this.define(templateVar, subTemplate);
-      this.insertBlock(`call(this, ${templateVar}, ${ctxVar}, node, ${key})`, block!, {
+      this.insertBlock(`call(this, ${templateVar}, ${ctxExpr}, node, ${key})`, block!, {
         ...ctx,
         forceNewBlock: !block,
       });
     } else {
       const id = generateId(`callTemplate_`);
       this.staticDefs.push({ id, expr: `app.getTemplate(${subTemplate})` });
-      this.insertBlock(`${id}.call(this, ${ctxVar}, node, ${key})`, block!, {
+      this.insertBlock(`${id}.call(this, ${ctxExpr}, node, ${key})`, block!, {
         ...ctx,
         forceNewBlock: !block,
       });
     }
-    if (ast.body && !ctx.isLast) {
-      this.addLine(`${ctxVar} = ${ctxVar}.__proto__;`);
+    if (!ast.attrs && ast.body && !ctx.isLast) {
+      this.addLine(`${ctxExpr} = ${ctxExpr}.__proto__;`);
     }
     return block.varName;
   }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index aff0bc862..7e31c1f9b 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -126,7 +126,9 @@ export interface ASTTKey extends BaseAST {
 export interface ASTTCall extends BaseAST {
   type: ASTType.TCall;
   name: string;
-  body: AST[] | null;
+  attrs: Attrs | null;
+  attrsTranslationCtx: Attrs | null;
+  body: AST | null;
   context: string | null;
 }
 
@@ -642,9 +644,35 @@ function parseTCall(node: Element, ctx: ParsingContext): AST | null {
   node.removeAttribute("t-call");
   node.removeAttribute("t-call-context");
 
+  let attrs: Attrs | null = null;
+  let attrsTranslationCtx: Attrs | null = null;
+  for (let attributeName of node.getAttributeNames()) {
+    const value = node.getAttribute(attributeName)!;
+    if (attributeName.startsWith("t-translation-context-")) {
+      const attrName = attributeName.slice(22);
+      attrsTranslationCtx = attrsTranslationCtx || {};
+      attrsTranslationCtx[attrName] = value;
+    } else {
+      attrs = attrs || {};
+      attrs[attributeName] = value;
+    }
+  }
+
   if (node.tagName !== "t") {
+    if (attrs) {
+      throw new OwlError(
+        `Directive 't-call' with params can only be used on <t> nodes (used on a <${node.tagName}>)`
+      );
+    }
     const ast = parseNode(node, ctx);
-    const tcall: AST = { type: ASTType.TCall, name: subTemplate, body: null, context };
+    const tcall: AST = {
+      type: ASTType.TCall,
+      name: subTemplate,
+      attrs: null,
+      attrsTranslationCtx: null,
+      body: null,
+      context,
+    };
     if (ast && ast.type === ASTType.DomNode) {
       ast.content = [tcall];
       return ast;
@@ -664,12 +692,13 @@ function parseTCall(node: Element, ctx: ParsingContext): AST | null {
       };
     }
   }
-  const body = parseChildren(node, ctx);
-
+  const body = parseChildNodes(node, ctx);
   return {
     type: ASTType.TCall,
     name: subTemplate,
-    body: body.length ? body : null,
+    attrs,
+    attrsTranslationCtx,
+    body,
     context,
   };
 }
diff --git a/tests/compiler/__snapshots__/misc.test.ts.snap b/tests/compiler/__snapshots__/misc.test.ts.snap
index 2e4969c0b..11be0ea05 100644
--- a/tests/compiler/__snapshots__/misc.test.ts.snap
+++ b/tests/compiler/__snapshots__/misc.test.ts.snap
@@ -118,7 +118,7 @@ exports[`misc global 1`] = `
       setContextValue(ctx, \\"foo\\", 'bbb');
       const b9 = callTemplate_3.call(this, ctx, node, key + \`__3__\${key1}\`);
       const b6 = multi([b7, b8, b9]);
-      ctx[zero] = b6;
+      ctx[zero] = () => b6;
       const b5 = callTemplate_4.call(this, ctx, node, key + \`__4__\${key1}\`);
       ctx = ctx.__proto__;
       c_block2[i1] = withKey(multi([b4, b5]), key1);
@@ -156,7 +156,7 @@ exports[`misc global 3`] = `
   
   return function template(ctx, node, key = \\"\\") {
     let attr1 = 'agüero';
-    const b2 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
     return block1([attr1], [b2]);
   }
 }"
diff --git a/tests/compiler/__snapshots__/t_call.test.ts.snap b/tests/compiler/__snapshots__/t_call.test.ts.snap
index 1d2fbefc8..fd81ff11a 100644
--- a/tests/compiler/__snapshots__/t_call.test.ts.snap
+++ b/tests/compiler/__snapshots__/t_call.test.ts.snap
@@ -71,7 +71,7 @@ exports[`t-call (template calling) call with several sub nodes on same line 1`]
     const b5 = text(\` \`);
     const b6 = block6();
     const b3 = multi([b4, b5, b6]);
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -87,7 +87,7 @@ exports[`t-call (template calling) call with several sub nodes on same line 2`]
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
     return block1([], [b2]);
   }
 }"
@@ -111,7 +111,7 @@ exports[`t-call (template calling) cascading t-call t-out='0' 1`] = `
     const b5 = text(\` \`);
     const b6 = block6();
     const b3 = multi([b4, b5, b6]);
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -132,9 +132,9 @@ exports[`t-call (template calling) cascading t-call t-out='0' 2`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b4 = block4();
-    const b5 = ctx[zero];
+    const b5 = ctx[zero]?.(node, key);
     const b3 = multi([b4, b5]);
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -155,9 +155,9 @@ exports[`t-call (template calling) cascading t-call t-out='0' 3`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b4 = block4();
-    const b5 = ctx[zero];
+    const b5 = ctx[zero]?.(node, key);
     const b3 = multi([b4, b5]);
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -173,7 +173,7 @@ exports[`t-call (template calling) cascading t-call t-out='0' 4`] = `
   let block1 = createBlock(\`<div><span>cascade 2</span><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
     return block1([], [b2]);
   }
 }"
@@ -196,7 +196,7 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
     const b4 = text(\` \`);
     const b5 = block5();
     const b2 = multi([b3, b4, b5]);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -215,9 +215,9 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    const b4 = ctx[zero];
+    const b4 = ctx[zero]?.(node, key);
     const b2 = multi([b3, b4]);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -236,9 +236,9 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    const b4 = ctx[zero];
+    const b4 = ctx[zero]?.(node, key);
     const b2 = multi([b3, b4]);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -254,7 +254,7 @@ exports[`t-call (template calling) cascading t-call t-out='0', without external
   
   return function template(ctx, node, key = \\"\\") {
     const b2 = block2();
-    const b3 = ctx[zero];
+    const b3 = ctx[zero]?.(node, key);
     return multi([b2, b3]);
   }
 }"
@@ -350,10 +350,10 @@ exports[`t-call (template calling) nested t-calls with magic variable 0 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     ctx = ctx.__proto__;
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_2.call(this, ctx, node, key + \`__2\`);
   }
 }"
@@ -367,7 +367,7 @@ exports[`t-call (template calling) nested t-calls with magic variable 0 2`] = `
   
   return function template(ctx, node, key = \\"\\") {
     const b2 = text(\`grandchild\`);
-    const b3 = ctx[zero];
+    const b3 = ctx[zero]?.(node, key);
     return multi([b2, b3]);
   }
 }"
@@ -380,7 +380,7 @@ exports[`t-call (template calling) nested t-calls with magic variable 0 3`] = `
   let { zero } = helpers;
   
   return function template(ctx, node, key = \\"\\") {
-    return ctx[zero];
+    return ctx[zero]?.(node, key);
   }
 }"
 `;
@@ -590,7 +590,7 @@ exports[`t-call (template calling) root t-call with body: t-foreach 1`] = `
     }
     ctx = ctx.__proto__;
     const b2 = list(c_block2);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -622,7 +622,7 @@ exports[`t-call (template calling) root t-call with body: t-if false 1`] = `
       b3 = text(\`zero\`);
     }
     const b2 = multi([b3]);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -654,7 +654,7 @@ exports[`t-call (template calling) root t-call with body: t-if true 1`] = `
       b3 = text(\`zero\`);
     }
     const b2 = multi([b3]);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -682,7 +682,7 @@ exports[`t-call (template calling) root t-call with body: t-out with default 1`]
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b2 = safeOutput(ctx['nothing']);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -839,7 +839,7 @@ exports[`t-call (template calling) t-call with body content as root of a templat
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b2 = block2();
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -854,7 +854,7 @@ exports[`t-call (template calling) t-call with body content as root of a templat
   let block1 = createBlock(\`<foo><block-child-0/></foo>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
     return block1([], [b2]);
   }
 }"
@@ -1204,7 +1204,7 @@ exports[`t-call (template calling) with unused body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b2 = text(\`WHEEE\`);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -1265,7 +1265,7 @@ exports[`t-call (template calling) with used body 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b2 = text(\`ok\`);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     return callTemplate_1.call(this, ctx, node, key + \`__1\`);
   }
 }"
@@ -1280,7 +1280,7 @@ exports[`t-call (template calling) with used body 2`] = `
   let block1 = createBlock(\`<h1><block-text-0/></h1>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx[zero];
+    let txt1 = ctx[zero]?.(node, key);
     return block1([txt1]);
   }
 }"
diff --git a/tests/compiler/__snapshots__/t_call2.test.ts.snap b/tests/compiler/__snapshots__/t_call2.test.ts.snap
new file mode 100644
index 000000000..d62d8f828
--- /dev/null
+++ b/tests/compiler/__snapshots__/t_call2.test.ts.snap
@@ -0,0 +1,1395 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`t-call v_2 (template calling) basic caller 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`_basic-callee\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = callTemplate_1.call(this, {'v_2': 1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) basic caller 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span>ok</span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) basic caller, no parent node 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`_basic-callee\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return callTemplate_1.call(this, {'v_2': 1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) basic caller, no parent node 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span>ok</span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) call with several sub nodes on same line 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block4 = createBlock(\`<span>hey</span>\`);
+  let block6 = createBlock(\`<span>yay</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b4 = block4();
+    const b5 = text(\` \`);
+    const b6 = block6();
+    return multi([b4, b5, b6]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) call with several sub nodes on same line 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = ctx[zero]?.(node, key);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0' 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block4 = createBlock(\`<span>hey</span>\`);
+  let block6 = createBlock(\`<span>yay</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b4 = block4();
+    const b5 = text(\` \`);
+    const b6 = block6();
+    return multi([b4, b5, b6]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0' 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subSubTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block4 = createBlock(\`<span>cascade 0</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b4 = block4();
+    const b5 = ctx[zero]?.(node, key);
+    return multi([b4, b5]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0' 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`finalTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  let block4 = createBlock(\`<span>cascade 1</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b4 = block4();
+    const b5 = ctx[zero]?.(node, key);
+    return multi([b4, b5]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0' 4`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<div><span>cascade 2</span><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = ctx[zero]?.(node, key);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0', without external divs 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  let block3 = createBlock(\`<span>hey</span>\`);
+  let block5 = createBlock(\`<span>yay</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b3 = block3();
+    const b4 = text(\` \`);
+    const b5 = block5();
+    return multi([b3, b4, b5]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0', without external divs 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subSubTemplate\`);
+  
+  let block3 = createBlock(\`<span>cascade 0</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b3 = block3();
+    const b4 = ctx[zero]?.(node, key);
+    return multi([b3, b4]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0', without external divs 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`finalTemplate\`);
+  
+  let block3 = createBlock(\`<span>cascade 1</span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const b3 = block3();
+    const b4 = ctx[zero]?.(node, key);
+    return multi([b3, b4]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) cascading t-call t-out='0', without external divs 4`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block2 = createBlock(\`<span>cascade 2</span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = block2();
+    const b3 = ctx[zero]?.(node, key);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) does not inherit context 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"foo\\", 1);
+    setContextValue(ctx, \\"bar\\", 2);
+    const b2 = callTemplate_1.call(this, {'v_2': 1, bar: ctx['bar']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) does not inherit context 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = text(ctx['foo']);
+    const b3 = text(ctx['bar']);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) dynamic t-call 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const call = app.callTemplate.bind(app);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const template1 = (ctx['template']);
+    const b2 = call(this, template1, {'v_2': 1, val: ctx['val']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) dynamic t-call 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<foo><block-text-0/></foo>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['val'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) dynamic t-call 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<bar><block-text-0/></bar>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['val'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) nested t-calls with magic variable 0 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`grandchild\`);
+  const callTemplate_2 = app.getTemplate(\`child\`);
+  
+  let block3 = createBlock(\`<p>Some content...</p>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    const ctx2 = capture(ctx);
+    const lazyBlock1 = callBody2.bind(this, Object.create(ctx2));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+  
+  function callBody2(ctx, node, key = \\"\\") {
+    return block3();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock2 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_2.call(this, {'v_2': 1, [zero]: lazyBlock2}, node, key + \`__2\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) nested t-calls with magic variable 0 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = text(\`grandchild\`);
+    const b3 = ctx[zero]?.(node, key);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) nested t-calls with magic variable 0 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return ctx[zero]?.(node, key);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 1 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`recursive\`);
+  
+  let block1 = createBlock(\`<div><span>hey</span><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (false) {
+      b2 = callTemplate_1.call(this, {'v_2': 1}, node, key + \`__1\`);
+    }
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 2 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = callTemplate_1.call(this, {'v_2': 1, node: ctx['root']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 2 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { prepareList, withKey } = helpers;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['node'].val;
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`subtree\`] = k_block2[i1];
+      ctx[\`subtree_first\`] = i1 === 0;
+      ctx[\`subtree_last\`] = i1 === k_block2.length - 1;
+      ctx[\`subtree_index\`] = i1;
+      ctx[\`subtree_value\`] = v_block2[i1];
+      const key1 = ctx['subtree_index'];
+      c_block2[i1] = withKey(callTemplate_1.call(this, {'v_2': 1, node: ctx['subtree']}, node, key + \`__1__\${key1}\`), key1);
+    }
+    const b2 = list(c_block2);
+    return block1([txt1], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 3 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = callTemplate_1.call(this, {'v_2': 1, node: ctx['root']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 3 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { prepareList, withKey } = helpers;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><p><block-text-0/></p><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['node'].val;
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`subtree\`] = k_block2[i1];
+      ctx[\`subtree_first\`] = i1 === 0;
+      ctx[\`subtree_last\`] = i1 === k_block2.length - 1;
+      ctx[\`subtree_index\`] = i1;
+      ctx[\`subtree_value\`] = v_block2[i1];
+      const key1 = ctx['subtree_index'];
+      c_block2[i1] = withKey(callTemplate_1.call(this, {'v_2': 1, node: ctx['subtree']}, node, key + \`__1__\${key1}\`), key1);
+    }
+    const b2 = list(c_block2);
+    return block1([txt1], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 4: with t-set recursive index 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = callTemplate_1.call(this, {'v_2': 1, recursive_idx: 1, node: ctx['root']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) recursive template, part 4: with t-set recursive index 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue, prepareList, withKey } = helpers;
+  const callTemplate_1 = app.getTemplate(\`nodeTemplate\`);
+  
+  let block1 = createBlock(\`<div><p><block-text-0/> <block-text-1/></p><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"recursive_idx\\", ctx['recursive_idx']+1);
+    let txt1 = ctx['node'].val;
+    let txt2 = ctx['recursive_idx'];
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['node'].children||[]);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`subtree\`] = k_block2[i1];
+      ctx[\`subtree_first\`] = i1 === 0;
+      ctx[\`subtree_last\`] = i1 === k_block2.length - 1;
+      ctx[\`subtree_index\`] = i1;
+      ctx[\`subtree_value\`] = v_block2[i1];
+      const key1 = ctx['subtree_index'];
+      c_block2[i1] = withKey(callTemplate_1.call(this, {'v_2': 1, node: ctx['subtree'], recursive_idx: ctx['recursive_idx']}, node, key + \`__1__\${key1}\`), key1);
+    }
+    const b2 = list(c_block2);
+    return block1([txt1, txt2], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-foreach 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, prepareList, withKey, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList([1]);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`i\`] = k_block2[i1];
+      const key1 = ctx['i'];
+      c_block2[i1] = withKey(text(\`1\`), key1);
+    }
+    ctx = ctx.__proto__;
+    return list(c_block2);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-foreach 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(\`sub\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-if false 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    let b3;
+    if (false) {
+      b3 = text(\`zero\`);
+    }
+    return multi([b3]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-if false 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(\`sub\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-if true 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    let b3;
+    if (true) {
+      b3 = text(\`zero\`);
+    }
+    return multi([b3]);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-if true 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(\`sub\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-out with default 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, safeOutput, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`subTemplate\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return safeOutput(ctx['nothing']);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) root t-call with body: t-out with default 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(\`sub\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) scoped parameters 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, isBoundary, withDefault, setContextValue, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"foo\\", 42);
+  return text('');
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+    let txt1 = ctx['foo'];
+    return block1([txt1], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) scoped parameters 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(\`ok\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) scoped parameters, part 2 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue, capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-text-0/></div>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"foo\\", 42);
+    return text(ctx['foo']);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"foo\\", 11);
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, foo: 43, [zero]: lazyBlock1}, node, key + \`__1\`);
+    let txt1 = ctx['foo'];
+    return block1([txt1], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) scoped parameters, part 2 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = text(ctx['foo']);
+    const b3 = ctx[zero]?.(node, key);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call on a div with t-call-context 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let ctx1 = ctx['obj'];
+    const b2 = callTemplate_1.call(this, ctx1, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call on a div with t-call-context 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['value'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return callTemplate_1.call(this, {'v_2': 1, 'v1': ctx['val1'], 'v2': ctx['val2']}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['v1'];
+    let txt2 = ctx['v2'];
+    return block1([txt1, txt2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes and t-call-context 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = ctx['obj'];
+    return callTemplate_1.call(this, Object.assign({}, ctx1, {'v_2': 1, 'v1': ctx['val1'], 'v2': ctx['val2']}), node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes and t-call-context 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/><block-text-1/><block-text-2/><block-text-3/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['v1'];
+    let txt2 = ctx['v2'];
+    let txt3 = ctx['v3'];
+    let txt4 = ctx['v4'];
+    return block1([txt1, txt2, txt3, txt4]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes and t-out='0' 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return text(\`Hello\`);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with attributes and t-out='0' 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<span><block-text-0/><block-child-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['v_2'];
+    const b2 = ctx[zero]?.(node, key);
+    return block1([txt1], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with body content as root of a template 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`antony\`);
+  
+  let block2 = createBlock(\`<p>antony</p>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return block2();
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with body content as root of a template 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<foo><block-child-0/></foo>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const b2 = ctx[zero]?.(node, key);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-if 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let b2;
+    if (ctx['flag']) {
+      b2 = callTemplate_1.call(this, {'v_2': 1}, node, key + \`__1\`);
+    }
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-if 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span>ok</span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and body text content 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"val\\", \`yip yip\`);
+    const b2 = callTemplate_1.call(this, {'v_2': 1, val: ctx['val']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and body text content 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<p><block-text-0/></p>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['val'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and outside 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { prepareList, isBoundary, withDefault, setContextValue, withKey } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`v\`] = k_block2[i1];
+      ctx[\`v_first\`] = i1 === 0;
+      ctx[\`v_last\`] = i1 === k_block2.length - 1;
+      ctx[\`v_index\`] = i1;
+      ctx[\`v_value\`] = v_block2[i1];
+      const key1 = ctx['v_index'];
+      setContextValue(ctx, \\"val\\", ctx['v'].val);
+      c_block2[i1] = withKey(callTemplate_1.call(this, {'v_2': 1, 'val3': ctx['val']*3}, node, key + \`__1__\${key1}\`), key1);
+    }
+    const b2 = list(c_block2);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and outside 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['val3'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and outside. 2 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue } = helpers;
+  const callTemplate_1 = app.getTemplate(\`main\`);
+  
+  let block1 = createBlock(\`<p><block-child-0/></p>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"w\\", 'fromwrapper');
+    const b2 = callTemplate_1.call(this, {'v_2': 1, w: ctx['w'], list: ctx['list']}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and outside. 2 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { prepareList, isBoundary, withDefault, setContextValue, withKey } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    ctx = Object.create(ctx);
+    const [k_block2, v_block2, l_block2, c_block2] = prepareList(ctx['list']);;
+    for (let i1 = 0; i1 < l_block2; i1++) {
+      ctx[\`v\`] = k_block2[i1];
+      ctx[\`v_first\`] = i1 === 0;
+      ctx[\`v_last\`] = i1 === k_block2.length - 1;
+      ctx[\`v_index\`] = i1;
+      ctx[\`v_value\`] = v_block2[i1];
+      const key1 = ctx['v_index'];
+      setContextValue(ctx, \\"val\\", ctx['v'].val);
+      c_block2[i1] = withKey(callTemplate_1.call(this, {'v_2': 1, 'val3': ctx['val']*3, w: ctx['w']}, node, key + \`__1__\${key1}\`), key1);
+    }
+    const b2 = list(c_block2);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call with t-set inside and outside. 2 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block2 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['val3'];
+    const b2 = block2([txt1]);
+    const b3 = text(ctx['w']);
+    return multi([b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call, conditional and t-set in t-call body 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue } = helpers;
+  const callTemplate_1 = app.getTemplate(\`callee1\`);
+  const callTemplate_2 = app.getTemplate(\`callee2\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/><block-child-1/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    let b2, b3;
+    setContextValue(ctx, \\"v1\\", 'elif');
+    if (ctx['v1']==='if') {
+      b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
+    } else if (ctx['v1']==='elif') {
+      ctx = Object.create(ctx);
+      ctx[isBoundary] = 1;
+      setContextValue(ctx, \\"v\\", 'success');
+      b3 = callTemplate_2.call(this, ctx, node, key + \`__2\`);
+      ctx = ctx.__proto__;
+    }
+    return block1([], [b2, b3]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call, conditional and t-set in t-call body 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div>callee1</div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call, conditional and t-set in t-call body 3`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div>callee2 <block-text-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['v'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call-context 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = ctx['obj'];
+    return callTemplate_1.call(this, Object.assign({}, ctx1, {'v_2': 1}), node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call-context 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['value'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call-context and value in body 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, isBoundary, withDefault, setContextValue, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"value2\\", ctx['aaron']);
+  return text('');
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const ctx2 = ctx['obj'];
+    return callTemplate_1.call(this, Object.assign({}, ctx2, {'v_2': 1, [zero]: lazyBlock1}), node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call-context and value in body 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['value1'];
+    let txt2 = ctx['value2'];
+    return block1([txt1, txt2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-esc inside t-call, with t-set outside 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { isBoundary, withDefault, setContextValue } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<div><block-child-0/></div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"v\\", \`Hi\`);
+    const b2 = callTemplate_1.call(this, {'v_2': 1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-esc inside t-call, with t-set outside 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<span><block-text-0/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['v'];
+    return block1([txt1]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) values set in body are in call context 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, isBoundary, withDefault, setContextValue, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  let block1 = createBlock(\`<span><block-child-0/></span>\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"foo\\", 'ko');
+  return text('');
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    const b2 = callTemplate_1.call(this, {'v_2': 1, foo: 'ok', [zero]: lazyBlock1}, node, key + \`__1\`);
+    return block1([], [b2]);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) values set in body are in call context 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  return function template(ctx, node, key = \\"\\") {
+    return text(ctx['foo']);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with unused body 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return text(\`WHEEE\`);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with unused body 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div>ok</div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with unused setbody 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, isBoundary, withDefault, setContextValue, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    ctx = Object.create(ctx);
+    ctx[isBoundary] = 1
+    setContextValue(ctx, \\"qux\\", 3);
+  return text('');
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with unused setbody 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  
+  let block1 = createBlock(\`<div>ok</div>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    return block1();
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with used body 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return text(\`ok\`);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {'v_2': 1, [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) with used body 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<h1><block-text-0/></h1>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx[zero]?.(node, key);
+    return block1([txt1]);
+  }
+}"
+`;
diff --git a/tests/compiler/__snapshots__/t_esc.test.ts.snap b/tests/compiler/__snapshots__/t_esc.test.ts.snap
index f623df5f4..1507b4136 100644
--- a/tests/compiler/__snapshots__/t_esc.test.ts.snap
+++ b/tests/compiler/__snapshots__/t_esc.test.ts.snap
@@ -222,7 +222,7 @@ exports[`t-esc t-esc=0 is escaped 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -238,7 +238,7 @@ exports[`t-esc t-esc=0 is escaped 2`] = `
   let block1 = createBlock(\`<span><block-text-0/></span>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    let txt1 = ctx[zero];
+    let txt1 = ctx[zero]?.(node, key);
     return block1([txt1]);
   }
 }"
diff --git a/tests/compiler/__snapshots__/t_out.test.ts.snap b/tests/compiler/__snapshots__/t_out.test.ts.snap
index 12e077344..d26161bd6 100644
--- a/tests/compiler/__snapshots__/t_out.test.ts.snap
+++ b/tests/compiler/__snapshots__/t_out.test.ts.snap
@@ -41,7 +41,7 @@ exports[`t-out multiple calls to t-out 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -57,8 +57,8 @@ exports[`t-out multiple calls to t-out 2`] = `
   let block1 = createBlock(\`<div><block-child-0/><div>Greeter</div><block-child-1/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
-    const b3 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
+    const b3 = ctx[zero]?.(node, key + \`__1\`);
     return block1([], [b2, b3]);
   }
 }"
@@ -108,7 +108,7 @@ exports[`t-out t-out 0 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b3 = block3();
-    ctx[zero] = b3;
+    ctx[zero] = () => b3;
     const b2 = callTemplate_1.call(this, ctx, node, key + \`__1\`);
     return block1([], [b2]);
   }
@@ -124,7 +124,7 @@ exports[`t-out t-out 0 2`] = `
   let block1 = createBlock(\`<div><block-child-0/></div>\`);
   
   return function template(ctx, node, key = \\"\\") {
-    const b2 = ctx[zero];
+    const b2 = ctx[zero]?.(node, key);
     return block1([], [b2]);
   }
 }"
diff --git a/tests/compiler/parser.test.ts b/tests/compiler/parser.test.ts
index c75a5c336..c1453bb86 100644
--- a/tests/compiler/parser.test.ts
+++ b/tests/compiler/parser.test.ts
@@ -1082,6 +1082,8 @@ describe("qweb parser", () => {
       body: {
         type: ASTType.TCall,
         name: "blap",
+        attrs: null,
+        attrsTranslationCtx: null,
         body: null,
         context: null,
       },
@@ -1120,6 +1122,8 @@ describe("qweb parser", () => {
     expect(parse(`<t t-call="blabla" />`)).toEqual({
       type: ASTType.TCall,
       name: "blabla",
+      attrs: null,
+      attrsTranslationCtx: null,
       body: null,
       context: null,
     });
@@ -1129,8 +1133,10 @@ describe("qweb parser", () => {
     expect(parse(`<t t-call="sub">ok</t>`)).toEqual({
       type: ASTType.TCall,
       name: "sub",
+      attrs: null,
+      attrsTranslationCtx: null,
       context: null,
-      body: [{ type: ASTType.Text, value: "ok" }],
+      body: { type: ASTType.Text, value: "ok" },
     });
   });
 
@@ -1138,6 +1144,8 @@ describe("qweb parser", () => {
     expect(parse(`<t t-call="blabla" t-call-context="someContext"/>`)).toEqual({
       type: ASTType.TCall,
       name: "blabla",
+      attrs: null,
+      attrsTranslationCtx: null,
       body: null,
       context: "someContext",
     });
@@ -1158,6 +1166,8 @@ describe("qweb parser", () => {
         {
           type: ASTType.TCall,
           name: "blabla",
+          attrs: null,
+          attrsTranslationCtx: null,
           body: null,
           context: null,
         },
@@ -1174,6 +1184,8 @@ describe("qweb parser", () => {
       content: {
         type: ASTType.TCall,
         name: "blabla",
+        attrs: null,
+        attrsTranslationCtx: null,
         body: null,
         context: null,
       },
@@ -1493,7 +1505,7 @@ describe("qweb parser", () => {
           scope: null,
         },
       },
-      type: 11,
+      type: ASTType.TComponent,
     });
   });
 
@@ -1697,7 +1709,14 @@ describe("qweb parser", () => {
       on: null,
       slots: {
         default: {
-          content: { body: null, name: "subTemplate", type: ASTType.TCall, context: null },
+          content: {
+            body: null,
+            name: "subTemplate",
+            type: ASTType.TCall,
+            attrs: null,
+            attrsTranslationCtx: null,
+            context: null,
+          },
           attrs: null,
           attrsTranslationCtx: null,
           scope: null,
diff --git a/tests/compiler/t_call2.test.ts b/tests/compiler/t_call2.test.ts
new file mode 100644
index 000000000..4984f1ba9
--- /dev/null
+++ b/tests/compiler/t_call2.test.ts
@@ -0,0 +1,560 @@
+import { snapshotEverything, TestContext } from "../helpers";
+
+snapshotEverything();
+
+// -----------------------------------------------------------------------------
+// t-call
+// -----------------------------------------------------------------------------
+
+describe("t-call v_2 (template calling)", () => {
+  test("basic caller", () => {
+    const context = new TestContext();
+    context.addTemplate("_basic-callee", `<span>ok</span>`);
+    context.addTemplate("caller", `<div><t t-call="_basic-callee" v_2="1"/></div>`);
+
+    expect(context.renderToString("caller")).toBe("<div><span>ok</span></div>");
+  });
+
+  test("basic caller, no parent node", () => {
+    const context = new TestContext();
+    context.addTemplate("_basic-callee", `<span>ok</span>`);
+    context.addTemplate("caller", `<t t-call="_basic-callee" v_2="1"/>`);
+
+    expect(context.renderToString("caller")).toBe("<span>ok</span>");
+  });
+
+  test("t-esc inside t-call, with t-set outside", () => {
+    const context = new TestContext();
+    const main = `<div><t t-set="v">Hi</t><t t-call="sub" v_2="1"/></div>`;
+    context.addTemplate("main", main);
+    context.addTemplate("sub", `<span t-esc="v"/>`);
+
+    expect(context.renderToString("main")).toBe("<div><span></span></div>");
+  });
+
+  test("t-call with t-if", () => {
+    const context = new TestContext();
+    const main = '<div><t t-if="flag" t-call="sub" v_2="1"/></div>';
+    context.addTemplate("main", main);
+    context.addTemplate("sub", "<span>ok</span>");
+
+    expect(context.renderToString("main", { flag: true })).toBe("<div><span>ok</span></div>");
+  });
+
+  test("t-call not allowed on a non t node", () => {
+    const context = new TestContext();
+    const main = '<div t-call="sub" v_2="1"/>';
+    context.addTemplate("main", main);
+    context.addTemplate("sub", "<span>ok</span>");
+
+    expect(() => context.renderToString("main")).toThrow(
+      "Directive 't-call' with params can only be used on <t> nodes (used on a <div>)"
+    );
+  });
+
+  test("with unused body", () => {
+    const context = new TestContext();
+    const sub = "<div>ok</div>";
+    const main = '<t t-call="sub" v_2="1">WHEEE</t>';
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<div>ok</div>");
+  });
+
+  test("with unused setbody", () => {
+    const context = new TestContext();
+    const sub = "<div>ok</div>";
+    const main = `<t t-call="sub" v_2="1"><t t-set="qux" t-value="3"/></t>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<div>ok</div>");
+  });
+
+  test("with used body", () => {
+    const context = new TestContext();
+    const sub = '<h1><t t-esc="0"/></h1>';
+    const main = '<t t-call="sub" v_2="1">ok</t>';
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<h1>ok</h1>");
+  });
+
+  test("values set in body are in call context", () => {
+    const context = new TestContext();
+    const sub = '<t t-esc="foo"/>';
+    const main = `<span><t t-call="sub" v_2="1" foo="'ok'"><t t-set="foo" t-value="'ko'"/></t></span>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<span>ok</span>");
+  });
+
+  test("does not inherit context", () => {
+    const context = new TestContext();
+    const sub = '<t t-esc="foo"/><t t-esc="bar"/>';
+    const main = `<div><t t-set="foo" t-value="1"/><t t-set="bar" t-value="2"/><t t-call="sub" v_2="1" bar="bar"/></div>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<div>2</div>");
+  });
+
+  test("scoped parameters", () => {
+    const context = new TestContext();
+    const sub = "<t>ok</t>";
+    const main = `
+        <div>
+          <t t-call="sub" v_2="1">
+            <t t-set="foo" t-value="42"/>
+          </t>
+          <t t-esc="foo"/>
+        </div>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<div>ok</div>");
+  });
+
+  test("scoped parameters, part 2", () => {
+    const context = new TestContext();
+    const sub = '<t t-esc="foo"/><t t-out="0"/>';
+    const main = `
+        <div>
+          <t t-set="foo" t-value="11"/>
+          <t t-call="sub" v_2="1" foo="43">
+            <t t-set="foo" t-value="42"/>
+            <t t-esc="foo"/>
+          </t>
+          <t t-esc="foo"/>
+        </div>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    expect(context.renderToString("main")).toBe("<div>434211</div>");
+  });
+
+  test("call with several sub nodes on same line", () => {
+    const context = new TestContext();
+    const sub = `
+        <div>
+          <t t-out="0"/>
+        </div>`;
+    const main = `
+        <div>
+          <t t-call="sub" v_2="1">
+            <span>hey</span> <span>yay</span>
+          </t>
+        </div>`;
+    context.addTemplate("sub", sub);
+    context.addTemplate("main", main);
+
+    const expected = "<div><div><span>hey</span> <span>yay</span></div></div>";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("cascading t-call t-out='0'", () => {
+    const context = new TestContext();
+    const finalTemplate = `
+        <div>
+          <span>cascade 2</span>
+          <t t-out="0"/>
+        </div>`;
+
+    const subSubTemplate = `
+        <div>
+          <t t-call="finalTemplate" v_2="1">
+            <span>cascade 1</span>
+            <t t-out="0"/>
+          </t>
+        </div>`;
+
+    const subTemplate = `
+        <div>
+          <t t-call="subSubTemplate" v_2="1">
+            <span>cascade 0</span>
+            <t t-out="0"/>
+          </t>
+        </div>`;
+
+    const main = `
+        <div>
+          <t t-call="subTemplate" v_2="1">
+            <span>hey</span> <span>yay</span>
+          </t>
+        </div>`;
+
+    context.addTemplate("finalTemplate", finalTemplate);
+    context.addTemplate("subSubTemplate", subSubTemplate);
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+
+    const expected =
+      "<div><div><div><div><span>cascade 2</span><span>cascade 1</span><span>cascade 0</span><span>hey</span> <span>yay</span></div></div></div></div>";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("cascading t-call t-out='0', without external divs", () => {
+    const context = new TestContext();
+    const finalTemplate = `
+          <span>cascade 2</span>
+          <t t-out="0"/>`;
+
+    const subSubTemplate = `
+          <t t-call="finalTemplate" v_2="1">
+            <span>cascade 1</span>
+            <t t-out="0"/>
+          </t>`;
+
+    const subTemplate = `
+          <t t-call="subSubTemplate" v_2="1">
+            <span>cascade 0</span>
+            <t t-out="0"/>
+          </t>`;
+
+    const main = `
+          <t t-call="subTemplate" v_2="1">
+            <span>hey</span> <span>yay</span>
+          </t>`;
+
+    context.addTemplate("finalTemplate", finalTemplate);
+    context.addTemplate("subSubTemplate", subSubTemplate);
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+
+    const expected =
+      "<span>cascade 2</span><span>cascade 1</span><span>cascade 0</span><span>hey</span> <span>yay</span>";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("recursive template, part 1", () => {
+    const context = new TestContext();
+    const recursive = `
+        <div>
+          <span>hey</span>
+          <t t-if="false">
+            <t t-call="recursive" v_2="1"/>
+          </t>
+        </div>`;
+
+    context.addTemplate("recursive", recursive);
+
+    const expected = "<div><span>hey</span></div>";
+    expect(context.renderToString("recursive")).toBe(expected);
+  });
+
+  test("recursive template, part 2", () => {
+    const context = new TestContext();
+    const Parent = `
+        <div>
+          <t t-call="nodeTemplate" v_2="1" node="root"/>
+        </div>`;
+
+    const nodeTemplate = `
+        <div>
+          <p><t t-esc="node.val"/></p>
+          <t t-foreach="node.children or []" t-as="subtree" t-key="subtree_index">
+              <t t-call="nodeTemplate" v_2="1" node="subtree"/>
+          </t>
+        </div>`;
+
+    context.addTemplate("Parent", Parent);
+    context.addTemplate("nodeTemplate", nodeTemplate);
+
+    const root = { val: "a", children: [{ val: "b" }, { val: "c" }] };
+    const expected = "<div><div><p>a</p><div><p>b</p></div><div><p>c</p></div></div></div>";
+    expect(context.renderToString("Parent", { root })).toBe(expected);
+  });
+
+  test("recursive template, part 3", () => {
+    const context = new TestContext();
+    const Parent = `
+        <div>
+          <t t-call="nodeTemplate" v_2="1" node="root"/>
+        </div>`;
+
+    const nodeTemplate = `
+        <div>
+          <p><t t-esc="node.val"/></p>
+          <t t-foreach="node.children or []" t-as="subtree" t-key="subtree_index">
+            <t t-call="nodeTemplate" v_2="1" node="subtree"/>
+        </t>
+        </div>`;
+
+    context.addTemplate("Parent", Parent);
+    context.addTemplate("nodeTemplate", nodeTemplate);
+
+    const root = { val: "a", children: [{ val: "b", children: [{ val: "d" }] }, { val: "c" }] };
+    const expected =
+      "<div><div><p>a</p><div><p>b</p><div><p>d</p></div></div><div><p>c</p></div></div></div>";
+    expect(context.renderToString("Parent", { root })).toBe(expected);
+  });
+
+  test("recursive template, part 4: with t-set recursive index", () => {
+    const context = new TestContext();
+    const Parent = `
+        <div>
+          <t t-call="nodeTemplate" v_2="1" recursive_idx="1" node="root"/>
+        </div>`;
+
+    const nodeTemplate = `
+        <div>
+          <t t-set="recursive_idx" t-value="recursive_idx + 1"/>
+          <p><t t-esc="node.val"/> <t t-esc="recursive_idx"/></p>
+          <t t-foreach="node.children or []" t-as="subtree" t-key="subtree_index">
+            <t t-call="nodeTemplate" v_2="1" node="subtree" recursive_idx="recursive_idx"/>
+          </t>
+        </div>`;
+
+    context.addTemplate("Parent", Parent);
+    context.addTemplate("nodeTemplate", nodeTemplate);
+
+    const root = {
+      val: "a",
+      children: [{ val: "b", children: [{ val: "c", children: [{ val: "d" }] }] }],
+    };
+    const expected =
+      "<div><div><p>a 2</p><div><p>b 3</p><div><p>c 4</p><div><p>d 5</p></div></div></div></div></div>";
+    expect(context.renderToString("Parent", { root })).toBe(expected);
+  });
+
+  test("t-call, conditional and t-set in t-call body", () => {
+    const context = new TestContext();
+    const callee1 = `<div>callee1</div>`;
+    const callee2 = `<div>callee2 <t t-esc="v"/></div>`;
+    const caller = `
+        <div>
+          <t t-set="v1" t-value="'elif'"/>
+          <t t-if="v1 === 'if'" t-call="callee1" />
+          <t t-elif="v1 === 'elif'" t-call="callee2" >
+            <t t-set="v" t-value="'success'" />
+          </t>
+        </div>`;
+
+    context.addTemplate("callee1", callee1);
+    context.addTemplate("callee2", callee2);
+    context.addTemplate("caller", caller);
+
+    const expected = `<div><div>callee2 success</div></div>`;
+    expect(context.renderToString("caller")).toBe(expected);
+  });
+
+  test("t-call with t-set inside and outside", () => {
+    const context = new TestContext();
+    const main = `
+        <div>
+          <t t-foreach="list" t-as="v" t-key="v_index">
+            <t t-set="val" t-value="v.val"/>
+            <t t-call="sub" v_2="1" val3="val*3"/>
+          </t>
+        </div>`;
+    const sub = `
+        <t>
+          <span t-esc="val3"/>
+        </t>`;
+
+    context.addTemplate("main", main);
+    context.addTemplate("sub", sub);
+
+    const expected = "<div><span>3</span><span>6</span><span>9</span></div>";
+    const ctx = { list: [{ val: 1 }, { val: 2 }, { val: 3 }] };
+    expect(context.renderToString("main", ctx)).toBe(expected);
+  });
+
+  test("t-call with t-set inside and outside. 2", () => {
+    const context = new TestContext();
+    const main = `
+        <div>
+          <t t-foreach="list" t-as="v" t-key="v_index">
+            <t t-set="val" t-value="v.val"/>
+            <t t-call="sub" v_2="1" val3="val*3" w="w"/>
+          </t>
+        </div>`;
+    const sub = `
+        <t>
+          <span t-esc="val3"/>
+          <t t-esc="w"/>
+        </t>`;
+    const wrapper = `<p><t t-set="w" t-value="'fromwrapper'"/><t t-call="main" v_2="1" w="w" list="list"/></p>`;
+
+    context.addTemplate("main", main);
+    context.addTemplate("sub", sub);
+    context.addTemplate("wrapper", wrapper);
+
+    const expected =
+      "<p><div><span>3</span>fromwrapper<span>6</span>fromwrapper<span>9</span>fromwrapper</div></p>";
+    const ctx = { list: [{ val: 1 }, { val: 2 }, { val: 3 }] };
+    expect(context.renderToString("wrapper", ctx)).toBe(expected);
+  });
+
+  test("t-call with t-set inside and body text content", () => {
+    const context = new TestContext();
+    const main = `
+        <div>
+          <t t-set="val">yip yip</t>
+          <t t-call="sub" v_2="1" val="val">
+          </t>
+        </div>`;
+    const sub = `<p><t t-esc="val"/></p>`;
+
+    context.addTemplate("main", main);
+    context.addTemplate("sub", sub);
+
+    const expected = "<div><p>yip yip</p></div>";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("t-call with body content as root of a template", () => {
+    const context = new TestContext();
+    const antony = `<foo><t t-out="0"/></foo>`;
+    const main = `<t><t t-call="antony" v_2="1"><p>antony</p></t></t>`;
+    context.addTemplate("antony", antony);
+    context.addTemplate("main", main);
+    const expected = "<foo><p>antony</p></foo>";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("root t-call with body: t-if true", () => {
+    const context = new TestContext();
+    const subTemplate = `sub`;
+    const main = `<t t-call="subTemplate" v_2="1"><t t-if="true">zero</t></t>`;
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+    const expected = "sub";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("root t-call with body: t-if false", () => {
+    const context = new TestContext();
+    const subTemplate = `sub`;
+    const main = `<t t-call="subTemplate" v_2="1"><t t-if="false">zero</t></t>`;
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+    const expected = "sub";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("root t-call with body: t-out with default", () => {
+    const context = new TestContext();
+    const subTemplate = `sub`;
+    const main = `<t t-call="subTemplate" v_2="1"><t t-out="nothing">default</t></t>`;
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+    const expected = "sub";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("root t-call with body: t-foreach", () => {
+    const context = new TestContext();
+    const subTemplate = `sub`;
+    const main = `<t t-call="subTemplate" v_2="1">
+      <t t-foreach="[1]" t-as="i" t-key="i">1</t>
+    </t>`;
+    context.addTemplate("subTemplate", subTemplate);
+    context.addTemplate("main", main);
+    const expected = "sub";
+    expect(context.renderToString("main")).toBe(expected);
+  });
+
+  test("dynamic t-call", () => {
+    const context = new TestContext();
+    const foo = `<foo><t t-esc="val"/></foo>`;
+    const bar = `<bar><t t-esc="val"/></bar>`;
+    const main = `<div><t t-call="{{template}}" v_2="1" val="val"/></div>`;
+
+    context.addTemplate("foo", foo);
+    context.addTemplate("bar", bar);
+    context.addTemplate("main", main);
+
+    const expected1 = "<div><foo>foo</foo></div>";
+    expect(context.renderToString("main", { template: "foo", val: "foo" })).toBe(expected1);
+    const expected2 = "<div><bar>quux</bar></div>";
+    expect(context.renderToString("main", { template: "bar", val: "quux" })).toBe(expected2);
+  });
+
+  test("t-call-context", () => {
+    const context = new TestContext();
+    context.addTemplate("sub", `<span><t t-esc="value"/></span>`);
+    context.addTemplate("main", `<t t-call="sub" v_2="1" t-call-context="obj"/>`);
+
+    expect(context.renderToString("main", { obj: { value: 123 } })).toBe("<span>123</span>");
+  });
+
+  test("t-call on a div with t-call-context", () => {
+    const context = new TestContext();
+    context.addTemplate("sub", `<span><t t-esc="value"/></span>`);
+    context.addTemplate("main", `<div t-call="sub" t-call-context="obj"/>`);
+
+    expect(context.renderToString("main", { obj: { value: 123 } })).toBe(
+      "<div><span>123</span></div>"
+    );
+  });
+
+  test("t-call-context and value in body", () => {
+    const context = new TestContext();
+    context.addTemplate("sub", `<span><t t-esc="value1"/><t t-esc="value2"/></span>`);
+    context.addTemplate(
+      "main",
+      `
+      <t t-call="sub" v_2="1" t-call-context="obj">
+        <t t-set="value2" t-value="aaron" />
+      </t>`
+    );
+
+    expect(context.renderToString("main", { obj: { value1: 123 }, aaron: "lucas" })).toBe(
+      "<span>123</span>"
+    );
+  });
+
+  test("nested t-calls with magic variable 0", () => {
+    const context = new TestContext();
+    context.addTemplate("grandchild", `grandchild<t t-out="0"/>`);
+    context.addTemplate("child", `<t t-out="0"/>`);
+    context.addTemplate(
+      "main",
+      `
+        <t t-call="child" v_2="1">
+            <t t-call="grandchild" v_2="1">
+                <p>Some content...</p>
+            </t>
+        </t>`
+    );
+
+    expect(context.renderToString("main")).toBe("grandchild<p>Some content...</p>");
+  });
+
+  test("t-call with attributes", () => {
+    const context = new TestContext();
+    context.addTemplate("sub", `<span><t t-esc="v1"/><t t-esc="v2"/></span>`);
+    context.addTemplate("main", `<t t-call="sub" v_2="1" v1="val1" v2="val2"/>`);
+
+    expect(context.renderToString("main", { val1: "abc", val2: "def" })).toBe(
+      "<span>abcdef</span>"
+    );
+  });
+
+  test("t-call with attributes and t-call-context", () => {
+    const context = new TestContext();
+    context.addTemplate(
+      "sub",
+      `<span><t t-esc="v1"/><t t-esc="v2"/><t t-esc="v3"/><t t-esc="v4"/></span>`
+    );
+    context.addTemplate(
+      "main",
+      `<t t-call="sub" v_2="1" t-call-context="obj" v1="val1" v2="val2"/>`
+    );
+
+    expect(
+      context.renderToString("main", { obj: { v3: "ghi", v4: "jkl" }, val1: "abc", val2: "def" })
+    ).toBe("<span>abcdefghijkl</span>");
+  });
+
+  test("t-call with attributes and t-out='0'", () => {
+    const context = new TestContext();
+    context.addTemplate("sub", `<span><t t-esc="v_2"/><t t-out="0"/></span>`);
+    context.addTemplate("main", `<t t-call="sub" v_2="1">Hello</t>`);
+    expect(context.renderToString("main")).toBe("<span>1Hello</span>");
+  });
+});
diff --git a/tests/components/__snapshots__/t_call.test.ts.snap b/tests/components/__snapshots__/t_call.test.ts.snap
index 5eb05c16a..05b9164e1 100644
--- a/tests/components/__snapshots__/t_call.test.ts.snap
+++ b/tests/components/__snapshots__/t_call.test.ts.snap
@@ -11,7 +11,7 @@ exports[`t-call dynamic t-call 1`] = `
     ctx = Object.create(ctx);
     ctx[isBoundary] = 1;
     const b2 = text(\` owl \`);
-    ctx[zero] = b2;
+    ctx[zero] = () => b2;
     const template1 = (ctx['current'].template);
     return call(this, template1, ctx, node, key + \`__1\`);
   }

From b97573c744509a240ecb72e1a97bf4f9122f7647 Mon Sep 17 00:00:00 2001
From: Mathieu Duckerts-Antoine <mathieuduckerts@gmail.com>
Date: Thu, 23 Oct 2025 10:10:19 +0200
Subject: [PATCH 2/2] [WIP] fix problems with translation contexts + test

---
 src/compiler/parser.ts                        |  4 +--
 .../__snapshots__/t_call2.test.ts.snap        | 35 +++++++++++++++++++
 tests/compiler/t_call2.test.ts                | 14 ++++++++
 3 files changed, 51 insertions(+), 2 deletions(-)

diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 7e31c1f9b..bf759b7bb 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -259,10 +259,10 @@ function parseNode(node: Node, ctx: ParsingContext): AST | null {
     parseTForEach(node, ctx) ||
     parseTIf(node, ctx) ||
     parseTPortal(node, ctx) ||
-    parseTCall(node, ctx) ||
-    parseTCallBlock(node, ctx) ||
     parseTTranslation(node, ctx) ||
     parseTTranslationContext(node, ctx) ||
+    parseTCall(node, ctx) ||
+    parseTCallBlock(node, ctx) ||
     parseTKey(node, ctx) ||
     parseTEscNode(node, ctx) ||
     parseTOutNode(node, ctx) ||
diff --git a/tests/compiler/__snapshots__/t_call2.test.ts.snap b/tests/compiler/__snapshots__/t_call2.test.ts.snap
index d62d8f828..f3ec3da06 100644
--- a/tests/compiler/__snapshots__/t_call2.test.ts.snap
+++ b/tests/compiler/__snapshots__/t_call2.test.ts.snap
@@ -772,6 +772,41 @@ exports[`t-call v_2 (template calling) scoped parameters, part 2 2`] = `
 }"
 `;
 
+exports[`t-call v_2 (template calling) t-call and translation contexts 1`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { capture, zero } = helpers;
+  const callTemplate_1 = app.getTemplate(\`sub\`);
+  
+  function callBody1(ctx, node, key = \\"\\") {
+    return text(\`jeu\`);
+  }
+  
+  return function template(ctx, node, key = \\"\\") {
+    const ctx1 = capture(ctx);
+    const lazyBlock1 = callBody1.bind(this, Object.create(ctx1));
+    return callTemplate_1.call(this, {title: 'title', [zero]: lazyBlock1}, node, key + \`__1\`);
+  }
+}"
+`;
+
+exports[`t-call v_2 (template calling) t-call and translation contexts 2`] = `
+"function anonymous(app, bdom, helpers
+) {
+  let { text, createBlock, list, multi, html, toggler, comment } = bdom;
+  let { zero } = helpers;
+  
+  let block1 = createBlock(\`<span><block-text-0/><block-text-1/></span>\`);
+  
+  return function template(ctx, node, key = \\"\\") {
+    let txt1 = ctx['title'];
+    let txt2 = ctx[zero]?.(node, key);
+    return block1([txt1, txt2]);
+  }
+}"
+`;
+
 exports[`t-call v_2 (template calling) t-call on a div with t-call-context 1`] = `
 "function anonymous(app, bdom, helpers
 ) {
diff --git a/tests/compiler/t_call2.test.ts b/tests/compiler/t_call2.test.ts
index 4984f1ba9..26f005d5b 100644
--- a/tests/compiler/t_call2.test.ts
+++ b/tests/compiler/t_call2.test.ts
@@ -557,4 +557,18 @@ describe("t-call v_2 (template calling)", () => {
     context.addTemplate("main", `<t t-call="sub" v_2="1">Hello</t>`);
     expect(context.renderToString("main")).toBe("<span>1Hello</span>");
   });
+
+  test("t-call and translation contexts", () => {
+    const translateFn = jest.fn((expr: string, translationCtx: string) =>
+      translationCtx === "fr" ? "jeu" : translationCtx === "pt" ? "título" : expr
+    );
+
+    const context = new TestContext({ translateFn });
+    context.addTemplate("sub", `<span><t t-esc="title"/><t t-esc="0"/></span>`);
+    context.addTemplate("main", `<t t-call="sub" title="'title'" t-translation-context-title="pt" t-translation-context="fr">game</t>`);
+
+    expect(context.renderToString("main")).toBe(
+      "<span>títulojeu</span>"
+    );
+  });
 });