@bablr/bablr-vm 0.20.1 → 0.22.0

package/lib/evaluate.js

@@ -1,35 +1,51 @@
 import { Coroutine } from '@bablr/coroutine';
-import { buildEmbeddedNode, buildOpenNodeTag, buildShiftTag } from '@bablr/agast-helpers/builders';
+import {
+  buildAttributeDefinition,
+  buildBindingTag,
+  buildChild,
+  buildCloseNodeTag,
+  buildFacadeProperty,
+  buildProperty,
+} 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';
-import { nodeStates, State } from './state.js';
+import { State } from './state.js';
 import { updateSpans } from './spans.js';
 import {
   OpenNodeTag,
   CloseNodeTag,
   GapTag,
+  BindingTag,
   LiteralTag,
   ReferenceTag,
-  DoctypeTag,
   NullTag,
   ShiftTag,
+  InitializerTag,
+  AttributeDefinition,
+  Property,
 } from '@bablr/agast-helpers/symbols';
 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 { agast, PathFacade, TagPathFacade as TagPath } from '@bablr/agast-vm';
+import { states } from './node.js';
+import {
+  buildOpenNodeTag,
+  buildReferenceTag,
+  buildStubNode,
+  getFlagsWithGap,
+  getRoot,
+  treeFromStreamSync,
+} from '@bablr/agast-helpers/tree';
 import { getEmbeddedObject, getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
 import { Match } from './match.js';
 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 defineAttribute = (m, s, key, value) => {
-  defineAttribute_(m.node, key, value);
+import { buildEmbeddedNode, buildWriteEffect } from '@bablr/agast-vm-helpers/builders';
+import { has } from '@bablr/agast-helpers/object';
+import { referencesAreEqual } from '@bablr/agast-helpers/path';
+import { isPlainObject } from '@bablr/helpers/object';
 
-  nodeStates.get(m.node).undefinedAttributes.delete(key);
+const defineAttribute = (m, path, value) => {
+  m.agast.vm.next(buildAttributeDefinition(path, value));
 };
 
 const getSourceLength = (tags) => {
@@ -64,6 +80,18 @@ function* __bablr(ctx, rootSource, strategy, options) {
     }
 
     if (co.done) {
+      if (!s.source.done) {
+        throw new Error(`parse ate ${s.source.index} characters but the input was not consumed`);
+      }
+
+      let { exchange } = s.source;
+
+      s.source.release();
+
+      if (exchange && exchange.sources > 0) {
+        throw new Error('Source did not close all forks: ' + exchange.sources);
+      }
+
       return co.value && states.get(co.value).node;
     }
 
@@ -73,24 +101,27 @@ function* __bablr(ctx, rootSource, strategy, options) {
     const { verb } = instr;
 
     switch (verb) {
-      case 'init': {
-        let { arguments: { 0: canonicalURL } = [] } = instr;
-
-        if (language !== null) throw new Error();
+      case 'write': {
+        const { arguments: { 0: text, 1: { value: writeOptions } = {} } = [] } = instr;
 
-        s = State.from(rootSource, ctx, canonicalURL, options.expressions);
+        if (options.emitEffects) {
+          yield buildWriteEffect(text, writeOptions);
+        }
+        break;
+      }
 
-        s.source.advance();
+      case 'match': {
+        let { arguments: { 0: pattern } = [] } = instr;
 
-        const sourceStep = s.source.fork.head.step;
+        let result = s.guardedMatch(pattern, pattern.attributes);
 
-        if (sourceStep instanceof Promise) {
-          yield sourceStep;
+        if (result instanceof Promise) {
+          result = yield result;
         }
 
-        language = ctx.languages.get(canonicalURL);
+        let node = result && treeFromStreamSync(result);
 
-        returnValue = facades.get(s);
+        returnValue = node && buildEmbeddedNode(node);
         break;
       }
 
@@ -100,50 +131,141 @@ function* __bablr(ctx, rootSource, strategy, options) {
         const tag = getEmbeddedTag(embeddedTags);
 
         if (tag.type !== ReferenceTag) {
-          s.referencePath = null;
+          s.referenceTagPath = null;
         }
 
-        if (m.cover && !m.isNode && !(s.holding && tag.type === GapTag))
+        if (
+          !m.isNode &&
+          m.coveredBoundary !== m &&
+          !((s.holding && tag.type === GapTag) || tag.type === OpenNodeTag)
+        ) {
           throw new Error('cannot advance inside a cover');
+        }
 
         switch (tag.type) {
-          case DoctypeTag: {
-            s.node = m.node;
-            s.node.type = null;
-            s.node.language = tag.value.attributes.bablrLanguage;
-            s.advance(tag);
+          case ReferenceTag: {
+            if (s.node.type && tag.value.type === '.') throw new Error();
+            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.setRangePreviousIndex(0);
+            m.advance(tag, s);
+
+            s.referenceTagPath = TagPath.from(s.path, -1, 0);
+            if (s.referenceTagPath.tag.type === BindingTag) throw new Error();
             break;
           }
 
-          case ReferenceTag: {
-            s.advance(tag);
+          case ShiftTag: {
+            let { index, height } = tag.value;
+            let refTag = s.node.tags.at(-1, 0);
+            let lastShiftTag = refTag;
+
+            if (refTag.type === ShiftTag) {
+              refTag = s.node.tags.at(-refTag.value.index - 1, 0);
+            }
+
+            if (refTag.type !== ReferenceTag) throw new Error();
+
+            s.depths.shift = height;
+            s.depths.nodeShift = index;
+
+            if (index !== (lastShiftTag.type === ShiftTag ? lastShiftTag.value.index + 1 : 1)) {
+              throw new Error();
+            }
+
+            s.source.shift();
+            s.held = buildFacadeProperty(
+              refTag.value,
+              s.resultPath.tag.value,
+              s.resultPath.nextSibling.tag.value.node,
+            );
 
-            s.referencePath = TagPath.fromNode(s.node, -1);
-            if (s.referencePath.tag.type === GapTag) throw new Error();
+            m.advance(tag, s);
+            s.referenceTagPath = TagPath.from(s.path, 0);
+            break;
+          }
+
+          case BindingTag: {
+            m.advance(tag, s);
+
+            let propertyChild = buildChild(
+              sym.Property,
+              buildProperty(s.held.reference, tag.value, s.held.node.node),
+            );
+
+            m.agastFragment.vm.next(propertyChild);
+
+            s.held = null;
             break;
           }
 
           case OpenNodeTag: {
-            s.depths.path++;
+            let { literalValue, selfClosing } = tag.value;
 
-            if (tag.value.type) {
-              m.add(m.node);
+            s.depths.path++;
+            s.depths.nodeShift = 0;
 
-              s.node = m.node;
+            if (!m.coveredBoundary.shiftMatch) {
+              s.depths.shift = 0;
             }
 
-            for (const { 0: key, 1: value } of Object.entries(tag.value.attributes)) {
-              if (value === undefined) {
-                nodeStates.get(m.node).undefinedAttributes.add(key);
+            s.agast = m.agast;
+
+            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,
+              });
             }
 
-            s.advance(tag);
+            if (s.depths.path === 0) {
+              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;
@@ -153,41 +275,67 @@ function* __bablr(ctx, rootSource, strategy, options) {
             const { node } = s;
 
             s.depths.path--;
+            s.depths.nodeShift = 0;
+            s.depths.shift = 0;
 
-            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
-                      .get(node.language)
-                      .getCooked?.(
-                        FragmentFacade.wrap(
-                          node,
-                          ctx,
-                          true,
-                          [refPath.childrenIndex, refPath.childrenIndex + 1],
-                          null,
-                        ),
-                        s.span.name,
-                        facades.get(ctx),
-                      ) || null;
-
-                defineAttribute(m, s, 'cooked', cooked);
-
-                nodeStates.get(m.node).undefinedAttributes.delete('cooked');
-              }
+            if (m.rangeInitial?.tag.type === ShiftTag) {
+              s.depths.nodeShift = m.rangeInitial.tag.value.index;
+              s.depths.shift = m.rangeInitial.tag.value.height;
+            }
+
+            if (node.tags.at(0).value.type) {
+              const refPath = m.referencePath;
+
+              m.advance(tag, s);
+              let gaplessNode = null;
+
+              if (refPath?.tag.value.type === '@') {
+                let { vm: escapeVm, state: escapeState } = agast();
+
+                let tagPath = PathFacade.from(node).tagPathAt(0);
+
+                while (tagPath) {
+                  if (tagPath.tag.type === GapTag) {
+                    throw new Error();
+                  }
+                  if (tagPath.tag.type === OpenNodeTag) {
+                    let { flags, type, attributes, literalValue } = tagPath.tag.value;
 
-              s.advance(tag);
+                    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;
 
-              // if (s.depth > 0) {
-              //   m.add(m.node);
-              // }
+                    flags = getFlagsWithGap(flags, false);
 
-              s.node = m.fragmentNode;
+                    escapeVm.next(buildReferenceTag(type, name, isArray, flags, index));
+                  } else {
+                    escapeVm.next(tagPath.tag);
+                  }
 
-              updateSpans(m, s.resultPath.path.node, 'close');
+                  if (tagPath.tag.type === CloseNodeTag && !tagPath.nextUnshifted) {
+                    gaplessNode = escapeState.resultPath.node;
+                  }
+
+                  tagPath = tagPath.nextUnshifted;
+                }
+              }
+
+              s.agast = m.agastFragment;
+
+              s.held = Object.freeze({
+                reference: refPath?.tag.value,
+                binding: null,
+                node: gaplessNode || m.node,
+              });
+
+              updateSpans(m, s.resultPath.node, 'close');
 
               if (!m.parent) {
                 if (!s.source.done) {
@@ -199,8 +347,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 }
               }
             } else {
-              s.advance(tag);
-              s.node = m.fragmentNode;
+              m.advance(tag, s);
+              s.agast = m.agastFragment;
             }
 
             break;
@@ -231,7 +379,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
                 sourceStep = yield sourceStep;
               }
 
-              s.advance(tag);
+              m.advance(tag, s);
             } else {
               throw new Error('Failed to advance literal');
             }
@@ -251,64 +399,87 @@ function* __bablr(ctx, rootSource, strategy, options) {
               }
 
               if (s.held) {
-                m.add(s.held);
+                if (!s.agast.state.held) throw new Error();
+                s.agast.vm.next(
+                  buildChild(
+                    Property,
+                    buildProperty(m.referencePath.tag.value, null, buildStubNode(tag)),
+                  ),
+                );
 
-                s.resultPath = TagPath.fromNode(s.resultPath.node, -1);
+                s.resultPath = TagPath.from(s.resultPath.path, -1);
 
                 s.held = null;
                 break;
               }
 
               if (s.expressions.size) {
-                const expression = s.expressions.value;
+                let expression = s.expressions.value;
+                let node = getRoot(isPlainObject(expression) ? expression : expression.node);
+
+                let mergedBinding = buildBindingTag(m.mergedLanguagePath);
 
-                m.add(expression);
+                s.agast.vm.next(mergedBinding);
+                s.agast.vm.next(
+                  buildChild(
+                    Property,
+                    buildProperty(s.resultPath.tag.value, mergedBinding.value, node),
+                  ),
+                );
 
                 s.expressions = s.expressions.pop();
                 break;
               }
 
-              if (sumtree.getSize(s.node.children)) {
-                s.advance(tag);
+              if (s.node.tags.size) {
+                m.advance(tag, s);
               } else {
                 m.add(m.node);
 
-                s.advance(tag);
+                m.advance(tag, s);
               }
 
-              s.referencePath = null;
+              s.referenceTagPath = null;
 
-              s.node = m.fragmentNode;
+              s.agast = m.agastFragment;
             } else {
               throw new Error('Failed to advance gap');
             }
             break;
           }
 
-          default:
-            s.advance(tag);
-        }
+          case InitializerTag: {
+            if (s.held && s.node.tags.at(2)?.type === InitializerTag) {
+              throw new Error();
+            }
+            m.advance(tag, s);
+            break;
+          }
 
-        if (s.depth === 0) {
-          yield* m.emit();
-        }
+          case AttributeDefinition: {
+            const { path, value } = tag.value;
 
-        returnValue = tag;
-        break;
-      }
+            if (!has(m.node.attributes, path)) {
+              throw new Error('undefined attributes must be declared');
+            }
 
-      case 'match': {
-        let { arguments: { 0: pattern } = [] } = instr;
+            if (s.held) throw new Error('invalid place for an attribute binding');
 
-        let result = s.guardedMatch(pattern);
+            if (value && typeof value === 'object') throw new Error('unimplemented');
 
-        if (result instanceof Promise) {
-          result = yield result;
+            defineAttribute(m, path, value);
+            break;
+          }
+
+          default:
+            m.advance(tag, s);
         }
 
-        let node = result && treeFromStreamSync(result);
+        if (s.depth === 0 && (s.node || s.resultPath?.node)) {
+          yield* m.emit(options);
+        }
 
-        returnValue = node && buildEmbeddedNode(node);
+        returnValue = tag;
         break;
       }
 
@@ -327,6 +498,8 @@ function* __bablr(ctx, rootSource, strategy, options) {
       case 'branch': {
         s = s.branch();
 
+        // m.node = s.agast.node;
+
         returnValue = facades.get(s);
         break;
       }
@@ -334,6 +507,10 @@ function* __bablr(ctx, rootSource, strategy, options) {
       case 'accept': {
         s = s.accept(finishedMatch.fragmentNode);
 
+        if (s.depth === 0 && (s.node || s.resultPath?.node)) {
+          yield* m.emit(options);
+        }
+
         returnValue = facades.get(s);
         break;
       }
@@ -351,6 +528,10 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         s = finishedState.parent;
 
+        if (s.depth === 0 && (s.node || s.resultPath?.node)) {
+          yield* m.emit(options);
+        }
+
         returnValue = facades.get(s);
         break;
       }
@@ -361,9 +542,7 @@ function* __bablr(ctx, rootSource, strategy, options) {
         } = instr;
 
         let effects = effectsFor(verb.description);
-        let didShift = verb.description.startsWith('holdFor');
-
-        let { undefinedAttributes } = options;
+        let didShift = verb.description.startsWith('shift');
 
         let parentMatch = m;
 
@@ -379,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`);
 
@@ -388,45 +565,42 @@ 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.name === '.' && !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) {
-          s.source.shift();
-          s.held = s.resultPath.node;
-
-          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 (s.node.tags.at(-1, 0)?.type !== ShiftTag) {
+            throw new Error('advance shift tag before starting new held frame');
+          }
         }
 
-        if (!m.isNode && options.undefinedAttributes) throw new Error();
-
-        m.fragmentNode = s.node;
+        let broken = !parentMatch || effects.success === 'none' || s.agast.state.node.type === null;
 
-        nodeStates.set(m.node, {
-          undefinedAttributes: m.isNode
-            ? new Set(undefinedAttributes)
-            : new Set(
-                parentMatch ? nodeStates.get(parentMatch.node).undefinedAttributes || [] : [],
-              ),
-        });
+        if (effects.success !== 'none') {
+          m.agastFragment = s.agast;
+        } else {
+          s.agast = m.agastFragment = m.agast;
+          s.referenceTagPath = null;
+        }
 
         ({ language } = m);
 
-        if (parentMatch) {
+        let offset = [ReferenceTag, ShiftTag].includes(s.resultPath?.tag.type) ? -1 : 0;
+
+        if (!broken) {
           let previousIndex = [CloseNodeTag, NullTag, GapTag].includes(s.resultPath.tag.type)
-            ? sumtree.getSize(m.fragmentNode.children) - 1
-            : s.resultPath.childrenIndex;
+            ? m.fragmentNode.tags.size - 1
+            : s.resultPath.tagsIndex;
 
-          m.setRangePreviousIndex(previousIndex);
+          m.setRangePreviousIndex(previousIndex + offset);
+        } else if (parentMatch) {
+          m.setRangePreviousIndex(m.fragmentNode.tags.size - 1 + offset);
         }
 
         returnValue = facades.get(m);
@@ -436,22 +610,23 @@ function* __bablr(ctx, rootSource, strategy, options) {
       }
 
       case 'endFrame': {
-        const {
-          arguments: { 0: hasContinuation },
-        } = instr;
         finishedMatch = m;
 
         m = m.endFrame();
 
+        if (finishedMatch.effects.success !== 'none') {
+          s.agast = finishedMatch.agastFragment;
+        } else {
+          finishedMatch.agastFragment.vm.next(buildCloseNodeTag());
+          s.agast = m.agast;
+          s.referenceTagPath = m.referencePath;
+        }
+
         if (!m) {
           returnValue = m;
           break;
         }
 
-        if (finishedMatch.state.status !== 'rejected') {
-          yield* m.emit();
-        }
-
         returnValue = m && facades.get(m);
         break;
       }
@@ -461,50 +636,45 @@ function* __bablr(ctx, rootSource, strategy, options) {
 
         m = m.throw_();
 
-        s.status = 'rejected';
         if (m && finishedMatch.s === s) {
-          s.node = m.node;
+          s.agast = m.agast;
         }
 
         returnValue = m && facades.get(m);
         break;
       }
 
-      case 'defineAttribute': {
-        const { arguments: { 0: key, 1: value } = [] } = instr;
+      case 'getState': {
+        returnValue = facades.get(s);
+        break;
+      }
 
-        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');
+      case 'init': {
+        let { arguments: { 0: canonicalURL } = [] } = instr;
 
-        defineAttribute(m, s, key, value);
+        if (language !== null) throw new Error();
 
-        yield* m.emit();
+        s = State.from(rootSource, ctx, canonicalURL, options.expressions);
 
-        break;
-      }
+        s.source.advance();
 
-      case 'write': {
-        const { arguments: { 0: text, 1: { value: writeOptions } = {} } = [] } = instr;
+        const sourceStep = s.source.head.step;
 
-        if (options.emitEffects) {
-          yield buildWriteEffect(text, writeOptions);
+        if (sourceStep instanceof Promise) {
+          yield sourceStep;
         }
-        break;
-      }
 
-      case 'getState': {
+        language = ctx.languages.get(canonicalURL);
+
         returnValue = facades.get(s);
         break;
       }
 
       default: {
-        throw new Error(`Unexpected call of {type: ${formatType(verb)}}`);
+        throw new Error(`Unexpected call of {type: ${printType(verb)}}`);
       }
     }
 
     co.advance(returnValue);
   }
-
-  return s.node;
 }