@bablr/bablr-vm 0.21.0 → 0.22.0

package/lib/node.js

@@ -1,12 +1,14 @@
 import {
+  buildBindingTag,
   buildCloseNodeTag,
   buildGapTag,
   buildOpenNodeTag,
+  buildReferenceTag,
   buildStubNode,
   fragmentFlags,
   isNullNode,
 } from '@bablr/agast-helpers/tree';
-import { NullTag, OpenNodeTag, ReferenceTag } from '@bablr/agast-helpers/symbols';
+import { NullTag, OpenNodeTag, PropertyWrapper, ReferenceTag } from '@bablr/agast-helpers/symbols';
 import {
   buildFullPathSegment,
   buildFullRange,
@@ -26,7 +28,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
     node,
     context,
     transparent = false,
-    childrenIndexRange = null,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
@@ -37,7 +39,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         context,
         transparent,
         false,
-        childrenIndexRange,
+        tagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       )
@@ -48,7 +50,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
     node,
     context,
     transparent = false,
-    childrenIndexRange = null,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
@@ -59,7 +61,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         context,
         transparent,
         true,
-        childrenIndexRange,
+        tagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       )
@@ -71,19 +73,20 @@ export const FragmentFacade = class BABLRFragmentFacade {
     context,
     transparent = false,
     isFragmentFacade = true,
-    childrenIndexRange = null,
+    tagsIndexRange = null,
     dotPropertyReference = null,
     dotPropertyIndex = null,
   ) {
-    if (!node || hasOwn(node, 'properties')) throw new Error();
+    if (!node || hasOwn(node, 'tags')) throw new Error();
+    if (isNaN(dotPropertyIndex)) throw new Error();
 
-    if (childrenIndexRange && (childrenIndexRange[0] == null || !childrenIndexRange[1] == null)) {
+    if (tagsIndexRange && (tagsIndexRange[0] == null || !tagsIndexRange[1] == null)) {
       throw new Error();
     }
 
     if (!context) throw new Error();
 
-    if (dotPropertyReference && !node.properties.at(dotPropertyReference.name)) throw new Error();
+    if (dotPropertyReference && !node.properties.get(dotPropertyReference.name)) throw new Error();
 
     if (dotPropertyReference?.isArray && dotPropertyIndex == null) throw new Error();
 
@@ -106,7 +109,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
       fragmentNode,
       transparent,
       isFragmentFacade,
-      childrenIndexRange,
+      tagsIndexRange,
       dotPropertyReference,
       dotPropertyIndex,
     });
@@ -127,18 +130,23 @@ export const FragmentFacade = class BABLRFragmentFacade {
     return node.sigilTag.type === NullTag;
   }
 
