aontu 0.67.0 → 0.69.0

package/src/lang.ts

@@ -106,6 +106,8 @@ import { DisjunctVal } from './val/DisjunctVal'
 import { IntegerVal } from './val/IntegerVal'
 import { ListVal } from './val/ListVal'
 import { MapVal } from './val/MapVal'
+import { repathInstance } from './val/Val'
+import { AontuContext } from './ctx'
 import { NilVal } from './val/NilVal'
 import { NullVal } from './val/NullVal'
 import { NumberVal } from './val/NumberVal'
@@ -188,11 +190,34 @@ const CC_d = 100
 const CC_D = 68
 
 const CC_PCT = 37
-const ALIAS_RE = /^%[A-Za-z_][A-Za-z0-9_]*/
+import type { AliasBind } from './aliasname'
+import {
+  ALIAS_RE,
+  ALIAS_SET,
+  ALIAS_SHORTHAND_RE,
+  EXPORT_DECL_NAME,
+  RESERVED_KEY_PREFIX,
+  exportHoldKey,
+  aliasBareName,
+  aliasScopedKey,
+  aliasSetItems,
+} from './aliasname'
 
 const CC_EQ = 61
 const CC_SP = 32
 const CC_TAB = 9
+const CC_OB = 123
+const WS_RE = /\s/
+
+let SCOPE_SEQ = 0
+const MERGE_KEY = RESERVED_KEY_PREFIX + 'merge'
+const ALIAS_MARK_KEY = RESERVED_KEY_PREFIX + 'alias'
+const OPTIONAL_MARK_KEY = RESERVED_KEY_PREFIX + 'optional'
+
+// `{ %a } = @"f.aon"` is the pair `<head>: <include>`, so the head is
+// one token and the grammar needs nothing new.
+const IMPORT_HEAD_RE = new RegExp('^(' + ALIAS_SET + ')[ \\t]*=(?!=)')
+const EXPORT_RE = /^export[ \t]*\([ \t]*([^()\s][^()]*?)[ \t]*\)/
 
 const CC_9 = 57
 const CC_A = 65
@@ -326,6 +351,72 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     },
   })
 
