@bablr/bablr-vm 0.19.1 → 0.20.0

package/lib/match.js

@@ -1,32 +1,16 @@
 import { resolveLanguage } from '@bablr/helpers/grammar';
 import { WeakStackFrame } from '@bablr/weak-stack';
 
-import { allTagPathsFor, allTagsFor, get, isGapNode, TagPath } from '@bablr/agast-helpers/path';
-import { isEmpty } from '@bablr/agast-helpers/stream';
-import * as btree from '@bablr/agast-helpers/btree';
-import {
-  buildCall,
-  buildEmbeddedNode,
-  buildEmbeddedTag,
-  buildGapTag,
-  buildReferenceTag,
-  mergeReferences,
-} from '@bablr/agast-helpers/tree';
-import { effectsFor, shouldBranch } from '@bablr/agast-vm-helpers';
+import { getChildPropertyIndex, Path, TagPath } from '@bablr/agast-helpers/path';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
+import { buildGapTag, buildReferenceTag, mergeReferences } from '@bablr/agast-helpers/tree';
+import { effectsFor } from '@bablr/agast-vm-helpers';
 import { buildInternalState, internalStates, FragmentFacade } from './node.js';
 
 import { facades, actuals } from './facades.js';
-import {
-  CloseNodeTag,
-  EmbeddedNode,
-  GapTag,
-  OpenNodeTag,
-  ReferenceTag,
-  ShiftTag,
-} from '@bablr/agast-helpers/symbols';
+import { CloseNodeTag, OpenNodeTag } from '@bablr/agast-helpers/symbols';
 import { nodeStates } from './state.js';
