@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/state.js

@@ -1,40 +1,46 @@
+import { agast as createAgast, TagPathFacade as TagPath } from '@bablr/agast-vm';
 import emptyStack from '@iter-tools/imm-stack';
 import { WeakStackFrame } from '@bablr/weak-stack';
-import { getCooked } from '@bablr/agast-helpers/stream';
+import { getCooked, maybeWait } from '@bablr/agast-helpers/stream';
+import * as Tags from '@bablr/agast-helpers/tags';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
 import {
-  CloseNodeTag,
-  EmbeddedMatcher,
-  EmbeddedNode,
-  EmbeddedRegex,
+  Matcher,
+  Node,
+  Regex,
   GapTag,
   InitializerTag,
   OpenNodeTag,
   ReferenceTag,
   ShiftTag,
+  Property,
+  BindingTag,
+  PropertyWrapper,
 } from '@bablr/agast-vm-helpers/symbols';
-import * as btree from '@bablr/agast-helpers/btree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
 import {
-  buildGapTag,
+  buildBindingTag,
+  buildChild,
   buildInitializerTag,
   buildNullNode,
+  buildProperty,
+  buildPropertyWrapper,
   buildReferenceTag,
-  buildStubNode,
+  getOr,
+  multiFragmentFlags,
 } from '@bablr/agast-helpers/tree';
-import { getShifted, TagPath } from '@bablr/agast-helpers/path';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { facades, actuals } from './facades.js';
-import { buildInternalState, FragmentFacade, internalStates } from './node.js';
-import { buildCall, buildEmbeddedTag } from '@bablr/agast-vm-helpers/builders';
+import { FragmentFacade } from './node.js';
+import { wrapperIsFull } from '@bablr/agast-helpers/path';
 
-const { hasOwn } = Object;
+const { freeze } = Object;
 
 export const nodeStates = new WeakMap();
 
 export const StateFacade = class BABLRStateFacade {
   constructor(state) {
     facades.set(state, this);
+    freeze(this);
   }
 
   static from(source) {
@@ -57,38 +63,34 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).result;
   }
 