-  get children() {
-    let { node, isFragmentNode, transparent, childrenIndexRange } = states.get(this);
+  get tagsInner() {
+    let { node, isFragmentNode, transparent, tagsIndexRange } = states.get(this);
 
-    childrenIndexRange =
-      isFragmentNode || !childrenIndexRange ? buildFullRange(node) : childrenIndexRange;
+    tagsIndexRange = isFragmentNode || !tagsIndexRange ? buildFullRange(node) : tagsIndexRange;
 
     return {
       *[Symbol.iterator]() {
-        for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
-          const interpolated = false; // TODO
-          if (!interpolated || transparent) {
-            yield node.children.at(i);
+        for (let tag of node.tags) {
+          if (tag.type === PropertyWrapper) {
+            let { property, tags } = tag.value;
+            if (transparent || !property.reference.flags.hasGap) {
+              yield* tags;
+            } else {
+              yield buildReferenceTag(property.reference);
+              yield buildBindingTag();
+              yield buildGapTag();
+            }
           }
         }
       },
@@ -146,14 +154,14 @@ export const FragmentFacade = class BABLRFragmentFacade {
   }
 
   getRootIndex() {
-    const { node, dotPropertyName, childrenIndexRange } = states.get(this);
+    const { node, dotPropertyName, tagsIndexRange } = states.get(this);
 
-    if (!childrenIndexRange) return null;
+    if (!tagsIndexRange) return null;
 
-    if (childrenIndexRange[0] > childrenIndexRange[1]) throw new Error();
+    if (tagsIndexRange[0] > tagsIndexRange[1]) throw new Error();
 
-    for (let i = childrenIndexRange[0]; i <= childrenIndexRange[1]; i++) {
-      let tag = node.children.at(i);
+    for (let i = tagsIndexRange[0]; i <= tagsIndexRange[1]; i++) {
+      let tag = node.tags.at(i);
       if (tag.type === ReferenceTag) {
         const { name, isArray } = tag.value;
         let resolvedTagName = name === '.' ? dotPropertyName : name;
@@ -191,21 +199,13 @@ export const FragmentFacade = class BABLRFragmentFacade {
   get openTag() {
     const { node, openTag, isFragmentFacade } = states.get(this);
 
-    return isFragmentNode(node)
-      ? node.children.at(1)
-      : isFragmentFacade
-      ? openTag
-      : node.children.at(0);
+    return isFragmentNode(node) ? node.tags.at(1) : isFragmentFacade ? openTag : node.tags.at(0);
   }
 
   get closeTag() {
     const { node, closeTag, isFragmentFacade } = states.get(this);
 
-    return isFragmentFacade
-      ? isFragmentNode(node)
-        ? node.closeTag
-        : closeTag
-      : node.children.at(-1);
+    return isFragmentFacade ? (isFragmentNode(node) ? node.closeTag : closeTag) : node.tags.at(-1);
   }
 
   merge(targetFragment) {
@@ -217,7 +217,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
       dotPropertyReference,
       dotPropertyIndex,
     } = states.get(this);
-    const { fragmentNode: targetFragmentNode, childrenIndexRange: targetChildrenIndexRange } =
+    const { fragmentNode: targetFragmentNode, tagsIndexRange: targetTagsIndexRange } =
       states.get(targetFragment);
     if (fragmentNode === targetFragmentNode) {
       // TODO restrict what is legal here
@@ -227,7 +227,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
         context,
         transparent,
         isFragmentFacade,
-        targetChildrenIndexRange,
+        targetTagsIndexRange,
         dotPropertyReference,
         dotPropertyIndex,
       );
@@ -242,7 +242,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
       context,
       transparent,
       isFragmentFacade,
-      childrenIndexRange,
+      tagsIndexRange,
       dotPropertyReference: dotReference,
       dotPropertyIndex: dotIndex,
     } = states.get(this);
@@ -269,15 +269,17 @@ export const FragmentFacade = class BABLRFragmentFacade {
       }
 
       if (!node) break;
-      let refIndex = outerNode.getPropertyChildrenIndex(null, seg.name, seg.index);
-      childrenIndexRange = [refIndex, refIndex + 2];
+      let refIndex = outerNode.getPropertyTagsIndex(null, seg.name, seg.index);
+      tagsIndexRange = [refIndex, refIndex];
 
       let boundRef = outerNode.properties.referenceAt(seg.name, seg.index);
 
       if (!node) return null;
 
+      let arraySize = outerNode.countList(seg.name);
+
       ref = boundRef;
-      index = seg.index === -1 ? outerNode.properties.at(seg.name).size + seg.index : seg.index;
+      index = seg.index < 0 ? arraySize + seg.index : seg.index;
 
       node =
         (ref && ref.type === ReferenceTag && !ref.flags.hasGap) || transparent
@@ -292,7 +294,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
           context,
           transparent,
           isFragmentFacade,
-          childrenIndexRange,
+          tagsIndexRange,
           ref,
           index,
         );
@@ -310,7 +312,7 @@ export const FragmentFacade = class BABLRFragmentFacade {
     for (let i = 0; i < path_.length; i++) {
       if (!node.properties.has(path_[i])) return false;
       if (i < path.length - 1) {
-        node = node.properties.at(path_[i]);
+        node = node.properties.get(path_[i]);
       }
     }
 

package/lib/source.js

@@ -1,12 +1,6 @@
-import { maybeWait, getStreamIterator, StreamIterable } from '@bablr/agast-helpers/stream';
+import { maybeWait, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { facades, actuals } from './facades.js';
-
-function* __concat(...iterables) {
-  for (let iter of iterables) {
-    yield* getStreamIterator(iter);
-  }
-}
-const concat = (...iterables) => new StreamIterable(__concat(...iterables));
+import { streamIteratorSymbol } from '@bablr/stream-iterator';
 
 // Queue item instances are shared between all sources.
 class QueueItem {
@@ -35,9 +29,9 @@ class Exchange {
   }
 
   allocateSource(source) {
-    const { head = this.tail, exchange = this, index, holding } = source || {};
+    const { head = this.tail, exchange = this, index, holding, prevValue } = source || {};
     ++this.sources;
-    return new Source(head, exchange, index, holding);
+    return new Source(head, exchange, index, holding, prevValue);
   }
 
   releaseSource(source) {
@@ -108,7 +102,7 @@ class SourceIterator {
     return this;
   }
 
-  [Symbol.for('@@streamIterator')]() {
+  [streamIteratorSymbol]() {
     return this;
   }
 }
@@ -124,8 +118,8 @@ export const SourceFacade = class BABLRSourceFacade {
     Object.freeze(this);
   }
 
-  [Symbol.for('@@streamIterator')]() {
-    return actuals.get(this)[Symbol.for('@@streamIterator')]();
+  [streamIteratorSymbol]() {
+    return actuals.get(this)[streamIteratorSymbol]();
   }
 
   get done() {
@@ -151,13 +145,14 @@ export const Source = class BABLRSource {
     return exchange.allocateSource();
   }
 
-  constructor(head, exchange, index = -1, holding = false) {
+  constructor(head, exchange, index = -1, holding = false, prevValue = undefined) {
     if (!head || !exchange) throw new Error();
 
     this.head = head;
     this.exchange = exchange;
     this.index = index;
     this.holding = holding;
+    this.prevValue = prevValue;
 
     new SourceFacade(this);
   }
@@ -195,7 +190,7 @@ export const Source = class BABLRSource {
         if (this.done) {
           throw new Error('cannot advance a source that is done');
         } else {
-          let { head } = this;
+          let { head, value } = this;
 
           let nextItem = head.next;
 
@@ -205,6 +200,7 @@ export const Source = class BABLRSource {
             }
 
             this.head = head = nextItem;
+            this.prevValue = value;
 
             if (head.step?.done) {
               exchange.releaseSource(this);
@@ -240,6 +236,7 @@ export const Source = class BABLRSource {
     this.head = source.head;
     this.index = source.index;
     this.holding = source.holding;
+    this.prevValue = source.prevValue;
 
     source.release();
   }
@@ -252,7 +249,7 @@ export const Source = class BABLRSource {
     return SourceIterator.from(this);
   }
 
-  [Symbol.for('@@streamIterator')]() {
+  [streamIteratorSymbol]() {
     return SourceIterator.from(this);
   }
 

package/lib/spans.js

@@ -1,15 +1,12 @@
 import { ReferenceTag } from '@bablr/agast-helpers/symbols';
-import { getOpenTag } from '@bablr/agast-helpers/tree';
 
 export function updateSpans(m, node, phase) {
   const { state: s } = m;
-  const { flags, attributes } = node;
+  const { attributes } = node;
   const refPath = m.reference;
 
   if (refPath && refPath.tag.type !== ReferenceTag) throw new Error();
 
-  const openTag = getOpenTag(node);
-
   const intrinsic = !refPath || (refPath.tag.type === ReferenceTag && !refPath.tag.value.hasGap);
 
   switch (phase) {

package/lib/state.js

@@ -1,16 +1,13 @@
-import {
-  agast as createAgast,
-  TagPathFacade as TagPath,
-  PathFacade as Path,
-} from '@bablr/agast-vm';
+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, maybeWait } from '@bablr/agast-helpers/stream';
+import * as Tags from '@bablr/agast-helpers/tags';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
 import {
-  EmbeddedMatcher,
-  EmbeddedNode,
-  EmbeddedRegex,
+  Matcher,
+  Node,
+  Regex,
   GapTag,
   InitializerTag,
   OpenNodeTag,
@@ -18,6 +15,7 @@ import {
   ShiftTag,
   Property,
   BindingTag,
+  PropertyWrapper,
 } from '@bablr/agast-vm-helpers/symbols';
 import {
   buildBindingTag,
@@ -25,13 +23,17 @@ import {
   buildInitializerTag,
   buildNullNode,
   buildProperty,
+  buildPropertyWrapper,
+  buildReferenceTag,
+  getOr,
+  multiFragmentFlags,
 } from '@bablr/agast-helpers/tree';
 import { match, guardWithPattern } from './utils/pattern.js';
 import { facades, actuals } from './facades.js';
 import { FragmentFacade } from './node.js';
-import { buildFullPathSegment } from '@bablr/agast-helpers/path';
+import { wrapperIsFull } from '@bablr/agast-helpers/path';
 
-const { hasOwn, freeze } = Object;
+const { freeze } = Object;
 
 export const nodeStates = new WeakMap();
 
@@ -61,8 +63,8 @@ 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 referenceTagPath() {
@@ -77,11 +79,6 @@ export const StateFacade = class BABLRStateFacade {
     return actuals.get(this).holding;
   }
 
-  // FACADEME
-  get path() {
-    return actuals.get(this).path;
-  }
-
   get language() {
     return actuals.get(this).language;
   }
@@ -164,7 +161,12 @@ 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() {
@@ -182,7 +184,7 @@ export const State = class BABLRState extends WeakStackFrame {
     let referenceTagPath = previousSibling;
 
     if (isShift) {
-      let refIndex = previousSibling.childrenIndex - 1 - previousSibling.tag.value.index * 3;
+      let refIndex = previousSibling.tagsIndex - 1 - previousSibling.tag.value.index * 3;
       referenceTagPath = previousSibling.siblingAt(refIndex);
     }
     return referenceTagPath;
@@ -200,7 +202,7 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get path() {
-    throw new Error('not implemented');
+    return this.agast?.state.path;
   }
 
   get result() {
@@ -215,7 +217,7 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.held;
   }
 
-  get reference() {
+  get referenceTag() {
     return this.referenceTagPath?.tag;
   }
 
@@ -227,39 +229,26 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.parent;
   }
 
-  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_);
@@ -301,27 +290,29 @@ export const State = class BABLRState extends WeakStackFrame {
 
     let newAgast = createAgast(agast.options);
 
-    for (let tagPath = TagPath.fromNode(node, 0); tagPath; tagPath = tagPath.nextSibling) {
-      let { tag } = tagPath;
-
-      if (tag.type === Property) {
-        newAgast.vm.next(
-          buildChild(
-            Property,
-            buildProperty(tag.value.reference, tag.value.binding, tag.value.node.node),
+    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,
           ),
-        );
-      } else {
-        newAgast.vm.next(tag);
-      }
+        ),
+      );
     }
+    if (node.tags.closeTag) newAgast.vm.next(node.tags.closeTag);
 
     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;
     }
@@ -357,14 +348,30 @@ export const State = class BABLRState extends WeakStackFrame {
     }
 
     if (parent.depths.path === accepted.depths.path) {
-      let parentChildren = parent.node.children;
+      let parentChildren = parent.node.tags;
 
       if (parent.node.type !== accepted.node.type) throw new Error();
 
-      for (let i = parentChildren.size; i < accepted.node.children.size; i++) {
-        let tag = accepted.node.children.at(i);
+      let lastParentProp = parentChildren.at(-1);
+
+      let partialOffset =
+        lastParentProp.type === PropertyWrapper && !wrapperIsFull(lastParentProp) ? -1 : 0;
 
-        parent.agast.vm.next(tag);
+      for (let i = parentChildren.size + partialOffset; i < accepted.node.tags.size; i++) {
+        let acceptedTag = accepted.node.tags.at(i);
+        let tag = parentChildren.at(i);
+
+        // 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);
+        }
       }
     }
 
@@ -377,7 +384,7 @@ export const State = class BABLRState extends WeakStackFrame {
     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;
     }
@@ -406,10 +413,9 @@ export const State = class BABLRState extends WeakStackFrame {
         : this.parent;
 
     if (!abandon && shallower) {
-      let parentChildren = shallower.node.children;
-      let ourChildren = finishedMatch.fragmentNode.children;
+      let parentChildren = shallower.node.tags;
+      let ourChildren = finishedMatch.fragmentNode.tags;
       let refTag;
-      let bindTag;
 
       if (shallower.node.type) {
         if (shallower.node.type !== rejectedState.node.type) throw new Error();
@@ -417,51 +423,52 @@ export const State = class BABLRState extends WeakStackFrame {
         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 = ourChildren.at(i - 1);
-            let isShift = previousSibling.type === ShiftTag;
-
-            let reference = previousSibling;
-
-            if (isShift) {
-              let refIndex = i - 1 - previousSibling.value.index * 3;
-              reference = ourChildren.at(refIndex);
-            }
-
-            if (
-              !['#', '@'].includes(reference.value.type) &&
-              !reference.value.isArray &&
-              !hasOwn(shallower.node.properties, reference.value.name) &&
-              refTag !== ShiftTag
-            ) {
-              if (refTag !== ReferenceTag) {
-                shallower.agast.vm.next(refTag);
+          if (tag.type === PropertyWrapper) {
+            for (let wrappedTag of tag.value.tags) {
+              if (wrappedTag.type === ReferenceTag) {
+                refTag = wrappedTag;
               }
 
-              if (bind || tag.type === GapTag) {
-                shallower.agast.vm.next(
-                  buildChild(Property, buildProperty(refTag.value, null, buildNullNode())),
-                );
-              } else {
-                shallower.agast.vm.next(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;
               }
             }
-            refTag = null;
           }
         }
 
         if (refTag?.type === ReferenceTag) {
           if (
-            !['#', '@'].includes(refTag.value.type) &&
+            refTag.value.name &&
             !refTag.value.isArray &&
-            !hasOwn(shallower.node.properties, refTag.value.name)
+            !shallower.node.properties.has(refTag.value.name)
           ) {
             if (bind) {
               shallower.agast.vm.next(refTag);