aontu 0.50.1 → 0.52.0

package/src/val/PrefVal.ts

@@ -23,6 +23,7 @@ import {
 import { top } from './top'
 
 import { FeatureVal } from './FeatureVal'
+import { ScalarKindVal, kindFamily } from './ScalarKindVal'
 
 
 class PrefVal extends FeatureVal {
@@ -30,7 +31,26 @@ class PrefVal extends FeatureVal {
   isGenable = true
   cjo = 30000
 
-  superpeg: Val
+  // The preferred value's own type: the yardstick for "did the peer say
+  // anything I did not already say?". A peer that resolves to this (or
+  // to the family gate below) leaves the preference standing.
+  // Both are assigned by resuper(), called from the constructor.
+  superpeg!: Val
+
+  // The gate an overriding peer must pass. A preference is a DEFAULT, so
+  // a concrete peer replaces it -- but only within the preferred value's
+  // FAMILY: `*lower(1.1) & a` is a conflict, not an override.
+  //
+  // Family and not leaf, because the number tower made `integer` and
+  // `float` disjoint siblings under `number`. Gating on the leaf would
+  // turn `*lower(2.2) & 3` (a float default overridden by an integer)
+  // into an error, which is a tightening no document asked for; gating
+  // on the family keeps it working and makes the mirror case
+  // (`*2 & 3.0`, an error before the tower) work too. For every
+  // non-numeric value the family root IS the leaf, so this is the
+  // preferred value's type as before.
+  familypeg!: Val
+
   rank: number = 0
 
   constructor(
@@ -46,18 +66,54 @@ class PrefVal extends FeatureVal {
       this.rank = 1 + spec.peg.rank
     }
 
-    this.superpeg = this.peg.superior()
+    this.resuper()
     // console.log('PVC', this.peg.canon, this.superpeg.canon)
   }
 
 
+  // Recompute the type yardstick and the override gate from the current
+  // peg. Called again whenever the peg resolves (e.g. a ref).
+  private resuper() {
+    const peg: any = this.peg
+
+    // A preference whose peg is ITSELF a kind (`*integer`) constrains
+    // nothing: there is no type-of-a-type in this lattice, so any peer
+    // wins. (Pinned by test/spec/var.tsv:var-pref-kind-narrow. Before
+    // the tower this fell out of a ScalarKindVal's superior being top;
+    // now that a leaf kind lifts to `number`, it has to be said.)
+    if (true === peg.isScalarKind) {
+      this.superpeg = top()
+      this.familypeg = this.superpeg
+      return
+    }
+
+    const sup: any = peg.superior()
+    this.superpeg = sup
+
+    // No optional chain: superior() is contractually non-null (every
+    // Val returns one, a NilVal returning itself), so guarding against
+    // nullish here would claim a possibility the type does not have.
+    if (true === sup.isScalarKind) {
+      const family = kindFamily(sup.peg)
+      // The gate stands in for the preferred value in any conflict it
+      // reports, so it must carry the same site and path as the type it
+      // widens -- otherwise NilVal.make picks a different primary and
+      // the error moves to the wrong path.
+      this.familypeg = family === sup.peg ?
+        sup : sup.place(new ScalarKindVal({ peg: family, path: sup.path }))
+    }
+    else {
+      this.familypeg = sup
+    }
+  }
+
+
   // PrefVal unify always returns a PrefVal
   // PrefVals can only be removed by becoming Nil in a Disjunct
   unify(peer: Val, ctx: AontuContext): Val {
     peer = peer ?? top()
 
     const te = ctx.explain && explainOpen(ctx, ctx.explain, 'Pref', this, peer)
-    let done = true
     let out: Val = this
     let why = ''
 
@@ -66,7 +122,7 @@ class PrefVal extends FeatureVal {
         this.peg, top(), 'pref/resolve')
       // console.log('PREF-RESOLVED', this.peg.canon, '->', resolved)
       this.peg = resolved
-      this.superpeg = this.peg.superior()
+      this.resuper()
     }
 
     if (peer instanceof PrefVal) {
@@ -107,8 +163,12 @@ class PrefVal extends FeatureVal {
       why += 'super-'
 
       out = unite(te ? ctx.clone({ explain: ec(te, 'SUPER') }) : ctx,
-        this.superpeg, peer, 'pref-super/' + this.id)
-      if (out.same(this.superpeg)) {
+        this.familypeg, peer, 'pref-super/' + this.id)
+
+      // The peer added nothing beyond a type the preferred value already
+      // satisfies (`*1 & integer`, `*1 & number`), so the preference
+      // stands. Anything else is a concrete override and wins.
+      if (out.same(this.superpeg) || out.same(this.familypeg)) {
         out = this.peg
         why += 'same'
       }
@@ -119,7 +179,9 @@ class PrefVal extends FeatureVal {
       why += 'none'
     }
 
-    out.dc = done ? DONE : this.dc + 1
+    // Every pref result is DONE, including a stuck conjunct from the
+    // superior-unify (mirrored by PrefVal.Unify in go/pref.go).
+    out.dc = DONE
 
     // console.log('PREFVAL-OUT', why, this.canon, peer.canon, '->', out.canon, out.done)
 
@@ -165,7 +227,7 @@ class PrefVal extends FeatureVal {
 
     return val.gen(ctx)
   }
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/RefVal.ts

@@ -37,9 +37,18 @@ import { NumberVal } from './NumberVal'
 import { ConjunctVal } from './ConjunctVal'
 import { VarVal } from './VarVal'
 import { FeatureVal } from './FeatureVal'
+import { integerDigits } from './numkind'
+import { BigIntegerVal } from './BigIntegerVal'
+import { BigDecimalVal } from './BigDecimalVal'
 
 
 
+// A path segment no spelling can produce, used when append meets a Val
+// class it has no rule for. A key cannot contain a NUL, so this can never
+// match, which turns a silent path-shortening bug into a visible miss.
+const UNSPELLABLE_SEGMENT = '\u0000unspellable'
+
+
 class RefVal extends FeatureVal {
   isRef = true
   isGenable = true
@@ -59,8 +68,9 @@ class RefVal extends FeatureVal {
     super(spec, ctx)
     this.peg = []
 
-    this.absolute = true === this.absolute ? true : // absolute sticks
-      true === spec.absolute ? true : false
+    // The field initialiser (absolute = false) has just run, so only
+    // the spec can carry absoluteness in (RefVal.clone re-passes it).
+    this.absolute = true === spec.absolute
 
     this.prefix = true === spec.prefix
 
@@ -102,6 +112,22 @@ class RefVal extends FeatureVal {
       this.peg.push(...partvals)
     }
 
+    // THE EXACT LEAVES ARE PATH TEXT LIKE ANY OTHER SPELLING. `0d1` as a
+    // segment addresses the key literally spelled `0d1` -- the same key
+    // `a:{0d1:7}` creates -- and is NOT the number 1, so it neither
+    // indexes a list nor reaches a key spelled `1`.
+    //
+    // Without these branches the part fell off the end of the chain and
+    // was SILENTLY DROPPED, so `$.a.0d0` resolved to `$.a` and handed back
+    // the CONTAINER. That is a wrong value, not a miss -- strictly worse
+    // than an error -- and it made `$.a.0d0` and `$.a.0d1` denote the same
+    // location.
+    else if (part instanceof BigIntegerVal || part instanceof BigDecimalVal) {
+      // A bigdecimal splits on its point exactly as a float does, so
+      // `$.x.0d1.5` addresses two levels.
+      this.peg.push(...part.src.split('.'))
+    }
+
     else if (part instanceof VarVal) {
       partval = part
       this.peg.push(partval)
@@ -131,6 +157,16 @@ class RefVal extends FeatureVal {
 
       this.peg.push(...part.peg)
     }
+
+    // A closed chain, deliberately. Every branch above ends in a push, so
+    // an unhandled Val class used to fall through in SILENCE and shorten
+    // the path by one segment -- which is how the two exact leaves, added
+    // by the number tower, made references resolve to their own container.
+    // A segment that cannot be spelled is pushed as one that cannot match,
+    // so the reference misses loudly instead of succeeding wrongly.
+    else {
+      this.peg.push(UNSPELLABLE_SEGMENT)
+    }
   }
 
 
@@ -146,14 +182,13 @@ class RefVal extends FeatureVal {
       // TODO: not resolved when all Vals in path are done is an error
       // as path cannot be found
       // let resolved: Val | undefined = null == ctx ? this : ctx.find(this)
-      let found: Val | undefined = null == ctx ? this : this.find(ctx)
+      let found: Val | undefined = this.find(ctx)
 
+      // `?? this` makes resolved non-nullish, so an unresolved reference
+      // takes the RefVal arm below rather than a separate null arm.
       const resolved = found ?? this
 
-      if (null == resolved && this.canon === peer.canon) {
-        out = this
-      }
-      else if (resolved instanceof RefVal) {
+      if (resolved instanceof RefVal) {
         if (peer.isTop) {
           out = this
           why = 'pt'
@@ -272,7 +307,19 @@ class RefVal extends FeatureVal {
               // The resolved variable IS a path segment: $seg.r with
               // seg="x" reads ...x.r (previously the coerced value was
               // dropped, silently reading the path without it).
-              parts.push('' + part.peg)
+              //
+              // Integer kind renders its EXACT digits -- the FOURTH site
+              // to get this wrong (see integerDigits and #21). `'' + peg`
+              // on a JS number gives the shortest round-tripping form, so
+              // a variable bound to 2^60 addressed the key
+              // "1152921504606847000" and missed the real one. Go's
+              // ref.go dispatches on kind here and was already correct.
+              //
+              // Every other kind is already right under `'' +`: a bigint
+              // and a Decimal stringify to exact digits, and a float must
+              // keep JS parity.
+              parts.push(part.isInteger ?
+                integerDigits(part.peg as number) : '' + part.peg)
             }
           }
         }
@@ -302,8 +349,20 @@ class RefVal extends FeatureVal {
           (p === sep ? a.length = a.length - 1 : a.push(p), a)), [])
 
       if (modes.includes('KEY')) {
+        // STRINGIFY. A LIST index arrives here as a JS NUMBER (jsonic puts
+        // it in the path as one, and lang.ts copies the path wholesale),
+        // so `.$KEY` inside a list built a StringVal whose peg was the
+        // number 0 -- an ill-formed value, not a design choice: it canoned
+        // as a bare 0, generated a JSON number, satisfied `number` and
+        // failed `string`. Go stringifies, and key() already agreed with
+        // Go, so this port disagreed with itself.
+        //
+        // Coerced HERE, at the consumption site, rather than by
+        // normalising Val.path: the numeric segment originates in jsonic's
+        // own r.k.path and every other path consumer (find's descent,
+        // key(), the clone/spread machinery) already handles it.
         let key = this.path[this.path.length - 2]
-        let sv = new StringVal({ peg: null == key ? '' : key }, ctx)
+        let sv = new StringVal({ peg: null == key ? '' : '' + key }, ctx)
 
         // TODO: other props?
         sv.dc = DONE
@@ -354,8 +413,16 @@ 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)) {
+          out = makeNilErr(ctx, 'path_cycle', this)
+        }
         // Types and hidden values are cloned and made concrete
-        if (null != out) { //  && (out.mark.type || out.mark.hide)) {
+        else if (null != out) { //  && (out.mark.type || out.mark.hide)) {
 
           // console.log('FOUND-A', out)
 
@@ -397,6 +464,71 @@ class RefVal extends FeatureVal {
   }
 
 
+  // Follow the chain of plain references from this node; true iff the
+  // 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.
+  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()
+      if (null == rp) {
+        return false
+      }
+      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) {
+        return false
+      }
+      cur = node
+    }
+  }
+
+
+  // The resolved absolute path of a reference whose segments are all
+  // plain strings; undefined when the ref has variable segments (no
+  // cycle proof is attempted for those). Mirrors find's refpath
+  // computation for the plain case, including the `.` prefix reduction.
+  plainRefPath(): string[] | undefined {
+    const parts: string[] = []
+    for (const p of this.peg) {
+      if ('string' !== typeof p) {
+        return undefined
+      }
+      parts.push(p)
+    }
+    const refpath = this.absolute ? parts :
+      this.path.slice(0, -1).concat(parts)
+    const reduced: string[] = []
+    for (const p of refpath) {
+      if ('.' === p) {
+        // A parent step off the top of the path proves nothing.
+        if (0 === reduced.length) {
+          return undefined
+        }
+        reduced.length = reduced.length - 1
+      }
+      else {
+        reduced.push(p)
+      }
+    }
+    return reduced
+  }
+
+
   same(peer: Val): boolean {
     return null == peer ? false : this.peg === peer.peg
   }
@@ -450,7 +582,7 @@ class RefVal extends FeatureVal {
     ].filter(p => '' != p).join(',')
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/ScalarKindVal.ts

@@ -24,17 +24,101 @@ import { makeNilErr, AontuError } from '../err'
 import { FeatureVal } from './FeatureVal'
 
 
-// A ScalarKind for integers. Number includes floats.
+// Kind markers.
+//
+// A ScalarKindVal's canon is its marker's constructor name, lowercased,
+// so these class names are load-bearing language surface: `Integer` is
+// the keyword `integer`, `Float` is the keyword `float`.
+//
+// The numeric part of the lattice is a pure supertype over disjoint
+// leaves:
+//
+//   number                       (the global Number constructor)
+//   |- integer     Integer       int64-window exact
+//   |- float       Float         IEEE-754 binary64
+//   |- biginteger  BigInteger    exact, opt-in via 0d
+//   |- bigdecimal  BigDecimal    exact, opt-in via 0d
+//
+// The global `Number` constructor is the marker for the SUPERTYPE only:
+// no concrete ScalarVal ever carries it. A binary64 value is FLOAT kind
+// (NumberVal is the binary64 leaf; the class name is historical).
+//
+// A ScalarKindVal for `number` matches a concrete value of any numeric
+// leaf, and meeting it with a leaf yields that leaf. Two distinct leaves
+// are disjoint sets with no common lower bound, so they do not unify.
+
+// A ScalarKind for the int64-window exact integers.
 class Integer { }
 
+// A ScalarKind for IEEE-754 binary64 values.
+class Float { }
+
+// A ScalarKind for the unbounded exact integers, reached only by a `0d`
+// literal with no fraction and no exponent.
+class BigInteger { }
+
+// A ScalarKind for the exact base-10 decimals, reached only by a `0d`
+// literal carrying a `.` or an exponent.
+class BigDecimal { }
+
 // A ScalarKind for null.
 class Null { }
 
 
+// The immediate lattice parent of each kind marker. A marker absent from
+// this table sits directly under top (string, boolean, null -- and
+// `number` itself, which is the root of the numeric family).
+//
+// Adding a leaf is one row.
+const KIND_PARENT = new Map<any, any>([
+  [Integer, Number],
+  [Float, Number],
+  [BigInteger, Number],
+  [BigDecimal, Number],
+])
+
+
+// The immediate lattice superior of a kind marker, or undefined when the
+// marker's superior is top.
+function kindParent(kind: any): any {
+  return KIND_PARENT.get(kind)
+}
+
+
+// The root of a kind marker's family: the highest ancestor below top.
+// Every numeric leaf answers `number`; a kind with no parent is its own
+// family root (string, boolean, null).
+function kindFamily(kind: any): any {
+  let root = kind
+  for (let k = KIND_PARENT.get(kind); null != k; k = KIND_PARENT.get(k)) {
+    root = k
+  }
+  return root
+}
+
+
+// True when `sub` is `sup`, or sits anywhere below it. The numeric
+// lattice is two deep today; walking the chain keeps this correct if it
+// ever deepens.
+function kindSubsumes(sup: any, sub: any): boolean {
+  for (let k = sub; null != k; k = KIND_PARENT.get(k)) {
+    if (k === sup) {
+      return true
+    }
+  }
+  return false
+}
+
+
 type ScalarConstructor =
   StringConstructor |
   NumberConstructor |
   BooleanConstructor |
+  (typeof Integer) |
+  (typeof Float) |
+  (typeof BigInteger) |
+  (typeof BigDecimal) |
+  (typeof Null) |
   (typeof Integer.constructor)
 
 
@@ -64,13 +148,19 @@ class ScalarKindVal extends FeatureVal {
 
     let out: Val = this
 
-    if (peerIsScalarVal) {
+    if ((peer as any).isConstraint) {
+      // The constraint algebra owns the kind-meets-constraint rules
+      // (narrowing, domain checks) -- delegate, so disjunct trials and
+      // direct drives agree with the sorted conjunct fold.
+      out = (peer as any).unify(this, ctx)
+    }
+    else if (peerIsScalarVal) {
       let peerKind = (peer as any).kind
 
-      if (peerKind === this.peg) {
-        out = peer
-      }
-      else if (Number === this.peg && Integer === peerKind) {
+      // A kind admits a concrete value of that kind, or of any kind
+      // below it: `float & 1.5` is 1.5, and `number & 1` is 1 because
+      // integer sits under number.
+      if (kindSubsumes(this.peg, peerKind)) {
         out = peer
       }
       else {
@@ -78,13 +168,16 @@ class ScalarKindVal extends FeatureVal {
       }
     }
     else if (peerIsScalarKind) {
-      if (Number === this.peg && Integer === peer.peg) {
-        out = peer
-      }
-      else if (Number === peer.peg && Integer === this.peg) {
+      // The meet of two kinds is the narrower one when they are
+      // comparable. Distinct leaves (float & integer) are disjoint sets
+      // of values, so they have no common lower bound and fail.
+      if (this.peg === peer.peg) {
         out = this
       }
-      else if (this.peg === peer.peg) {
+      else if (kindSubsumes(this.peg, peer.peg)) {
+        out = peer
+      }
+      else if (kindSubsumes(peer.peg, this.peg)) {
         out = this
       }
       else {
@@ -108,18 +201,36 @@ class ScalarKindVal extends FeatureVal {
   }
 
 
+  // The super() ladder: a leaf kind lifts to its parent kind
+  // (super(integer) -> number, super(float) -> number), and a kind with
+  // no parent lifts to top (super(number) -> top). A concrete value
+  // lifts to its own leaf via ScalarVal.superior.
+  superior(): Val {
+    const parent = kindParent(this.peg)
+    return null == parent ?
+      super.superior() :
+      this.place(new ScalarKindVal({ peg: parent }))
+  }
+
+
   same(peer: any): boolean {
     let out = peer?.isScalarKind ? this.peg === peer?.peg : super.same(peer)
     return out
   }
 
 
-}
+} /* node:coverage ignore next 15 */
 
 
 export {
+  BigDecimal,
+  BigInteger,
+  Float,
   Integer,
   Null,
   ScalarConstructor,
   ScalarKindVal,
+  kindFamily,
+  kindParent,
+  kindSubsumes,
 }

package/src/val/ScalarVal.ts

@@ -60,7 +60,7 @@ class ScalarVal extends Val {
     let out: Val
 
     // Exactly equal scalars are handled in unify.unite
-    if (peer.isScalarKind) {
+    if (peer.isScalarKind || (peer as any).isConstraint) {
       out = peer.unify(this, ctx)
     }
     else if (peer.isTop) {
@@ -87,7 +87,24 @@ class ScalarVal extends Val {
 
 
   same(peer: any): boolean {
-    return peer?.isScalar ? peer.peg === this.peg : super.same(peer)
+    // Two concrete scalars are the same only when KIND and value both
+    // match. Comparing peg alone is a leftover from before integer and
+    // number were distinct kinds; without the kind test `1|1.0` would
+    // collapse to a single alternative and `(1|1.0) & 1.0` could pick
+    // the integer.
+    return peer?.isScalar ?
+      (peer.kind === this.kind && this.samePeg(peer.peg)) :
+      super.same(peer)
+  }
+
+
+  // Value comparison for this leaf's peg (D2: identity is kind AND
+  // value, NEVER the identity of the object holding the value). `===` is
+  // right for every peg that is a primitive -- including a bigint, where
+  // two separately built copies of the same number compare equal -- and
+  // wrong for a peg that is an object, so BigDecimalVal overrides it.
+  samePeg(peg: any): boolean {
+    return peg === this.peg
   }
 
 
@@ -104,7 +121,7 @@ class ScalarVal extends Val {
     }))
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/StringVal.ts

@@ -30,7 +30,7 @@ class StringVal extends ScalarVal {
     return JSON.stringify(this.peg)
   }
 
-}
+} /* node:coverage ignore next 5 */
 
 export {
   StringVal,

package/src/val/SuperFuncVal.ts

@@ -34,11 +34,24 @@ class SuperFuncVal extends FuncBaseVal {
   }
 
 
-  resolve(_ctx: AontuContext, _args: Val[]) {
+  resolve(_ctx: AontuContext, args: Val[]) {
+    // super(x) is the lattice-superior of its ARGUMENT, not of the
+    // super() call itself: super(1) -> integer, super(1.5) -> number,
+    // super(a) -> string, super(true) -> boolean. Returning the
+    // function's own superior (top) is what made super() inert.
+    const arg: any = args?.[0]
+    if (arg?.isVal) {
+      const sup = arg.superior()
+      // Where the argument has no meaningful superior (superior()
+      // defaults to top), fall back to the previous behaviour.
+      if (null != sup && true !== sup.isTop) {
+        return this.place(sup)
+      }
+    }
     return this.place(this.superior())
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/TopVal.ts

@@ -61,7 +61,7 @@ class TopVal extends Val {
     return undefined
   }
 
-}
+} /* node:coverage ignore next 6 */
 
 
 export {

package/src/val/TypeFuncVal.ts

@@ -61,7 +61,7 @@ class TypeFuncVal extends FuncBaseVal {
 
     return out
   }
-}
+} /* node:coverage ignore next 6 */
 
 
 export {