xmlui 0.8.6 → 0.9.1

package/dist/scripts/src/components-core/script-runner/process-statement-async.js

@@ -11,15 +11,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processStatementQueueAsync = processStatementQueueAsync;
 exports.processDeclarationsAsync = processDeclarationsAsync;
+const ScriptingSourceTreeExp_1 = require("../../abstractions/scripting/ScriptingSourceTreeExp");
 const EngineError_1 = require("../EngineError");
 const reportEngineError_1 = require("../reportEngineError");
+const statement_queue_1 = require("./statement-queue");
 const eval_tree_async_1 = require("./eval-tree-async");
 const process_statement_common_1 = require("./process-statement-common");
-const statement_queue_1 = require("./statement-queue");
+const Parser_1 = require("../../parsers/scripting-exp/Parser");
 // --- Helper function to process the entire queue asynchronously
-function processStatementQueueAsync(statements, evalContext, thread, onStatementCompleted) {
+function processStatementQueueAsync(statements, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c, _d;
         if (!thread) {
             // --- Create the main thread for the queue
             thread = (0, process_statement_common_1.ensureMainThread)(evalContext);
@@ -28,7 +30,7 @@ function processStatementQueueAsync(statements, evalContext, thread, onStatement
         (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statements);
         // --- Fill the queue with items
         const queue = new statement_queue_1.StatementQueue();
-        queue.push((0, statement_queue_1.mapStatementsToQueueItems)(statements));
+        queue.push((0, statement_queue_1.mapStatementsToQueueItems)((0, process_statement_common_1.toStatementItems)(statements)));
         // --- Prepare queue diagnostics information
         const diagInfo = {
             processedStatements: 0,
@@ -50,7 +52,10 @@ function processStatementQueueAsync(statements, evalContext, thread, onStatement
             thread.breakLabelValue = queue.length > 0 ? queue.peek().label : -1;
             let outcome;
             try {
-                outcome = yield processStatementAsync(queueItem.statement, evalContext, thread, onStatementCompleted);
+                // --- Sign that the statement is about to start
+                yield ((_b = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementStarted) === null || _b === void 0 ? void 0 : _b.call(evalContext, evalContext, queueItem.statement));
+                // --- Execute the statement
+                outcome = yield processStatementAsync(queueItem.statement, (_c = queueItem === null || queueItem === void 0 ? void 0 : queueItem.execInfo) !== null && _c !== void 0 ? _c : {}, evalContext, thread);
             }
             catch (err) {
                 if (thread.tryBlocks && thread.tryBlocks.length > 0) {
@@ -70,7 +75,8 @@ function processStatementQueueAsync(statements, evalContext, thread, onStatement
                         (0, reportEngineError_1.reportEngineError)(err);
                     }
                     else {
-                        (0, reportEngineError_1.reportEngineError)(new EngineError_1.StatementExecutionError(err, (_b = queueItem.statement) === null || _b === void 0 ? void 0 : _b.source), err);
+                        // TODO: Provide source code information
+                        (0, reportEngineError_1.reportEngineError)(new EngineError_1.StatementExecutionError(err /* queueItem!.statement?.source */), err);
                     }
                 }
             }
@@ -85,7 +91,8 @@ function processStatementQueueAsync(statements, evalContext, thread, onStatement
                     diagInfo.clearToLabels++;
                 }
             }
-            yield (onStatementCompleted === null || onStatementCompleted === void 0 ? void 0 : onStatementCompleted(evalContext, queueItem.statement));
+            // --- Sign that the statement has been completed
+            yield ((_d = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementCompleted) === null || _d === void 0 ? void 0 : _d.call(evalContext, evalContext, queueItem.statement));
             // --- Provide diagnostics
             if (queue.length > diagInfo.maxQueueLength) {
                 diagInfo.maxQueueLength = queue.length;
@@ -98,140 +105,108 @@ function processStatementQueueAsync(statements, evalContext, thread, onStatement
             }
             diagInfo.processedStatements++;
         }
+        // --- Done.
         return diagInfo;
     });
 }
 /**
  * Process the specified statement asynchronously
  * @param statement Statement to process
+ * @param execInfo Execution information
  * @param evalContext Evaluation context used for processing
  * @param thread Logical thread to use for statement processing
  * @param onStatementCompleted
  * @returns Items to put back into the queue of statements
  */
-function processStatementAsync(statement, evalContext, thread, onStatementCompleted) {
+function processStatementAsync(statement, execInfo, evalContext, thread) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         // --- These items should be put in the statement queue after return
         let toUnshift = [];
         let clearToLabel;
         // --- Process the statement according to its type
         switch (statement.type) {
-            case "ImportD":
-                // --- Get module information
-                const thisModule = statement.module;
-                if (!thisModule) {
-                    throw new Error("Missing module");
-                }
-                const parentModule = (_a = statement.module) === null || _a === void 0 ? void 0 : _a.parent;
-                if (!parentModule) {
-                    throw new Error("Missing parent module");
-                }
-                // --- At this point the imported module is set
-                // if (!statement.module!.executed) {
-                //   // --- Run the module, it has not been executed yet
-                //   const childEvalContext = createEvalContext({
-                //     cancellationToken: evalContext.cancellationToken,
-                //     timeout: evalContext.timeout ?? 1000
-                //   });
-                //   statement.module!.executed = true;
-                //   executeScriptModule(statement.module!, childEvalContext);
-                // }
-                // --- Import the module's exported variables into the parent module
-                const topVars = evalContext.mainThread.blocks[0].vars;
-                const topConst = evalContext.mainThread.blocks[0].constVars;
-                for (const modImports of Object.values(statement.imports)) {
-                    for (const key of Object.keys(modImports)) {
-                        if (key in topVars) {
-                            throw new Error(`Import ${key} already exists`);
-                        }
-                        topVars[key] = statement.module.exports.get(modImports[key]);
-                        topConst.add(key);
-                    }
-                }
-                break;
-            case "FuncD":
+            case ScriptingSourceTreeExp_1.T_FUNCTION_DECLARATION:
                 // --- Function declarations are already hoisted, nothing to do
                 break;
-            case "VarS":
+            case ScriptingSourceTreeExp_1.T_VAR_STATEMENT:
                 if (thread !== evalContext.mainThread) {
                     throw new Error("'var' declarations are not allowed within functions");
                 }
                 break;
-            case "EmptyS":
+            case ScriptingSourceTreeExp_1.T_EMPTY_STATEMENT:
                 // --- Nothing to do
                 break;
-            case "BlockS":
+            case ScriptingSourceTreeExp_1.T_BLOCK_STATEMENT:
                 // --- No statement, nothing to process
-                if (statement.statements.length === 0)
+                if (statement.stmts.length === 0)
                     break;
                 // --- Create a new block scope
-                (_b = thread.blocks) !== null && _b !== void 0 ? _b : (thread.blocks = []);
+                (_a = thread.blocks) !== null && _a !== void 0 ? _a : (thread.blocks = []);
                 thread.blocks.push({ vars: {} });
                 // --- Hoist function declarations to the innermost block scope
-                (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statement.statements);
-                // --- Prepare an empty statement that will only remove the block scope when the entire block is processed
-                const closing = {
-                    type: "EmptyS",
-                    removeBlockScope: true,
-                }; // --- We need the cast as we do not provide required props
-                // --- Queue the block scope's body
-                toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...statement.statements, closing]);
+                (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statement.stmts);
+                // --- Queue the block scope's body...
+                toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                    ...(0, process_statement_common_1.toStatementItems)(statement.stmts),
+                    // --- ...and an empty statement to remove the block scope
+                    (0, process_statement_common_1.closing)(),
+                ]);
                 break;
