@bablr/bablr-vm 0.19.2 → 0.20.0

package/lib/context.js

@@ -1,10 +1,11 @@
 import { buildDependentLanguages } from '@bablr/helpers/grammar';
 import { facades, actuals } from './facades.js';
 import { getPrototypeOf } from '@bablr/helpers/object';
-import { reifyExpressionShallow } from '@bablr/agast-vm-helpers';
 import { states as nodeStates } from './node.js';
 
-import { sourceTextFor } from '@bablr/agast-helpers/tree';
+import { sourceTextFor } from '@bablr/agast-helpers/stream';
+import { streamFromTree } from '@bablr/agast-helpers/tree';
+import { allTagsFor, buildFullRange, Path, TagPath } from '@bablr/agast-helpers/path';
 
 export const ContextFacade = class BABLRContextFacade {
   constructor(actual) {
@@ -30,7 +31,31 @@ export const ContextFacade = class BABLRContextFacade {
   // }
 
   sourceTextFor(node) {
-    return node && sourceTextFor(nodeStates.get(node).node);
+    let fragmentStream;
+    if (!node) return null;
+    if (getPrototypeOf(node) === Object.prototype) {
+      fragmentStream = streamFromTree(node);
+    } else if (nodeStates.has(node)) {
+      let state = nodeStates.get(node);
+      let { childrenIndexRange } = state;
+      let path = Path.from(state.fragmentNode);
+
+      if (!childrenIndexRange) {
+        childrenIndexRange = buildFullRange(state.node);
+      }
+
+      fragmentStream = allTagsFor(
+        [
+          TagPath.from(path, childrenIndexRange[0]),
+          TagPath.from(path, childrenIndexRange[1] ?? undefined),
+        ],
+        { unshift: true },
+      );
+    } else {
+      return null;
+    }
+
+    return fragmentStream && sourceTextFor(fragmentStream);
   }
 };
 
@@ -56,13 +81,4 @@ export const Context = class BABLRContext {
       this.grammars.set(language, new language.grammar());
     }
   }
-
-  unbox(value) {
-    const { unboxedValues } = this;
-    if (!unboxedValues.has(value)) {
-      unboxedValues.set(value, reifyExpressionShallow(value));
-    }
-
-    return unboxedValues.get(value);
-  }
 };

package/lib/evaluate.js

@@ -1,5 +1,5 @@
 import { Coroutine } from '@bablr/coroutine';
-import { buildOpenNodeTag, buildShiftTag, buildWriteEffect } from '@bablr/agast-helpers/builders';
+import { buildEmbeddedNode, buildOpenNodeTag, buildShiftTag } from '@bablr/agast-helpers/builders';
 import { getStreamIterator, printType, StreamIterable } from '@bablr/agast-helpers/stream';
 import { formatType } from './utils/format.js';
 import { facades } from './facades.js';
@@ -15,43 +15,21 @@ import {
   NullTag,
   ShiftTag,
 } from '@bablr/agast-helpers/symbols';
