aontu 0.52.0 → 0.52.1

package/src/val/ExpectVal.ts

@@ -35,6 +35,21 @@ class ExpectVal extends FeatureVal {
   parent?: Val
   key?: string
 
+  // An expectation canons as THE EXPECTATION ITSELF -- the peg the peer
+  // must satisfy. Val.canon's default was the empty string, which
+  // rendered a key with no value (`{"r":}`): text that is not a document
+  // and could not be reparsed, breaking canon's round-trip contract in
+  // both engines (issue #43).
+  //
+  // Not `top`, which was the first fix here and was wrong. An ExpectVal
+  // is created for EVERY peer-introduced non-generable key, not just for
+  // `&:` spread children -- `m:{x:1} m:{y:string}` makes one at `y` with
+  // no spread in sight -- so rendering `top` erased the `string` and the
+  // canon reparsed into a document that accepts values the original
+  // rejects. A canon that silently drops a constraint is worse than one
+  // that fails to parse. Go's ExpectVal.Canon renders the same peg.
+  get canon() { return this.peg.canon }
+
   constructor(
     spec: ValSpec,
     ctx?: AontuContext

package/src/val/FuncBaseVal.ts

@@ -11,7 +11,7 @@ import {
 } from '../type'
 
 import { AontuContext } from '../ctx'
-import { unite } from '../unify'
+import { unite, withDepth } from '../unify'
 
 
 import {
@@ -100,7 +100,13 @@ class FuncBaseVal extends FeatureVal {
 
             let newarg = arg
             if (!arg.done) {
-              newarg = arg.unify(TOP, te ? ctx.clone({ explain: ec(te, 'ARG') }) : ctx)
+              // Charged to the depth budget: this recurses without going
+              // through `unite`, so the counter would otherwise stay flat
+              // while the stack grows (see withDepth in unify.ts). The
+              // arg context is built OUTSIDE the closure so its explain
+              // ternary stays one branch rather than one per call.
+              const argctx = te ? ctx.clone({ explain: ec(te, 'ARG') }) : ctx
+              newarg = withDepth(ctx, arg, TOP, () => arg.unify(TOP, argctx))
               newtype = newtype || newarg.mark.type
               newhide = newhide || newarg.mark.hide
               // console.log('FUNCBASE-UNIFY-PEG-B', arg.canon, arg.done, '->', newarg.canon, newarg.done)

package/src/val/ListVal.ts

@@ -76,6 +76,16 @@ class ListVal extends BagVal {
     const TOP = top()
     peer = peer ?? TOP
 
+    // A sizing residual (`length`, `unique`) sorts AFTER containers in a
+    // conjunct so that it counts the MERGED list rather than the first
+    // fragment (SIZING_CJO in ConstraintVal.ts). That makes the list the
+    // accumulator and the constraint its peer, the reverse of the usual
+    // order — and the reading belongs to the constraint either way, so
+    // hand it straight back.
+    if (true === (peer as any).isConstraint) {
+      return peer.unify(this, ctx)
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'List', this, peer)
     let done: boolean = true
     let exit = false
@@ -263,10 +273,14 @@ class ListVal extends BagVal {
       '[' +
       (this.spread.cj ? '&:' + this.spread.cj.canon +
         (0 < keys.length ? ',' : '') : '') +
-      keys
-        .map(k => this.optionalKeys.includes(k) ?
-          k + '?:' + this.peg[k].canon :
-          this.peg[k].canon).join(',') +
+      // No optional-element rendering. A list HAS no optional elements to
+      // render: a key:value pair in list position contributes no element
+      // at all, in either spelling and whatever its key (issue #40), so
+      // nothing a source can write reaches this method with an optional
+      // key. The Go port's ListVal.Canon has no such arm either, and the
+      // two canons must agree -- a canon is round-trippable, and a marker
+      // on an element the grammar cannot produce would not reparse.
+      keys.map(k => this.peg[k].canon).join(',') +
       ']'
   }
 } /* node:coverage ignore next 8 */

package/src/val/MapVal.ts

@@ -125,6 +125,17 @@ class MapVal extends BagVal {
 
     const TOP = top()
     peer = peer ?? TOP
+
+    // A sizing residual (`length`, `unique`) sorts AFTER containers in a
+    // conjunct so that it counts the MERGED map rather than the first
+    // fragment (SIZING_CJO in ConstraintVal.ts). That makes the map the
+    // accumulator and the constraint its peer, the reverse of the usual
+    // order — and the reading belongs to the constraint either way, so
+    // hand it straight back.
+    if (true === (peer as any).isConstraint) {
+      return peer.unify(this, ctx)
+    }
+
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Map', this, peer)
 
     let done: boolean = true

package/src/val/OpBaseVal.ts

@@ -17,7 +17,7 @@ import {
 } from '../err'
 
 import { AontuContext } from '../ctx'
-import { unite } from '../unify'
+import { unite, withDepth } from '../unify'
 
 import {
   explainOpen,
@@ -83,7 +83,11 @@ class OpBaseVal extends FeatureVal {
 
     for (let arg of this.peg) {
       if (!arg.done) {
-        arg = arg.unify(top(), ctx, ec(te, 'ARG'))
+        // Charged to the depth budget: this recurses without going
+        // through `unite`, so the counter would otherwise stay flat
+        // while the stack grows (see withDepth in unify.ts).
+        const a = arg
+        arg = withDepth(ctx, a, top(), () => a.unify(top(), ctx, ec(te, 'ARG')))
       }
       pegdone &&= arg.done
       newpeg.push(arg)

package/src/val/RefVal.ts

@@ -413,12 +413,15 @@ class RefVal extends FeatureVal {
       else if (pI === refpath.length) {
         out = node
 
-        // A reference landing on another reference may be a PROVEN
-        // mutual cycle (a: $.b, b: $.a) -- follow the plain-ref chain
-        // and, if it revisits a node, report path_cycle now instead of
-        // deferring every pass and dying later as a generic ref error.
-        // No proof (chain leaves plain refs, or ends) defers as before.
-        if (null != out && (out as any).isRef && this.detectRefCycle(ctx)) {
+        // A reference landing on another reference -- or on a FUNCTION,
+        // whose arguments the chase now follows (issue #35) -- may be a
+        // PROVEN mutual cycle (a: $.b, b: $.a; a: $.b, b: upper($.a)).
+        // Follow the chain and, if it returns to a node still open above
+        // it, report path_cycle now instead of deferring every pass and
+        // dying later as a spent budget. No proof (the chain leaves plain
+        // refs and calls, or ends) defers as before.
+        if (null != out && ((out as any).isRef || (out as any).isFunc) &&
+          this.detectRefCycle(ctx)) {
           out = makeNilErr(ctx, 'path_cycle', this)
         }
         // Types and hidden values are cloned and made concrete
@@ -468,33 +471,80 @@ class RefVal extends FeatureVal {
   // chain revisits a node -- a PROVEN reference cycle, distinct from a
   // merely unresolved reference. Detection is only on the resolution
   // chain revisiting a node, never on syntactic shape: a chain that
-  // passes through a variable segment, a conjunct, a function, or any
-  // non-ref value yields no proof and the ref defers as before.
+  // passes through a variable segment, a conjunct or any other non-ref
+  // value yields no proof and the ref defers as before.
+  //
+  // A FUNCTION is followed, through its arguments (issue #35). A
+  // function resolves only once every argument does, so a chain that
+  // reaches `b:upper($.a)` and out through `$.a` has proved the same
+  // dependency a bare `b:$.a` proves -- `a:$.b b:upper($.a)` is a cycle
+  // whichever link wears the call. Without this the shape exhausted the
+  // depth budget instead: a `unify_cycle`, which under the G5 taxonomy
+  // means "retry with more may help", where a proven structural cycle is
+  // FIX THE MODEL. A conjunct and a disjunct stay unfollowed for reasons
+  // that are not the same: a disjunct member may simply not be taken, so
+  // reaching one proves nothing; a conjunct would be sound to follow, and
+  // is left out only because nothing needs it yet.
+  //
+  // The Go port reaches the same verdict on this shape by a DIFFERENT
+  // arm, and that difference outlives this method: its clonePath re-paths
+  // a resolved clone to the referring site, so the inner `$.a` lands at
+  // path [a] and the plain isprefixpath test proves the cycle before any
+  // chase is needed. TypeScript's clone keeps the source paths. ADR-001
+  // asks for arm-for-arm correspondence, so the clone-path difference is
+  // worth closing on its own; it is wider than this issue and both ports
+  // now agree on the verdict and the code either way.
   detectRefCycle(ctx: AontuContext): boolean {
-    const seen = new Set<number>()
-    let cur: RefVal = this
-    // No hop cap: every iteration either returns or adds a NEW ref to
-    // `seen`, and the tree holds finitely many refs, so the chase
-    // terminates at the first repetition or the first non-ref — a cap
-    // would just make cycles longer than it invisible.
-    for (; ;) {
-      if (seen.has(cur.id)) {
-        return true
-      }
-      seen.add(cur.id)
-      const rp = cur.plainRefPath()
+    // Depth-first with an explicit ANCESTOR set, because a function may
+    // carry several reference arguments and the cycle can run through
+    // any one of them. The set holds the chain currently being walked,
+    // not every node ever walked: revisiting a node reached down a
+    // DIFFERENT branch is an ordinary shared reference (two keys reading
+    // one third key), and only revisiting one that is still open above
+    // us is a cycle.
+    //
+    // Identity is the RESOLVED PATH, not the RefVal instance: the same
+    // target can be reached through distinct ref instances, and it is
+    // returning to the same place that closes a loop.
+    const chase = (ref: RefVal, ancestors: Set<string>): boolean => {
+      const rp = ref.plainRefPath()
       if (null == rp) {
         return false
       }
+      const key = rp.join('')
+      if (ancestors.has(key)) {
+        return true
+      }
+
       let node: any = ctx.root
       for (let i = 0; i < rp.length && null != node; i++) {
         node = (node.isMap || node.isList) ? node.peg[rp[i]] : undefined
       }
-      if (null == node || !node.isRef) {
+      if (null == node) {
         return false
       }
-      cur = node
+
+      // Terminates: each level adds a path to `ancestors` and refuses a
+      // repeat, and the tree holds finitely many distinct paths.
+      ancestors.add(key)
+      let found = false
+      if (node.isRef) {
+        found = chase(node, ancestors)
+      }
+      else if (node.isFunc && Array.isArray(node.peg)) {
+        for (const arg of node.peg) {
+          if (null != arg && arg.isRef && chase(arg, ancestors)) {
+            found = true
+            break
+          }
+        }
+      }
+      ancestors.delete(key)
+
+      return found
     }
+
+    return chase(this, new Set<string>())
   }
 
 

package/src/val/Val.ts

@@ -297,7 +297,14 @@ abstract class Val {
 
   // TODO: indicate marks in some way that is ignored by reparse.
   // Need an annotation/taggins syntax? a:{}/type ?
-  get canon(): string { return '' }
+  // ABSTRACT: every concrete Val renders its own canonical form. There
+  // used to be an empty-string default here, and the one class relying
+  // on it (ExpectVal) was rendering a key with no value -- `{"r":}`,
+  // text that is not a document (issue #43). With that fixed, nothing
+  // reached the default, so it is declared rather than defaulted: a new
+  // Val that forgets `canon` is now a compile error instead of silently
+  // canoning as nothing.
+  abstract get canon(): string
 
 
   errcanon(): string {