xmlui 0.8.6 → 0.9.1

package/dist/scripts/src/components-core/script-runner/eval-tree-async.js

@@ -11,8 +11,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evalBindingAsync = evalBindingAsync;
 exports.executeArrowExpression = executeArrowExpression;
-exports.isConstVar = isConstVar;
+exports.completeExprValue = completeExprValue;
 const lodash_es_1 = require("lodash-es");
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
 const process_statement_async_1 = require("./process-statement-async");
 const eval_tree_common_1 = require("./eval-tree-common");
 const process_statement_common_1 = require("./process-statement-common");
@@ -25,12 +26,14 @@ const bannedFunctions_1 = require("./bannedFunctions");
  * @param thread The logical thread to use for evaluation
  * @param onStatementCompleted Execute this function when a statement is completed
  */
-function evalBindingAsync(expr, evalContext, thread, onStatementCompleted) {
+function evalBindingAsync(expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
+        // --- Prepare the evaluation context
         const thisStack = [];
         (0, process_statement_common_1.ensureMainThread)(evalContext);
         thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
-        return yield evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, onStatementCompleted);
+        // --- Evaluate the expression using the context
+        return yield evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread);
     });
 }
 /**
@@ -41,10 +44,10 @@ function evalBindingAsync(expr, evalContext, thread, onStatementCompleted) {
  * @param thread The logical thread to use for evaluation
  * @param args Arguments of the arrow function to execute
  */
-function executeArrowExpression(expr, evalContext, onStatementCompleted, thread, ...args) {
+function executeArrowExpression(expr, evalContext, thread, ...args) {
     return __awaiter(this, void 0, void 0, function* () {
         // --- Just an extra safety check
-        if (expr.type !== "ArrowE") {
+        if (expr.type !== ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
             throw new Error("executeArrowExpression expects an 'ArrowExpression' object.");
         }
         // --- This is the evaluator that an arrow expression uses internally
@@ -55,7 +58,7 @@ function executeArrowExpression(expr, evalContext, onStatementCompleted, thread,
         // --- #1: The names of arrow function arguments
         // --- #2: The evaluation context the arrow function runs in
         // --- #others: The real arguments of the arrow function
-        return yield nativeFunction(expr.args, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, onStatementCompleted, ...args);
+        return yield nativeFunction(expr.args, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, ...args);
     });
 }
 /**
@@ -69,52 +72,49 @@ function executeArrowExpression(expr, evalContext, onStatementCompleted, thread,
  * We use `thisStack` to keep track of the partial results of the evaluation tree so that we can set
  * the real `this` context when invoking a function.
  */
-function evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!evalContext.options) {
             evalContext.options = { defaultToOptionalMemberAccess: true };
         }
         // --- Prepare evaluation
-        let customOp = null;
         const evaluator = evalBindingExpressionTreeAsync;
-        // --- Reset the expression scope
-        expr.valueScope = expr.valueIndex = undefined;
         // --- Process the expression according to its type
         try {
             switch (expr.type) {
-                case "TempLitE":
-                    return evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "LitE":
-                    return (0, eval_tree_common_1.evalLiteral)(thisStack, expr);
-                case "IdE":
+                case ScriptingSourceTreeExp_1.T_TEMPLATE_LITERAL_EXPRESSION:
+                    return evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_LITERAL:
+                    return (0, eval_tree_common_1.evalLiteral)(thisStack, expr, thread);
+                case ScriptingSourceTreeExp_1.T_IDENTIFIER:
                     return (0, eval_tree_common_1.evalIdentifier)(thisStack, expr, evalContext, thread);
-                case "MembE":
-                    return yield evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "CMembE":
-                    return yield evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "SeqE":
-                    return yield evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "ALitE":
-                    return yield evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "OLitE":
-                    return yield evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "UnaryE":
-                    return yield evalUnaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted);
-                case "BinaryE":
-                    return yield evalBinaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted);
-                case "CondE":
-                    return yield evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "AsgnE":
-                    return yield evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "PrefE":
-                case "PostfE":
-                    return yield evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "InvokeE":
+                case ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION:
+                    return yield evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
+                    return yield evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_SEQUENCE_EXPRESSION:
+                    return yield evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_ARRAY_LITERAL:
+                    return yield evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_OBJECT_LITERAL:
+                    return yield evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_UNARY_EXPRESSION:
+                    return yield evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_BINARY_EXPRESSION:
+                    return yield evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_CONDITIONAL_EXPRESSION:
+                    return yield evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_ASSIGNMENT_EXPRESSION:
+                    return yield evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_PREFIX_OP_EXPRESSION:
+                case ScriptingSourceTreeExp_1.T_POSTFIX_OP_EXPRESSION:
+                    return yield evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_FUNCTION_INVOCATION_EXPRESSION:
                     // --- Special async handling
-                    return yield evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
-                case "ArrowE":
+                    return yield evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread);
+                case ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION:
                     return (0, eval_tree_common_1.evalArrow)(thisStack, expr, thread);
-                case "SpreadE":
+                case ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION:
                     throw new Error("Cannot use spread expression (...) with the current intermediate value.");
                 default:
                     throw new Error(`Unknown expression tree node: ${expr.type}`);
@@ -126,66 +126,72 @@ function evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread, on
         }
     });
 }
