@abide/abide 0.123.3 → 0.124.1

package/src/compiler/Lowering.ts

@@ -371,7 +371,7 @@ export class Lowering {
      */
     reference(holder: object): string {
         const span = this.spanOf(holder)
-        return this.boundPath(span) ?? grouped(this.lowerChunk(span, true))
+        return grouped(this.lowerChunk(span, true))
     }
 
     /**
@@ -383,9 +383,17 @@ export class Lowering {
      * A COMPUTED STEP IS EMITTED SOURCE, as 31.8's is: `params[s.k]` writes through `s.k` lowered,
      * so the key is read when the input writes and the get reads it too — the binding follows the
      * key. A `!` is a type and no step. `undefined` for an operand that is not a name followed by
-     * steps, which `reference` lowers as it stands — save 32.76's optional step, which is refused.
+     * steps, which `lower` lowers as it stands — save 32.76's optional step, which is refused.
+     *
+     * IN `lower`, SO THE CHECKER READS THE PAIR THE BUILD EMITS. Taken only where the build asked
+     * (`reference`), the shadow lowered the same path as a read, and a component's `bind:` held
+     * `__bound` to the string it read — TS2769 on a binding the build compiles and runs.
      */
-    private boundPath(span: Span): string | undefined {
+    private boundPath(
+        span: Span,
+        origins: Origin[] | undefined,
+        base: number,
+    ): string | undefined {
         const source = this.projection.text
         const text = source.slice(span.start, span.end)
         const from = span.start + (text.length - text.trimStart().length)
@@ -433,7 +441,20 @@ export class Lowering {
         }
         if (segments.length === 0) return undefined
         const name = this.nameOf(read)
-        return `{ get: () => ${this.lowerChunk({ start: from, end: to })}, set: (${STORED}) => ${name}.set(${this.use('writePath')}(${name}(), [${segments.join(', ')}], ${STORED})) }`
+        const open = '{ get: () => '
+        origins?.push({ at: base, source: from, length: 0 })
+        const got = this.lower(
+            { start: from, end: to },
+            false,
+            origins,
+            base + open.length,
+        )
+        origins?.push({
+            at: base + open.length + got.length,
+            source: to,
+            length: 0,
+        })
+        return `${open}${got}, set: (${STORED}) => ${name}.set(${this.use('writePath')}(${name}(), [${segments.join(', ')}], ${STORED})) }`
     }
 
     /**
@@ -567,6 +588,10 @@ export class Lowering {
         const text = source.slice(from, to)
         const wholeFrom = from + (text.length - text.trimStart().length)
         const wholeTo = from + text.trimEnd().length
+        if (holds) {
+            const path = this.boundPath(span, origins, base)
+            if (path !== undefined) return path
+        }
         const reads = this.answer.reads
         let read = this.answer.firstRead(from)
         if (read === reads.length || (reads[read] as Read).start >= to) {
@@ -817,6 +842,21 @@ export class Lowering {
                 return this.checking && this.importsRaw
                     ? undefined
                     : this.use('raw')
+            // 31.9 — an array mutator called through a path: run on a copy the name then holds.
+            // The checker reads it as the call on the value it is, so its result is typed as one.
+            case 'mutate': {
+                const call = this.lower(read.value as Span).trim()
+                if (this.checking)
+                    return `${this.valueOf(spelled, read, name)}${this.lower({ start: read.end, end: (read.value as Span).start })}${call}`
+                const segments: string[] = []
+                for (const segment of read.path)
+                    segments.push(
+                        segment.name === undefined
+                            ? this.lower(segment)
+                            : JSON.stringify(segment.name),
+                    )
+                return `${this.use('mutatePath')}(${name}, [${segments.join(', ')}], (${MUTATED}) => ${MUTATED}${call})`
+            }
             // 27.13 — the call bound to a name, for the checker to read the defaults' type off.
             case 'config':
                 return this.checking
@@ -999,3 +1039,5 @@ function writeParts(
 // `__` for the reason every framework name in an emitted module is (`importClause`).
 const STORED = '__stored'
 const PREVIOUS = '__previous'
+// 31.9 — the copy a lifted mutator is called on.
+const MUTATED = '__mutated'

package/src/compiler/SHARED_NAMES.ts

@@ -17,6 +17,8 @@ export const SHARED_NAMES: ReadonlySet<string> = new Set([
     'markupRun',
     'RAW_WRITES',
     'writePath',
+    // 31.9 — an array mutator lifted to a write through its receiver's path.
+    'mutatePath',
     'listOf',
     // 32.23's abort, which only the server lane can need: a client binding is its own `watch`
     // and gets one from 2.12. Emitted on both sides because `renderMarkup` is both sides.