@bablr/bablr-vm 0.20.0 → 0.21.0

package/lib/state.js

@@ -1,9 +1,13 @@
+import {
+  agast as createAgast,
+  TagPathFacade as TagPath,
+  PathFacade as Path,
+} 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 { reifyExpression } from '@bablr/agast-vm-helpers';
 import {
-  CloseNodeTag,
   EmbeddedMatcher,
   EmbeddedNode,
   EmbeddedRegex,
@@ -12,29 +16,29 @@ import {
   OpenNodeTag,
   ReferenceTag,
   ShiftTag,
+  Property,
+  BindingTag,
 } 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,
-  buildReferenceTag,
-  buildStubNode,
+  buildProperty,
 } 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 { buildFullPathSegment } from '@bablr/agast-helpers/path';
 
-const { hasOwn } = Object;
+const { hasOwn, freeze } = Object;
 
 export const nodeStates = new WeakMap();
 
 export const StateFacade = class BABLRStateFacade {
   constructor(state) {
     facades.set(state, this);
+    freeze(this);
   }
 
   static from(source) {
@@ -61,18 +65,19 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).reference;
   }
 
-  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;
   }
 
+  // FACADEME
   get path() {
     return actuals.get(this).path;
   }
@@ -82,13 +87,13 @@ export const StateFacade = class BABLRStateFacade {
   }
 
   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 +134,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 +150,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';
 
@@ -162,30 +167,30 @@ export const State = class BABLRState extends WeakStackFrame {
     return State.create(source, context, language, emptyStack.push(...expressions));
   }
 
-  get unshiftedReferencePath() {
-    let refPath = this.referencePath;
+  get node() {
+    return this.agast?.state.node;
+  }
+
+  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.childrenIndex - 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;
   }
@@ -211,7 +216,7 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get reference() {
-    return this.referencePath?.tag;
+    return this.referenceTagPath?.tag;
   }
 
   get isGap() {
@@ -222,24 +227,6 @@ 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) {
     let { span, source } = this;
     let { guard } = span;
@@ -279,7 +266,16 @@ export const State = class BABLRState extends WeakStackFrame {
       }
     }
 
-    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,52 +283,41 @@ 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();
+    let newAgast = createAgast(agast.options);
 
     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,
+      if (tag.type === Property) {
+        newAgast.vm.next(
+          buildChild(
+            Property,
+            buildProperty(tag.value.reference, tag.value.binding, tag.value.node.node),
+          ),
         );
-        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();
+      } else {
+        newAgast.vm.next(tag);
       }
-
-      internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
-      internalState.agast.next();
     }
 