-  get reference() {
-    return actuals.get(this).reference;
+  get referenceTag() {
+    return actuals.get(this).referenceTag;
   }
 
-  get referencePath() {
-    return actuals.get(this).referencePath;
+  get referenceTagPath() {
+    return actuals.get(this).referenceTagPath;
   }
 
-  get unshiftedReferencePath() {
-    return actuals.get(this).unshiftedReferencePath;
+  get referencePath() {
+    return actuals.get(this).referencePath;
   }
 
   get holding() {
     return actuals.get(this).holding;
   }
 
-  get path() {
-    return actuals.get(this).path;
-  }
-
   get language() {
     return actuals.get(this).language;
   }
 
   get depths() {
-    const { path, result } = actuals.get(this).depths;
-    return { path, result };
+    const { path, result, shift, nodeShift } = actuals.get(this).depths;
+    return { path, result, shift, nodeShift };
   }
 
   get held() {
     const { held } = actuals.get(this);
-    return held && FragmentFacade.wrapNode(held, this.ctx);
+    return held && FragmentFacade.wrapNode(held.node, this.ctx);
   }
 
   get node() {
@@ -129,11 +131,11 @@ export const State = class BABLRState extends WeakStackFrame {
     expressions = emptyStack,
     balanced = emptyStack,
     spans = emptyStack.push({ name: 'Bare' }),
-    referencePath = null,
+    referenceTagPath = null,
     resultPath = null,
-    depths = { path: -1, result: -1, emitted: -1 },
+    depths = { path: -1, result: -1, emitted: -1, shift: 0, nodeShift: 0 },
     held = null,
-    node = null,
+    agast = null,
   ) {
     super(parent);
 
@@ -145,11 +147,11 @@ export const State = class BABLRState extends WeakStackFrame {
     this.expressions = expressions;
     this.balanced = balanced;
     this.spans = spans;
-    this.referencePath = referencePath;
+    this.referenceTagPath = referenceTagPath;
     this.resultPath = resultPath;
     this.depths = depths;
     this.held = held;
-    this.node = node;
+    this.agast = agast;
 
     this.status = 'active';
 
@@ -159,33 +161,38 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   static from(source, context, language, expressions = []) {
-    return State.create(source, context, language, emptyStack.push(...expressions));
+    return State.create(
+      source,
+      context,
+      language,
+      emptyStack.push(...emptyStack.push(...expressions).valuesReverse()),
+    );
+  }
+
+  get node() {
+    return this.agast?.state.node;
   }
 
-  get unshiftedReferencePath() {
-    let refPath = this.referencePath;
+  get referencePath() {
+    let refPath = this.referenceTagPath;
 
     if (!refPath) return null;
 
     let { previousSibling } = refPath;
     let isShift = previousSibling.tag.type === ShiftTag;
 
-    let referencePath = previousSibling;
+    let referenceTagPath = previousSibling;
 
     if (isShift) {
-      let refIndex = previousSibling.childrenIndex - 1 - previousSibling.tag.value.index * 2;
-      referencePath = previousSibling.siblingAt(refIndex);
+      let refIndex = previousSibling.tagsIndex - 1 - previousSibling.tag.value.index * 3;
+      referenceTagPath = previousSibling.siblingAt(refIndex);
     }
-    return referencePath;
-  }
-
-  get undefinedAttributes() {
-    return nodeStates.get(this.node).undefinedAttributes;
+    return referenceTagPath;
   }
 
   get guardedSource() {
-    const { source, span } = this;
-    const { guard } = span;
+    let { source, span } = this;
+    let { guard } = span;
 
     return guard ? guardWithPattern(guard, source) : source;
   }
@@ -195,7 +202,7 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get path() {
-    throw new Error('not implemented');
+    return this.agast?.state.path;
   }
 
   get result() {
@@ -210,8 +217,8 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.held;
   }
 
-  get reference() {
-    return this.referencePath?.tag;
+  get referenceTag() {
+    return this.referenceTagPath?.tag;
   }
 
   get isGap() {
@@ -222,64 +229,42 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.parent;
   }
 
-  advance(tag) {
-    const { path, instructionsPump, expressionsPump, agast } = internalStates.get(this.node);
-
-    if (tag.type === GapTag) {
-      expressionsPump.queue(
-        this.expressions.size ? this.expressions.value : buildStubNode(buildGapTag()),
-      );
-      this.expressions = this.expressions.pop();
-    }
-    instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
-    agast.next();
-
-    if (tag.type === OpenNodeTag) this.depths.result++;
-    if (tag.type === CloseNodeTag) this.depths.result--;
-
-    this.resultPath = TagPath.from(path, -1);
-  }
-
-  guardedMatch(pattern) {
+  guardedMatch(pattern, attributes = {}) {
     let { span, source } = this;
     let { guard } = span;
 
     let pattern_ = pattern;
-    if (pattern.type === EmbeddedMatcher) {
+    if (pattern.type === Matcher) {
       pattern_ = reifyExpression(pattern.value).nodeMatcher;
-    } else if (pattern.type === EmbeddedRegex || pattern.type === EmbeddedNode) {
+    } else if (pattern.type === Regex || pattern.type === Node) {
       pattern_ = pattern.value;
     } else if (typeof pattern !== 'string') {
       throw new Error();
     }
 
-    let openNode =
-      this.resultPath.tag.type === OpenNodeTag && this.resultPath.tag.value.flags.token
-        ? this.resultPath.node
-        : typeof pattern_ === 'string'
-        ? null
-        : pattern_;
-
-    if (
-      span.type === 'Lexical' &&
-      openNode &&
-      (openNode.flags.token
-        ? openNode.attributes.balancer || openNode.attributes.balanced
-        : openNode.attributes?.balancer)
-    ) {
+    if (span.type === 'Lexical' && attributes.balancer) {
       // also check that the open node starts a lexical span?
       guard = null;
     }
 
-    if (pattern_?.intrinsicValue) {
-      pattern_ = pattern_.intrinsicValue || getCooked(pattern_.children);
+    if (pattern_?.literalValue) {
+      pattern_ = pattern_.literalValue || getCooked(pattern_.tags);
 
       if (pattern_.type === Symbol.for('String')) {
         pattern_ = reifyExpression(pattern_);
       }
     }
 
-    return match(pattern_, guard ? guardWithPattern(guard, source) : source);
+    let guardedSource = guard && guardWithPattern(guard, source);
+
+    let result = match(pattern_, guardedSource || source);
+
+    return maybeWait(result, (result) => {
+      if (guardedSource && !guardedSource.done) {
+        guardedSource.return();
+      }
+      return result;
+    });
   }
 
   match(pattern) {
@@ -287,151 +272,119 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   branch() {
-    const baseState = this;
+    let baseState = this;
     let {
+      agast,
       source,
       context,
       balanced,
       spans,
       resultPath,
       depths,
-      referencePath,
+      referenceTagPath,
       held,
       node,
       language,
       expressions,
     } = baseState;
 
-    const internalState = buildInternalState();
-
-    for (let tagPath = TagPath.fromNode(node, 0); tagPath; tagPath = tagPath.nextSibling) {
-      let { tag } = tagPath;
-
-      if (tag.type === GapTag) {
-        let ref = tagPath.previousSibling.tag;
-        let firstRef =
-          ref.type === ShiftTag
-            ? tagPath.siblingAt(tagPath.childrenIndex - ref.value.index * 2 - 1)
-            : ref;
-        let { name, isArray, flags } = firstRef.value;
-        const resolvedPath = buildReferenceTag(
-          name,
-          isArray,
-          flags,
-          isArray ? btree.getSize(internalState.path.node.properties[name]) : null,
-        );
-        const expr = getShifted(ref.value.index || 0, resolvedPath, node);
-        internalState.expressionsPump.queue(expr);
-      } else if (tag.type === EmbeddedNode) {
-        internalState.expressionsPump.queue(tag.value);
-        tag = buildGapTag();
-      }
-
-      internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
-      internalState.agast.next();
+    let newAgast = createAgast(agast.options);
+
+    let fragRefTag = buildReferenceTag('_', null, false, multiFragmentFlags);
+
+    if (node.tags.openTag) newAgast.vm.next(node.tags.openTag);
+    if (node.tags.childrenNode) {
+      let property = buildProperty(fragRefTag.value, null, node.tags.childrenNode);
+      newAgast.vm.next(
+        buildChild(
+          PropertyWrapper,
+          buildPropertyWrapper(
+            [fragRefTag, buildBindingTag(), buildChild(Property, property)],
+            property,
+          ),
+        ),
+      );
     }
+    if (node.tags.closeTag) newAgast.vm.next(node.tags.closeTag);
 
-    const newNode = internalState.agastState.node;
-    const nodeState = nodeStates.get(node);
+    let newNode = newAgast.state.node;
+    let nodeState = nodeStates.get(node);
     let newResultPath;
 
     if (resultPath.path.node === node) {
-      newResultPath = TagPath.fromNode(newNode, resultPath.childrenIndex);
+      newResultPath = TagPath.fromNode(newNode, resultPath.tagsIndex);
     } else {
       newResultPath = resultPath;
     }
 
     nodeStates.set(newNode, { ...nodeState });
-    internalStates.set(newNode, internalState);
 
-    const child = this.push(
+    let child = this.push(
       source.branch(),
       context,
       language,
       expressions,
       balanced,
       spans,
-      referencePath,
+      referenceTagPath,
       newResultPath,
       { ...depths },
       held,
-      newNode,
+      newAgast,
     );
 
     return child;
   }
 
   accept() {
-    const accepted = this;
+    let accepted = this;
 
     this.status = 'accepted';
 
-    const { parent } = this;
+    let { parent } = this;
 
     if (!parent) {
       throw new Error('accepted the root state');
     }
 
     if (parent.depths.path === accepted.depths.path) {
-      const parentChildren = parent.node.children;
-
-      const internalState = internalStates.get(parent.node);
-      const { path: parentPath } = internalState;
+      let parentChildren = parent.node.tags;
 
       if (parent.node.type !== accepted.node.type) throw new Error();
 
-      for (
-        let i = sumtree.getSize(parentChildren);
-        i < sumtree.getSize(accepted.node.children);
-        i++
-      ) {
-        let tag = sumtree.getAt(i, accepted.node.children);
-
-        if (tag.type === GapTag) {
-          let previousSibling = sumtree.getAt(i - 1, accepted.node.children);
-          let isShift = previousSibling.type === ShiftTag;
-          let reference = previousSibling;
-
-          if (isShift) {
-            reference = sumtree.getAt(
-              i - 1 - previousSibling.value.index * 2,
-              accepted.node.children,
-            );
-          }
+      let lastParentProp = parentChildren.at(-1);
 
-          let { name, isArray, flags } = reference.value;
-          const resolvedPath = buildReferenceTag(
-            name,
-            isArray,
-            flags,
-            isArray ? btree.getSize(parentPath.node.properties[name]) - (isShift ? 1 : 0) : null,
-          );
-          const expr = getShifted(
-            isShift ? previousSibling.value.index : null,
-            resolvedPath,
-            accepted.node,
-          );
-          internalState.expressionsPump.queue(expr);
-        } else if (tag.type === EmbeddedNode) {
-          internalState.expressionsPump.queue(tag.value);
-          tag = buildGapTag();
-        }
+      let partialOffset =
+        lastParentProp.type === PropertyWrapper && !wrapperIsFull(lastParentProp) ? -1 : 0;
+
+      for (let i = parentChildren.size + partialOffset; i < accepted.node.tags.size; i++) {
+        let acceptedTag = accepted.node.tags.at(i);
+        let tag = parentChildren.at(i);
 
-        internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
-        internalState.agast.next();
+        // let wrapperTag =
+
+        for (
+          let i = tag ? Tags.getSize(tag.value.tags) : 0;
+          i < Tags.getSize(acceptedTag.value.tags);
+          i++
+        ) {
+          let tag = Tags.getAt(i, acceptedTag.value.tags);
+
+          parent.agast.vm.next(tag);
+        }
       }
     }
 
     parent.spans = accepted.spans;
     parent.balanced = accepted.balanced;
-    parent.referencePath = accepted.referencePath;
+    parent.referenceTagPath = accepted.referenceTagPath;
     parent.held = accepted.held;
     parent.depths = accepted.depths;
     parent.language = accepted.language;
     parent.expressions = accepted.expressions;
 
     if (parent.depths.result + 1 === accepted.depths.result) {
-      parent.resultPath = parent.resultPath.siblingAt(accepted.resultPath.childrenIndex);
+      parent.resultPath = parent.resultPath.siblingAt(accepted.resultPath.tagsIndex);
     } else {
       parent.resultPath = accepted.resultPath;
     }
@@ -453,75 +406,83 @@ export const State = class BABLRState extends WeakStackFrame {
       (!finishedMatch.isNode && !didBranch) ||
       finishedMatch.cover ||
       finishedMatch.effects.success === 'none';
-    let shallower = finishedMatch.didShift ? finishedMatch.shiftMatch.state : this.parent;
-
-    if (shallower) {
-      let parentChildren = shallower.node.children;
-      let ourChildren = finishedMatch.fragmentNode.children;
-      let internalState = internalStates.get(shallower.node);
-
-      if (!abandon && shallower.node.type) {
+    let shallower =
+      finishedMatch.coveredBoundary.didShift &&
+      finishedMatch.coveredBoundary.shiftMatch.state.depth === this.depth - 2
+        ? finishedMatch.coveredBoundary.shiftMatch.state
+        : this.parent;
+
+    if (!abandon && shallower) {
+      let parentChildren = shallower.node.tags;
+      let ourChildren = finishedMatch.fragmentNode.tags;
+      let refTag;
+
+      if (shallower.node.type) {
         if (shallower.node.type !== rejectedState.node.type) throw new Error();
 
-        for (let i = sumtree.getSize(parentChildren); i < sumtree.getSize(ourChildren); i++) {
-          let tag = sumtree.getAt(i, ourChildren);
-
-          if ([InitializerTag, GapTag].includes(tag.type)) {
-            let previousSibling = sumtree.getAt(i - 1, ourChildren);
-            let isShift = previousSibling.type === ShiftTag;
+        for (let i = parentChildren.size; i < ourChildren.size; i++) {
+          let tag = ourChildren.at(i);
 
-            let reference = previousSibling;
-
-            if (isShift) {
-              let refIndex = i - 1 - previousSibling.value.index * 2;
-              reference = sumtree.getAt(refIndex, ourChildren);
-            }
-
-            let lastParentTag = TagPath.from(internalState.path, -1).tag.type;
-
-            if (
-              !['#', '@'].includes(reference.value.name) &&
-              !reference.value.isArray &&
-              !hasOwn(shallower.node.properties, reference.value.name) &&
-              lastParentTag !== ShiftTag
-            ) {
-              if (lastParentTag !== ReferenceTag) {
-                internalState.instructionsPump.queue(
-                  buildCall('advance', buildEmbeddedTag(reference)),
-                );
-                internalState.agast.next();
+          if (tag.type === PropertyWrapper) {
+            for (let wrappedTag of tag.value.tags) {
+              if (wrappedTag.type === ReferenceTag) {
+                refTag = wrappedTag;
               }
-              if (bind || tag.type === GapTag) {
-                internalState.expressionsPump.queue(buildNullNode());
-                internalState.instructionsPump.queue(
-                  buildCall('advance', buildEmbeddedTag(buildGapTag())),
-                );
-              } else {
-                internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+
+              if ([InitializerTag, GapTag].includes(wrappedTag.type)) {
+                let previousSibling = ourChildren.at(i, 0);
+                let isShift = previousSibling.type === ShiftTag;
+
+                let referenceTag = previousSibling;
+
+                if (isShift) {
+                  let refIndex = i - 1 - previousSibling.value.index;
+                  referenceTag = ourChildren.at(refIndex, 0);
+                }
+
+                if (
+                  !['#', '@'].includes(referenceTag.value.type) &&
+                  !referenceTag.value.isArray &&
+                  getOr(0, referenceTag.value.name, shallower.node) === 0 &&
+                  refTag !== ShiftTag
+                ) {
+                  if (refTag !== ReferenceTag) {
+                    shallower.agast.vm.next(refTag);
+                  }
+
+                  if (bind || wrappedTag.type === GapTag) {
+                    shallower.agast.vm.next(
+                      buildChild(Property, buildProperty(refTag.value, null, buildNullNode())),
+                    );
+                  } else {
+                    shallower.agast.vm.next(wrappedTag);
+                  }
+                }
+                refTag = null;
               }
-              internalState.agast.next();
             }
           }
         }
 
-        let lastParentTagPath = TagPath.fromNode(shallower.node, -1);
-        if (lastParentTagPath?.tag.type === ReferenceTag) {
-          let ref = lastParentTagPath?.tag;
-          if (bind) {
-            internalState.expressionsPump.queue(buildNullNode());
-            internalState.instructionsPump.queue(
-              buildCall('advance', buildEmbeddedTag(buildGapTag())),
-            );
-            internalState.agast.next();
-          } else {
-            if (!ref.value.flags.expression) {
-              internalState.instructionsPump.queue(
-                buildCall('advance', buildEmbeddedTag(buildInitializerTag(ref.value.isArray))),
+        if (refTag?.type === ReferenceTag) {
+          if (
+            refTag.value.name &&
+            !refTag.value.isArray &&
+            !shallower.node.properties.has(refTag.value.name)
+          ) {
+            if (bind) {
+              shallower.agast.vm.next(refTag);
+              shallower.agast.vm.next(
+                buildChild(Property, buildProperty(refTag.value, [], buildNullNode())),
               );
-              internalState.agast.next();
+            } else {
+              if (!refTag.value.flags.expression) {
+                shallower.agast.vm.next(refTag);
+                shallower.agast.vm.next(buildInitializerTag(refTag.value.isArray));
+              }
             }
           }
-          shallower.referencePath = null;
+          shallower.referenceTagPath = null;
           shallower.resultPath = TagPath.fromNode(shallower.node, -1);
         }
       }