@odoo/owl 3.0.0-alpha.19 → 3.0.0-alpha.20

package/dist/compile_templates.mjs

@@ -328,6 +328,7 @@ function interpolate(s) {
     return replaceDynamicParts(s, compileExpr);
 }
 
+const zero = Symbol("zero");
 const whitespaceRE = /\s+/g;
 // using a non-html document so that <inner/outer>HTML serializes as XML instead
 // of HTML (as we will parse it as xml later)
@@ -446,10 +447,11 @@ class CodeTarget {
     name;
     indentLevel = 0;
     loopLevel = 0;
+    loopCtxVars = [];
+    tSetVars = new Map();
     code = [];
     hasRoot = false;
-    hasCache = false;
-    shouldProtectScope = false;
+    needsScopeProtection = false;
     on;
     constructor(name, on) {
         this.name = name;
@@ -467,13 +469,8 @@ class CodeTarget {
     generateCode() {
         let result = [];
         result.push(`function ${this.name}(ctx, node, key = "") {`);
-        if (this.shouldProtectScope) {
+        if (this.needsScopeProtection) {
             result.push(`  ctx = Object.create(ctx);`);
-            result.push(`  ctx[isBoundary] = 1`);
-        }
-        if (this.hasCache) {
-            result.push(`  let cache = ctx.cache || {};`);
-            result.push(`  let nextCache = ctx.cache = {};`);
         }
         for (let line of this.code) {
             result.push(line);
@@ -506,7 +503,6 @@ const translationRE = /^(\s*)([\s\S]+?)(\s*)$/;
 class CodeGenerator {
     blocks = [];
     nextBlockId = 1;
-    hasSafeContext;
     isDebug = false;
     targets = [];
     target = new CodeTarget("template");
@@ -532,7 +528,6 @@ class CodeGenerator {
             }
             this.translatableAttributes = [...attrs];
         }
-        this.hasSafeContext = options.hasSafeContext || false;
         this.dev = options.dev || false;
         this.ast = ast;
         this.templateName = options.name;
@@ -549,7 +544,6 @@ class CodeGenerator {
             block: null,
             index: 0,
             forceNewBlock: false,
-            isLast: true,
             translate: true,
             translationCtx: "",
             tKeyExpr: null,
@@ -656,39 +650,6 @@ class CodeGenerator {
             this.define(block.varName, blockExpr);
         }
     }
-    /**
-     * Captures variables that are used inside of an expression. This is useful
-     * because in compiled code, almost all variables are accessed through the ctx
-     * object. In the case of functions, that lookup in the context can be delayed
-     * which can cause issues if the value has changed since the function was
-     * defined.
-     *
-     * @param expr the expression to capture
-     * @param forceCapture whether the expression should capture its scope even if
-     *  it doesn't contain a function. Useful when the expression will be used as
-     *  a function body.
-     * @returns a new expression that uses the captured values
-     */
-    captureExpression(expr, forceCapture = false) {
-        if (!forceCapture && !expr.includes("=>")) {
-            return compileExpr(expr);
-        }
-        const tokens = compileExprToArray(expr);
-        const mapping = new Map();
-        return tokens
-            .map((tok) => {
-            if (tok.varName && !tok.isLocal) {
-                if (!mapping.has(tok.varName)) {
-                    const varId = generateId("v");
-                    mapping.set(tok.varName, varId);
-                    this.define(varId, tok.value);
-                }
-                tok.value = mapping.get(tok.varName);
-            }
-            return tok.value;
-        })
-            .join("");
-    }
     translate(str, translationCtx) {
         const match = translationRE.exec(str);
         return match[1] + this.translateFn(match[2], translationCtx) + match[3];
@@ -802,7 +763,28 @@ class CodeGenerator {
         if (modifiers.length) {
             modifiersCode = `${modifiers.join(",")}, `;
         }
-        return `[${modifiersCode}${this.captureExpression(handler)}, ctx]`;
+        const compiled = compileExpr(handler);
+        if (!compiled.trim()) {
+            return `[${modifiersCode}, ctx]`;
+        }
+        let hoistedExpr;
+        const arrowMatch = compiled.match(/^(\([^)]*\))\s*=>/);
+        const bareArrowMatch = !arrowMatch && compiled.match(/^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=>/);
+        if (arrowMatch) {
+            const inner = arrowMatch[1].slice(1, -1).trim();
+            const rest = compiled.slice(arrowMatch[0].length);
+            hoistedExpr = inner ? `(ctx,${inner})=>${rest}` : `(ctx)=>${rest}`;
+        }
+        else if (bareArrowMatch) {
+            const rest = compiled.slice(bareArrowMatch[0].length);
+            hoistedExpr = `(ctx,${bareArrowMatch[1]})=>${rest}`;
+        }
+        else {
+            hoistedExpr = `(ctx, ev) => (${compiled}).call(ctx['this'], ev)`;
+        }
+        const id = generateId("hdlr_fn");
+        this.staticDefs.push({ id, expr: hoistedExpr });
+        return `[${modifiersCode}${id}, ctx]`;
     }
     compileTDomNode(ast, ctx) {
         let { block, forceNewBlock } = ctx;
@@ -907,7 +889,7 @@ class CodeGenerator {
             let valueCode = `ev.target.${targetAttr}`;
             valueCode = shouldTrim ? `${valueCode}.trim()` : valueCode;
             valueCode = shouldNumberize ? `toNumber(${valueCode})` : valueCode;
-            const handler = `[(ev) => { ${exprId}.set(${valueCode}); }]`;
+            const handler = `[(ctx, ev) => { ${exprId}.set(${valueCode}); }, ctx]`;
             idx = block.insertData(handler, "hdlr");
             attrs[`block-handler-${idx}`] = eventType;
         }
@@ -945,7 +927,6 @@ class CodeGenerator {
                     block,
                     index: block.childNumber,
                     forceNewBlock: false,
-                    isLast: ctx.isLast && i === children.length - 1,
                     tKeyExpr: ctx.tKeyExpr,
                     nameSpace,
                     tModelSelectedExpr,
@@ -975,6 +956,16 @@ 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}) || text("")`;
+    }
     compileTOut(ast, ctx) {
         let { block } = ctx;
         if (block) {
@@ -983,8 +974,7 @@ 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;
@@ -1064,7 +1054,9 @@ class CodeGenerator {
         block = this.createBlock(block, "list", ctx);
         this.target.loopLevel++;
         const loopVar = `i${this.target.loopLevel}`;
-        this.addLine(`ctx = Object.create(ctx);`);
+        const ctxVar = generateId("ctx");
+        this.addLine(`const ${ctxVar} = ctx;`);
+        this.target.loopCtxVars.push(ctxVar);
         const vals = `v_block${block.id}`;
         const keys = `k_block${block.id}`;
         const l = `l_block${block.id}`;
@@ -1077,17 +1069,18 @@ class CodeGenerator {
         }
         this.addLine(`for (let ${loopVar} = 0; ${loopVar} < ${l}; ${loopVar}++) {`);
         this.target.indentLevel++;
+        this.addLine(`let ctx = Object.create(${ctxVar});`);
         this.addLine(`ctx[\`${ast.elem}\`] = ${keys}[${loopVar}];`);
-        if (!ast.hasNoFirst) {
+        if (!(ast.noFlags & 1 /* ForEachNoFlag.First */)) {
             this.addLine(`ctx[\`${ast.elem}_first\`] = ${loopVar} === 0;`);
         }
-        if (!ast.hasNoLast) {
+        if (!(ast.noFlags & 2 /* ForEachNoFlag.Last */)) {
             this.addLine(`ctx[\`${ast.elem}_last\`] = ${loopVar} === ${keys}.length - 1;`);
         }
-        if (!ast.hasNoIndex) {
+        if (!(ast.noFlags & 4 /* ForEachNoFlag.Index */)) {
             this.addLine(`ctx[\`${ast.elem}_index\`] = ${loopVar};`);
         }
-        if (!ast.hasNoValue) {
+        if (!(ast.noFlags & 8 /* ForEachNoFlag.Value */)) {
             this.addLine(`ctx[\`${ast.elem}_value\`] = ${vals}[${loopVar}];`);
         }
         this.define(`key${this.target.loopLevel}`, ast.key ? compileExpr(ast.key) : loopVar);
@@ -1097,35 +1090,12 @@ class CodeGenerator {
             this.addLine(`if (keys${block.id}.has(String(key${this.target.loopLevel}))) { throw new OwlError(\`Got duplicate key in t-foreach: \${key${this.target.loopLevel}}\`)}`);
             this.addLine(`keys${block.id}.add(String(key${this.target.loopLevel}));`);
         }
-        let id;
-        if (ast.memo) {
-            this.target.hasCache = true;
-            id = generateId();
-            this.define(`memo${id}`, compileExpr(ast.memo));
-            this.define(`vnode${id}`, `cache[key${this.target.loopLevel}];`);
-            this.addLine(`if (vnode${id}) {`);
-            this.target.indentLevel++;
-            this.addLine(`if (shallowEqual(vnode${id}.memo, memo${id})) {`);
-            this.target.indentLevel++;
-            this.addLine(`${c}[${loopVar}] = vnode${id};`);
-            this.addLine(`nextCache[key${this.target.loopLevel}] = vnode${id};`);
-            this.addLine(`continue;`);
-            this.target.indentLevel--;
-            this.addLine("}");
-            this.target.indentLevel--;
-            this.addLine("}");
-        }
         const subCtx = createContext(ctx, { block, index: loopVar });
         this.compileAST(ast.body, subCtx);
-        if (ast.memo) {
-            this.addLine(`nextCache[key${this.target.loopLevel}] = Object.assign(${c}[${loopVar}], {memo: memo${id}});`);
-        }
         this.target.indentLevel--;
         this.target.loopLevel--;
+        this.target.loopCtxVars.pop();
         this.addLine(`}`);
-        if (!ctx.isLast) {
-            this.addLine(`ctx = ctx.__proto__;`);
-        }
         this.insertBlock("l", block, ctx);
         return block.varName;
     }
@@ -1163,7 +1133,6 @@ class CodeGenerator {
                 block,
                 index,
                 forceNewBlock,
-                isLast: ctx.isLast && i === l - 1,
             });
             this.compileAST(child, subCtx);
             if (forceNewBlock) {
@@ -1192,11 +1161,9 @@ class CodeGenerator {
     }
     compileTCall(ast, ctx) {
         let { block, forceNewBlock } = ctx;
-        let ctxVar = ctx.ctxVar || "ctx";
-        if (ast.context) {
-            ctxVar = generateId("ctx");
-            this.addLine(`let ${ctxVar} = {this: ${compileExpr(ast.context)}, __owl__: this.__owl__};`);
-        }
+        const attrs = ast.attrs
+            ? this.formatPropObject(ast.attrs, ast.attrsTranslationCtx, ctx.translationCtx)
+            : [];
         const isDynamic = INTERP_REGEXP.test(ast.name);
         const subTemplate = isDynamic ? interpolate(ast.name) : "`" + ast.name + "`";
         if (block && !forceNewBlock) {
@@ -1204,39 +1171,39 @@ 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: 3 /* ASTType.Multi */, content: ast.body }, subCtx);
-            if (bl) {
-                this.helpers.add("zero");
-                this.addLine(`${ctxVar}[zero] = ${bl};`);
-            }
+            const name = this.compileInNewTarget("callBody", ast.body, ctx);
+            const zeroStr = generateId("lazyBlock");
+            this.define(zeroStr, `${name}.bind(this, ctx)`);
+            this.helpers.add("zero");
+            attrs.push(`[zero]: ${zeroStr}`);
         }
-        const key = this.generateComponentKey();
-        if (isDynamic) {
-            const templateVar = generateId("template");
-            if (!this.staticDefs.find((d) => d.id === "call")) {
-                this.staticDefs.push({ id: "call", expr: `app.callTemplate.bind(app)` });
+        let ctxExpr;
+        const ctxString = `{${attrs.join(", ")}}`;
+        if (ast.context) {
+            const dynCtxVar = generateId("ctx");
+            this.addLine(`const ${dynCtxVar} = ${compileExpr(ast.context)};`);
+            if (ast.attrs) {
+                ctxExpr = `Object.assign({}, ${dynCtxVar}${attrs.length ? ", " + ctxString : ""})`;
+            }
+            else {
+                const thisCtx = `{this: ${dynCtxVar}, __owl__: this.__owl__}`;
+                ctxExpr = `Object.assign({}, ${dynCtxVar}, ${thisCtx}${attrs.length ? ", " + ctxString : ""})`;
             }
-            this.define(templateVar, subTemplate);
-            this.insertBlock(`call(this, ${templateVar}, ${ctxVar}, 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, {
-                ...ctx,
-                forceNewBlock: !block,
-            });
-        }
-        if (ast.body && !ctx.isLast) {
-            this.addLine(`${ctxVar} = ${ctxVar}.__proto__;`);
+            if (attrs.length === 0) {
+                ctxExpr = "ctx";
+            }
+            else {
+                ctxExpr = `Object.assign(Object.create(ctx), ${ctxString})`;
+            }
         }
+        const key = this.generateComponentKey();
+        this.helpers.add("callTemplate");
+        this.insertBlock(`callTemplate(${subTemplate}, this, app, ${ctxExpr}, node, ${key})`, block, {
+            ...ctx,
+            forceNewBlock: !block,
+        });
         return block.varName;
     }
     compileTCallBlock(ast, ctx) {
@@ -1251,9 +1218,10 @@ class CodeGenerator {
         return block.varName;
     }
     compileTSet(ast, ctx) {
-        this.target.shouldProtectScope = true;
-        this.helpers.add("isBoundary").add("withDefault");
         const expr = ast.value ? compileExpr(ast.value || "") : "null";
+        const isOuterScope = this.target.loopLevel === 0;
+        const defLevel = this.target.tSetVars.get(ast.name);
+        const isReassignment = defLevel !== undefined && this.target.loopLevel > defLevel;
         if (ast.body) {
             this.helpers.add("LazyValue");
             const bodyAst = { type: 3 /* ASTType.Multi */, content: ast.body };
@@ -1261,13 +1229,27 @@ class CodeGenerator {
             let key = this.target.currentKey(ctx);
             let value = `new LazyValue(${name}, ctx, this, node, ${key})`;
             value = ast.value ? (value ? `withDefault(${expr}, ${value})` : expr) : value;
-            this.addLine(`ctx[\`${ast.name}\`] = ${value};`);
+            this.helpers.add("withDefault");
+            if (isReassignment) {
+                const ctxVar = this.target.loopCtxVars[defLevel];
+                this.addLine(`${ctxVar}[\`${ast.name}\`] = ${value};`);
+            }
+            else if (isOuterScope) {
+                this.target.needsScopeProtection = true;
+                this.addLine(`ctx[\`${ast.name}\`] = ${value};`);
+                this.target.tSetVars.set(ast.name, 0);
+            }
+            else {
+                this.addLine(`ctx[\`${ast.name}\`] = ${value};`);
+                this.target.tSetVars.set(ast.name, this.target.loopLevel);
+            }
         }
         else {
             let value;
             if (ast.defaultValue) {
                 const defaultValue = toStringExpression(ctx.translate ? this.translate(ast.defaultValue, ctx.translationCtx) : ast.defaultValue);
                 if (ast.value) {
+                    this.helpers.add("withDefault");
                     value = `withDefault(${expr}, ${defaultValue})`;
                 }
                 else {
@@ -1277,8 +1259,19 @@ class CodeGenerator {
             else {
                 value = expr;
             }
-            this.helpers.add("setContextValue");
-            this.addLine(`setContextValue(${ctx.ctxVar || "ctx"}, "${ast.name}", ${value});`);
+            if (isReassignment) {
+                const ctxVar = this.target.loopCtxVars[defLevel];
+                this.addLine(`${ctxVar}["${ast.name}"] = ${value};`);
+            }
+            else if (isOuterScope) {
+                this.target.needsScopeProtection = true;
+                this.addLine(`ctx["${ast.name}"] = ${value};`);
+                this.target.tSetVars.set(ast.name, 0);
+            }
+            else {
+                this.addLine(`ctx["${ast.name}"] = ${value};`);
+                this.target.tSetVars.set(ast.name, this.target.loopLevel);
+            }
         }
         return null;
     }
@@ -1306,7 +1299,7 @@ class CodeGenerator {
             value = toStringExpression(this.translateFn(value, attrTranslationCtx));
         }
         else {
-            value = this.captureExpression(value);
+            value = compileExpr(value);
         }
         if (name.includes(".")) {
             let [_name, suffix] = name.split(".");
@@ -1345,19 +1338,13 @@ class CodeGenerator {
         // slots
         let slotDef = "";
         if (ast.slots) {
-            let ctxStr = "ctx";
-            if (this.target.loopLevel || !this.hasSafeContext) {
-                ctxStr = generateId("ctx");
-                this.helpers.add("capture");
-                this.define(ctxStr, `capture(ctx)`);
-            }
             let slotStr = [];
             for (let slotName in ast.slots) {
                 const slotAst = ast.slots[slotName];
                 const params = [];
                 if (slotAst.content) {
                     const name = this.compileInNewTarget("slot", slotAst.content, ctx, slotAst.on);
-                    params.push(`__render: ${name}.bind(this), __ctx: ${ctxStr}`);
+                    params.push(`__render: ${name}.bind(this), __ctx: ctx`);
                 }
                 const scope = ast.slots[slotName].scope;
                 if (scope) {
@@ -1411,9 +1398,10 @@ class CodeGenerator {
                 propList.push(`"${name}"`);
             }
         }
+        this.helpers.add("createComponent");
         this.staticDefs.push({
             id,
-            expr: `app.createComponent(${ast.isDynamic ? null : expr}, ${!ast.isDynamic}, ${!!ast.slots}, ${!!ast.dynamicProps}, [${propList}])`,
+            expr: `createComponent(app, ${ast.isDynamic ? null : expr}, ${!ast.isDynamic}, ${!!ast.slots}, ${!!ast.dynamicProps}, [${propList}])`,
         });
         if (ast.isDynamic) {
             // If the component class changes, this can cause delayed renders to go
@@ -1515,25 +1503,18 @@ class CodeGenerator {
         return null;
     }
     compileTPortal(ast, ctx) {
-        if (!this.staticDefs.find((d) => d.id === "Portal")) {
-            this.staticDefs.push({ id: "Portal", expr: `app.Portal` });
-        }
+        this.helpers.add("Portal");
         let { block } = ctx;
         const name = this.compileInNewTarget("slot", ast.content, ctx);
-        let ctxStr = "ctx";
-        if (this.target.loopLevel || !this.hasSafeContext) {
-            ctxStr = generateId("ctx");
-            this.helpers.add("capture");
-            this.define(ctxStr, `capture(ctx)`);
-        }
         let id = generateId("comp");
+        this.helpers.add("createComponent");
         this.staticDefs.push({
             id,
-            expr: `app.createComponent(null, false, true, false, false)`,
+            expr: `createComponent(app, null, false, true, false, false)`,
         });
         const target = compileExpr(ast.target);
         const key = this.generateComponentKey();
-        const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ${ctxStr}}}}, ${key}, node, ctx, Portal)`;
+        const blockString = `${id}({target: ${target},slots: {'default': {__render: ${name}.bind(this), __ctx: ctx}}}, ${key}, node, ctx, Portal)`;
         if (block) {
             this.insertAnchor(block);
         }
@@ -1613,10 +1594,10 @@ function parseNode(node, ctx) {
         parseTForEach(node, ctx) ||
         parseTIf(node, ctx) ||
         parseTPortal(node, ctx) ||
-        parseTCall(node, ctx) ||
-        parseTCallBlock(node) ||
         parseTTranslation(node, ctx) ||
         parseTTranslationContext(node, ctx) ||
+        parseTCall(node, ctx) ||
+        parseTCallBlock(node) ||
         parseTKey(node, ctx) ||
         parseTOutNode(node, ctx) ||
         parseTCallSlot(node, ctx) ||
@@ -1862,28 +1843,27 @@ function parseTForEach(node, ctx) {
         throw new OwlError(`"Directive t-foreach should always be used with a t-key!" (expression: t-foreach="${collection}" t-as="${elem}")`);
     }
     node.removeAttribute("t-key");
-    const memo = node.getAttribute("t-memo") || "";
-    node.removeAttribute("t-memo");
     const body = parseNode(node, ctx);
     if (!body) {
         return null;
     }
     const hasNoTCall = !html.includes("t-call");
-    const hasNoFirst = hasNoTCall && !html.includes(`${elem}_first`);
-    const hasNoLast = hasNoTCall && !html.includes(`${elem}_last`);
-    const hasNoIndex = hasNoTCall && !html.includes(`${elem}_index`);
-    const hasNoValue = hasNoTCall && !html.includes(`${elem}_value`);
+    let noFlags = 0;
+    if (hasNoTCall && !html.includes(`${elem}_first`))
+        noFlags |= 1 /* ForEachNoFlag.First */;
+    if (hasNoTCall && !html.includes(`${elem}_last`))
+        noFlags |= 2 /* ForEachNoFlag.Last */;
+    if (hasNoTCall && !html.includes(`${elem}_index`))
+        noFlags |= 4 /* ForEachNoFlag.Index */;
+    if (hasNoTCall && !html.includes(`${elem}_value`))
+        noFlags |= 8 /* ForEachNoFlag.Value */;
     return {
         type: 8 /* ASTType.TForEach */,
         collection,
         elem,
         body,
-        memo,
         key,
-        hasNoFirst,
-        hasNoLast,
-        hasNoIndex,
-        hasNoValue,
+        noFlags,
     };
 }
 function parseTKey(node, ctx) {
@@ -1913,37 +1893,34 @@ function parseTCall(node, ctx) {
     if (!node.hasAttribute("t-call")) {
         return null;
     }
+    if (node.tagName !== "t") {
+        throw new OwlError(`Directive 't-call' can only be used on <t> nodes (used on a <${node.tagName}>)`);
+    }
     const subTemplate = node.getAttribute("t-call");
     const context = node.getAttribute("t-call-context");
     node.removeAttribute("t-call");
     node.removeAttribute("t-call-context");
-    if (node.tagName !== "t") {
-        const ast = parseNode(node, ctx);
-        const tcall = { type: 6 /* ASTType.TCall */, name: subTemplate, body: null, context };
-        if (ast && ast.type === 2 /* ASTType.DomNode */) {
-            ast.content = [tcall];
-            return ast;
-        }
-        if (ast && ast.type === 10 /* ASTType.TComponent */) {
-            return {
-                ...ast,
-                slots: {
-                    default: {
-                        content: tcall,
-                        scope: null,
-                        on: null,
-                        attrs: null,
-                        attrsTranslationCtx: null,
-                    },
-                },
-            };
+    let attrs = null;
+    let attrsTranslationCtx = 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;
         }
     }
-    const body = parseChildren(node, ctx);
+    const body = parseChildNodes(node, ctx);
     return {
         type: 6 /* ASTType.TCall */,
         name: subTemplate,
-        body: body.length ? body : null,
+        attrs,
+        attrsTranslationCtx,
+        body,
         context,
     };
 }
@@ -2385,12 +2362,8 @@ function compile(template, options = {
 }) {
     // parsing
     const ast = parse(template, options.customDirectives);
-    // some work
-    const hasSafeContext = template instanceof Node
-        ? !(template instanceof Element) || template.querySelector("[t-set], [t-call]") === null
-        : !template.includes("t-set=") && !template.includes("t-call=");
     // code generation
-    const codeGenerator = new CodeGenerator(ast, { ...options, hasSafeContext });
+    const codeGenerator = new CodeGenerator(ast, options);
     const code = codeGenerator.generateCode();
     // template function
     try {