+  // THE FIXED MATCHER'S CHECK RUNS AT EVERY POSITION: `{` opens a fixed
+  // token the text check never sees.
+  jsonic.options({
+    fixed: {
+      check: (lex: any) => {
+        const pnt = lex.pnt
+        const ex = lex.aontu_export
+
+        // The `(` is the pair's separator, the argument its value.
+        if (null != ex && pnt.sI === ex.cl) {
+          const cltkn = lex.token('#CL', undefined, '(', pnt)
+          pnt.cI += ex.arg - pnt.sI
+          pnt.sI = ex.arg
+          return { done: true, token: cltkn }
+        }
+
+        if (null != ex && pnt.sI === ex.arg) {
+          delete lex.aontu_export
+          const atkn = lex.token('#TX', ex.src, ex.src, pnt)
+          pnt.cI += ex.end - pnt.sI
+          pnt.sI = ex.end
+          return { done: true, token: atkn }
+        }
+
+        // THE SHORTHAND IS READ OFF THE SOURCE: a name lexes as its pair.
+        const sh = lex.aontu_shorthand
+        if (null != sh && pnt.sI === sh.at) {
+          if (1 === sh.stage) {
+            sh.stage = 2
+            return { done: true, token: lex.token('#CL', undefined, ':', pnt) }
+          }
+          delete lex.aontu_shorthand
+          return {
+            done: true, token: lex.token(
+              '#VL',
+              (r: Rule, ctx: JsonicContext) =>
+                addsite(new RefVal(
+                  { peg: [aliasScopedKey(sh.name, srcUrl(ctx))], absolute: true }),
+                  r, ctx),
+              sh.name, pnt)
+          }
+        }
+
+        if (CC_OB === lex.src.charCodeAt(pnt.sI)) {
+          const sres = ALIAS_SHORTHAND_RE.exec(lex.refwd())
+          if (null != sres) {
+            lex.aontu_shorthand_end = pnt.sI + sres[0].length
+          }
+          const hres = IMPORT_HEAD_RE.exec(lex.refwd())
+          if (null != hres) {
+            const hsrc = hres[1]
+            lex.aontu_eq_at = pnt.sI + hres[0].length - 1
+            const htkn = lex.token('#TX', hsrc, hsrc, pnt, {
+              aontu_import: aliasSetItems(hsrc) as AliasBind[],
+            })
+            pnt.sI += hsrc.length
+            pnt.cI += hsrc.length
+            return { done: true, token: htkn }
+          }
+        }
+
+        return undefined
+      },
+    },
+  })
+
   jsonic.options({
     text: {
       check: (lex: any) => {
@@ -346,10 +437,29 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
             lex.aontu_eq_at = j
           }
 
+          // The name is the KEY; separator and reference follow it.
+          const shend = lex.aontu_shorthand_end
+          if (null != shend && pnt.sI < shend) {
+            let k = pnt.sI + asrc.length
+            while (k < src.length && WS_RE.test(src[k])) {
+              k++
+            }
+            const ktkn = lex.token('#TX', asrc.substring(1), asrc, pnt)
+            pnt.cI += k - pnt.sI
+            pnt.sI = k
+            lex.aontu_shorthand = { at: k, name: asrc, stage: 1 }
+            if (shend - 1 <= k) {
+              delete lex.aontu_shorthand_end
+            }
+            return { done: true, token: ktkn }
+          }
+
           const atkn = lex.token(
             '#VL',
             (r: Rule, ctx: JsonicContext) =>
-              addsite(new RefVal({ peg: [asrc], absolute: true }), r, ctx),
+              addsite(new RefVal(
+                { peg: [aliasScopedKey(asrc, srcUrl(ctx))], absolute: true }),
+                r, ctx),
             asrc,
             pnt)
           pnt.sI += asrc.length
@@ -357,6 +467,27 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
           return { done: true, token: atkn }
         }
 
+        // `export(...)`: the word is the key, spelled unwritably.
+        if (CC_e === src.charCodeAt(pnt.sI)) {
+          const eres = EXPORT_RE.exec(lex.refwd())
+          if (null != eres) {
+            const open = eres[0].indexOf('(')
+            const arg = eres[0].indexOf(eres[1], open)
+            lex.aontu_export = {
+              cl: pnt.sI + open,
+              arg: pnt.sI + arg,
+              end: pnt.sI + eres[0].length,
+              src: eres[1],
+            }
+            const etkn = lex.token(
+              '#TX', exportHoldKey(), EXPORT_DECL_NAME, pnt,
+              { aontu_export: true, aontu_export_items: aliasSetItems(eres[1]) })
+            pnt.sI += EXPORT_DECL_NAME.length
+            pnt.cI += EXPORT_DECL_NAME.length
+            return { done: true, token: etkn }
+          }
+        }
+
         if (CC_EQ === src.charCodeAt(pnt.sI) && lex.aontu_eq_at === pnt.sI) {
           delete lex.aontu_eq_at
           const eqtkn = lex.token('#CL', undefined, '=', pnt, { aontu_eq: true })
@@ -434,6 +565,28 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
     return v
   }
 
+  // `export` publishes a name; it renames none, and `{%}` is theirs.
+  const publishedNames = (items?: AliasBind[]): string[] | undefined =>
+    undefined === items || 0 === items.length ? undefined :
+      items.every((i) => i.local === i.remote) ?
+        items.map((i) => i.local) : undefined
+
+  // A ROOT MAY BE WRAPPED: a file's names are its MAP'S, not open()'s.
+  const declaringMap = (val: any): any => {
+    let cur = val
+    while (true === cur?.isFunc && 1 === cur.peg?.length) {
+      cur = cur.peg[0]
+    }
+    return cur
+  }
+
+  // The file a value was written in, and so any alias name's scope. A
+  // DOCUMENT IS ITS OWN SCOPE too, so a fileless parse is tagged.
+  const srcUrl = (ctx: JsonicContext): string => {
+    const url = ctx.meta.multisource && ctx.meta.multisource.path
+    return url ? url : ((ctx.meta as any).aontu_scope ??= '#' + (++SCOPE_SEQ))
+  }
+
   let addsite = (v: Val, r: Rule, ctx: JsonicContext) => {
     // The source text comes from the SAME token the row and column
     // come from. jsonic has carried it all along; not reading it is
@@ -449,8 +602,16 @@ let AontuJsonic: Plugin = function AontuLang(jsonic: Jsonic) {
   const isAliasDecl = (ktkn: any, sep: any): boolean =>
     null != ktkn && VL === ktkn.tin && ALIAS_RE.test('' + ktkn.src) &&
     true === sep?.use?.aontu_eq
+  const keyName = (ktkn: any): string =>
+    'string' === typeof ktkn?.val ? ktkn.val : '' + ktkn?.src
+
   const keyRefusalOf = (ktkn: any, sep: any):
     { why: string, details?: Record<string, any> } | undefined => {
+    // THE SENTINEL NAMESPACE IS THE ENGINE'S; it writes `export` here.
+    if (keyName(ktkn).startsWith(RESERVED_KEY_PREFIX) &&
+      true !== ktkn.use?.aontu_export) {
+      return { why: 'reserved_key' }
+    }
     if (null == ktkn || VL !== ktkn.tin) {
       return undefined
     }
@@ -576,14 +737,14 @@ help isolate the syntax error.`,
                 ((prev as any)[SPREAD] || { o: '&', v: [] })
               ;(prev as any)[SPREAD].v.push(lm.spread.cj)
             }
-            prev.___optional = (prev.___optional || [])
-            for (const k of lm.optionalKeys) { prev.___optional.push(k) }
-            prev.___alias = (prev.___alias || [])
-            for (const k of lm.aliasKeys) { prev.___alias.push(k) }
+            prev[OPTIONAL_MARK_KEY] = (prev[OPTIONAL_MARK_KEY] || [])
+            for (const k of lm.optionalKeys) { prev[OPTIONAL_MARK_KEY].push(k) }
+            prev[ALIAS_MARK_KEY] = (prev[ALIAS_MARK_KEY] || [])
+            for (const k of lm.aliasKeys) { prev[ALIAS_MARK_KEY].push(k) }
             return prev
           }
-          prev.___merge = (prev.___merge || [])
-          prev.___merge.push(curr)
+          prev[MERGE_KEY] = (prev[MERGE_KEY] || [])
+          prev[MERGE_KEY].push(curr)
           return prev
         }
       }
@@ -940,6 +1101,16 @@ help isolate the syntax error.`,
   jsonic.rule('val', (rs: RuleSpec) => {
 
     rs
+      // Before the core implicit-map alts: a value prefix, not a key.
+      .open([
+        {
+          s: [VL, CL],
+          c: (r: Rule) => 0 !== r.d && isAliasDecl(r.o0, r.o1),
+          p: 'val',
+          a: (r: Rule) => { r.u.aontu_alias_val = '' + r.o0.src },
+          g: 'aontu-alias-val',
+        },
+      ], { append: false })
       .open([
         {
           s: [CJ, CL], p: 'map', b: 2, n: { pk: 1 },
@@ -1017,6 +1188,13 @@ help isolate the syntax error.`,
 
         r.node = valnode
 
+        const aname = r.u.aontu_alias_val
+        if (null != aname && null != valnode) {
+          const hoist = ((ctx as any).aontu_alias_hoist ||= [])
+          hoist.push(
+            { name: aliasScopedKey('' + aname, srcUrl(ctx)), val: valnode })
+        }
+
         return undefined
       })
 
@@ -1036,13 +1214,27 @@ help isolate the syntax error.`,
 
       .bc((r: Rule, ctx: JsonicContext) => {
         const optionalKeys = r.u.aontu_optional_keys ?? []
-        const aliasKeys = r.u.aontu_alias_keys ?? []
+        const aliasDecls = r.u.aontu_alias_keys ?? []
+        const aliasKeys: string[] = []
+        const exportKeys: string[] = []
 
         let mo = r.node
 
+        // A REFUSED KEY TAKES NO KEY and is not OPTIONAL: its name is a
+        // mark's, and the elision below would put it back.
+        for (const kr of (r.u.aontu_key_refusals ?? []) as any[]) {
+          if ('reserved_key' === kr.why) {
+            delete mo[kr.key]
+            const oi = optionalKeys.indexOf(kr.key)
+            if (-1 !== oi) {
+              optionalKeys.splice(oi, 1)
+            }
+          }
+        }
+
         for (const k in mo) {
-          if (null == mo[k] && '___merge' !== k &&
-            '___optional' !== k && '___alias' !== k) {
+          if (null == mo[k] && MERGE_KEY !== k &&
+            OPTIONAL_MARK_KEY !== k && ALIAS_MARK_KEY !== k) {
             // Pathed at the KEY, not at the enclosing map. addsite takes
             // the rule's path, which here is the map's, so the error
             // would otherwise name the container and leave the reader to
@@ -1070,45 +1262,167 @@ help isolate the syntax error.`,
           return undefined
         }
 
-        for (const { key, tkn, why, details } of
+        const reservedRefusals: Val[] = []
+        for (const { key, tkn, why, details, url } of
           (r.u.aontu_key_refusals ?? []) as any[]) {
           const en: any = siteAt(addsite(new NilVal({ why }), r, ctx), tokenSite(tkn))
           if (null != details) {
             en.details = details
           }
           en.path = [...(r.k?.path ?? []), key]
-          mo[key] = en
+          // A COLON DECLARATION IS REFUSED AND STILL NAMES SOMETHING, so
+          // the refusal is held under the key that name would have had
+          // and a use of it reports why; not an alias key, so it
+          // generates unused.
+          if ('alias_colon' === why) {
+            delete mo[key]
+            mo[aliasScopedKey(key, url)] = en
+          }
+          // A RESERVED KEY WAITS: its name is where the marks are kept.
+          else if ('reserved_key' === why) {
+            reservedRefusals.push(en)
+          }
+          else {
+            mo[key] = en
+          }
+        }
+
+        // A NAME BELONGS TO THE FILE THAT DECLARED IT. Renamed here and
+        // not at the key, so an elided value is still reported by the
+        // name the source spells; rebuilt, as key order is resolution.
+        const renamed = new Map<string, string>()
+        for (const { name, key } of aliasDecls as any[]) {
+          renamed.set(name, key)
+          if (!aliasKeys.includes(key)) {
+            aliasKeys.push(key)
+          }
+        }
+        if (0 < renamed.size) {
+          const entries = Object.entries(mo)
+          for (const [k] of entries) {
+            delete mo[k]
+          }
+          for (const [k, v] of entries) {
+            const key = renamed.get(k)
+            if (undefined === key) {
+              mo[k] = v
+            }
+            else {
+              mo[key] = v
+              repathInstance(v, [...(r.k?.path ?? []), key])
+            }
+          }
+        }
+
+        // `export` PUBLISHES NAMES AND NOTHING ELSE; a bare name, a key
+        // and the wildcard are refused, and the argument is erased.
+        for (const { items, tkn } of (r.u.aontu_export_decls ?? []) as any[]) {
+          delete mo[tkn.val]
+          const names = publishedNames(items)
+          if (undefined === names) {
+            const en: any =
+              siteAt(addsite(new NilVal({ why: 'export_arg' }), r, ctx), tokenSite(tkn))
+            en.path = [...(r.k?.path ?? []), EXPORT_DECL_NAME]
+            mo[EXPORT_DECL_NAME] = en
+          }
+          else {
+            exportKeys.push(...names.map((n) => aliasScopedKey(n, srcUrl(ctx))))
+          }
+        }
+
+        // THE DESTRUCTURE IS ADDITIVE: the values land where the head
+        // stands, each name binds in THIS file's scope, and a file
+        // publishes only what IT declares. A DECLARATION IS THE
+        // DOCUMENT'S, so the names go to the root and the values may
+        // sit under a key.
+        for (const im of (r.u.aontu_import_decls ?? []) as any[]) {
+          const hoist = ((ctx as any).aontu_alias_hoist ||= [])
+          const iv: any = mo[im.key]
+          delete mo[im.key]
+          const dv: any = declaringMap(iv)
+          const ex: string[] = dv.exportKeys ?? []
+          const ak: string[] = dv.aliasKeys ?? []
+          for (const k of ak) {
+            hoist.push({ name: k, val: dv.peg[k] })
+            delete dv.peg[k]
+          }
+          if (0 < ak.length + ex.length) {
+            dv.aliasKeys = []
+            dv.exportKeys = []
+          }
+          repathInstance(iv, [...(r.k?.path ?? [])])
+          ; (mo[MERGE_KEY] = mo[MERGE_KEY] || []).push(iv)
+          const binds: AliasBind[] = 0 === im.names.length ?
+            ex.map((k: string) =>
+              ({ local: aliasBareName(k), remote: aliasBareName(k) })) : im.names
+          for (const { local, remote } of binds) {
+            const from = ex.find((k: string) => aliasBareName(k) === remote)
+            let bind: Val
+            if (undefined === from || !ak.includes(from)) {
+              bind = siteAt(addsite(
+                new NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn))
+              ; (bind as any).details = { name: remote }
+                  const en: any = siteAt(addsite(
+                new NilVal({ why: 'import_not_exported' }), r, ctx), tokenSite(im.tkn))
+              en.details = { name: remote }
+              mo[MERGE_KEY].push(en)
+            }
+            else {
+              bind = addsite(new RefVal({ peg: [from], absolute: true }), r, ctx)
+            }
+            hoist.push({ name: aliasScopedKey(local, im.url), val: bind })
+          }
         }
 
         // Marks carried over from a map include folded in the merge
         // hook above, applied here where the MapVal is built.
-        if (mo.___optional || mo.___alias) {
-          for (const k of (mo.___optional || [])) {
+        if (mo[OPTIONAL_MARK_KEY] || mo[ALIAS_MARK_KEY]) {
+          for (const k of (mo[OPTIONAL_MARK_KEY] || [])) {
             if (!optionalKeys.includes(k)) { optionalKeys.push(k) }
           }
-          for (const k of (mo.___alias || [])) {
+          for (const k of (mo[ALIAS_MARK_KEY] || [])) {
             if (!aliasKeys.includes(k)) { aliasKeys.push(k) }
           }
-          delete mo.___optional
-          delete mo.___alias
+          delete mo[OPTIONAL_MARK_KEY]
+          delete mo[ALIAS_MARK_KEY]
+        }
+
+        // A value-prefix declaration lands here, at the document root
+        // (ALIASES.0.md), as a copy pathed at its name.
+        if (1 === r.d) {
+          for (const { name, val } of ((ctx as any).aontu_alias_hoist ?? [])) {
+            const acx = new AontuContext({ path: [name] })
+            const copy: any = (val as any).clone(acx, { path: [name] })
+            repathInstance(copy, [name])
+            mo[name] = null == mo[name] ? copy :
+              addsite(new ConjunctVal({ peg: [mo[name], copy] }), r, ctx)
+            if (!aliasKeys.includes(name)) { aliasKeys.push(name) }
+          }
         }
 
         //  Handle defered conjuncts, e.g. `{x:1 @"foo"}`
-        if (mo.___merge) {
+        const deferred = mo[MERGE_KEY]
+        delete mo[MERGE_KEY]
+
+        const merge = 0 < reservedRefusals.length ?
+          [...(deferred ?? []), ...reservedRefusals] : deferred
+
+        if (merge) {
           let mop = { ...mo }
-          delete mop.___merge
 
           let mopv = new MapVal({ peg: mop })
           mopv.optionalKeys = optionalKeys
           mopv.aliasKeys = aliasKeys
+          mopv.exportKeys = exportKeys
 
           r.node =
-            addsite(new ConjunctVal({ peg: [mopv, ...mo.___merge] }), r, ctx)
+            addsite(new ConjunctVal({ peg: [mopv, ...merge] }), r, ctx)
         }
         else {
           r.node = addsite(new MapVal({ peg: mo }), r, ctx)
           r.node.optionalKeys = optionalKeys
           r.node.aliasKeys = aliasKeys
+          r.node.exportKeys = exportKeys
         }
 
         return undefined
@@ -1137,7 +1451,7 @@ help isolate the syntax error.`,
           }
         }
 
-        // No ___merge arm here: the deferred map.merge that writes it
+        // No merge-key arm here: the deferred map.merge that writes it
         // only ever fires for a `pair` rule, whose parent is always a
         // `map` rule with a plain-object node — never a list.
         {
@@ -1231,19 +1545,39 @@ help isolate the syntax error.`,
         }
       })
 
-      .bc((rule: Rule) => {
+      .bc((rule: Rule, ctx: JsonicContext) => {
         // TRAVERSE PARENTS TO GET PATH
 
-        const ktkn: any = rule.o0
+        // AN OPTIONAL PAIR OPENS ON ITS `?`: the rule before read the key.
+        const ktkn: any = true === rule.prev?.u?.aontu_optional ?
+          rule.prev.o0 : rule.o0
         const holder: any = rule.parent
         const kr = keyRefusalOf(ktkn, rule.o1)
         if (null != kr) {
           holder.u.aontu_key_refusals = (holder.u.aontu_key_refusals || [])
-          holder.u.aontu_key_refusals.push({ key: '' + ktkn.src, tkn: ktkn, ...kr })
+          holder.u.aontu_key_refusals.push(
+            { key: keyName(ktkn), tkn: ktkn, url: srcUrl(ctx), ...kr })
         }
         else if (isAliasDecl(ktkn, rule.o1)) {
           holder.u.aontu_alias_keys = (holder.u.aontu_alias_keys || [])
-          holder.u.aontu_alias_keys.push('' + ktkn.src)
+          holder.u.aontu_alias_keys.push({
+            name: '' + ktkn.src,
+            key: aliasScopedKey('' + ktkn.src, srcUrl(ctx)),
+          })
+        }
+        else if (true === ktkn?.use?.aontu_export) {
+          holder.u.aontu_export_decls = (holder.u.aontu_export_decls || [])
+          holder.u.aontu_export_decls.push(
+            { items: ktkn.use.aontu_export_items, tkn: ktkn })
+        }
+        else if (null != ktkn?.use?.aontu_import) {
+          holder.u.aontu_import_decls = (holder.u.aontu_import_decls || [])
+          holder.u.aontu_import_decls.push({
+            key: '' + ktkn.src,
+            names: ktkn.use.aontu_import,
+            url: srcUrl(ctx),
+            tkn: ktkn,
+          })
         }
 
         if (rule.u.spread) {
@@ -1360,6 +1694,14 @@ help isolate the syntax error.`,
             v.path = [...(rule.k?.path ?? []),
               '' + rule.node.length, key]
           }
+          // An element is a value position, so the prefix form applies.
+          if (null == kr && isAliasDecl(ktkn, rule.o1)) {
+            ; ((ctx as any).aontu_alias_hoist ||= [])
+              .push({ name: aliasScopedKey(key, srcUrl(ctx)), val: v })
+            rule.node.push(v)
+            return undefined
+          }
+
           const mv: any = addsite(
             new MapVal({ peg: { [key]: v } }), rule, ctx)
           // The element's path is the list's plus its index, as any
@@ -1367,15 +1709,10 @@ help isolate the syntax error.`,
           // "is this the top level" test reads the path, so an element
           // of a top-level list must not read as the root.
           mv.path = [...(rule.k?.path ?? []), '' + rule.node.length]
-          if (true === rule.u.aontu_optional_elem) {
+          // A REFUSED KEY IS NOT OPTIONAL: the refusal would be dropped.
+          if (true === rule.u.aontu_optional_elem && null == kr) {
             mv.optionalKeys = [key]
           }
-          // ... and a declaration is a declaration IN the element, which
-          // is where MapVal.unify refuses it: a list element is not the
-          // top level.
-          if (isAliasDecl(ktkn, rule.o1)) {
-            mv.aliasKeys = [key]
-          }
           rule.node.push(mv)
         }