-function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const parentObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
-        return (0, eval_tree_common_1.evalMemberAccessCore)(parentObj, thisStack, expr, evalContext);
-    });
-}
-function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const parentObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
+        yield evaluator(thisStack, expr.obj, evalContext, thread);
+        yield completeExprValue(expr.obj, thread);
         // --- At this point we definitely keep the parent object on `thisStack`, as it will be the context object
         // --- of a FunctionInvocationExpression, if that follows the MemberAccess. Other operations would call
         // --- `thisStack.pop()` to remove the result from the previous `evalBindingExpressionTree` call.
-        const memberObj = yield evaluator(thisStack, expr.member, evalContext, thread, onStatementCompleted);
+        return (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr, evalContext, thread);
+    });
+}
+function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield evaluator(thisStack, expr.obj, evalContext, thread);
+        yield completeExprValue(expr.obj, thread);
+        yield evaluator(thisStack, expr.member, evalContext, thread);
         thisStack.pop();
-        return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(parentObj, memberObj, thisStack, expr, evalContext);
+        yield completeExprValue(expr.member, thread);
+        return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(thisStack, expr, evalContext, thread);
     });
 }
-function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        if (!expr.expressions || expr.expressions.length === 0) {
+        if (!expr.exprs || expr.exprs.length === 0) {
             throw new Error(`Missing expression sequence`);
         }
-        const result = expr.expressions.map((e) => __awaiter(this, void 0, void 0, function* () {
-            const exprValue = yield evaluator(thisStack, e, evalContext, thread, onStatementCompleted);
+        const result = expr.exprs.map((e) => __awaiter(this, void 0, void 0, function* () {
+            const value = yield evaluator(thisStack, e, evalContext, thread);
+            (0, eval_tree_common_1.setExprValue)(e, { value }, thread);
             thisStack.pop();
-            return exprValue;
+            return value;
         }));
         const lastObj = result[result.length - 1];
         thisStack.push(lastObj);
         return lastObj;
     });
 }
-function evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const arrayValue = [];
+        const value = [];
         for (const item of expr.items) {
-            if (item.type === "SpreadE") {
-                const spreadArray = yield evaluator(thisStack, item.operand, evalContext, thread, onStatementCompleted);
+            if (item.type === ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION) {
+                const spreadArray = yield evaluator(thisStack, item.expr, evalContext, thread);
                 thisStack.pop();
                 if (!Array.isArray(spreadArray)) {
                     throw new Error("Spread operator within an array literal expects an array operand.");
                 }
-                arrayValue.push(...spreadArray);
+                value.push(...spreadArray);
             }
             else {
-                arrayValue.push(yield evaluator(thisStack, item, evalContext, thread, onStatementCompleted));
+                value.push(yield evaluator(thisStack, item, evalContext, thread));
                 thisStack.pop();
-                thisStack.push(arrayValue);
+                thisStack.push(value);
             }
         }
-        return arrayValue;
+        // --- Done.
+        (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
+        return value;
     });
 }
