@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/match.js

@@ -1,24 +1,36 @@
 import { resolveLanguage } from '@bablr/helpers/grammar';
 import { WeakStackFrame } from '@bablr/weak-stack';
 
-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 { agast, TagPathFacade as TagPath, PathFacade as Path } from '@bablr/agast-vm';
+import {
+  buildOpenNodeTag,
+  buildProperty,
+  buildReference,
+  fragmentFlags,
+  mergeReferences,
+} from '@bablr/agast-helpers/tree';
 import { effectsFor } from '@bablr/agast-vm-helpers';
-import { buildInternalState, internalStates, FragmentFacade } from './node.js';
+import { FragmentFacade } from './node.js';
 
 import { facades, actuals } from './facades.js';
-import { CloseNodeTag, OpenNodeTag } from '@bablr/agast-helpers/symbols';
-import { nodeStates } from './state.js';
-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;
-};
+import {
+  CloseNodeTag,
+  OpenNodeTag,
+  ReferenceTag,
+  ShiftTag,
+  AttributeDefinition,
+  Property,
+  PropertyWrapper,
+  InitializerTag,
+  BindingTag,
+  LiteralTag,
+} from '@bablr/agast-helpers/symbols';
+import { offsetForTag } from '@bablr/agast-helpers/path';
 
 export class MatchFacade {
   constructor(match) {
     facades.set(match, this);
+    Object.freeze(this);
   }
 
   get language() {
@@ -49,36 +61,41 @@ export class MatchFacade {
     return actuals.get(this).path;
   }
 
-  get innerPath() {
-    return actuals.get(this).innerPath;
-  }
-
   get fragment() {
     const {
       ctx,
-      path,
+      effects,
+      isCoverBoundary,
       isNode,
       fragmentNode,
+      node,
       mergedReference,
       rangePreviousIndex,
       rangeFinalIndex,
     } = actuals.get(this);
 
-    const { name, isArray } = mergedReference.value;
+    const { name, isArray } = mergedReference;
 
-    if (isNode && !['#', '@'].includes(name)) {
+    let prev =
+      rangePreviousIndex != null
+        ? (fragmentNode || node).tags.at(rangePreviousIndex)
+        : rangePreviousIndex;
+
+    let offset = [ReferenceTag, ShiftTag].includes(prev?.type) ? 0 : 1;
+
+    if ((isNode || isCoverBoundary) && name) {
       return new FragmentFacade(
-        fragmentNode,
+        effects.success !== 'none' ? fragmentNode : null,
         ctx,
         false,
         true,
-        [rangePreviousIndex + 1, rangeFinalIndex],
+        [rangePreviousIndex + offset, rangeFinalIndex],
         mergedReference,
-        isArray ? getChildPropertyIndex(fragmentNode, rangePreviousIndex + 1) : null,
+        isArray ? fragmentNode.getChildPropertyIndex(rangePreviousIndex + offset) : null,
       );
     } else {
-      return new FragmentFacade(fragmentNode || path.node, ctx, false, true, [
-        rangePreviousIndex + 1,
+      return new FragmentFacade(fragmentNode || node, ctx, false, true, [
+        rangePreviousIndex + offset,
         rangeFinalIndex,
       ]);
     }
@@ -129,12 +146,16 @@ export class MatchFacade {
     return actuals.get(this).isCoverBoundary;
   }
 
+  get coveredBoundary() {
+    return facades.get(actuals.get(this).coveredBoundary);
+  }
+
   get cover() {
     return facades.get(actuals.get(this).cover);
   }
 
   get shiftMatch() {
-    return facades.get(actuals.get(this).shiftMatch);
+    return facades.get(actuals.get(this).coveredBoundary.shiftMatch);
   }
 
   get captured() {
@@ -142,7 +163,8 @@ export class MatchFacade {
   }
 
   get range() {
-    return actuals.get(this).range;
+    let { range } = actuals.get(this);
+    return range && [range[0], range[1]];
   }
 
   get effects() {
@@ -185,6 +207,10 @@ export class MatchFacade {
     return actuals.get(this).rangeFinalIndex;
   }
 
+  get mergedLanguagePath() {
+    return actuals.get(this).mergedLanguagePath;
+  }
+
   ancestors(...args) {
     return actuals.get(this).ancestors(...args);
   }
@@ -207,39 +233,43 @@ export class Match extends WeakStackFrame {
 
     this.rangePreviousIndex = null;
     this.rangeFinalIndex = null;
+    this.agast = null;
+    this.agastFragment = null; // why do it this way?
     this.node = null;
-    this.fragmentNode = null; // why do it this way?
     this.cover = null;
+    this.running = null;
     this.options = options;
 
-    let internalState;
-    let { isNode } = this;
-    const { grammar, type } = this;
-    let isCover = grammar.covers?.has(type);
-
-    this.cover = isNode ? null : parent?.cover || (isCover ? this : null);
-
-    let isCoverBoundary = ((isNode || isCover) && !this.cover) || !parent;
-
-    if (isCoverBoundary) {
-      internalState = buildInternalState();
-      internalState.path.node;
+    let isNode = !matcher.nodeMatcher.flags.fragment;
+    let isCover = matcher.nodeMatcher.flags.cover;
+
+    this.agast = isNode ? null : state.agast ?? null;
+    this.node = isNode ? null : parent?.node;
+    this.cover =
+      effects.success === 'none'
+        ? null
+        : !parent?.isNode && parent?.cover
+        ? parent.cover
+        : isCover && parent
+        ? this
+        : null;
+
+    if (isNode || !parent?.node) {
+      let held = null;
+      // TODO wat
+      if (this.coveredBoundary.shiftMatch) {
+        let { reference, binding, node } = state.held;
+        held = buildProperty(reference, binding, node.node);
+      }
+      this.agast = agast({ held });
     } else {
-      const { instructionsPump, expressionsPump, agastState, agast, path } = internalStates.get(
-        parent.node,
-      );
-      internalState = { instructionsPump, expressionsPump, agastState, agast, path };
-    }
-
-    this.node = internalState.path.node;
-
-    if (this.isNode) {
-      this.node.type = Symbol.for(this.type);
-      this.node.language = this.language.canonicalURL;
+      this.agast = parent.agast;
+      if (effects.success === 'none') {
+        this.agast = agast();
+        this.agast.vm.next(buildOpenNodeTag(fragmentFlags));
+      }
     }
 
-    internalStates.set(this.node, internalState);
-
     new MatchFacade(this);
   }
 
@@ -248,28 +278,36 @@ export class Match extends WeakStackFrame {
   }
 
   get isCoverBoundary() {
-    return (this.isNode && !this.parent.cover) || this.cover === this;
+    let { cover } = this;
+    return cover === this;
   }
 
   get matcher() {
     return this.propertyMatcher?.nodeMatcher;
   }
 
+  get vm() {
+    return this.agast.vm;
+  }
+
   get mergedReference() {
-    let ref = buildReferenceTag('.');
+    let ref = buildReference('.');
 
     let first = true;
     let m = this;
     let lastName = null;
+    let lastRefType = 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 !== '.') {
+        const parentRef = m.propertyMatcher.refMatcher;
+        const { type: refType, name } = parentRef;
+
+        if (lastName && (lastName !== name || lastRefType !== refType)) break;
+        ref = ['#', '@'].includes(ref.type) ? ref : mergeReferences(ref, parentRef);
+        if (refType !== '.') {
           lastName = name;
+          lastRefType = refType;
         }
       }
       first = false;
@@ -278,13 +316,30 @@ export class Match extends WeakStackFrame {
     return ref;
   }
 
+  get mergedLanguagePath() {
+    let languagePath = [];
+
+    let first = true;
+    let m = this;
+    do {
+      if (m.isNode && !first) break;
+      if (m.propertyMatcher.bindingMatcher) {
+        languagePath = m.propertyMatcher.bindingMatcher.languagePath.concat(languagePath);
+      }
+      first = false;
+    } while ((m = m.shiftMatch || m.parent));
+
+    return Object.freeze(languagePath);
+  }
+
   get pathName() {
-    return this.mergedReference.value.name;
+    return this.mergedReference.name;
   }
 
   get path() {
-    let { agastState } = internalStates.get(this.fragmentNode || this.node);
-    return agastState.path || agastState.resultPath.path;
+    let { agast } = this;
+
+    return agast.state.path || agast.state.resultPath?.path;
   }
 
   get pathParent() {
@@ -297,7 +352,7 @@ export class Match extends WeakStackFrame {
   }
 
   get coveredBoundary() {
-    return this.isNode ? this.parent.cover || this : this.cover || this;
+    return this.cover || this;
   }
 
   get parentPath() {
@@ -332,33 +387,63 @@ export class Match extends WeakStackFrame {
     return !!this.grammar.emptyables?.has(this.type) || this.options.allowEmpty;
   }
 
+  get fragmentNode() {
+    if (!this.agastFragment) return null;
+
+    let { node, resultPath } = this.agastFragment.state;
+    return resultPath?.tag.type === CloseNodeTag ? resultPath.node : node;
+  }
+
+  get fragmentPath() {
+    if (!this.agastFragment) return null;
+
+    let { path, resultPath } = this.agastFragment.state;
+    return resultPath?.tag.type === CloseNodeTag ? resultPath.path : path;
+  }
+
   get rangePrevious() {
-    return this.rangePreviousIndex == null
+    let path = this.fragmentPath || this.path;
+
+    return this.rangePreviousIndex == null || path == null
       ? null
-      : TagPath.from(this.path, this.rangePreviousIndex);
+      : TagPath.from(path, this.rangePreviousIndex, -1);
   }
 
   setRangePreviousIndex(value) {
+    if ((value != null && !Number.isFinite(value)) || value < 0) throw new Error();
     this.rangePreviousIndex = value;
-    this.rangePrevious;
+    if (
+      value != null &&
+      (!this.rangePrevious ||
+        (this.isNode &&
+          ![OpenNodeTag, Property, InitializerTag, LiteralTag, AttributeDefinition].includes(
+            this.rangePrevious.tag.type,
+          )))
+    )
+      throw new Error();
   }
 
   setRangeFinalIndex(value) {
+    if (value != null && !Number.isFinite(value)) throw new Error();
     this.rangeFinalIndex = value;
     this.rangeFinal;
   }
 
   get rangeFinal() {
-    const path = Path.from(this.fragmentNode || this.node);
+    let path = this.fragmentPath || this.path;
 
-    return this.rangeFinalIndex == null ? null : new TagPath(path, this.rangeFinalIndex);
+    return this.rangeFinalIndex == null || path == null
+      ? null
+      : TagPath.from(path, this.rangeFinalIndex, -1);
   }
 
   get rangeInitial() {
-    const { rangePrevious } = this;
+    const { rangePrevious, isNode, fragmentPath, path, rangePreviousIndex } = this;
 
     if (!rangePrevious) return rangePrevious;
 
+    if (isNode) return TagPath.from(fragmentPath || path, rangePreviousIndex + 1, 0);
+
     return rangePrevious?.nextSibling;
   }
 
@@ -371,59 +456,76 @@ export class Match extends WeakStackFrame {
     return !!this.shiftMatch;
   }
 
-  get unshiftedReferencePath() {
-    const previous = this.rangePrevious;
-
-    if (!this.isNode) {
+  get referencePath() {
+    if (!(this.isNode || this.isCoverBoundary || this.cover) || this.state.depths.path < 0) {
       return null;
     }
 
-    if (this.parent.cover) {
-      return previous;
-    }
+    let parentPath = this.fragmentPath || this.path;
 
-    if (this.didShift) {
-      let refIndex = previous.childrenIndex - previous.tag.value.index * 2;
-      return previous.siblingPathAt(refIndex);
+    let ref = TagPath.from(parentPath, this.rangePreviousIndex + 1, 0);
+
+    if (!ref) return null;
+
+    if (ref.tag.type === ShiftTag) {
+      let refIndex = ref.tagsIndex - ref.tag.value.index;
+      ref = TagPath.from(ref.path, refIndex, 0);
     }
 
-    return previous;
+    if (ref && ref.tag.type !== ReferenceTag) throw new Error();
+    return ref;
   }
 
   get isNode() {
-    let { flags, type } = this.matcher;
-    return !flags.fragment && type !== Symbol.for('@bablr/fragment');
+    let { flags } = this.matcher;
+    return !this.parent || !flags.fragment;
   }
 
   get isCover() {
     return this.cover === this;
   }
 
-  get innerPath() {
-    return internalStates.get(this.node).path;
-  }
+  advance(tag, s = this.state) {
+    let { vm, state: agastState } = s.agast;
 
-  add(node) {
-    let internalState = internalStates.get(this.fragmentNode);
-    const { expressionsPump, instructionsPump, agast, agastState } = internalState;
+    let result = vm.next(tag);
 
-    expressionsPump.queue(node);
-    instructionsPump.queue(buildCall('advance', buildEmbeddedTag(buildGapTag())));
+    if (tag.type === OpenNodeTag) {
+      s.depths.result++;
+      this.node = s.node || s.resultPath.node;
+    } else if (tag.type === CloseNodeTag) {
+      s.depths.result--;
+    }
 
-    agast.next();
+    s.resultPath =
+      (agastState.path || agastState.resultPath?.path) &&
+      TagPath.from(
+        agastState.path || agastState.resultPath?.path,
+        -1,
+        tag.type === PropertyWrapper ? -1 : offsetForTag(tag),
+      );
+    return result.value;
   }
 
-  startFrame(state, propertyMatcher, effects, didShift, options) {
+  startFrame(state, propertyMatcher, effects, shiftMatch, options) {
     let { context } = this;
-    const { nodeMatcher } = propertyMatcher;
+    const { bindingMatcher } = propertyMatcher;
+
+    let language = shiftMatch?.language ?? this.language;
 
-    const language = resolveLanguage(context, this.language, nodeMatcher.language);
+    if (bindingMatcher) {
+      language = resolveLanguage(context, language, bindingMatcher.languagePath);
 
-    if (!language) {
-      throw new Error(`Unknown language ${nodeMatcher.language.join('.')}`);
+      if (!language) {
+        throw new Error(`Unknown language ${bindingMatcher.languagePath.join('.')}`);
+      }
     }
 
-    return this.push(context, language, state, propertyMatcher, effects, didShift, options);
+    let m = this.push(context, language, state, propertyMatcher, effects, shiftMatch, options);
+
+    this.running = m;
+
+    return m;
   }
 
   endFrame() {
@@ -432,9 +534,9 @@ export class Match extends WeakStackFrame {
 
     if (!m) return m;
 
-    finishedMatch.setRangeFinalIndex(
-      sumtree.getSize((finishedMatch.fragmentNode || m.node).children) - 1,
-    );
+    finishedMatch.setRangeFinalIndex((finishedMatch.fragmentNode || m.node).tags.size - 1);
+
+    m.running = null;
 
     return m;
   }
@@ -445,40 +547,54 @@ export class Match extends WeakStackFrame {
 
     if (!m) return m;
 
+    m.running = null;
+
     finishedMatch.setRangePreviousIndex(null);
 
     return m;
   }
 
-  *emit() {
+  *emit(options) {
     let { state } = this;
+    let { emitted } = state;
 
-    if (!state.depth) {
-      let { node, emitted } = state;
+    let m = emitted?.match ?? this;
 
-      if (!node) {
-        node = state.resultPath.node;
-      }
+    if (!state.depth) {
+      let { node } = m;
 
-      let { path } = internalStates.get(node);
+      // if (!node) {
+      //   node = resultPath.node;
+      // }
 
-      let tagPath = emitted || (sumtree.getSize(path.node.children) ? new TagPath(path, 0) : null);
+      let path = Path.from(node);
 
-      // two basic cases:
-      //   emitted can move
-      //   emitted cannot move
+      let tagPath = emitted?.tagPath || (path.node.tags.size ? TagPath.from(path, 0) : null);
 
       while (tagPath) {
         if (
+          options.holdUndefinedAttributes &&
           tagPath.tag.type === OpenNodeTag &&
           tagPath.tag.value.type &&
-          nodeStates.get(tagPath.path.node)?.undefinedAttributes?.size
+          (m.node.undefinedAttributes ?? 0) > 0
         ) {
           break;
         }
 
-        if (!tagPathsAreEqual(tagPath, state.emitted)) {
-          state.emitted = emitted = tagPath;
+        if (
+          tagPath.tag.type === OpenNodeTag &&
+          m.referencePath?.tag.value.type === '@' &&
+          tagPath.node.flags.hasGap
+        )
+          break;
+
+        let holdShifted =
+          options.holdShiftedNodes &&
+          tagPath.tag.type === ReferenceTag &&
+          tagPath.tag.value.flags.expression;
+
+        if (!state.emitted || !tagPath.equalTo(state.emitted.tagPath)) {
+          state.emitted = emitted = { match: m, tagPath };
 
           if (tagPath.tag.type === OpenNodeTag) {
             state.depths.emitted++;
@@ -486,10 +602,57 @@ export class Match extends WeakStackFrame {
             state.depths.emitted--;
           }
 
-          yield tagPath.tag;
+          if (
+            !(
+              (tagPath.tag.type === BindingTag && !tagPath.tag.value.languagePath?.length) ||
+              (tagPath.tag.type === AttributeDefinition && options.holdUndefinedAttributes)
+            )
+          ) {
+            yield tagPath.tag;
+          }
+        }
+
+        if (
+          (tagPath.tag.type === CloseNodeTag ||
+            (tagPath.tag.type === OpenNodeTag && tagPath.tag.value.selfClosing)) &&
+          !tagPath.next
+        ) {
+          tagPath = TagPath.from(m.fragmentPath, m.rangeInitial.tagsIndex + 1, 0);
+
+          do {
+            m = m.parent;
+          } while (m && !m.isNode);
+
+          if (!m) break;
+
+          continue;
         }
 
-        tagPath = emitted.next;
+        if (!holdShifted && tagPath.tag.type === ReferenceTag && !tagPath.nextSibling) {
+          let { running } = m;
+
+          while (running && !running.isNode) {
+            if (running.state.depth > 0) {
+              running = null;
+              break;
+            } else {
+              running = running.running;
+            }
+          }
+
+          if (running) {
+            m = running;
+          } else {
+            break;
+          }
+          tagPath = TagPath.from(m.path, 0);
+        } else {
+          if (holdShifted) {
+            tagPath = tagPath.nextUnshifted;
+          } else {
+            tagPath = tagPath.next;
+          }
+        }
       }
     }
   }