Implement LOOP blocks in compiler

Author: GarboMuffin

src/compiler/compat-block-utility.js

@@ -1,6 +1,15 @@
 const BlockUtility = require('../engine/block-utility');
 
 class CompatibilityLayerBlockUtility extends BlockUtility {
+    constructor () {
+        super();
+        this._stackFrame = {};
+    }
+
+    get stackFrame () {
+        return this._stackFrame;
+    }
+
     // Branching operations are not supported.
     startBranch () {
         throw new Error('startBranch is not supported by this BlockUtility');
@@ -20,9 +29,10 @@ class CompatibilityLayerBlockUtility extends BlockUtility {
         throw new Error('getParam is not supported by this BlockUtility');
     }
 
-    init (thread, fakeBlockId) {
+    init (thread, fakeBlockId, stackFrame) {
         this.thread = thread;
         this.sequencer = thread.target.runtime.sequencer;
+        this._stackFrame = stackFrame;
         thread.stack[0] = fakeBlockId;
     }
 }

src/compiler/irgen.js

@@ -1145,7 +1145,7 @@ class ScriptTreeGenerator {
                 const blockInfo = this.getBlockInfo(block.opcode);
                 if (blockInfo) {
                     const type = blockInfo.info.blockType;
-                    if (type === BlockType.COMMAND || type === BlockType.CONDITIONAL) {
+                    if (type === BlockType.COMMAND || type === BlockType.CONDITIONAL || type === BlockType.LOOP) {
                         return this.descendCompatLayer(block);
                     }
                 }
@@ -1402,7 +1402,7 @@ class ScriptTreeGenerator {
         const blockInfo = this.getBlockInfo(block.opcode);
         const blockType = (blockInfo && blockInfo.info && blockInfo.info.blockType) || BlockType.COMMAND;
         const substacks = [];
-        if (blockType === BlockType.LOOP || blockType === BlockType.CONDITIONAL) {
+        if (blockType === BlockType.CONDITIONAL || blockType === BlockType.LOOP) {
             const branchCount = blockInfo.info.branchCount;
             for (let i = 0; i < branchCount; i++) {
                 const inputName = i === 0 ? 'SUBSTACK' : `SUBSTACK${i + 1}`;

src/compiler/jsexecute.js

@@ -101,6 +101,7 @@ runtimeFunctions.waitThreads = `const waitThreads = function*(threads) {
  * @param {function} blockFunction The primitive's function.
  * @param {boolean} useFlags Whether to set flags (hasResumedFromPromise)
  * @param {string} blockId Block ID to set on the emulated block utility.
+ * @param {*|null} stackFrame Object to use as stack frame.
  * @returns {*} the value returned by the block, if any.
  */
 runtimeFunctions.executeInCompatibilityLayer = `let hasResumedFromPromise = false;
@@ -131,16 +132,13 @@ const isPromise = value => (
     typeof value === 'object' &&
     typeof value.then === 'function'
 );
-const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, useFlags, blockId) {
+const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, useFlags, blockId, stackFrame) {
     const thread = globalState.thread;
-
-    // reset the stackframe
-    // we only ever use one stackframe at a time, so this shouldn't cause issues
-    thread.stackFrames[thread.stackFrames.length - 1].reuse(isWarp);
+    const blockUtility = globalState.blockUtility;
+    if (!stackFrame) stackFrame = {};
 
     const executeBlock = () => {
-        const blockUtility = globalState.blockUtility;
-        blockUtility.init(thread, blockId);
+        blockUtility.init(thread, blockId, stackFrame);
         return blockFunction(inputs, blockUtility);
     };
 
@@ -195,6 +193,11 @@ const executeInCompatibilityLayer = function*(inputs, blockFunction, isWarp, use
     return returnValue;
 }`;
 
+/**
+ * @returns {unknown} An object to use as a stack frame.
+ */
+runtimeFunctions.persistentStackFrame = `const persistentStackFrame = () => ({});`;
+
 /**
  * End the current script.
  */

src/compiler/jsgen.js

@@ -774,6 +774,12 @@ class JSGenerator {
                     this.source += `}\n`;
                 }
                 this.source += `}\n`;
+            } else if (node.blockType === BlockType.LOOP) {
+                const stackFrameName = this.localVariables.next();
+                this.source += `const ${stackFrameName} = persistentStackFrame();\n`;
+                this.source += `while (toBoolean(${this.generateCompatibilityLayerCall(node, isLastInLoop, stackFrameName)})) {\n`;
+                this.descendStack(node.substacks[0], new Frame(true));
+                this.source += '}\n';
             }
 
             if (isLastInLoop) {
@@ -1307,9 +1313,10 @@ class JSGenerator {
      * Generate a call into the compatibility layer.
      * @param {*} node The "compat" kind node to generate from.
      * @param {boolean} setFlags Whether flags should be set describing how this function was processed.
+     * @param {string|null} [frameName] Name of the stack frame variable, if any
      * @returns {string} The JS of the call.
      */
-    generateCompatibilityLayerCall (node, setFlags) {
+    generateCompatibilityLayerCall (node, setFlags, frameName = null) {
         const opcode = node.opcode;
 
         let result = 'yield* executeInCompatibilityLayer({';
@@ -1324,7 +1331,7 @@ class JSGenerator {
             result += `"${sanitize(fieldName)}":"${sanitize(field)}",`;
         }
         const opcodeFunction = this.evaluateOnce(`runtime.getOpcodeFunction("${sanitize(opcode)}")`);
-        result += `}, ${opcodeFunction}, ${this.isWarp}, ${setFlags}, null)`;
+        result += `}, ${opcodeFunction}, ${this.isWarp}, ${setFlags}, null, ${frameName})`;
 
         return result;
     }