-function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         const objectHash = {};
         for (const prop of expr.props) {
             if (!Array.isArray(prop)) {
                 // --- We're using a spread expression
-                const spreadItems = yield evaluator(thisStack, prop.operand, evalContext, thread, onStatementCompleted);
+                const spreadItems = yield evaluator(thisStack, prop.expr, evalContext, thread);
                 thisStack.pop();
                 if (Array.isArray(spreadItems)) {
                     // --- Spread of an array
@@ -204,140 +210,160 @@ function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread,
             // --- We're using key/[value] pairs
             let key;
             switch (prop[0].type) {
-                case "LitE":
+                case ScriptingSourceTreeExp_1.T_LITERAL:
                     key = prop[0].value;
                     break;
-                case "IdE":
+                case ScriptingSourceTreeExp_1.T_IDENTIFIER:
                     key = prop[0].name;
                     break;
                 default:
-                    key = yield evaluator(thisStack, prop[0], evalContext, thread, onStatementCompleted);
+                    key = yield evaluator(thisStack, prop[0], evalContext, thread);
                     thisStack.pop();
                     break;
             }
-            objectHash[key] = yield evaluator(thisStack, prop[1], evalContext, thread, onStatementCompleted);
+            objectHash[key] = yield evaluator(thisStack, prop[1], evalContext, thread);
             thisStack.pop();
         }
+        // --- Done.
+        (0, eval_tree_common_1.setExprValue)(expr, { value: objectHash }, thread);
         thisStack.push(objectHash);
         return objectHash;
     });
 }
-function evalUnaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted) {
+function evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const operand = yield evaluator(thisStack, expr.operand, evalContext, thread, onStatementCompleted);
+        yield evaluator(thisStack, expr.expr, evalContext, thread);
         thisStack.pop();
-        return (0, eval_tree_common_1.evalUnaryCore)(expr, operand, thisStack, customOp);
+        yield completeExprValue(expr.expr, thread);
+        return (0, eval_tree_common_1.evalUnaryCore)(expr, thisStack, evalContext, thread);
     });
 }
-function evalBinaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted) {
+function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const l = yield evaluator(thisStack, expr.left, evalContext, thread, onStatementCompleted);
+        yield evaluator(thisStack, expr.left, evalContext, thread);
         thisStack.pop();
-        if (expr.operator === "&&" && !l) {
-            thisStack.push(l);
+        const l = yield completeExprValue(expr.left, thread);
+        if (expr.op === "&&" && !l) {
+            (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
             return l;
         }
-        if (expr.operator === "||" && l) {
-            thisStack.push(l);
+        if (expr.op === "||" && l) {
+            (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
             return l;
         }
-        const r = yield evaluator(thisStack, expr.right, evalContext, thread, onStatementCompleted);
+        yield evaluator(thisStack, expr.right, evalContext, thread);
         thisStack.pop();
-        return (0, eval_tree_common_1.evalBinaryCore)(l, r, thisStack, customOp, expr.operator);
+        yield completeExprValue(expr.right, thread);
+        return (0, eval_tree_common_1.evalBinaryCore)(expr, thisStack, evalContext, thread);
     });
 }
-function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        const condition = yield evaluator(thisStack, expr.condition, evalContext, thread, onStatementCompleted);
+        yield evaluator(thisStack, expr.cond, evalContext, thread);
         thisStack.pop();
-        return yield evaluator(thisStack, condition ? expr.consequent : expr.alternate, evalContext, thread, onStatementCompleted);
-    });
-}
-function runAssignment(evalContext, doAssignment) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const updateHook = evalContext.onUpdateHook || ((updateFn) => __awaiter(this, void 0, void 0, function* () { return yield updateFn(); }));
-        return yield updateHook(() => __awaiter(this, void 0, void 0, function* () {
-            return yield doAssignment();
-        }));
+        const condition = yield completeExprValue(expr.cond, thread);
+        const value = yield evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
+        (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
+        return value;
     });
 }