-
-const nodeTopType = Symbol.for('@bablr/node');
+import { buildCall, buildEmbeddedTag } from '@bablr/agast-vm-helpers/builders';
 
 const tagPathsAreEqual = (a, b) => {
   return !a || !b ? a == b : a.path.node === b.path.node && a.childrenIndex === b.childrenIndex;
@@ -45,6 +29,10 @@ export class MatchFacade {
     return actuals.get(this).matcher;
   }
 
+  get options() {
+    return actuals.get(this).options;
+  }
+
   get mergedReference() {
     return actuals.get(this).mergedReference;
   }
@@ -65,6 +53,37 @@ export class MatchFacade {
     return actuals.get(this).innerPath;
   }
 
+  get fragment() {
+    const {
+      ctx,
+      path,
+      isNode,
+      fragmentNode,
+      mergedReference,
+      rangePreviousIndex,
+      rangeFinalIndex,
+    } = actuals.get(this);
+
+    const { name, isArray } = mergedReference.value;
+
+    if (isNode && !['#', '@'].includes(name)) {
+      return new FragmentFacade(
+        fragmentNode,
+        ctx,
+        false,
+        true,
+        [rangePreviousIndex + 1, rangeFinalIndex],
+        mergedReference,
+        isArray ? getChildPropertyIndex(fragmentNode, rangePreviousIndex + 1) : null,
+      );
+    } else {
+      return new FragmentFacade(fragmentNode || path.node, ctx, false, true, [
+        rangePreviousIndex + 1,
+        rangeFinalIndex,
+      ]);
+    }
+  }
+
   get pathDepth() {
     return actuals.get(this).depths.path;
   }
@@ -82,14 +101,8 @@ export class MatchFacade {
     return FragmentFacade.wrap(node, ctx, false);
   }
 
-  get fragmentNode() {
-    const { fragmentNode, ctx } = actuals.get(this);
-    return FragmentFacade.wrap(fragmentNode, ctx, false);
-  }
-
   get props() {
-    const { props, ctx } = actuals.get(this);
-    return FragmentFacade.wrap(props, ctx, false);
+    return actuals.get(this).props;
   }
 
   get type() {
@@ -104,8 +117,24 @@ export class MatchFacade {
     return actuals.get(this).isCover;
   }
 
+  get allowEmpty() {
+    return actuals.get(this).allowEmpty;
+  }
+
+  get didShift() {
+    return actuals.get(this).didShift;
+  }
+
+  get isCoverBoundary() {
+    return actuals.get(this).isCoverBoundary;
+  }
+
   get cover() {
-    return actuals.get(this).cover;
+    return facades.get(actuals.get(this).cover);
+  }
+
+  get shiftMatch() {
+    return facades.get(actuals.get(this).shiftMatch);
   }
 
   get captured() {
@@ -162,16 +191,7 @@ export class MatchFacade {
 }
 
 export class Match extends WeakStackFrame {
-  constructor(
-    parent,
-    context,
-    language,
-    state,
-    matcher,
-    effects,
-    didShift = false,
-    suppressNode = false,
-  ) {
+  constructor(parent, context, language, state, matcher, effects, shiftMatch = null, options = {}) {
     if (!context || !language || !state) {
       throw new Error('Invalid arguments to Match constructor');
     }
@@ -180,26 +200,28 @@ export class Match extends WeakStackFrame {
 
     this.context = context;
     this.language = language;
-    this.state = shouldBranch(effects) ? state.branch() : state;
+    this.state = state;
     this.propertyMatcher = matcher;
     this.effects = effects;
-    this.didShift = didShift;
+    this.shiftMatch = shiftMatch;
 
     this.rangePreviousIndex = null;
     this.rangeFinalIndex = null;
     this.node = null;
     this.fragmentNode = null; // why do it this way?
     this.cover = null;
-    this.suppressNode = suppressNode;
+    this.options = options;
 
     let internalState;
-    let { isNode, isCover } = this;
+    let { isNode } = this;
+    const { grammar, type } = this;
+    let isCover = grammar.covers?.has(type);
 
-    this.cover = isCover ? this : isNode ? null : parent?.cover || null;
+    this.cover = isNode ? null : parent?.cover || (isCover ? this : null);
 
-    let shouldConstructNode = (isNode && !parent.isCover) || isCover || !parent;
+    let isCoverBoundary = ((isNode || isCover) && !this.cover) || !parent;
 
-    if (shouldConstructNode) {
+    if (isCoverBoundary) {
       internalState = buildInternalState();
       internalState.path.node;
     } else {
@@ -221,8 +243,12 @@ export class Match extends WeakStackFrame {
     new MatchFacade(this);
   }
 
-  static from(context, language, state, matcher, props, suppressNode) {
-    return Match.create(context, language, state, matcher, effectsFor('eat'), props, suppressNode);
+  static from(context, language, state, matcher, props, options) {
+    return Match.create(context, language, state, matcher, effectsFor('eat'), props, options);
+  }
+
+  get isCoverBoundary() {
+    return (this.isNode && !this.parent.cover) || this.cover === this;
   }
 
   get matcher() {
@@ -233,15 +259,21 @@ export class Match extends WeakStackFrame {
     let ref = buildReferenceTag('.');
 
     let first = true;
-    for (const m of this.ancestors(true)) {
+    let m = this;
+    let lastName = null;
+    do {
       if (m.isNode && !first) break;
       if (m.propertyMatcher.refMatcher) {
         const { name, isArray, flags } = m.propertyMatcher.refMatcher;
         const parentRef = buildReferenceTag(name, isArray, flags);
+        if (lastName && lastName !== name) break;
         ref = ['#', '@'].includes(ref.value.name) ? ref : mergeReferences(ref, parentRef);
+        if (name !== '.') {
+          lastName = name;
+        }
       }
       first = false;
-    }
+    } while ((m = m.shiftMatch || m.parent));
 
     return ref;
   }
@@ -264,6 +296,10 @@ export class Match extends WeakStackFrame {
     return m;
   }
 
+  get coveredBoundary() {
+    return this.isNode ? this.parent.cover || this : this.cover || this;
+  }
+
   get parentPath() {
     return this.pathParent?.path;
   }
@@ -293,11 +329,13 @@ export class Match extends WeakStackFrame {
   }
 
   get allowEmpty() {
-    return !!this.grammar.emptyables?.has(this.type);
+    return !!this.grammar.emptyables?.has(this.type) || this.options.allowEmpty;
   }
 
   get rangePrevious() {
-    return this.rangePreviousIndex == null ? null : new TagPath(this.path, this.rangePreviousIndex);
+    return this.rangePreviousIndex == null
+      ? null
+      : TagPath.from(this.path, this.rangePreviousIndex);
   }
 
   setRangePreviousIndex(value) {
@@ -311,7 +349,7 @@ export class Match extends WeakStackFrame {
   }
 
   get rangeFinal() {
-    const path = !this.parent ? this.path : this.parent.path;
+    const path = Path.from(this.fragmentNode || this.node);
 
     return this.rangeFinalIndex == null ? null : new TagPath(path, this.rangeFinalIndex);
   }
@@ -321,13 +359,6 @@ export class Match extends WeakStackFrame {
 
     if (!rangePrevious) return rangePrevious;
 
-    if (rangePrevious.tag.type === ShiftTag) {
-      let tagPath = rangePrevious;
-      while (tagPath.tag.type !== ReferenceTag) {
-        tagPath = tagPath.previousSibling;
-      }
-      return tagPath;
-    }
     return rangePrevious?.nextSibling;
   }
 
@@ -336,7 +367,11 @@ export class Match extends WeakStackFrame {
     return rangeInitial === null ? null : [rangeInitial, rangeFinal];
   }
 
-  get referencePath() {
+  get didShift() {
+    return !!this.shiftMatch;
+  }
+
+  get unshiftedReferencePath() {
     const previous = this.rangePrevious;
 
     if (!this.isNode) {
@@ -344,28 +379,24 @@ export class Match extends WeakStackFrame {
     }
 
     if (this.parent.cover) {
-      return previous.nextSibling;
+      return previous;
     }
 
     if (this.didShift) {
-      let tagPath = previous;
-      while ([GapTag, ShiftTag].includes(tagPath.tag.type)) {
-        tagPath = tagPath.previousSibling;
-      }
-      return tagPath;
+      let refIndex = previous.childrenIndex - previous.tag.value.index * 2;
+      return previous.siblingPathAt(refIndex);
     }
 
-    return previous.nextSibling;
+    return previous;
   }
 
   get isNode() {
-    const { grammar, type } = this;
-    return !this.suppressNode && grammar.covers?.get(nodeTopType).has(type);
+    let { flags, type } = this.matcher;
+    return !flags.fragment && type !== Symbol.for('@bablr/fragment');
   }
 
   get isCover() {
-    const { grammar, type } = this;
-    return grammar.covers?.has(type);
+    return this.cover === this;
   }
 
   get innerPath() {
@@ -373,9 +404,8 @@ export class Match extends WeakStackFrame {
   }
 
   add(node) {
-    const { expressionsPump, instructionsPump, agast, agastState } = internalStates.get(
-      this.fragmentNode,
-    );
+    let internalState = internalStates.get(this.fragmentNode);
+    const { expressionsPump, instructionsPump, agast, agastState } = internalState;
 
     expressionsPump.queue(node);
     instructionsPump.queue(buildCall('advance', buildEmbeddedTag(buildGapTag())));
@@ -383,7 +413,7 @@ export class Match extends WeakStackFrame {
     agast.next();
   }
 
-  startFrame(state, propertyMatcher, effects, didShift, suppressNode) {
+  startFrame(state, propertyMatcher, effects, didShift, options) {
     let { context } = this;
     const { nodeMatcher } = propertyMatcher;
 
@@ -393,37 +423,29 @@ export class Match extends WeakStackFrame {
       throw new Error(`Unknown language ${nodeMatcher.language.join('.')}`);
     }
 
-    return this.push(context, language, state, propertyMatcher, effects, didShift, suppressNode);
+    return this.push(context, language, state, propertyMatcher, effects, didShift, options);
   }
 
   endFrame() {
     const finishedMatch = this;
     const m = finishedMatch.parent;
-    let finishedState = finishedMatch.state;
 
-    // if (
-    //   finishedMatch.isNode &&
-    //   finishedState.status !== 'rejected' &&
-    //   !getCloseTag(finishedMatch.node)
-    // )
-    //   throw new Error();
+    if (!m) return m;
+
+    finishedMatch.setRangeFinalIndex(
+      sumtree.getSize((finishedMatch.fragmentNode || m.node).children) - 1,
+    );
+
+    return m;
+  }
+
+  throw_() {
+    const finishedMatch = this;
+    const m = finishedMatch.parent;
 
     if (!m) return m;
 
-    if (finishedState !== m.state) {
-      if (
-        (!isEmpty(allTagsFor(finishedMatch.range)) || finishedMatch.allowEmpty) &&
-        finishedMatch.state.status !== 'rejected'
-      ) {
-        finishedState.accept();
-        finishedMatch.setRangeFinalIndex(btree.getSum(m.fragmentNode.children) - 1);
-      } else {
-        finishedState.reject();
-        finishedMatch.setRangePreviousIndex(null);
-      }
-    } else {
-      finishedMatch.setRangeFinalIndex(btree.getSum((m.fragmentNode || m.node).children) - 1);
-    }
+    finishedMatch.setRangePreviousIndex(null);
 
     return m;
   }
@@ -434,9 +456,13 @@ export class Match extends WeakStackFrame {
     if (!state.depth) {
       let { node, emitted } = state;
 
+      if (!node) {
+        node = state.resultPath.node;
+      }
+
       let { path } = internalStates.get(node);
 
-      let tagPath = emitted || (btree.getSum(path.node.children) ? new TagPath(path, 0) : null);
+      let tagPath = emitted || (sumtree.getSize(path.node.children) ? new TagPath(path, 0) : null);
 
       // two basic cases:
       //   emitted can move
@@ -446,7 +472,7 @@ export class Match extends WeakStackFrame {
         if (
           tagPath.tag.type === OpenNodeTag &&
           tagPath.tag.value.type &&
-          nodeStates.get(tagPath.path.node).unboundAttributes?.size
+          nodeStates.get(tagPath.path.node)?.undefinedAttributes?.size
         ) {
           break;
         }