From d15c93af053452c8818059001947caf17e10e8cd Mon Sep 17 00:00:00 2001
From: Tim Mickel <tim.mickel@gmail.com>
Date: Fri, 17 Jun 2016 15:53:58 -0400
Subject: [PATCH] Keep "waiting reporter name" on the stack frame.

Also add highlighting for inputs.
---
 src/engine/execute.js | 14 ++++++++------
 src/engine/thread.js  |  8 +++++---
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/src/engine/execute.js b/src/engine/execute.js
index add9c9909..6657a3e15 100644
--- a/src/engine/execute.js
+++ b/src/engine/execute.js
@@ -10,10 +10,9 @@ var DEBUG_BLOCK_CALLS = true;
  * Execute a block.
  * @param {!Sequencer} sequencer Which sequencer is executing.
  * @param {!Thread} thread Thread which to read and execute.
- * @param {string=} opt_waitingInputName If evaluating an input, its name.
  * @return {?Any} Reported value, if available immediately.
  */
-var execute = function (sequencer, thread, opt_waitingInputName) {
+var execute = function (sequencer, thread) {
     var runtime = sequencer.runtime;
 
     // Current block to execute is the one on the top of the stack.
@@ -48,14 +47,18 @@ var execute = function (sequencer, thread, opt_waitingInputName) {
             if (DEBUG_BLOCK_CALLS) {
                 console.time('Yielding reporter evaluation');
             }
-            var result = execute(sequencer, thread, inputName);
+            runtime.glowBlock(inputBlockId, true);
+            var result = execute(sequencer, thread);
             // Did the reporter yield?
             if (thread.status === Thread.STATUS_YIELD) {
                 // Reporter yielded; don't pop stack and wait for it to unyield.
                 // The value will be populated once the reporter unyields,
                 // and passed up to the currentStackFrame on next execution.
+                // Save name of this input to be filled by child `util.report`.
+                currentStackFrame.waitingReporter = inputName;
                 return;
             }
+            runtime.glowBlock(inputBlockId, false);
             thread.popStack();
             argValues[inputName] = result;
         }
@@ -84,12 +87,11 @@ var execute = function (sequencer, thread, opt_waitingInputName) {
             sequencer.proceedThread(thread);
         },
         report: function(reportedValue) {
-            thread.pushReportedValue(opt_waitingInputName, reportedValue);
             if (DEBUG_BLOCK_CALLS) {
-                console.log('Reported: ', reportedValue,
-                    ' for ', opt_waitingInputName);
+                console.log('Reported: ', reportedValue);
                 console.timeEnd('Yielding reporter evaluation');
             }
+            thread.pushReportedValue(reportedValue);
             sequencer.proceedThread(thread);
         },
         timeout: thread.addTimeout.bind(thread),
diff --git a/src/engine/thread.js b/src/engine/thread.js
index 65b251648..bbb23f678 100644
--- a/src/engine/thread.js
+++ b/src/engine/thread.js
@@ -71,6 +71,7 @@ Thread.prototype.pushStack = function (blockId) {
     if (this.stack.length > this.stackFrames.length) {
         this.stackFrames.push({
             reported: {}, // Collects reported input values.
+            waitingReporter: null, // Name of waiting reporter.
             executionContext: {} // A context passed to block implementations.
         });
     }
@@ -104,13 +105,14 @@ Thread.prototype.peekStackFrame = function () {
 
 /**
  * Push a reported value to the parent of the current stack frame.
- * @param {!string} inputName Name of input reported.
  * @param {!Any} value Reported value to push.
  */
-Thread.prototype.pushReportedValue = function (inputName, value) {
+Thread.prototype.pushReportedValue = function (value) {
     var parentStackFrame = this.stackFrames[this.stackFrames.length - 2];
     if (parentStackFrame) {
-        parentStackFrame.reported[inputName] = value;
+        var waitingReporter = parentStackFrame.waitingReporter;
+        parentStackFrame.reported[waitingReporter] = value;
+        parentStackFrame.waitingReporter = null;
     }
 };