-import * as sym from '@bablr/agast-helpers/symbols';
-import { internalStates, FragmentFacade } from './node.js';
-import {
-  buildArrayInitializerTag,
-  buildNullTag,
-  getOpenTag,
-  treeFromStreamSync,
-} from '@bablr/agast-helpers/tree';
-import * as btree from '@bablr/agast-helpers/btree';
-import { getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
+import * as sym from '@bablr/agast-vm-helpers/symbols';
+import { FragmentFacade, states } from './node.js';
+import { defineAttribute as defineAttribute_, treeFromStreamSync } from '@bablr/agast-helpers/tree';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
+import { getEmbeddedObject, getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
 import { Match } from './match.js';
-import { reifyExpression, shouldBranch } from '@bablr/agast-vm-helpers';
+import { effectsFor, reifyExpression } from '@bablr/agast-vm-helpers';
 import { TagPath } from '@bablr/agast-helpers/path';
 import { getProduction } from '@bablr/helpers/grammar';
+import { buildWriteEffect } from '@bablr/agast-vm-helpers/builders';
 
-const { hasOwn } = Object;
-
-const bindAttribute = (m, s, key, value) => {
-  const openTag = getOpenTag(m.node);
-
-  if (value != null) {
-    const { flags, language, type } = openTag.value;
-    const attributes = { ...openTag.value.attributes, [key]: value };
-    const newOpenTag = buildOpenNodeTag(flags, language, type, attributes);
+const defineAttribute = (m, s, key, value) => {
+  defineAttribute_(m.node, key, value);
 
-    m.node.attributes = attributes;
-
-    // if (openNext) {
-    // } else {
-    //   // could this tag be stored anywhere else?
-    //   s.resultPath = newOpenTag;
-    // }
-
-    m.node.children = btree.replaceAt(0, m.node.children, newOpenTag);
-  }
-
-  nodeStates.get(m.node).unboundAttributes.delete(key);
+  nodeStates.get(m.node).undefinedAttributes.delete(key);
 };
 
 const getSourceLength = (tags) => {
@@ -71,30 +49,23 @@ export const bablr = (ctx, rootSource, strategy, options = {}) => {
 };
 
 function* __bablr(ctx, rootSource, strategy, options) {
-  let s = State.from(rootSource, ctx, options.expressions);
+  let s = null;
   let m = null;
   let language = null;
+  let finishedMatch = null;
 
-  let co = new Coroutine(getStreamIterator(strategy(facades.get(s), facades.get(ctx))));
+  let co = new Coroutine(getStreamIterator(strategy(facades.get(ctx))));
 
   co.advance();
 
-  {
-    s.source.advance();
-
-    const sourceStep = s.source.fork.head.step;
-
-    if (sourceStep instanceof Promise) {
-      yield sourceStep;
-    }
-  }
-
   for (;;) {
     if (co.current instanceof Promise) {
       co.current = yield co.current;
     }
 
-    if (co.done) break;
+    if (co.done) {
+      return co.value && states.get(co.value).node;
+    }
 
     const instr = co.value;
     let returnValue = undefined;
@@ -107,7 +78,19 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         if (language !== null) throw new Error();
 
+        s = State.from(rootSource, ctx, canonicalURL, options.expressions);
+
+        s.source.advance();
+
+        const sourceStep = s.source.fork.head.step;
+
+        if (sourceStep instanceof Promise) {
+          yield sourceStep;
+        }
+
         language = ctx.languages.get(canonicalURL);
+
+        returnValue = facades.get(s);
         break;
       }
 
@@ -120,6 +103,9 @@ function* __bablr(ctx, rootSource, strategy, options) {
           s.referencePath = null;
         }
 
+        if (m.cover && !m.isNode && !(s.holding && tag.type === GapTag))
+          throw new Error('cannot advance inside a cover');
+
         switch (tag.type) {
           case DoctypeTag: {
             s.node = m.node;
@@ -134,7 +120,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
           case ReferenceTag: {
             s.advance(tag);
 
-            s.referencePath = TagPath.from(m.path, -1);
+            s.referencePath = TagPath.fromNode(s.node, -1);
+            if (s.referencePath.tag.type === GapTag) throw new Error();
             break;
           }
 
@@ -142,13 +129,17 @@ function* __bablr(ctx, rootSource, strategy, options) {
             s.depths.path++;
 
             if (tag.value.type) {
-              if (s.depth === 0 && !m.mergedReference.value.flags.expression) {
-                m.add(m.node);
-              }
+              m.add(m.node);
 
               s.node = m.node;
             }
 
+            for (const { 0: key, 1: value } of Object.entries(tag.value.attributes)) {
+              if (value === undefined) {
+                nodeStates.get(m.node).undefinedAttributes.add(key);
+              }
+            }
+
             s.advance(tag);
 
             if (tag.value.type) {
@@ -161,10 +152,12 @@ function* __bablr(ctx, rootSource, strategy, options) {
           case CloseNodeTag: {
             const { node } = s;
 
-            if (btree.getAt(0, node.children).value.type) {
-              const refPath = m.referencePath;
+            s.depths.path--;
 
-              if (refPath.tag.type === ReferenceTag && refPath?.tag.value.name === '@') {
+            if (sumtree.getAt(0, node.children).value.type) {
+              const refPath = m.unshiftedReferencePath;
+
+              if (refPath?.tag.type === ReferenceTag && refPath?.tag.value.name === '@') {
                 const cooked = node.flags.hasGap
                   ? null
                   : ctx.languages
@@ -174,29 +167,28 @@ function* __bablr(ctx, rootSource, strategy, options) {
                           node,
                           ctx,
                           true,
-                          [refPath.childrenIndex, refPath.childrenIndex],
+                          [refPath.childrenIndex, refPath.childrenIndex + 1],
                           null,
                         ),
                         s.span.name,
                         facades.get(ctx),
                       ) || null;
 
-                bindAttribute(m, s, 'cooked', cooked);
+                defineAttribute(m, s, 'cooked', cooked);
 
-                nodeStates.get(m.node).unboundAttributes.delete('cooked');
+                nodeStates.get(m.node).undefinedAttributes.delete('cooked');
               }
 
               s.advance(tag);
 
+              // if (s.depth > 0) {
+              //   m.add(m.node);
+              // }
+
               s.node = m.fragmentNode;
-              s.depths.path--;
 
               updateSpans(m, s.resultPath.path.node, 'close');
 
-              if (s.depth > 0 || m.mergedReference.value.flags.expression) {
-                m.add(m.node);
-              }
-
               if (!m.parent) {
                 if (!s.source.done) {
                   throw new Error('Parser failed to consume input');
@@ -208,7 +200,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
               }
             } else {
               s.advance(tag);
-              s.node = m.node;
+              s.node = m.fragmentNode;
             }
 
             break;
@@ -221,7 +213,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
             if (
               s.resultPath.tag.type === OpenNodeTag &&
               s.resultPath.tag.value.attributes.balancer &&
-              s.balanced.value.attributes.balanced === pattern
+              s.balanced.value?.attributes.balanced === pattern
             ) {
               result = s.match(pattern);
             } else {
@@ -247,7 +239,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
           }
 
           case GapTag: {
-            if (s.source.value == null && !s.source.done) {
+            if (s.source.value == null && (!s.source.done || s.source.holding)) {
               if (s.source.holding) {
                 s.source.unshift();
               } else {
@@ -261,7 +253,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
               if (s.held) {
                 m.add(s.held);
 
-                s.resultPath = s.resultPath.nextSibling;
+                s.resultPath = TagPath.fromNode(s.resultPath.node, -1);
+
                 s.held = null;
                 break;
               }
@@ -275,7 +268,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 break;
               }
 
-              if (btree.getSum(s.node.children)) {
+              if (sumtree.getSize(s.node.children)) {
                 s.advance(tag);
               } else {
                 m.add(m.node);
@@ -283,6 +276,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 s.advance(tag);
               }
 
+              s.referencePath = null;
+
               s.node = m.fragmentNode;
             } else {
               throw new Error('Failed to advance gap');
@@ -313,7 +308,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         let node = result && treeFromStreamSync(result);
 
-        returnValue = result && FragmentFacade.wrap(node, ctx, true);
+        returnValue = node && buildEmbeddedNode(node);
         break;
       }
 
@@ -329,18 +324,48 @@ function* __bablr(ctx, rootSource, strategy, options) {
         break;
       }
 
+      case 'branch': {
+        s = s.branch();
+
+        returnValue = facades.get(s);
+        break;
+      }
+
+      case 'accept': {
+        s = s.accept(finishedMatch.fragmentNode);
+
+        returnValue = facades.get(s);
+        break;
+      }
+
+      case 'reject': {
+        let finishedState = s;
+        const { arguments: { 0: embeddedOptions } = [] } = instr;
+        let options = getEmbeddedObject(embeddedOptions);
+
+        s = finishedState.reject(
+          finishedMatch,
+          // finishedMatch.effects.success === 'none',
+          options,
+        );
+
+        s = finishedState.parent;
+
+        returnValue = facades.get(s);
+        break;
+      }
+
       case 'startFrame': {
-        const {
-          arguments: {
-            0: { value: matcher } = {},
-            1: { value: effects } = {},
-            2: { value: options = {} } = {},
-          } = [],
+        let {
+          arguments: { 0: verb, 1: { value: matcher } = {}, 2: { value: options = {} } = {} } = [],
         } = instr;
 
-        const { unboundAttributes, didShift, suppressNode } = options;
+        let effects = effectsFor(verb.description);
+        let didShift = verb.description.startsWith('holdFor');
+
+        let { undefinedAttributes } = options;
 
-        const parentMatch = m;
+        let parentMatch = m;
 
         if (!language) throw new Error('not initialized');
 
@@ -349,8 +374,10 @@ function* __bablr(ctx, rootSource, strategy, options) {
         if (didShift && !parentMatch) throw new Error();
 
         m = parentMatch
-          ? parentMatch.startFrame(s, matcher_, effects, didShift, suppressNode)
-          : Match.from(ctx, language, s, matcher_, null, suppressNode);
+          ? parentMatch.startFrame(s, matcher_, effects, didShift ? finishedMatch : null, options)
+          : Match.from(ctx, language, s, matcher_, null, options);
+
+        finishedMatch = null;
 
         if (m.isNode && m.isCover) throw new Error();
 
@@ -365,43 +392,46 @@ function* __bablr(ctx, rootSource, strategy, options) {
           if (matcher_.refMatcher) {
             let m = matcher_.refMatcher;
             if (!(m.name === '.' && !m.flags.expression && !m.flags.hasGap && !m.isArray)) {
-              throw new Error();
+              throw new Error('no references inside covers');
             }
           }
         }
 
-        s = m.state;
-
         if (didShift) {
           s.source.shift();
           s.held = s.resultPath.node;
 
-          let refTag = btree.getAt(-2, parentMatch.node.children);
+          let refTag = sumtree.getAt(-2, s.node.children);
 
           s.advance(buildShiftTag(refTag.type === ShiftTag ? refTag.value.index + 1 : 1));
+          s.referencePath = TagPath.fromNode(s.node, -1);
         }
 
-        if (!m.isNode && options.unboundAttributes) throw new Error();
+        if (!m.isNode && options.undefinedAttributes) throw new Error();
 
         m.fragmentNode = s.node;
 
         nodeStates.set(m.node, {
-          unboundAttributes: m.isNode
-            ? new Set(unboundAttributes)
-            : new Set(parentMatch ? nodeStates.get(parentMatch.node).unboundAttributes || [] : []),
+          undefinedAttributes: m.isNode
+            ? new Set(undefinedAttributes)
+            : new Set(
+                parentMatch ? nodeStates.get(parentMatch.node).undefinedAttributes || [] : [],
+              ),
         });
 
         ({ language } = m);
 
         if (parentMatch) {
           let previousIndex = [CloseNodeTag, NullTag, GapTag].includes(s.resultPath.tag.type)
-            ? btree.getSum(m.fragmentNode.children) - 1
+            ? sumtree.getSize(m.fragmentNode.children) - 1
             : s.resultPath.childrenIndex;
 
           m.setRangePreviousIndex(previousIndex);
         }
 
         returnValue = facades.get(m);
+
+        m.range;
         break;
       }
 
@@ -409,71 +439,48 @@ function* __bablr(ctx, rootSource, strategy, options) {
         const {
           arguments: { 0: hasContinuation },
         } = instr;
-        const finishedMatch = m;
+        finishedMatch = m;
 
         m = m.endFrame();
 
-        if (m && internalStates.get(m.s.node).path.node !== m.s.node) {
-          throw new Error('waaat');
-        }
-
         if (!m) {
           returnValue = m;
           break;
         }
 
-        s = m.state;
-
         if (finishedMatch.state.status !== 'rejected') {
           yield* m.emit();
         }
 
-        returnValue = facades.get(m.node);
+        returnValue = m && facades.get(m);
         break;
       }
 
-      case 'bindAttribute': {
-        const { arguments: { 0: key, 1: value } = [] } = instr;
+      case 'throw': {
+        finishedMatch = m;
 
-        bindAttribute(m, s, key, value);
+        m = m.throw_();
 
-        yield* m.emit();
+        s.status = 'rejected';
+        if (m && finishedMatch.s === s) {
+          s.node = m.node;
+        }
 
+        returnValue = m && facades.get(m);
         break;
       }
 
-      case 'throw': {
-        s.reject();
-
-        let rejectedMatch = m;
-
-        m = m.endFrame();
-        s = m.state;
-
-        let ref = null;
-
-        if (rejectedMatch.isNode) {
-          ref = rejectedMatch.mergedReference;
-        }
+      case 'defineAttribute': {
+        const { arguments: { 0: key, 1: value } = [] } = instr;
 
-        if (ref && ref.value.name !== '#' && !rejectedMatch.didShift) {
-          if (shouldBranch(rejectedMatch.effects) && !hasOwn(s.node.properties, ref.value.name)) {
-            s.advance(ref);
+        if (!nodeStates.get(m.node).undefinedAttributes.has(key))
+          throw new Error('undefined attributes must be declared');
+        if (value && typeof value === 'object') throw new Error('unimplemented');
 
-            if (ref.value.isArray) {
-              s.advance(buildArrayInitializerTag());
-            } else {
-              s.advance(buildNullTag());
-            }
-          }
-        }
+        defineAttribute(m, s, key, value);
 
-        if (!m) {
-          returnValue = m;
-          break;
-        }
+        yield* m.emit();
 
-        returnValue = facades.get(m);
         break;
       }