From d0d9add20c52facce49c8c30642e25f4480d57cb Mon Sep 17 00:00:00 2001
From: Shu-yu Guo <shu@rfrn.org>
Date: Wed, 8 Dec 2021 17:47:01 -0800
Subject: [PATCH] Do not propagate user-code across Abstract Closure boundaries
 (#382)

---
 src/Spec.ts                                   |  2 +-
 src/Xref.ts                                   | 20 +++++++++++++---
 .../generated-reference/effect-user-code.html | 12 ++++++++++
 test/baselines/sources/effect-user-code.html  | 24 +++++++++++++++++++
 4 files changed, 54 insertions(+), 4 deletions(-)

diff --git a/src/Spec.ts b/src/Spec.ts
index 13d04f89..1b93813b 100644
--- a/src/Spec.ts
+++ b/src/Spec.ts
@@ -474,7 +474,7 @@ export default class Spec {
 
     this.autolink();
 
-    this.log('Propagating can-call-user-code annotations...');
+    this.log('Propagating effect annotations...');
     this.propagateEffects();
     this.log('Linking xrefs...');
     this._xrefs.forEach(xref => xref.build());
diff --git a/src/Xref.ts b/src/Xref.ts
index 21dc6fae..32233742 100644
--- a/src/Xref.ts
+++ b/src/Xref.ts
@@ -89,8 +89,22 @@ export default class Xref extends Builder {
 
   canHaveEffect(effectName: string) {
     if (!this.isInvocation) return false;
-    if (this.clause && !this.clause.canHaveEffect(effectName)) {
-      return false;
+    if (this.clause) {
+      // Xrefs nested inside Abstract Closures should not propagate the
+      // user-code effect, since those are effectively nested functions.
+      //
+      // Calls to Abstract Closures that can call user code must be explicitly
+      // marked as such with <emu-meta effects="user-code">...</emu-meta>.
+      for (let node = this.node; node.parentElement; node = node.parentElement) {
+        const parent = node.parentElement;
+        // This is super hacky. It's checking the output of ecmarkdown.
+        if (parent.tagName === 'LI' && parent.textContent?.includes('be a new Abstract Closure')) {
+          return false;
+        }
+      }
+      if (!this.clause.canHaveEffect(effectName)) {
+        return false;
+      }
     }
     if (this.suppressEffects !== null) {
       return !this.suppressEffects.includes(effectName);
@@ -223,7 +237,7 @@ export default class Xref extends Builder {
         }
         if (this.addEffects !== null) {
           if (effects !== null) {
-            effects.push(...this.addEffects);
+            effects = effects.concat(...this.addEffects);
           } else {
             effects = this.addEffects;
           }
diff --git a/test/baselines/generated-reference/effect-user-code.html b/test/baselines/generated-reference/effect-user-code.html
index d883b1e5..ced6cc64 100644
--- a/test/baselines/generated-reference/effect-user-code.html
+++ b/test/baselines/generated-reference/effect-user-code.html
@@ -90,4 +90,16 @@ <h1><span class="secnum">15</span> RenderedMeta()</h1>
   <p>The abstract operation RenderedMeta takes no arguments. emu-meta tags with the effects attribute that aren't surrounding what ecmarkup recognizes as invocations are changed into span tags to be rendered. The effects list is prefixed with e- and changed into class names. It performs the following steps when called:</p>
   <emu-alg><ol><li>Perform ?&nbsp;<span class="e-user-code"><var>O</var>.[[Call]]()</span>.</li></ol></emu-alg>
 </emu-clause>
+
+<emu-clause id="sec-make-abstract-closure" type="abstract operation" aoid="MakeAbstractClosure">
+  <h1><span class="secnum">16</span> MakeAbstractClosure()</h1>
+  <p>The abstract operation MakeAbstractClosure takes no arguments. The user-code effect doesn't propagate through Abstract Closure boundaries by recognizing the "be a new Abstract Closure" substring. It performs the following steps when called:</p>
+  <emu-alg><ol><li>Let <var>closure</var> be a new Abstract Closure that captures nothing and performs the following steps when called:<ol><li><emu-xref aoid="UserCode" id="_ref_12"><a href="#sec-user-code" class="e-user-code">UserCode</a></emu-xref>().</li></ol></li><li>Return <var>closure</var>.</li></ol></emu-alg>
+</emu-clause>
+
+<emu-clause id="sec-call-make-abstract-closure" type="abstract operation" aoid="CallMakeAbstractClosure">
+  <h1><span class="secnum">17</span> CallMakeAbstractClosure()</h1>
+  <p>The abstract operation CallMakeAbstractClosure takes no arguments. The user-code effect doesn't propagate through Abstract Closure boundaries by recognizing the "be a new Abstract Closure" substring. It performs the following steps when called:</p>
+  <emu-alg><ol><li><emu-xref aoid="MakeAbstractClosure" id="_ref_13"><a href="#sec-make-abstract-closure">MakeAbstractClosure</a></emu-xref>().</li></ol></emu-alg>
+</emu-clause>
 </div></body>
\ No newline at end of file
diff --git a/test/baselines/sources/effect-user-code.html b/test/baselines/sources/effect-user-code.html
index 647ff438..f1612011 100644
--- a/test/baselines/sources/effect-user-code.html
+++ b/test/baselines/sources/effect-user-code.html
@@ -166,3 +166,27 @@ <h1>RenderedMeta()</h1>
     1. Perform ? <emu-meta effects="user-code">_O_.[[Call]]()</emu-meta>.
   </emu-alg>
 </emu-clause>
+
+<emu-clause id="sec-make-abstract-closure" type="abstract operation">
+  <h1>MakeAbstractClosure()</h1>
+  <dl class="header">
+    <dt>description</dt>
+    <dd>The user-code effect doesn't propagate through Abstract Closure boundaries by recognizing the "be a new Abstract Closure" substring.</dd>
+  </dl>
+  <emu-alg>
+    1. Let _closure_ be a new Abstract Closure that captures nothing and performs the following steps when called:
+      1. UserCode().
+    1. Return _closure_.
+  </emu-alg>
+</emu-clause>
+
+<emu-clause id="sec-call-make-abstract-closure" type="abstract operation">
+  <h1>CallMakeAbstractClosure()</h1>
+  <dl class="header">
+    <dt>description</dt>
+    <dd>The user-code effect doesn't propagate through Abstract Closure boundaries by recognizing the "be a new Abstract Closure" substring.</dd>
+  </dl>
+  <emu-alg>
+    1. MakeAbstractClosure().
+  </emu-alg>
+</emu-clause>