-function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        return runAssignment(evalContext, () => __awaiter(this, void 0, void 0, function* () {
-            const leftValue = expr.leftValue;
-            yield evaluator(thisStack, leftValue, evalContext, thread, onStatementCompleted);
-            thisStack.pop();
-            const newValue = yield evaluator(thisStack, expr.operand, evalContext, thread, onStatementCompleted);
-            thisStack.pop();
-            return (0, eval_tree_common_1.evalAssignmentCore)(leftValue, newValue, thisStack, expr, thread);
-        }));
+        const leftValue = expr.leftValue;
+        const rootScope = (0, eval_tree_common_1.getRootIdScope)(leftValue, evalContext, thread);
+        const updatesState = rootScope && rootScope.type !== "block";
+        if (updatesState && evalContext.onWillUpdate) {
+            evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
+        }
+        yield evaluator(thisStack, leftValue, evalContext, thread);
+        thisStack.pop();
+        yield completeExprValue(leftValue, thread);
+        yield evaluator(thisStack, expr.expr, evalContext, thread);
+        thisStack.pop();
+        yield completeExprValue(expr.expr, thread);
+        const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
+        if (updatesState && evalContext.onDidUpdate) {
+            evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
+        }
+        return value;
     });
 }
-function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        return runAssignment(evalContext, () => __awaiter(this, void 0, void 0, function* () {
-            const operand = expr.operand;
-            yield evaluator(thisStack, operand, evalContext, thread, onStatementCompleted);
-            thisStack.pop();
-            return (0, eval_tree_common_1.evalPreOrPostCore)(operand, thisStack, expr, evalContext, thread);
-        }));
+        const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.expr, evalContext, thread);
+        const updatesState = rootScope && rootScope.type !== "block";
+        if (updatesState && evalContext.onWillUpdate) {
+            evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
+        }
+        yield evaluator(thisStack, expr.expr, evalContext, thread);
+        thisStack.pop();
+        yield completeExprValue(expr.expr, thread);
+        const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
+        if (updatesState && evalContext.onDidUpdate) {
+            evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
+        }
+        return value;
     });
 }
-function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
         let functionObj;
         let implicitContextObject = null;
         let hostObject;
         // --- Check for contexted object
