[FIX] qweb: t-foreach needs to hold on scope

Have a t-on within a t-foreach
the t-on has an expression

Before this commit, when triggering the t-on, the expression was falsely evaluated
In details, the expression took scope from outside the foreach loop
as we protect it to have similar results than an actual for loop

But, at triggering time, the scope protection had already been terminated
meaning the info of the iteration of the loop the handler has been built in
had already disappeared

This commit fixes that

closes #594

src/qweb/compilation_context.ts

@@ -1,4 +1,4 @@
-import { compileExpr, QWebVar } from "./expression_parser";
+import { compileExpr , compileExprToArray , QWebVar } from "./expression_parser";
 
 export const INTERP_REGEXP = /\{\{.*?\}\}/g;
 //------------------------------------------------------------------------------
@@ -156,6 +156,22 @@ export class CompilationContext {
     this.rootContext.shouldDefineScope = true;
     return compileExpr(expr, this.variables);
   }
+  captureExpression(expr: string): string {
+    this.rootContext.shouldDefineScope = true;
+    const argId = this.generateID();
+    const tokens = compileExprToArray(expr, this.variables);
+    const done = new Set();
+    return tokens.map((tok) => {
+      if (tok.varName) {
+        if (!done.has(tok.varName)) {
+          done.add(tok.varName);
+          this.addLine(`const ${tok.varName}_${argId} = ${tok.value};`);
+        }
+        tok.value = `${tok.varName}_${argId}`;
+      }
+      return tok.value;
+    }).join("");
+  }
 
   /**
    * Perform string interpolation on the given string. Note that if the whole
@@ -187,4 +203,4 @@ export class CompilationContext {
     this.rootContext.protectedScopeNumber--;
     this.addLine(`scope = _origScope${protectID};`);
   }
-}
+}

src/qweb/expression_parser.ts

@@ -66,6 +66,7 @@ interface Token {
   value: string;
   originalValue?: string;
   size?: number;
+  varName?: string;
 }
 
 const STATIC_TOKEN_MAP: { [key: string]: TKind } = {
@@ -234,7 +235,7 @@ export function tokenize(expr: string): Token[] {
  * the arrow operator, then we add the current (or some previous tokens) token to
  * the list of variables so it does not get replaced by a lookup in the context
  */
-export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
+export function compileExprToArray(expr: string, scope: { [key: string]: QWebVar }): Token[] {
   scope = Object.create(scope);
   const tokens = tokenize(expr);
   for (let i = 0; i < tokens.length; i++) {
@@ -269,6 +270,7 @@ export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): st
     }
 
     if (isVar) {
+      token.varName = token.value;
       if (token.value in scope && "id" in scope[token.value]) {
         token.value = scope[token.value].expr!;
       } else {
@@ -277,5 +279,9 @@ export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): st
       }
     }
   }
-  return tokens.map(t => t.value).join("");
+  return tokens;
+}
+
+export function compileExpr(expr: string, scope: { [key: string]: QWebVar }): string {
+  return compileExprToArray(expr, scope).map(t => t.value).join("");
 }

src/qweb/extensions.ts

@@ -58,7 +58,7 @@ export function makeHandlerCode(
     ctx.rootContext.shouldDefineUtils = true;
     const comp = `utils.getComponent(context)`;
     if (args) {
-      let argId = ctx.generateID();
+      const argId = ctx.generateID();
       ctx.addLine(`let args${argId} = [${ctx.formatExpression(args)}];`);
       code = `${comp}['${name}'](...args${argId}, e);`;
       putInCache = false;
@@ -67,8 +67,9 @@ export function makeHandlerCode(
     }
   } else {
     // if we get here, then it is an expression
+    // we need to capture every variable in it
     putInCache = false;
-    code = ctx.formatExpression(value);
+    code = ctx.captureExpression(value);
   }
   const modCode = mods.map(mod => modcodes[mod]).join("");
   let handler = `function (e) {if (!context.__owl__.isMounted){return}${modCode}${code}}`;