-            case "ExprS":
+            case ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT:
                 // --- Just evaluate it
-                const statementValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted);
+                const statementValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread);
                 if (thread.blocks && thread.blocks.length !== 0) {
                     thread.blocks[thread.blocks.length - 1].returnValue = statementValue;
                 }
                 break;
-            case "ArrowS":
+            case ScriptingSourceTreeExp_1.T_ARROW_EXPRESSION_STATEMENT:
                 // --- Compile the arrow expression
-                const arrowFuncValue = yield (0, eval_tree_async_1.executeArrowExpression)(statement.expression, evalContext, onStatementCompleted, thread, ...((_c = evalContext.eventArgs) !== null && _c !== void 0 ? _c : []));
+                const arrowFuncValue = yield (0, eval_tree_async_1.executeArrowExpression)(statement.expr, evalContext, thread, ...((_b = evalContext.eventArgs) !== null && _b !== void 0 ? _b : []));
                 if (thread.blocks && thread.blocks.length !== 0) {
                     thread.blocks[thread.blocks.length - 1].returnValue = arrowFuncValue;
                 }
                 break;
-            case "LetS": {
+            case ScriptingSourceTreeExp_1.T_LET_STATEMENT: {
                 // --- Create a new variable in the innermost scope
                 const block = (0, process_statement_common_1.innermostBlockScope)(thread);
                 if (!block) {
                     throw new Error("Missing block scope");
                 }
-                yield processDeclarationsAsync(block, evalContext, thread, onStatementCompleted, statement.declarations);
+                yield processDeclarationsAsync(block, evalContext, thread, statement.decls);
                 break;
             }
-            case "ConstS": {
+            case ScriptingSourceTreeExp_1.T_CONST_STATEMENT: {
                 // --- Create a new variable in the innermost scope
                 const block = (0, process_statement_common_1.innermostBlockScope)(thread);
                 if (!block) {
                     throw new Error("Missing block scope");
                 }
-                yield processDeclarationsAsync(block, evalContext, thread, onStatementCompleted, statement.declarations, true);
+                yield processDeclarationsAsync(block, evalContext, thread, statement.decls, true);
                 break;
             }
-            case "IfS":
+            case ScriptingSourceTreeExp_1.T_IF_STATEMENT:
                 // --- Evaluate the condition
-                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, evalContext, thread));
                 if (condition) {
-                    toUnshift = (0, statement_queue_1.mapToItem)(statement.thenBranch);
+                    toUnshift = (0, statement_queue_1.mapToItem)(statement.thenB);
                 }