-        if (expr.object.type === "MembE") {
-            hostObject = yield evaluator(thisStack, expr.object.object, evalContext, thread, onStatementCompleted);
-            functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(hostObject, thisStack, expr.object, evalContext);
-            if (expr.object.object.type === "IdE" && (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
+        if (expr.obj.type === ScriptingSourceTreeExp_1.T_MEMBER_ACCESS_EXPRESSION) {
+            hostObject = yield evaluator(thisStack, expr.obj.obj, evalContext, thread);
+            yield completeExprValue(expr.obj.obj, thread);
+            functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr.obj, evalContext, thread);
+            if (expr.obj.obj.type === ScriptingSourceTreeExp_1.T_IDENTIFIER && (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
                 implicitContextObject = hostObject;
             }
         }
         else {
             // --- Get the object on which to invoke the function
-            functionObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
+            yield evaluator(thisStack, expr.obj, evalContext, thread);
+            functionObj = yield completeExprValue(expr.obj, thread);
         }
         thisStack.pop();
         // --- Keep function arguments here, we pass it to the function later
         const functionArgs = [];
         // --- The functionObj may be an ArrowExpression. In this care we need to create the invokable arrow function
         if (functionObj === null || functionObj === void 0 ? void 0 : functionObj._ARROW_EXPR_) {
-            functionArgs.push(functionObj.args, evalContext, thread, onStatementCompleted, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+            functionArgs.push(functionObj.args, evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
             functionObj = yield createArrowFunctionAsync(evaluator, functionObj);
         }
-        else if (expr.object.type === "ArrowE") {
+        else if (expr.obj.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
             // --- We delay evaluating expression values. We pass the argument names as the first parameter, and then
             // --- all parameter expressions
-            functionArgs.push(expr.object.args.map((a) => a.name), evalContext, thread, onStatementCompleted, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+            functionArgs.push(expr.obj.args.map((a) => a.name), evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
         }
         else {
             // --- We evaluate the argument values to pass to a JavaScript function
             for (let i = 0; i < expr.arguments.length; i++) {
                 const arg = expr.arguments[i];
-                if (arg.type === "SpreadE") {
-                    const funcArg = yield evaluator([], arg.operand, evalContext, thread, onStatementCompleted);
+                if (arg.type === ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION) {
+                    yield evaluator([], arg.expr, evalContext, thread);
+                    const funcArg = yield completeExprValue(arg.expr, thread);
                     if (!Array.isArray(funcArg)) {
                         throw new Error("Spread operator within a function invocation expects an array operand.");
                     }
                     functionArgs.push(...funcArg);
                 }
                 else {
-                    if (arg.type === "ArrowE") {
+                    if (arg.type === ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION) {
                         const funcArg = yield createArrowFunctionAsync(evaluator, arg);
                         const wrappedFunc = (...args) => __awaiter(this, void 0, void 0, function* () {
-                            return funcArg(arg.args, evalContext, thread, onStatementCompleted, ...args);
+                            return funcArg(arg.args, evalContext, thread, ...args);
                         });
                         functionArgs.push(wrappedFunc);
                     }
                     else {
-                        const funcArg = yield evaluator([], arg, evalContext, thread, onStatementCompleted);
+                        yield evaluator([], arg, evalContext, thread);
+                        const funcArg = yield completeExprValue(arg, thread);
                         if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
                             const wrappedFuncArg = yield createArrowFunctionAsync(evaluator, funcArg);
-                            const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, onStatementCompleted, ...args);
+                            const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
                             functionArgs.push(wrappedFunc);
                         }
                         else {
@@ -369,17 +395,22 @@ function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, th
         // --- async arguments
         functionObj = (0, asyncProxy_1.getAsyncProxy)(functionObj, functionArgs, currentContext);
         // --- Now, invoke the function
-        try {
-            const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
-                ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
-                : functionObj.call(currentContext, ...functionArgs);
-            let returnValue = yield completePromise(value);
-            thisStack.push(returnValue);
-            return returnValue;
+        const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.obj, evalContext, thread);
+        const updatesState = rootScope && rootScope.type !== "block";
+        if (updatesState && evalContext.onWillUpdate) {
+            evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
         }
-        catch (err) {
-            throw err;
+        const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
+            ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
+            : functionObj.call(currentContext, ...functionArgs);
+        let returnValue = yield completePromise(value);
+        if (updatesState && evalContext.onDidUpdate) {
+            evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
         }
+        // --- Done.
+        (0, eval_tree_common_1.setExprValue)(expr, { value: returnValue }, thread);
+        thisStack.push(returnValue);
+        return returnValue;
     });
 }
 function createArrowFunctionAsync(evaluator, expr) {
@@ -390,7 +421,6 @@ function createArrowFunctionAsync(evaluator, expr) {
             // --- Prepare the variables to pass
             const runTimeEvalContext = args[1];
             const runtimeThread = args[2];
-            const runTimeOnStatementCompleted = args[3];
             // --- Create the thread that runs the arrow function
             const workingThread = {
                 parent: runtimeThread,
@@ -420,27 +450,27 @@ function createArrowFunctionAsync(evaluator, expr) {
                 const argSpec = argSpecs[i];
                 let decl;
                 switch (argSpec.type) {
-                    case "IdE": {
+                    case ScriptingSourceTreeExp_1.T_IDENTIFIER: {
                         decl = {
-                            type: "VarD",
+                            type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
                             id: argSpec.name,
                         };
                         break;
                     }
-                    case "Destr": {
+                    case ScriptingSourceTreeExp_1.T_DESTRUCTURE: {
                         decl = {
-                            type: "VarD",
+                            type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
                             id: argSpec.id,
-                            arrayDestruct: argSpec.arrayDestruct,
-                            objectDestruct: argSpec.objectDestruct,
+                            aDestr: argSpec.aDestr,
+                            oDestr: argSpec.oDestr,
                         };
                         break;
                     }
-                    case "SpreadE": {
+                    case ScriptingSourceTreeExp_1.T_SPREAD_EXPRESSION: {
                         restFound = true;
                         decl = {
-                            type: "VarD",
-                            id: argSpec.operand.name,
+                            type: ScriptingSourceTreeExp_1.T_VAR_DECLARATION,
+                            id: argSpec.expr.name,
                         };
                         break;
                     }
@@ -450,25 +480,25 @@ function createArrowFunctionAsync(evaluator, expr) {
                 if (decl) {
                     if (restFound) {
                         // --- Get the rest of the arguments
-                        const restArgs = args.slice(i + 4);
+                        const restArgs = args.slice(i + 3);
                         let argVals = [];
                         for (const arg of restArgs) {
                             if (arg === null || arg === void 0 ? void 0 : arg._EXPRESSION_) {
-                                argVals.push(yield evaluator([], arg, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted));
+                                argVals.push(yield evaluator([], arg, runTimeEvalContext, runtimeThread));
                             }
                             else {
                                 argVals.push(arg);
                             }
                         }
-                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted, [decl], false, true, argVals);
+                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
                     }
                     else {
                         // --- Get the actual value to work with
-                        let argVal = args[i + 4];
+                        let argVal = args[i + 3];
                         if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
-                            argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted);
+                            argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread);
                         }
-                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted, [decl], false, true, argVal);
+                        yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
                     }
                 }
             }
@@ -476,27 +506,27 @@ function createArrowFunctionAsync(evaluator, expr) {
             let returnValue;
             let statements;
             switch (expr.statement.type) {
-                case "EmptyS":
+                case ScriptingSourceTreeExp_1.T_EMPTY_STATEMENT:
                     statements = [];
                     break;
-                case "ExprS":
+                case ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT:
                     // --- Create a new thread for the call
                     statements = [
                         {
-                            type: "RetS",
-                            expression: expr.statement.expression,
+                            type: ScriptingSourceTreeExp_1.T_RETURN_STATEMENT,
+                            expr: expr.statement.expr,
                         },
                     ];
                     break;
-                case "BlockS":
+                case ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT:
                     // --- Create a new thread for the call
-                    statements = expr.statement.statements;
+                    statements = expr.statement.stmts;
                     break;
                 default:
                     throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
             }
             // --- Process the statement with a new processor
-            yield (0, process_statement_async_1.processStatementQueueAsync)(statements, runTimeEvalContext, workingThread, runTimeOnStatementCompleted);
+            yield (0, process_statement_async_1.processStatementQueueAsync)(statements, runTimeEvalContext, workingThread);
             // --- Return value is in a return value slot
             returnValue = workingThread.returnValue;
             // --- Remove the current working thread
@@ -562,32 +592,23 @@ function completePromise(input) {
         }
     });
 }
-/**
- * Gets the context of the variable
- * @param id Identifier to test
- * @param thread Thread to use for evaluation
- */
-function isConstVar(id, thread) {
-    var _a;
-    // --- Start search the block context
-    if (thread.blocks) {
-        for (let idx = thread.blocks.length; idx >= 0; idx--) {
-            const constContext = (_a = thread.blocks[idx]) === null || _a === void 0 ? void 0 : _a.constVars;
-            if (constContext && constContext.has(id))
-                return true;
-        }
-    }
-    // --- Not in block context
-    return false;
-}
-function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
         const segmentValues = new Array(expr.segments.length);
         for (let i = 0; i < expr.segments.length; ++i) {
-            const evaledValue = yield evaluator(thisStack, expr.segments[i], evalContext, thread, onStatementCompleted);
+            yield evaluator(thisStack, expr.segments[i], evalContext, thread);
             thisStack.pop();
-            segmentValues[i] = (evaledValue);
+            const evaledValue = yield completeExprValue(expr.segments[i], thread);
+            segmentValues[i] = evaledValue;
         }
         return (0, eval_tree_common_1.evalTemplateLiteralCore)(segmentValues);
     });
 }
+function completeExprValue(expr, thread) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const exprValue = (0, eval_tree_common_1.getExprValue)(expr, thread);
+        const awaited = yield completePromise(exprValue === null || exprValue === void 0 ? void 0 : exprValue.value);
+        (0, eval_tree_common_1.setExprValue)(expr, Object.assign(Object.assign({}, exprValue), { value: awaited }), thread);
+        return awaited;
+    });
+}