@bablr/bablr-vm 0.21.0 → 0.22.0

package/lib/context.js

@@ -7,6 +7,7 @@ import { PathFacade as Path } from '@bablr/agast-vm';
 import { sourceTextFor } from '@bablr/agast-helpers/stream';
 import { streamFromTree } from '@bablr/agast-helpers/tree';
 import { allTagsFor } from '@bablr/agast-helpers/path-facade';
+import { buildEmbeddedNode } from '@bablr/agast-vm-helpers/builders';
 
 export const ContextFacade = class BABLRContextFacade {
   constructor(actual) {
@@ -39,16 +40,16 @@ export const ContextFacade = class BABLRContextFacade {
       fragmentStream = streamFromTree(node);
     } else if (nodeStates.has(node)) {
       let state = nodeStates.get(node);
-      let { childrenIndexRange } = state;
+      let { tagsIndexRange } = state;
       let path = Path.from(state.fragmentNode);
 
-      if (!childrenIndexRange) {
+      if (!tagsIndexRange) {
         let nodePath = Path.from(state.node);
-        childrenIndexRange = [nodePath.tagPathAt(0), nodePath.tagPathAt(-1)];
+        tagsIndexRange = [0, nodePath.tagPathAt(-1).tagsIndex];
       }
 
       fragmentStream = allTagsFor(
-        [path.tagPathAt(childrenIndexRange[0]), path.tagPathAt(childrenIndexRange[1])],
+        [path.tagPathAt(tagsIndexRange[0], 0), path.tagPathAt(tagsIndexRange[1], -1)],
         { unshift: true },
       );
     } else {

package/lib/evaluate.js

@@ -18,7 +18,6 @@ import {
   BindingTag,
   LiteralTag,
   ReferenceTag,
-  DoctypeTag,
   NullTag,
   ShiftTag,
   InitializerTag,
@@ -70,7 +69,6 @@ function* __bablr(ctx, rootSource, strategy, options) {
   let m = null;
   let language = null;
   let finishedMatch = null;
-  let doctype = null;
 
   let co = new Coroutine(getStreamIterator(strategy(facades.get(ctx))));
 
@@ -115,7 +113,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
       case 'match': {
         let { arguments: { 0: pattern } = [] } = instr;
 
-        let result = s.guardedMatch(pattern);
+        let result = s.guardedMatch(pattern, pattern.attributes);
 
         if (result instanceof Promise) {
           result = yield result;
@@ -145,33 +143,28 @@ function* __bablr(ctx, rootSource, strategy, options) {
         }
 
         switch (tag.type) {
-          case DoctypeTag: {
-            doctype = tag;
-            break;
-          }
-
           case ReferenceTag: {
             if (s.node.type && tag.value.type === '.') throw new Error();
-            if (s.held && s.node.children.at(2)?.type === InitializerTag) {
-              if (!referencesAreEqual(s.node.children.at(1), tag) || s.node.children.size > 3) {
+            if (s.held && s.node.tags.at(2)?.type === InitializerTag) {
+              if (!referencesAreEqual(s.node.tags.at(1).value, tag.value) || s.node.tags.size > 3) {
                 throw new Error();
               }
             }
 
             m.advance(tag, s);
 
-            s.referenceTagPath = TagPath.fromNode(s.node, -1);
+            s.referenceTagPath = TagPath.from(s.path, -1, 0);
             if (s.referenceTagPath.tag.type === BindingTag) throw new Error();
             break;
           }
 
           case ShiftTag: {
             let { index, height } = tag.value;
-            let refTag = s.node.children.at(-3);
+            let refTag = s.node.tags.at(-1, 0);
             let lastShiftTag = refTag;
 
             if (refTag.type === ShiftTag) {
-              refTag = s.node.children.at(-3 - refTag.value.index * 3);
+              refTag = s.node.tags.at(-refTag.value.index - 1, 0);
             }
 
             if (refTag.type !== ReferenceTag) throw new Error();
@@ -191,7 +184,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
             );
 
             m.advance(tag, s);
-            s.referenceTagPath = TagPath.fromNode(s.node, -1);
+            s.referenceTagPath = TagPath.from(s.path, 0);
             break;
           }
 
@@ -210,6 +203,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
           }
 
           case OpenNodeTag: {
+            let { literalValue, selfClosing } = tag.value;
+
             s.depths.path++;
             s.depths.nodeShift = 0;
 
@@ -219,18 +214,58 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
             s.agast = m.agast;
 
-            if (s.depths.path === 0) {
-              m.advance(doctype);
-            }
-
             m.advance(tag, s);
+            const refPath = m.referencePath;
+
+            if (selfClosing) {
+              if (literalValue) {
+                let result;
+                if (
+                  s.resultPath.tag.type === OpenNodeTag &&
+                  s.resultPath.tag.value.attributes.balancer &&
+                  s.balanced.value?.attributes.balanced === literalValue
+                ) {
+                  result = s.match(literalValue, tag.value.attributes);
+                } else {
+                  result = s.guardedMatch(literalValue, tag.value.attributes);
+                }
+
+                if (result instanceof Promise) {
+                  result = yield result;
+                }
+
+                if (result) {
+                  let sourceStep = s.source.advance(getSourceLength(result));
+
+                  if (sourceStep instanceof Promise) {
+                    sourceStep = yield sourceStep;
+                  }
+                } else {
+                  throw new Error('Failed to advance literal');
+                }
+              }
+
+              s.depths.path--;
+              s.depths.nodeShift = 0;
+              s.depths.shift = 0;
+
+              s.agast = m.agastFragment;
+              s.held = Object.freeze({
+                reference: refPath.tag.value,
+                binding: null,
+                node: s.resultPath.node,
+              });
+            }
 
             if (s.depths.path === 0) {
-              m.setRangePreviousIndex(1);
+              m.setRangePreviousIndex(0);
             }
 
             if (tag.value.type) {
-              updateSpans(m, s.node, 'open');
+              updateSpans(m, s.resultPath.node, 'open');
+            }
+            if (literalValue) {
+              updateSpans(m, s.resultPath.node, 'close');
             }
 
             break;
@@ -243,12 +278,12 @@ function* __bablr(ctx, rootSource, strategy, options) {
             s.depths.nodeShift = 0;
             s.depths.shift = 0;
 
-            if (m.rangeInitial.tag.type === ShiftTag) {
+            if (m.rangeInitial?.tag.type === ShiftTag) {
               s.depths.nodeShift = m.rangeInitial.tag.value.index;
               s.depths.shift = m.rangeInitial.tag.value.height;
             }
 
-            if (node.children.at(0).value.type) {
+            if (node.tags.at(0).value.type) {
               const refPath = m.referencePath;
 
               m.advance(tag, s);
@@ -260,43 +295,32 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 let tagPath = PathFacade.from(node).tagPathAt(0);
 
                 while (tagPath) {
-                  let vmReturn = null;
                   if (tagPath.tag.type === GapTag) {
-                    break;
+                    throw new Error();
                   }
                   if (tagPath.tag.type === OpenNodeTag) {
-                    let { flags, type, attributes } = tagPath.tag.value;
-
-                    if (tagPath.node.flags.hasGap) {
-                      vmReturn = escapeVm.next(
-                        buildOpenNodeTag(getFlagsWithGap(flags, false), type, attributes),
-                      );
-                    } else {
-                      vmReturn = escapeVm.next(
-                        buildChild(
-                          sym.Property,
-                          buildProperty(
-                            tagPath.path.reference.value,
-                            tagPath.path.referenceTagPath.nextSibling.tag.value,
-                            tagPath.node.node,
-                          ),
-                        ),
-                      );
-                      tagPath = tagPath.path.tagPathAt(-1).nextUnshifted;
-                      continue;
-                    }
+                    let { flags, type, attributes, literalValue } = tagPath.tag.value;
+
+                    escapeVm.next(
+                      buildOpenNodeTag(
+                        getFlagsWithGap(flags, false),
+                        type,
+                        attributes,
+                        literalValue,
+                      ),
+                    );
                   } else if (tagPath.tag.type === ReferenceTag && tagPath.tag.value.flags.hasGap) {
                     let { flags, name, type, isArray, index } = tagPath.tag.value;
 
                     flags = getFlagsWithGap(flags, false);
 
-                    vmReturn = escapeVm.next(buildReferenceTag(type, name, isArray, flags, index));
+                    escapeVm.next(buildReferenceTag(type, name, isArray, flags, index));
                   } else {
-                    vmReturn = escapeVm.next(tagPath.tag);
+                    escapeVm.next(tagPath.tag);
                   }
 
                   if (tagPath.tag.type === CloseNodeTag && !tagPath.nextUnshifted) {
-                    gaplessNode = vmReturn.value;
+                    gaplessNode = escapeState.resultPath.node;
                   }
 
                   tagPath = tagPath.nextUnshifted;
@@ -306,7 +330,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
               s.agast = m.agastFragment;
 
               s.held = Object.freeze({
-                reference: refPath.tag.value,
+                reference: refPath?.tag.value,
                 binding: null,
                 node: gaplessNode || m.node,
               });
@@ -383,7 +407,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
                   ),
                 );
 
-                s.resultPath = TagPath.fromNode(s.resultPath.node, -1);
+                s.resultPath = TagPath.from(s.resultPath.path, -1);
 
                 s.held = null;
                 break;
@@ -407,7 +431,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 break;
               }
 
-              if (s.node.children.size) {
+              if (s.node.tags.size) {
                 m.advance(tag, s);
               } else {
                 m.add(m.node);
@@ -425,7 +449,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
           }
 
           case InitializerTag: {
-            if (s.held && s.node.children.at(2)?.type === InitializerTag) {
+            if (s.held && s.node.tags.at(2)?.type === InitializerTag) {
               throw new Error();
             }
             m.advance(tag, s);
@@ -534,8 +558,6 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         finishedMatch = null;
 
-        if (m.isNode && m.isCover) throw new Error();
-
         if (m.type !== sym.fragment && !getProduction(m.grammar, m.type))
           throw new Error(`Production {type: ${printType(m.type)}} does not exist`);
 
@@ -543,17 +565,17 @@ function* __bablr(ctx, rootSource, strategy, options) {
           throw new Error('tokens must be nodes');
         }
 
-        if (parentMatch && parentMatch.cover && !m.isNode) {
+        if (parentMatch && parentMatch.cover && !parentMatch.isNode) {
           if (matcher_.refMatcher) {
             let m = matcher_.refMatcher;
-            if (m.type !== '.' || m.flags.expression || m.flags.hasGap || m.isArray) {
+            if (!['.', '#'].includes(m.type) || m.flags.expression || m.flags.hasGap || m.isArray) {
               throw new Error('no references inside covers');
             }
           }
         }
 
         if (didShift) {
-          if (s.node.children.at(-1)?.type !== ShiftTag) {
+          if (s.node.tags.at(-1, 0)?.type !== ShiftTag) {
             throw new Error('advance shift tag before starting new held frame');
           }
         }
@@ -569,16 +591,16 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         ({ language } = m);
 
-        let offset = m.isNode ? -1 : 0;
+        let offset = [ReferenceTag, ShiftTag].includes(s.resultPath?.tag.type) ? -1 : 0;
 
         if (!broken) {
           let previousIndex = [CloseNodeTag, NullTag, GapTag].includes(s.resultPath.tag.type)
-            ? m.fragmentNode.children.size - 1
-            : s.resultPath.childrenIndex;
+            ? m.fragmentNode.tags.size - 1
+            : s.resultPath.tagsIndex;
 
           m.setRangePreviousIndex(previousIndex + offset);
         } else if (parentMatch) {
-          m.setRangePreviousIndex(m.fragmentNode.children.size - 1 + offset);
+          m.setRangePreviousIndex(m.fragmentNode.tags.size - 1 + offset);
         }
 
         returnValue = facades.get(m);

package/lib/match.js

@@ -5,9 +5,9 @@ import { agast, TagPathFacade as TagPath, PathFacade as Path } from '@bablr/agas
 import {
   buildOpenNodeTag,
   buildProperty,
-  buildReferenceTag,
+  buildReference,
   fragmentFlags,
-  mergeReferenceTags,
+  mergeReferences,
 } from '@bablr/agast-helpers/tree';
 import { effectsFor } from '@bablr/agast-vm-helpers';
 import { FragmentFacade } from './node.js';
@@ -20,10 +20,12 @@ import {
   ShiftTag,
   AttributeDefinition,
   Property,
+  PropertyWrapper,
   InitializerTag,
   BindingTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
+import { offsetForTag } from '@bablr/agast-helpers/path';
 
 export class MatchFacade {
   constructor(match) {
@@ -59,15 +61,10 @@ export class MatchFacade {
     return actuals.get(this).path;
   }
 
-  get inner() {
-    return actuals.get(this).inner;
-  }
-
   get fragment() {
     const {
       ctx,
       effects,
-      path,
       isCoverBoundary,
       isNode,
       fragmentNode,
@@ -77,11 +74,11 @@ export class MatchFacade {
       rangeFinalIndex,
     } = actuals.get(this);
 
-    const { name, isArray } = mergedReference.value;
+    const { name, isArray } = mergedReference;
 
     let prev =
       rangePreviousIndex != null
-        ? (fragmentNode || node).children.at(rangePreviousIndex)
+        ? (fragmentNode || node).tags.at(rangePreviousIndex)
         : rangePreviousIndex;
 
     let offset = [ReferenceTag, ShiftTag].includes(prev?.type) ? 0 : 1;
@@ -93,11 +90,11 @@ export class MatchFacade {
         false,
         true,
         [rangePreviousIndex + offset, rangeFinalIndex],
-        mergedReference.value,
+        mergedReference,
         isArray ? fragmentNode.getChildPropertyIndex(rangePreviousIndex + offset) : null,
       );
     } else {
-      return new FragmentFacade(fragmentNode || path.node, ctx, false, true, [
+      return new FragmentFacade(fragmentNode || node, ctx, false, true, [
         rangePreviousIndex + offset,
         rangeFinalIndex,
       ]);
@@ -249,11 +246,15 @@ export class Match extends WeakStackFrame {
     this.agast = isNode ? null : state.agast ?? null;
     this.node = isNode ? null : parent?.node;
     this.cover =
-      isNode || effects.success === 'none' ? null : parent?.cover || (isCover ? this : null);
-
-    let isCoverBoundary = ((isNode || isCover) && !this.cover) || !parent;
-
-    if (isCoverBoundary) {
+      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) {
@@ -277,7 +278,8 @@ export class Match extends WeakStackFrame {
   }
 
   get isCoverBoundary() {
-    return (this.isNode && this.parent && !this.parent.cover) || this.cover === this;
+    let { cover } = this;
+    return cover === this;
   }
 
   get matcher() {
@@ -289,7 +291,7 @@ export class Match extends WeakStackFrame {
   }
 
   get mergedReference() {
-    let ref = buildReferenceTag('.');
+    let ref = buildReference('.');
 
     let first = true;
     let m = this;
@@ -298,10 +300,11 @@ export class Match extends WeakStackFrame {
     do {
       if (m.isNode && !first) break;
       if (m.propertyMatcher.refMatcher) {
-        const { type: refType, name, isArray, flags } = m.propertyMatcher.refMatcher;
-        const parentRef = buildReferenceTag(refType, name, isArray, flags);
+        const parentRef = m.propertyMatcher.refMatcher;
+        const { type: refType, name } = parentRef;
+
         if (lastName && (lastName !== name || lastRefType !== refType)) break;
-        ref = ['#', '@'].includes(ref.value.type) ? ref : mergeReferenceTags(ref, parentRef);
+        ref = ['#', '@'].includes(ref.type) ? ref : mergeReferences(ref, parentRef);
         if (refType !== '.') {
           lastName = name;
           lastRefType = refType;
@@ -330,11 +333,11 @@ export class Match extends WeakStackFrame {
   }
 
   get pathName() {
-    return this.mergedReference.value.name;
+    return this.mergedReference.name;
   }
 
   get path() {
-    let { agast } = this.coveredBoundary.parent ?? this;
+    let { agast } = this;
 
     return agast.state.path || agast.state.resultPath?.path;
   }
@@ -349,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() {
@@ -391,12 +394,19 @@ export class Match extends WeakStackFrame {
     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() {
-    let node = this.fragmentNode || this.node;
+    let path = this.fragmentPath || this.path;
 
-    return this.rangePreviousIndex == null || node == null
+    return this.rangePreviousIndex == null || path == null
       ? null
-      : TagPath.fromNode(node, this.rangePreviousIndex);
+      : TagPath.from(path, this.rangePreviousIndex, -1);
   }
 
   setRangePreviousIndex(value) {
@@ -420,19 +430,19 @@ export class Match extends WeakStackFrame {
   }
 
   get rangeFinal() {
-    let node = this.fragmentNode || this.node;
+    let path = this.fragmentPath || this.path;
 
-    return this.rangeFinalIndex == null || node == null
+    return this.rangeFinalIndex == null || path == null
       ? null
-      : TagPath.fromNode(node, this.rangeFinalIndex);
+      : TagPath.from(path, this.rangeFinalIndex, -1);
   }
 
   get rangeInitial() {
-    const { rangePrevious, isNode, fragmentNode, node, rangePreviousIndex } = this;
+    const { rangePrevious, isNode, fragmentPath, path, rangePreviousIndex } = this;
 
     if (!rangePrevious) return rangePrevious;
 
-    if (isNode) return TagPath.fromNode(fragmentNode || node, rangePreviousIndex + 1);
+    if (isNode) return TagPath.from(fragmentPath || path, rangePreviousIndex + 1, 0);
 
     return rangePrevious?.nextSibling;
   }
@@ -451,15 +461,15 @@ export class Match extends WeakStackFrame {
       return null;
     }
 
-    let offset = this.isNode ? 1 : 0;
+    let parentPath = this.fragmentPath || this.path;
 
-    let ref = TagPath.fromNode(this.fragmentNode || this.node, this.rangePreviousIndex + offset);
+    let ref = TagPath.from(parentPath, this.rangePreviousIndex + 1, 0);
 
     if (!ref) return null;
 
     if (ref.tag.type === ShiftTag) {
-      let refIndex = ref.childrenIndex - ref.tag.value.index * 3;
-      ref = ref.siblingAt(refIndex);
+      let refIndex = ref.tagsIndex - ref.tag.value.index;
+      ref = TagPath.from(ref.path, refIndex, 0);
     }
 
     if (ref && ref.tag.type !== ReferenceTag) throw new Error();
@@ -475,10 +485,6 @@ export class Match extends WeakStackFrame {
     return this.cover === this;
   }
 
-  get inner() {
-    return Path.from(this.node);
-  }
-
   advance(tag, s = this.state) {
     let { vm, state: agastState } = s.agast;
 
@@ -486,14 +492,18 @@ export class Match extends WeakStackFrame {
 
     if (tag.type === OpenNodeTag) {
       s.depths.result++;
-      this.node = s.node;
+      this.node = s.node || s.resultPath.node;
     } else if (tag.type === CloseNodeTag) {
       s.depths.result--;
     }
 
     s.resultPath =
-      (agastState.node || agastState.resultPath?.node) &&
-      TagPath.fromNode(agastState.node || agastState.resultPath?.node, -1);
+      (agastState.path || agastState.resultPath?.path) &&
+      TagPath.from(
+        agastState.path || agastState.resultPath?.path,
+        -1,
+        tag.type === PropertyWrapper ? -1 : offsetForTag(tag),
+      );
     return result.value;
   }
 
@@ -524,7 +534,7 @@ export class Match extends WeakStackFrame {
 
     if (!m) return m;
 
-    finishedMatch.setRangeFinalIndex((finishedMatch.fragmentNode || m.node).children.size - 1);
+    finishedMatch.setRangeFinalIndex((finishedMatch.fragmentNode || m.node).tags.size - 1);
 
     m.running = null;
 
@@ -559,7 +569,7 @@ export class Match extends WeakStackFrame {
 
       let path = Path.from(node);
 
-      let tagPath = emitted?.tagPath || (path.node.children.size ? TagPath.from(path, 0) : null);
+      let tagPath = emitted?.tagPath || (path.node.tags.size ? TagPath.from(path, 0) : null);
 
       while (tagPath) {
         if (
@@ -602,8 +612,12 @@ export class Match extends WeakStackFrame {
           }
         }
 
-        if (tagPath.tag.type === CloseNodeTag && !tagPath.next) {
-          tagPath = TagPath.fromNode(m.fragmentNode, m.rangeInitial.childrenIndex + 3);
+        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;
@@ -631,7 +645,7 @@ export class Match extends WeakStackFrame {
           } else {
             break;
           }
-          tagPath = TagPath.fromNode(m.node, 0);
+          tagPath = TagPath.from(m.path, 0);
         } else {
           if (holdShifted) {
             tagPath = tagPath.nextUnshifted;