aontu 0.68.0 → 0.69.0

package/src/lsp.ts

@@ -207,6 +207,7 @@ function initializeResult() {
     capabilities: {
       textDocumentSync: 1,
       hoverProvider: true,
+      definitionProvider: true,
       completionProvider: {},
       signatureHelpProvider: { triggerCharacters: ['(', ','] },
     },
@@ -301,9 +302,104 @@ export function contributionsMarkdown(conjuncts: WhyConjunct[]): string {
 }
 
 
+// The alias name the cursor sits on, with its span. A `%` inside a
+// string is text (`a: "%foo"`), so quoted runs are stepped over.
+function aliasAt(
+  src: string, position: Position,
+): { name: string, start: number, end: number } | undefined {
+  const line = src.split('\n')[position.line]
+  if (null == line) {
+    return undefined
+  }
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i]
+    if ('"' === c || "'" === c) {
+      for (i++; i < line.length && line[i] !== c; i++) { }
+      continue
+    }
+    if ('%' !== c) {
+      continue
+    }
+    const m = ALIAS_RE.exec(line.substring(i))
+    if (null == m) {
+      continue
+    }
+    if (i <= position.character && position.character < i + m[0].length) {
+      return { name: m[0], start: i, end: i + m[0].length }
+    }
+    i += m[0].length - 1
+  }
+  return undefined
+}
+
+
+// The binding for a name the cursor is on, or nothing where the name is
+// used but never bound -- which the diagnostics already report.
+function aliasBindingAt(
+  src: string, position: Position,
+): { at: { name: string, start: number, end: number }, bind: AliasBinding }
+  | undefined {
+  const at = aliasAt(src, position)
+  if (undefined === at) {
+    return undefined
+  }
+  for (const bind of aliasScope(src)) {
+    if (bind.name === at.name) {
+      return { at, bind }
+    }
+  }
+  return undefined
+}
+
+
+function aliasMarkdown(bind: AliasBinding): string {
+  return '```aontu\n' + bind.decl + '\n```\n\n*alias' +
+    ('' === bind.from ? '' : ', taken from ' + bind.from) + '*'
+}
+
+
+type Location = { uri: string, range: Range }
+
+
+// Go to where the name is BOUND: its declaration, or the destructure
+// that brought it in, which is where this file gets the name.
+function computeDefinition(
+  src: string, position: Position, uri: string): Location | null {
+  const found = aliasBindingAt(src, position)
+  if (undefined === found) {
+    return null
+  }
+  const line = found.bind.row - 1
+  const col = found.bind.col - 1
+  return {
+    uri,
+    range: {
+      start: { line, character: col },
+      end: { line, character: col + found.bind.name.length },
+    },
+  }
+}
+
+
 function computeHover(
   src: string, position: Position, provenance?: boolean,
   trust?: any): Hover | null {
+  // A NAME IS NOT A VALUE: the tree holds what it resolves to, at the
+  // declaration's site, so a use has no span for the walk below to
+  // find. The unify below takes a parsed Val as well as text, and text
+  // is the only thing with a name in it to read.
+  const named = 'string' === typeof src ?
+    aliasBindingAt(src, position) : undefined
+  if (undefined !== named) {
+    return {
+      contents: { kind: 'markdown', value: aliasMarkdown(named.bind) },
+      range: {
+        start: { line: position.line, character: named.at.start },
+        end: { line: position.line, character: named.at.end },
+      },
+    }
+  }
+
   let root: any
   try {
     root = new Aontu(null == trust ? {} : { trust }).unify(src, { collect: true })
@@ -409,9 +505,13 @@ type CompletionItem = {
 }
 
 import { funcSig, renderSig, renderSigArg } from './sig'
+import { ALIAS_RE } from './aliasname'
+import { aliasScope } from './alias'
+import type { AliasBinding } from './alias'
 
 // LSP CompletionItemKind subset.
 const COMPLETION_FUNCTION = 3
+const COMPLETION_VARIABLE = 6
 const COMPLETION_KEYWORD = 14
 
 const BUILTIN_FUNCS = [
@@ -441,9 +541,9 @@ const KIND_KEYWORDS = [
 const LITERAL_KEYWORDS = ['_', 'true', 'false', 'null', 'top']
 
 
-// Context-free completion: the built-in functions, scalar-kind keywords
-// and literals. Clients filter by the typed prefix.
-function computeCompletions(): CompletionItem[] {
+// The built-in functions, scalar-kind keywords and literals, and the
+// names this document binds. Clients filter by the typed prefix.
+function computeCompletions(src: string): CompletionItem[] {
   const out: CompletionItem[] = []
   for (const f of BUILTIN_FUNCS) {
     // The detail is the rendered SIGNATURE (docs/design/SIGNATURES.0.md)
@@ -457,6 +557,18 @@ function computeCompletions(): CompletionItem[] {
   for (const k of LITERAL_KEYWORDS) {
     out.push({ label: k, kind: COMPLETION_KEYWORD, detail: 'keyword' })
   }
+  // A name that binds more than once is still one name to offer.
+  const named = new Set<string>()
+  for (const bind of aliasScope(src)) {
+    if (named.has(bind.name)) {
+      continue
+    }
+    named.add(bind.name)
+    out.push({
+      label: bind.name, kind: COMPLETION_VARIABLE,
+      detail: '' === bind.from ? 'alias' : 'alias from ' + bind.from,
+    })
+  }
   return out
 }
 
@@ -586,8 +698,23 @@ class LspHandler {
         return [{ jsonrpc: '2.0', id: msg.id, result: hover }]
       }
 
-      case 'textDocument/completion':
-        return [{ jsonrpc: '2.0', id: msg.id, result: computeCompletions() }]
+      case 'textDocument/completion': {
+        const uri = msg.params?.textDocument?.uri
+        const text = null != uri ? this.docs.get(uri) : undefined
+        return [{
+          jsonrpc: '2.0', id: msg.id,
+          result: computeCompletions(text ?? ''),
+        }]
+      }
+
+      case 'textDocument/definition': {
+        const uri = msg.params?.textDocument?.uri
+        const pos = msg.params?.position
+        const text = null != uri ? this.docs.get(uri) : undefined
+        const at = (null != text && null != pos)
+          ? computeDefinition(text, pos, uri) : null
+        return [{ jsonrpc: '2.0', id: msg.id, result: at }]
+      }
 
       case 'textDocument/signatureHelp': {
         const uri = msg.params?.textDocument?.uri
@@ -616,12 +743,13 @@ class LspHandler {
     return publishDiagnosticsMsg(uri,
       computeDiagnostics(this.docs.get(uri) ?? '', { trust: this.trust }))
   }
-} /* node:coverage ignore next 28 */
+} /* node:coverage ignore next 31 */
 
 
 export {
   computeDiagnostics,
   computeHover,
+  computeDefinition,
   computeCompletions,
   LspHandler,
   LSP_VERSION,
@@ -631,6 +759,7 @@ export {
   SEVERITY_INFORMATION,
   SEVERITY_HINT,
   COMPLETION_FUNCTION,
+  COMPLETION_VARIABLE,
   COMPLETION_KEYWORD,
 }
 
@@ -643,4 +772,5 @@ export type {
   Hover,
   MarkupContent,
   CompletionItem,
+  Location,
 }

package/src/site.ts

@@ -10,6 +10,13 @@ type SiteSpec = {
   row?: number, col?: number, url?: string, len?: number, src?: string,
 }
 
+// WHERE A NAME WAS USED, when the value arrived through one. A finding
+// names where a value is written; this names where it entered the path
+// the finding is about (ALIASES.0.md A-1).
+type ViaSite = {
+  row: number, col: number, url: string, src: string, name: string,
+}
+
 // row, col and len -1, url and src empty, mean UNKNOWN: a value the
 // engine minted rather than read has no site, and must not be edited
 // as though it had one.
@@ -19,6 +26,7 @@ class Site {
   url: string
   len: number
   src: string
+  via?: ViaSite
 
   constructor(val?: Val | SiteSpec) {
     const site = ((val as any)?.site ?? val) as SiteSpec
@@ -28,10 +36,16 @@ class Site {
     this.url = site?.url ?? ''
     this.len = site?.len ?? -1
     this.src = site?.src ?? ''
+    this.via = (site as any)?.via
   }
-} /* node:coverage ignore next 6 */
+} /* node:coverage ignore next 10 */
 
 
 export {
   Site,
 }
+
+
+export type {
+  ViaSite,
+}

package/src/subsume.ts

@@ -347,8 +347,10 @@ export function subsumeNode(
         'the general value is a map and the specific value is not')
       return 'no'
     }
-    return subsumeBag(state, path, g, s, Object.keys(g.peg),
-      Object.keys(s.peg), (v: any, k: string) => v.peg[k])
+    // A DECLARATION IS NOT A FIELD: an alias key is erased before the
+    // document exists, so neither side compares one.
+    return subsumeBag(state, path, g, s, fieldKeys(g), fieldKeys(s),
+      (v: any, k: string) => v.peg[k])
   }
 
   // Lists: element-wise by position; the same required/optional shape
@@ -378,6 +380,11 @@ export function subsumeNode(
 // must be required in the specific side and subsume; optional keys
 // compare when present; closedness bounds the specific key set; spread
 // templates govern the specific side's surplus.
+function fieldKeys(v: any): string[] {
+  return Object.keys(v.peg).filter((k: string) => !v.aliasKeys.includes(k))
+}
+
+
 function subsumeBag(
   state: SubState, path: string[], g: any, s: any,
   gKeys: string[], sKeys: string[],

package/src/val/BagVal.ts

@@ -32,6 +32,10 @@ abstract class BagVal extends FeatureVal {
 
   aliasKeys: string[] = []
 
+  // THE NAMES THIS FILE PUBLISHES, read at parse time by a destructure,
+  // so they do not travel through unify the way aliasKeys does.
+  exportKeys: string[] = []
+
   spread = {
     cj: (undefined as Val | undefined),
   }

package/src/val/EmitFuncVal.ts

@@ -17,7 +17,7 @@ import { cmpCodePoint } from '../keyorder'
 import { top } from './top'
 import { ListVal } from './ListVal'
 import { StringVal } from './StringVal'
-import { FuncBaseVal, trialUnify } from './FuncBaseVal'
+import { FuncBaseVal, trialUnify, sameMembers } from './FuncBaseVal'
 import { repathInstance } from './Val'
 import type { EmitOrigin } from './Val'
 import { boundArgStart, fillPlace, rebuild } from './PlaceVal'
@@ -464,7 +464,8 @@ class EmitFuncVal extends FuncBaseVal {
       // The trial is against CLONES: `unite` refines a bag in place
       // against a TOP peer, and a pattern that failed must be untouched
       // for the next node.
-      if (undefined !== trialUnify(ctx, node.clone(ctx), tmpl.match.clone(ctx))) {
+      const met = trialUnify(ctx, node.clone(ctx), tmpl.match.clone(ctx))
+      if (undefined !== met && sameMembers(node, met, ctx)) {
         return tmpl
       }
     }

package/src/val/FilterFuncVal.ts

@@ -13,7 +13,7 @@ import {
 import { makeNilErr } from '../err'
 import { MapVal } from './MapVal'
 import { ListVal } from './ListVal'
-import { FuncBaseVal, trialUnify } from './FuncBaseVal'
+import { FuncBaseVal, trialUnify, sameMembers } from './FuncBaseVal'
 import { repathInstance } from './Val'
 import { fillPlace } from './PlaceVal'
 import { bagMembers } from './members'
@@ -65,7 +65,7 @@ class FilterFuncVal extends FuncBaseVal {
       repathInstance(inst, inst.path)
       const test = fillPlace(inst, child, kctx)
       const met = trialUnify(kctx, child.clone(kctx), test)
-      return undefined !== met && met.canon === child.canon
+      return undefined !== met && sameMembers(child, met, kctx)
     }
 
     // The candidates are the bag's MEMBERS -- what generation would

package/src/val/FuncBaseVal.ts

@@ -31,6 +31,34 @@ import {
 import { ConjunctVal } from '../val/ConjunctVal'
 import { FeatureVal } from '../val/FeatureVal'
 import { hasPlace, fillPlace } from '../val/PlaceVal'
+import { bagMembers } from './members'
+
+
+// Did the meet ADD a key or narrow a leaf, or only constrain? MEMBERS,
+// not raw keys, so an unfilled optional is not something to add.
+function sameKids(a: any, b: any, ctx: AontuContext): boolean {
+  if (true === a?.isMap || true === a?.isList) {
+    const am = bagMembers(a, ctx)
+    const bm = bagMembers(b, ctx)
+    if (null == am || null == bm || am.length !== bm.length) {
+      return false
+    }
+    const peers = new Map(bm.map((m) => [m.key, m.val]))
+    return am.every((m) =>
+      peers.has(m.key) && sameKids(m.val, peers.get(m.key), ctx))
+  }
+  return a?.canon === b?.canon
+}
+
+
+// A pref-free disjunction is several values at once: any match counts.
+function sameMembers(a: any, b: any, ctx: AontuContext): boolean {
+  if (true === a?.isDisjunct && Array.isArray(a.peg) &&
+    !a.peg.some((m: any) => true === m?.isPref)) {
+    return true
+  }
+  return sameKids(a, b, ctx)
+}
 
 
 function trialUnify(ctx: AontuContext, a: Val, b: Val): Val | undefined {
@@ -326,10 +354,11 @@ class FuncBaseVal extends FeatureVal {
   }
 
 
-} /* node:coverage ignore next 6 */
+} /* node:coverage ignore next 7 */
 
 
 export {
   trialUnify,
+  sameMembers,
   FuncBaseVal,
 }

package/src/val/MapVal.ts

@@ -36,11 +36,12 @@ import { NilVal } from './NilVal'
 import { BagVal } from './BagVal'
 import { repathInstance, spreadId } from './Val'
 import { cmpCodePoint } from '../keyorder'
+import { aliasBareName, EXPORT_DECL_NAME } from '../aliasname'
 import { markSpread } from '../provenance'
 
 
 function spreadSnapKey(cj: any): string {
-  return cj.spelling + '~' + cj.site.row + ':' + cj.site.col
+  return cj.spelling + '~' + cj.site.url + '~' + cj.site.row + ':' + cj.site.col
 }
 
 function snapshotRefSpread(cj: any, ctx: AontuContext): Val | undefined {
@@ -115,13 +116,17 @@ class MapVal extends BagVal {
   }
 
 
+  // An `export` answers to the root rule a declaration does.
   aliasDeclarationsAreRooted(ctx: AontuContext): Val | undefined {
-    if (0 === this.aliasKeys.length || 0 === this.path.length) {
+    const named = 0 < this.aliasKeys.length ?
+      aliasBareName(this.aliasKeys[0]) :
+      0 < this.exportKeys.length ? EXPORT_DECL_NAME : undefined
+    if (undefined === named || 0 === this.path.length) {
       return undefined
     }
     const nv: any = new NilVal({ why: 'alias_not_toplevel' }, ctx)
     nv.site = this.site
-    nv.path = [...this.path, this.aliasKeys[0]]
+    nv.path = [...this.path, named]
     return nv
   }
 
@@ -267,7 +272,8 @@ class MapVal extends BagVal {
         for (let peerkey in upeer.peg) {
           let peerchild = upeer.peg[peerkey]
 
-          if (this.closed && !allowedKeys.includes(peerkey)) {
+          if (this.closed && !allowedKeys.includes(peerkey) &&
+            !upeer.aliasKeys.includes(peerkey)) {
             bad = makeNilErr(ctx, 'closed', peerchild, undefined)
           }
 

package/src/val/MatchFuncVal.ts

@@ -13,7 +13,7 @@ import {
 import { makeNilErr } from '../err'
 import { top } from './top'
 import { prefInnerPeg } from './PrefVal'
-import { FuncBaseVal, trialUnify } from './FuncBaseVal'
+import { FuncBaseVal, trialUnify, sameMembers } from './FuncBaseVal'
 
 
 export function effectiveScrutinee(v: Val): Val {
@@ -94,7 +94,8 @@ class MatchFuncVal extends FuncBaseVal {
       // The trial is against CLONES: `unite` refines a bag in place
       // against a TOP peer, and a pattern that failed must be
       // untouched for the next document that reads its canon.
-      if (undefined !== trialUnify(ctx, scrutinee.clone(ctx), pattern.clone(ctx))) {
+      const met = trialUnify(ctx, scrutinee.clone(ctx), pattern.clone(ctx))
+      if (undefined !== met && sameMembers(scrutinee, met, ctx)) {
         return args[i + 1].clone(ctx)
       }
     }

package/src/val/NilVal.ts

@@ -128,6 +128,9 @@ class NilVal extends Val {
     out.secondary = this.secondary
 
     out.msg = this.msg
+    // The hint reads the details, so a clone that dropped them left
+    // `{name}` in the message. A struct copy carries them in Go.
+    out.details = this.details
     return out
   }
 

package/src/val/RecurseVal.ts

@@ -15,6 +15,7 @@ import {
 } from '../ctx'
 
 import { makeNilErr } from '../err'
+import { aliasPathSegment } from '../aliasname'
 
 import { FeatureVal } from './FeatureVal'
 import { ConjunctVal } from './ConjunctVal'
@@ -80,7 +81,7 @@ class RecurseVal extends FeatureVal {
     if (true === p.isMap || true === p.isList || true === p.isScalar) {
       if (ctx.budget.depth <= this.xc) {
         return makeNilErr(ctx, 'recursion_budget', this, peer, 'recurse',
-          { target: '$.' + this.target.join('.') })
+          { target: this.targetSpelling })
       }
       const body = this.body(ctx)
       if (undefined === body) {
@@ -111,13 +112,17 @@ class RecurseVal extends FeatureVal {
     return out
   }
 
+  get targetSpelling(): string {
+    return '$.' + this.target.map(aliasPathSegment).join('.')
+  }
+
   get canon(): string {
-    return '$.' + this.target.join('.')
+    return this.targetSpelling
   }
 
   gen(ctx: AontuContext) {
     makeNilErr(ctx, 'recursion_unexpanded', this, undefined, 'recurse',
-      { target: '$.' + this.target.join('.') })
+      { target: this.targetSpelling })
     return undefined
   }
 }

package/src/val/RefVal.ts

@@ -80,9 +80,7 @@ function markedChild(v: any, part: any): Val | undefined {
 }
 
 
-// An alias name, whole: the sigil and an identifier (the lexer's
-// ALIAS_RE, anchored at both ends, for the canon spelling above).
-const ALIAS_NAME_RE = /^%[A-Za-z_][A-Za-z0-9_]*$/
+import { ALIAS_NAME_RE, aliasBareName } from '../aliasname'
 
 
 class RefVal extends FeatureVal {
@@ -223,6 +221,15 @@ class RefVal extends FeatureVal {
         }
       }
       else {
+        // A NAME IS WHERE THE VALUE ENTERED THIS PATH; find() answers
+        // a clone, so the use travels with it.
+        const aname = this.aliasName
+        if (undefined !== aname) {
+          resolved.site.via = {
+            row: this.site.row, col: this.site.col,
+            url: this.site.url, src: this.site.src, name: aname,
+          }
+        }
         out = unite(te ? ctx.clone({ explain: ec(te, 'RES') }) : ctx, resolved, peer, 'ref')
       }
 
@@ -423,7 +430,11 @@ class RefVal extends FeatureVal {
         if (undefined !== ctx.reads && null != node) {
           // The root's own address is `$`, as the coverage walk spells
           // it: a dot with nothing after it would match no path there.
-          const addr = '$' + refpath.map((seg: string) => '.' + seg).join('')
+          // An alias is addressed by the NAME its source spells.
+          const aname = this.aliasName
+          const addr = undefined === aname ?
+            '$' + refpath.map((seg: string) => '.' + seg).join('') :
+            '$.' + aname
           // AN ALIAS IS NOT A PATH. `%wire` names a value the document
           // holds unevaluated and the tree never carries, so it is an
           // address a rule can be reported AT and never a path coverage
@@ -500,7 +511,7 @@ class RefVal extends FeatureVal {
       if (null == rp) {
         return false
       }
-      const key = rp.join('')
+      const key = rp.join('\u0000')
       if (ancestors.has(key)) {
         return true
       }
@@ -588,18 +599,26 @@ class RefVal extends FeatureVal {
   }
 
 
-  // THE NAME OF THE ALIAS THIS REFERENCE NAMES, or undefined for a
-  // path reference. `%u` is spelled internally as the root reference
-  // `$.%u` (docs/design/ALIASES.0.md: the name is a path into the
-  // declaration), so an alias reference is an absolute reference of
-  // one segment that is an alias name.
-  get aliasName(): string | undefined {
+  // THE KEY THIS REFERENCE RESOLVES AGAINST, or undefined for a path
+  // reference. `%u` is spelled internally as the root reference `$.%u`
+  // (ALIASES.0.md), so an alias reference is an absolute reference of
+  // one segment that is a name -- carrying the url of the file the
+  // reference was WRITTEN in (ALIAS-FILE-SCOPE.0.md).
+  get aliasKey(): string | undefined {
     return this.absolute && 1 === this.peg.length &&
-      'string' === typeof this.peg[0] && ALIAS_NAME_RE.test(this.peg[0]) ?
+      'string' === typeof this.peg[0] &&
+      ALIAS_NAME_RE.test(aliasBareName(this.peg[0])) ?
       this.peg[0] : undefined
   }
 
 
+  // What the source spells: the key without its scope.
+  get aliasName(): string | undefined {
+    const key = this.aliasKey
+    return undefined === key ? undefined : aliasBareName(key)
+  }
+
+
   // THE REFERENCE'S OWN SPELLING: the alias name, or the path. This is
   // the reference's identity (the snapshot key of a ref spread, the
   // same-path test in unify), which `canon` below is not once an