-    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) {
@@ -342,89 +327,50 @@ export const State = class BABLRState extends WeakStackFrame {
     }
 
     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.children;
 
       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 { 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();
-        }
+      for (let i = parentChildren.size; i < accepted.node.children.size; i++) {
+        let tag = accepted.node.children.at(i);
 
-        internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
-        internalState.agast.next();
+        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;
@@ -453,75 +399,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;
+    let shallower =
+      finishedMatch.coveredBoundary.didShift &&
+      finishedMatch.coveredBoundary.shiftMatch.state.depth === this.depth - 2
+        ? finishedMatch.coveredBoundary.shiftMatch.state
+        : this.parent;
 
-    if (shallower) {
+    if (!abandon && shallower) {
       let parentChildren = shallower.node.children;
       let ourChildren = finishedMatch.fragmentNode.children;
-      let internalState = internalStates.get(shallower.node);
+      let refTag;
+      let bindTag;
 
-      if (!abandon && shallower.node.type) {
+      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);
+        for (let i = parentChildren.size; i < ourChildren.size; i++) {
+          let tag = ourChildren.at(i);
+
+          if (tag.type === ReferenceTag) {
+            refTag = tag;
+          }
+          if (tag.type === BindingTag) {
+            bindTag = tag;
+          }
 
           if ([InitializerTag, GapTag].includes(tag.type)) {
-            let previousSibling = sumtree.getAt(i - 1, ourChildren);
+            let previousSibling = ourChildren.at(i - 1);
             let isShift = previousSibling.type === ShiftTag;
 
             let reference = previousSibling;
 
             if (isShift) {
-              let refIndex = i - 1 - previousSibling.value.index * 2;
-              reference = sumtree.getAt(refIndex, ourChildren);
+              let refIndex = i - 1 - previousSibling.value.index * 3;
+              reference = ourChildren.at(refIndex);
             }
 
-            let lastParentTag = TagPath.from(internalState.path, -1).tag.type;
-
             if (
-              !['#', '@'].includes(reference.value.name) &&
+              !['#', '@'].includes(reference.value.type) &&
               !reference.value.isArray &&
               !hasOwn(shallower.node.properties, reference.value.name) &&
-              lastParentTag !== ShiftTag
+              refTag !== ShiftTag
             ) {
-              if (lastParentTag !== ReferenceTag) {
-                internalState.instructionsPump.queue(
-                  buildCall('advance', buildEmbeddedTag(reference)),
-                );
-                internalState.agast.next();
+              if (refTag !== ReferenceTag) {
+                shallower.agast.vm.next(refTag);
               }
+
               if (bind || tag.type === GapTag) {
-                internalState.expressionsPump.queue(buildNullNode());
-                internalState.instructionsPump.queue(
-                  buildCall('advance', buildEmbeddedTag(buildGapTag())),
+                shallower.agast.vm.next(
+                  buildChild(Property, buildProperty(refTag.value, null, buildNullNode())),
                 );
               } else {
-                internalState.instructionsPump.queue(buildCall('advance', buildEmbeddedTag(tag)));
+                shallower.agast.vm.next(tag);
               }
-              internalState.agast.next();
             }
+            refTag = null;
           }
         }
 
-        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 (
+            !['#', '@'].includes(refTag.value.type) &&
+            !refTag.value.isArray &&
+            !hasOwn(shallower.node.properties, 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);
         }
       }

package/lib/utils/pattern.js

@@ -2,7 +2,7 @@ import isString from 'iter-tools-es/methods/is-string';
 import isEmpty from 'iter-tools-es/methods/is-empty';
 import { generateMatches } from '@bablr/regex-vm';
 import { getStreamIterator, maybeWait, printType } from '@bablr/agast-helpers/stream';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as sumtree from '@bablr/agast-helpers/children';
 import * as l from '@bablr/agast-vm-helpers/languages';
 import {
   buildAlternative,
@@ -14,10 +14,14 @@ import {
 } from '@bablr/helpers/builders';
 import { buildEmbeddedRegex } from '@bablr/agast-vm-helpers/builders';
 import { GapTag, LiteralTag } from '@bablr/agast-helpers/symbols';
+import {
+  buildCloseNodeTag,
+  buildLiteralTag,
+  buildOpenNodeTag,
+  tokenFlags,
+} from '@bablr/agast-helpers/builders';
 
 export const assertValidRegex = (expr) => {
-  const { flags } = expr;
-
   if (!expr.language === 'Spamex' && expr.type === 'Regex') {
     throw new Error();
   }
@@ -28,7 +32,7 @@ export const assertValidRegex = (expr) => {
 const buildStringRegex = (str) => {
   return buildPattern(
     buildAlternatives([
-      buildAlternative(buildElements([...str].map((chr) => buildToken(l.Regex, 'Character', chr)))),
+      buildAlternative(buildElements([...str].map((chr) => buildToken('Character', chr)))),
     ]),
   );
 };
@@ -41,7 +45,7 @@ const buildFragmentRegex = (frag) => {
           [...sumtree.traverse(frag.children)].flatMap((tag) => {
             if (tag.type === LiteralTag) {
               let str = tag.value;
-              return [...str].map((chr) => buildToken(l.Regex, 'Character', chr));
+              return [...str].map((chr) => buildToken('Character', chr));
             } else if (tag.type === GapTag) {
               return [buildRegexGap()];
             } else {
@@ -54,7 +58,64 @@ const buildFragmentRegex = (frag) => {
   );
 };
 
+const promiseCo = (gen) => {
+  return (...args) => {
+    let generator = gen(...args);
+
+    const fn = (step) => {
+      if (step.done) {
+        return step.value;
+      } else if (step.value instanceof Promise) {
+        return step.value.then((value) => {
+          return fn(generator.next(value));
+        });
+      }
+    };
+
+    return fn(generator.next());
+  };
+};
+
+function* __stringEqual(str, iterable) {
+  let strIter = str[Symbol.iterator]();
+  let iter = getStreamIterator(iterable);
+
+  let strStep = strIter.next();
+  let step = iter.next();
+
+  while (!strStep.done) {
+    if (step instanceof Promise) {
+      step = yield step;
+    }
+
+    if (step.value !== strStep.value) {
+      iter.return();
+      return false;
+    }
+
+    strStep = strIter.next();
+    step = iter.next();
+  }
+
+  iter.return();
+  return true;
+}
+
+const stringEqual = (str, iterable) => {
+  return promiseCo(__stringEqual)(str, iterable);
+};
+
 export const match = (pattern, source) => {
+  if (typeof pattern === 'string' && pattern.length === 1) {
+    return pattern === source.value
+      ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
+      : null;
+  } else if (typeof pattern === 'string') {
+    return stringEqual(pattern, source)
+      ? [buildOpenNodeTag(tokenFlags), buildLiteralTag(pattern), buildCloseNodeTag()]
+      : null;
+  }
+
   const pattern_ =
     pattern.type === null && pattern.flags.token
       ? buildFragmentRegex(pattern)
@@ -72,6 +133,7 @@ export const match = (pattern, source) => {
 
   return maybeWait(step, (step) => {
     const result = step.done ? null : step.value[0];
+    iter.return();
     return isEmpty(result) ? null : result;
   });
 };
@@ -79,28 +141,33 @@ export const match = (pattern, source) => {
 class GuardedIterator {
   constructor(pattern, source) {
     this.pattern = pattern;
-    this.fork = source.fork.clone();
+    this.source = source.branch();
     this.done = false;
   }
 
+  get value() {
+    return this.source.value;
+  }
+
   next() {
-    const { pattern, fork } = this;
+    const { pattern, source } = this;
 
-    const guardMatch = match(pattern, fork.clone());
+    const guardMatch = match(pattern, source);
 
     return maybeWait(guardMatch, (guardMatch) => {
-      if (guardMatch || fork.done) {
+      if (guardMatch || source.done) {
         this.done = true;
+        source.release();
         return { value: undefined, done: true };
       } else {
-        const { value } = fork;
-        return maybeWait(fork.advance(), (_) => ({ value, done: false }));
+        const { value } = source;
+        return maybeWait(source.advance(), (_) => ({ value, done: false }));
       }
     });
   }
 
   return() {
-    this.fork.return();
+    this.source.release();
   }
 
   [Symbol.for('@@streamIterator')]() {
@@ -109,5 +176,5 @@ class GuardedIterator {
 }
 
 export const guardWithPattern = (pattern, source) => {
-  return new GuardedIterator(pattern, source.branch());
+  return new GuardedIterator(pattern, source);
 };