-                else if (statement.elseBranch) {
-                    toUnshift = (0, statement_queue_1.mapToItem)(statement.elseBranch);
+                else if (statement.elseB) {
+                    toUnshift = (0, statement_queue_1.mapToItem)(statement.elseB);
                 }
                 break;
-            case "RetS": {
+            case ScriptingSourceTreeExp_1.T_RETURN_STATEMENT: {
                 // --- Check if return is valid here
                 let blockScope = (0, process_statement_common_1.innermostBlockScope)(thread);
                 if (blockScope === undefined) {
                     throw new Error("Return requires a block scope");
                 }
                 // --- Store the return value
-                thread.returnValue = statement.expression
-                    ? yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted)
+                thread.returnValue = statement.expr
+                    ? yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread)
                     : undefined;
                 // --- Check for try blocks
-                if (((_d = thread.tryBlocks) !== null && _d !== void 0 ? _d : []).length > 0) {
+                if (((_c = thread.tryBlocks) !== null && _c !== void 0 ? _c : []).length > 0) {
                     // --- Mark the loop's try scope to exit with "return"
                     const returnTryScope = thread.tryBlocks[0];
                     returnTryScope.exitType = "return";
@@ -249,11 +224,11 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "WhileS": {
+            case ScriptingSourceTreeExp_1.T_WHILE_STATEMENT: {
                 // --- Create or get the loop's scope (guard is falsy for the first execution)
-                let loopScope = statement.guard ? (0, process_statement_common_1.innermostLoopScope)(thread) : (0, process_statement_common_1.createLoopScope)(thread);
+                let loopScope = execInfo.guard ? (0, process_statement_common_1.innermostLoopScope)(thread) : (0, process_statement_common_1.createLoopScope)(thread);
                 // --- Evaluate the loop condition
-                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, evalContext, thread));
                 if (condition) {
                     toUnshift = (0, process_statement_common_1.provideLoopBody)(loopScope, statement, thread.breakLabelValue);
                 }
@@ -263,14 +238,14 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "DoWS": {
-                if (!statement.guard) {
+            case ScriptingSourceTreeExp_1.T_DO_WHILE_STATEMENT: {
+                if (!execInfo.guard) {
                     // --- First loop execution (do-while is a post-test loop)
                     toUnshift = (0, process_statement_common_1.provideLoopBody)((0, process_statement_common_1.createLoopScope)(thread), statement, thread.breakLabelValue);
                     break;
                 }
                 // --- Evaluate the loop condition
-                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, evalContext, thread));
                 if (condition) {
                     toUnshift = (0, process_statement_common_1.provideLoopBody)((0, process_statement_common_1.innermostLoopScope)(thread), statement, thread.breakLabelValue);
                 }
@@ -280,7 +255,7 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "ContS": {
+            case ScriptingSourceTreeExp_1.T_CONTINUE_STATEMENT: {
                 // --- Search for the innermost non-switch loop scope, release the switch scopes
                 if (!thread.loops || thread.loops.length === 0) {
                     throw new Error("Missing loop scope");
@@ -296,7 +271,8 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 if (!loopScope) {
                     throw new Error("Missing loop scope");
                 }
-                if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < ((_e = thread.tryBlocks) !== null && _e !== void 0 ? _e : []).length) {
+                if (loopScope.tryBlockDepth >= 0 &&
+                    loopScope.tryBlockDepth < ((_d = thread.tryBlocks) !== null && _d !== void 0 ? _d : []).length) {
                     // --- Mark the loop's try scope to exit with "continue"
                     for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) {
                         thread.tryBlocks[loopScope.tryBlockDepth].exitType = "continue";
@@ -311,7 +287,7 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "BrkS": {
+            case ScriptingSourceTreeExp_1.T_BREAK_STATEMENT: {
                 const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
                 if (loopScope === undefined) {
                     throw new Error("Missing loop scope");
@@ -322,7 +298,8 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     break;
                 }
                 // --- Break is in a loop construct
-                if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < ((_f = thread.tryBlocks) !== null && _f !== void 0 ? _f : []).length) {
+                if (loopScope.tryBlockDepth >= 0 &&
+                    loopScope.tryBlockDepth < ((_e = thread.tryBlocks) !== null && _e !== void 0 ? _e : []).length) {
                     // --- Mark the loop's try scope to exit with "break"
                     for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) {
                         thread.tryBlocks[loopScope.tryBlockDepth].exitType = "break";
@@ -337,19 +314,19 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "ForS":
-                if (!statement.guard) {
+            case ScriptingSourceTreeExp_1.T_FOR_STATEMENT:
+                if (!execInfo.guard) {
                     // --- Init the loop with a new scope
                     (0, process_statement_common_1.createLoopScope)(thread, 1);
                     // --- Create a new block for the loop variables
-                    (_g = thread.blocks) !== null && _g !== void 0 ? _g : (thread.blocks = []);
+                    (_f = thread.blocks) !== null && _f !== void 0 ? _f : (thread.blocks = []);
                     thread.blocks.push({
                         vars: {},
                     });
-                    const guardStatement = Object.assign(Object.assign({}, statement), { guard: true });
+                    const guardStatement = (0, process_statement_common_1.guard)(statement);
                     if (statement.init) {
                         // --- Unshift the initialization part and the guarded for-loop
-                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.init, guardStatement]);
+                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([{ statement: statement.init }, guardStatement]);
                     }
                     else {
                         // --- No init, unshift only the guard statement
@@ -358,22 +335,31 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 else {
                     // --- Initialization already done. Evaluate the condition
-                    if (!statement.condition ||
-                        !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted))) {
+                    if (!statement.cond || !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, evalContext, thread))) {
                         // --- Stay in the loop, inject the body, the update expression, and the loop guard
                         const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
-                        if (statement.update) {
+                        if (statement.upd) {
                             const updateStmt = {
-                                type: "ExprS",
-                                expression: statement.update,
+                                statement: {
+                                    type: ScriptingSourceTreeExp_1.T_EXPRESSION_STATEMENT,
+                                    nodeId: (0, Parser_1.createXmlUiTreeNodeId)(),
+                                    expr: statement.upd,
+                                },
                             };
-                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, updateStmt, Object.assign({}, statement)]);
+                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                                { statement: statement.body },
+                                updateStmt,
+                                { statement, execInfo },
+                            ]);
                         }
                         else {
-                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                                { statement: statement.body },
+                                { statement, execInfo },
+                            ]);
                         }
                         // --- The next queue label is for "break"
-                        loopScope.breakLabel = (_h = thread.breakLabelValue) !== null && _h !== void 0 ? _h : -1;
+                        loopScope.breakLabel = (_g = thread.breakLabelValue) !== null && _g !== void 0 ? _g : -1;
                         // --- The guard action's label is for "continue"
                         loopScope.continueLabel = toUnshift[1].label;
                     }
@@ -383,10 +369,10 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     }
                 }
                 break;
-            case "ForInS":
-                if (!statement.guard) {
+            case ScriptingSourceTreeExp_1.T_FOR_IN_STATEMENT:
+                if (!execInfo.guard) {
                     // --- Get the object keys
-                    const keyedObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    const keyedObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread);
                     if (keyedObject == undefined) {
                         // --- Nothing to do, no object to traverse
                         break;
@@ -394,32 +380,32 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     // --- Init the loop with a new scope
                     (0, process_statement_common_1.createLoopScope)(thread, 1);
                     // --- Create a new block for the loop variables
-                    (_j = thread.blocks) !== null && _j !== void 0 ? _j : (thread.blocks = []);
+                    (_h = thread.blocks) !== null && _h !== void 0 ? _h : (thread.blocks = []);
                     thread.blocks.push({ vars: {} });
-                    statement.keys = Object.keys(keyedObject);
-                    statement.keyIndex = 0;
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([Object.assign(Object.assign({}, statement), { guard: true })]);
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                        { statement, execInfo: { guard: true, keys: Object.keys(keyedObject), keyIndex: 0 } },
+                    ]);
                 }
                 else {
                     // --- Just for the sake of extra safety
-                    if (statement.keyIndex === undefined || statement.keys === undefined) {
+                    if (execInfo.keyIndex === undefined || execInfo.keys === undefined) {
                         throw new Error("Keys information expected in for..in loop");
                     }
                     // --- Any key left?
-                    if (statement.keyIndex < statement.keys.length) {
+                    if (execInfo.keyIndex < execInfo.keys.length) {
                         // --- Set the binding variable to the next key
-                        const propValue = statement.keys[statement.keyIndex++];
-                        switch (statement.varBinding) {
+                        const propValue = execInfo.keys[execInfo.keyIndex++];
+                        switch (statement.varB) {
                             case "none": {
                                 const assigmentExpr = {
-                                    type: "AsgnE",
+                                    type: ScriptingSourceTreeExp_1.T_ASSIGNMENT_EXPRESSION,
                                     leftValue: {
-                                        type: "IdE",
-                                        name: statement.id,
+                                        type: ScriptingSourceTreeExp_1.T_IDENTIFIER,
+                                        name: statement.id.name,
                                     },
-                                    operator: "=",
-                                    operand: {
-                                        type: "LitE",
+                                    op: "=",
+                                    expr: {
+                                        type: ScriptingSourceTreeExp_1.T_LITERAL,
                                         value: propValue,
                                     },
                                 };
@@ -434,19 +420,22 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                                     if (!block) {
                                         throw new Error("Missing block scope");
                                     }
-                                    block.vars[statement.id] = propValue;
-                                    if (statement.varBinding === "const") {
-                                        (_k = block.constVars) !== null && _k !== void 0 ? _k : (block.constVars = new Set());
-                                        block.constVars.add(statement.id);
+                                    block.vars[statement.id.name] = propValue;
+                                    if (statement.varB === "const") {
+                                        (_j = block.constVars) !== null && _j !== void 0 ? _j : (block.constVars = new Set());
+                                        block.constVars.add(statement.id.name);
                                     }
                                 }
                                 break;
                         }
                         // --- Inject the loop body
                         const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
-                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                            { statement: statement.body },
+                            { statement, execInfo },
+                        ]);
                         // --- The next queue label is for "break"
-                        loopScope.breakLabel = (_l = thread.breakLabelValue) !== null && _l !== void 0 ? _l : -1;
+                        loopScope.breakLabel = (_k = thread.breakLabelValue) !== null && _k !== void 0 ? _k : -1;
                         // --- The guard action's label is for "continue"
                         loopScope.continueLabel = toUnshift[1].label;
                     }
@@ -456,10 +445,10 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     }
                 }
                 break;
-            case "ForOfS":
-                if (!statement.guard) {
+            case ScriptingSourceTreeExp_1.T_FOR_OF_STATEMENT:
+                if (!execInfo.guard) {
                     // --- Get the object keys
-                    const iteratorObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    const iteratorObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread);
                     if (iteratorObject == null || typeof iteratorObject[Symbol.iterator] !== "function") {
                         // --- The object is not an iterator
                         throw new Error("Object in for..of is not iterable");
@@ -467,18 +456,19 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     // --- Init the loop with a new scope
                     (0, process_statement_common_1.createLoopScope)(thread, 1);
                     // --- Create a new block for the loop variables
-                    (_m = thread.blocks) !== null && _m !== void 0 ? _m : (thread.blocks = []);
+                    (_l = thread.blocks) !== null && _l !== void 0 ? _l : (thread.blocks = []);
                     thread.blocks.push({ vars: {} });
-                    statement.iterator = iteratorObject[Symbol.iterator]();
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([Object.assign(Object.assign({}, statement), { guard: true })]);
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                        { statement, execInfo: { guard: true, iterator: iteratorObject[Symbol.iterator]() } },
+                    ]);
                 }
                 else {
                     // --- Just for the sake of extra safety
-                    if (statement.iterator === undefined) {
+                    if (execInfo.iterator === undefined) {
                         throw new Error("Iterator expected in for..of loop");
                     }
                     // --- Any iteration left?
-                    const nextIteration = statement.iterator.next();
+                    const nextIteration = execInfo.iterator.next();
                     if (nextIteration.done) {
                         // --- The for..of loop is complete. Remove the loop's scope from the evaluation context
                         (0, process_statement_common_1.releaseLoopScope)(thread);
@@ -486,17 +476,17 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     }
                     // --- Set the binding variable to the next key
                     const propValue = nextIteration.value;
-                    switch (statement.varBinding) {
+                    switch (statement.varB) {
                         case "none": {
                             const assigmentExpr = {
-                                type: "AsgnE",
+                                type: ScriptingSourceTreeExp_1.T_ASSIGNMENT_EXPRESSION,
                                 leftValue: {
-                                    type: "IdE",
-                                    name: statement.id,
+                                    type: ScriptingSourceTreeExp_1.T_IDENTIFIER,
+                                    name: statement.id.name,
                                 },
-                                operator: "=",
-                                operand: {
-                                    type: "LitE",
+                                op: "=",
+                                expr: {
+                                    type: ScriptingSourceTreeExp_1.T_LITERAL,
                                     value: propValue,
                                 },
                             };
@@ -511,28 +501,31 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                                 if (!block) {
                                     throw new Error("Missing block scope");
                                 }
-                                block.vars[statement.id] = propValue;
-                                if (statement.varBinding === "const") {
-                                    (_o = block.constVars) !== null && _o !== void 0 ? _o : (block.constVars = new Set());
-                                    block.constVars.add(statement.id);
+                                block.vars[statement.id.name] = propValue;
+                                if (statement.varB === "const") {
+                                    (_m = block.constVars) !== null && _m !== void 0 ? _m : (block.constVars = new Set());
+                                    block.constVars.add(statement.id.name);
                                 }
                             }
                             break;
                     }
                     // --- Inject the loop body
                     const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                        { statement: statement.body },
+                        { statement, execInfo },
+                    ]);
                     // --- The next queue label is for "break"
-                    loopScope.breakLabel = (_p = thread.breakLabelValue) !== null && _p !== void 0 ? _p : -1;
+                    loopScope.breakLabel = (_o = thread.breakLabelValue) !== null && _o !== void 0 ? _o : -1;
                     // --- The guard action's label is for "continue"
                     loopScope.continueLabel = toUnshift[1].label;
                 }
                 break;
-            case "ThrowS": {
-                throw new EngineError_1.ThrowStatementError(yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted));
+            case ScriptingSourceTreeExp_1.T_THROW_STATEMENT: {
+                throw new EngineError_1.ThrowStatementError(yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread));
             }
-            case "TryS": {
-                if (!statement.guard) {
+            case ScriptingSourceTreeExp_1.T_TRY_STATEMENT: {
+                if (!execInfo.guard) {
                     // --- Execute the try block
                     toUnshift = (0, process_statement_common_1.provideTryBody)(thread, (0, process_statement_common_1.createTryScope)(thread, statement));
                     break;
@@ -547,10 +540,10 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                                 // --- Remove the "try" block's scope
                                 thread.blocks.pop();
                                 // --- Go on with catch or finally
-                                if (statement.catchBlock) {
-                                    if (tryScope.statement.catchVariable) {
+                                if (statement.catchB) {
+                                    if (tryScope.statement.catchV) {
                                         const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                                        block.vars[tryScope.statement.catchVariable] =
+                                        block.vars[tryScope.statement.catchV.name] =
                                             tryScope.errorToThrow instanceof EngineError_1.ThrowStatementError
                                                 ? tryScope.errorToThrow.errorObject
                                                 : tryScope.errorToThrow;
@@ -559,7 +552,7 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                                     tryScope.processingPhase = "catch";
                                     toUnshift = (0, process_statement_common_1.provideCatchBody)(thread, tryScope);
                                 }
-                                else if (tryScope.statement.finallyBlock) {
+                                else if (tryScope.statement.finallyB) {
                                     // --- No catch, move on finally
                                     tryScope.processingPhase = "finally";
                                     toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
@@ -584,14 +577,14 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     case "try":
                         // --- We completed the try block successfully
                         tryScope.processingPhase = "finally";
-                        if (statement.finallyBlock) {
+                        if (statement.finallyB) {
                             toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
                         }
                         break;
                     case "catch":
                         // --- We completed the catch block successfully, remove the handled error
                         tryScope.processingPhase = "finally";
-                        if (statement.finallyBlock) {
+                        if (statement.finallyB) {
                             toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
                         }
                         break;
@@ -634,9 +627,9 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                 }
                 break;
             }
-            case "SwitchS": {
+            case ScriptingSourceTreeExp_1.T_SWITCH_STATEMENT: {
                 // --- Create or get the loop's scope (guard is falsy for the first execution)
-                if (statement.guard) {
+                if (execInfo.guard) {
                     // --- Complete the switch
                     (0, process_statement_common_1.releaseLoopScope)(thread);
                 }
@@ -645,18 +638,18 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     loopScope.isSwitch = true;
                     thread.blocks.push({ vars: {} });
                     // --- Evaluate the switch value
-                    const switchValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    const switchValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread);
                     // --- Find the matching label
                     let matchingIndex = -1;
                     for (let i = 0; i < statement.cases.length; i++) {
                         const currentCase = statement.cases[i];
                         // --- Check for default case
-                        if (currentCase.caseExpression === undefined) {
+                        if (currentCase.caseE === undefined) {
                             matchingIndex = i;
                             break;
                         }
                         // --- Check for matching case
-                        const caseValue = yield (0, eval_tree_async_1.evalBindingAsync)(currentCase.caseExpression, evalContext, thread);
+                        const caseValue = yield (0, eval_tree_async_1.evalBindingAsync)(currentCase.caseE, evalContext, thread);
                         if (caseValue === switchValue) {
                             matchingIndex = i;
                             break;
@@ -666,19 +659,21 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
                     const statementFlow = [];
                     if (matchingIndex >= 0) {
                         for (let i = matchingIndex; i < statement.cases.length; i++) {
-                            statementFlow.push(...statement.cases[i].statements);
+                            statementFlow.push(...statement.cases[i].stmts);
                         }
                     }
                     // --- Queue the statement flow and the guard
-                    const guardStatement = Object.assign(Object.assign({}, statement), { guard: true });
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...statementFlow, guardStatement]);
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
+                        ...(0, process_statement_common_1.toStatementItems)(statementFlow),
+                        (0, process_statement_common_1.guard)(statement),
+                    ]);
                     loopScope.breakLabel = toUnshift[toUnshift.length - 1].label;
                 }
                 break;
             }
         }
         // --- The statement may remove the innermost scope
-        if (statement.removeBlockScope) {
+        if (execInfo.removeBlockScope) {
             if (thread.blocks && thread.blocks.length > 0) {
                 thread.blocks.pop();
             }
@@ -688,16 +683,16 @@ function processStatementAsync(statement, evalContext, thread, onStatementComple
     });
 }
 // --- Process a variable declaration
-function processDeclarationsAsync(block_1, evalContext_1, thread_1, onStatementCompleted_1, declarations_1) {
-    return __awaiter(this, arguments, void 0, function* (block, evalContext, thread, onStatementCompleted, declarations, addConst = false, useValue = false, baseValue = undefined) {
+function processDeclarationsAsync(block_1, evalContext_1, thread_1, declarations_1) {
+    return __awaiter(this, arguments, void 0, function* (block, evalContext, thread, declarations, addConst = false, useValue = false, baseValue = undefined) {
         for (let i = 0; i < declarations.length; i++) {
             let value;
             const decl = declarations[i];
             if (useValue) {
                 value = baseValue;
             }
-            else if (decl.expression) {
-                value = yield (0, eval_tree_async_1.evalBindingAsync)(decl.expression, evalContext, thread, onStatementCompleted);
+            else if (decl.expr) {
+                value = yield (0, eval_tree_async_1.evalBindingAsync)(decl.expr, evalContext, thread);
             }
             visitDeclaration(block, decl, value, addConst);
         }
@@ -707,11 +702,11 @@ function processDeclarationsAsync(block_1, evalContext_1, thread_1, onStatementC
             if (decl.id) {
                 visitIdDeclaration(block, decl.id, baseValue, addConst);
             }
-            else if (decl.arrayDestruct) {
-                visitArrayDestruct(block, decl.arrayDestruct, baseValue, addConst);
+            else if (decl.aDestr) {
+                visitArrayDestruct(block, decl.aDestr, baseValue, addConst);
             }
-            else if (decl.objectDestruct) {
-                visitObjectDestruct(block, decl.objectDestruct, baseValue, addConst);
+            else if (decl.oDestr) {
+                visitObjectDestruct(block, decl.oDestr, baseValue, addConst);
             }
             else {
                 throw new Error("Unknown declaration specifier");
@@ -737,11 +732,11 @@ function processDeclarationsAsync(block_1, evalContext_1, thread_1, onStatementC
                 if (arrDecl.id) {
                     visitIdDeclaration(block, arrDecl.id, value, addConst);
                 }
-                else if (arrDecl.arrayDestruct) {
-                    visitArrayDestruct(block, arrDecl.arrayDestruct, value, addConst);
+                else if (arrDecl.aDestr) {
+                    visitArrayDestruct(block, arrDecl.aDestr, value, addConst);
                 }
-                else if (arrDecl.objectDestruct) {
-                    visitObjectDestruct(block, arrDecl.objectDestruct, value, addConst);
+                else if (arrDecl.oDestr) {
+                    visitObjectDestruct(block, arrDecl.oDestr, value, addConst);
                 }
             }
         }
@@ -751,11 +746,11 @@ function processDeclarationsAsync(block_1, evalContext_1, thread_1, onStatementC
             for (let i = 0; i < objectD.length; i++) {
                 const objDecl = objectD[i];
                 const value = baseValue === null || baseValue === void 0 ? void 0 : baseValue[objDecl.id];
-                if (objDecl.arrayDestruct) {
-                    visitArrayDestruct(block, objDecl.arrayDestruct, value, addConst);
+                if (objDecl.aDestr) {
+                    visitArrayDestruct(block, objDecl.aDestr, value, addConst);
                 }
-                else if (objDecl.objectDestruct) {
-                    visitObjectDestruct(block, objDecl.objectDestruct, value, addConst);
+                else if (objDecl.oDestr) {
+                    visitObjectDestruct(block, objDecl.oDestr, value, addConst);
                 }
                 else {
                     visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id, value, addConst);