@bablr/agast-vm 0.5.0 → 0.6.1

package/lib/context.js

@@ -3,10 +3,7 @@ import {
   getCooked as getCookedFromTree,
   sourceTextFor as sourceTextForTree,
 } from '@bablr/agast-helpers/tree';
-import {
-  getCooked as getCookedFromStream,
-  sourceTextFor as sourceTextForStream,
-} from '@bablr/agast-helpers/stream';
+import { getCooked as getCookedFromStream } from '@bablr/agast-helpers/stream';
 import { OpenNodeTag, CloseNodeTag } from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
 
@@ -52,6 +49,10 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).buildRange(tags);
   }
 
+  nodeForTag(tag) {
+    return actuals.get(this).nodeForTag(tag);
+  }
+
   unbox(value) {
     return actuals.get(this).unbox(value);
   }
@@ -65,6 +66,7 @@ export const Context = class AgastContext {
   constructor() {
     this.prevTags = new WeakMap();
     this.nextTags = new WeakMap();
+    this.tagNodes = new WeakMap();
     this.unboxedValues = new WeakMap();
     this.facade = new ContextFacade();
 
@@ -100,10 +102,12 @@ export const Context = class AgastContext {
     return this.nextTags.get(token);
   }
 
-  sourceTextFor(nodeOrRange) {
-    return isArray(nodeOrRange)
-      ? sourceTextForStream(this.allTagsFor(nodeOrRange))
-      : sourceTextForTree(nodeOrRange);
+  nodeForTag(tag) {
+    return this.tagNodes.get(tag);
+  }
+
+  sourceTextFor(node) {
+    return sourceTextForTree(node);
   }
 
   buildRange(tags) {

package/lib/evaluate.js

@@ -13,7 +13,13 @@ import {
 import { getEmbeddedExpression } from '@bablr/agast-vm-helpers/deembed';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
-import { getRange, getOpenTag, buildArrayTag } from '@bablr/agast-helpers/tree';
+import {
+  getRange,
+  getOpenTag,
+  buildArrayTag,
+  buildFragmentCloseTag,
+  buildFragmentOpenTag,
+} from '@bablr/agast-helpers/tree';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -24,6 +30,8 @@ import {
   NullTag,
   ArrayTag,
   LiteralTag,
+  CloseFragmentTag,
+  OpenFragmentTag,
 } from '@bablr/agast-helpers/symbols';
 import * as btree from '@bablr/agast-helpers/btree';
 import { State } from './state.js';
@@ -64,7 +72,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
         s = s.accept();
 
         if (s.depth === 0) {
-          yield* s.emit();
+          yield* s.emit(options);
         }
 
         returnValue = facades.get(s);
@@ -79,7 +87,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
       }
 
       case 'advance': {
-        const { 0: embeddedTag, 1: options } = args;
+        const { 0: embeddedTag, 1: advanceOptions } = args;
 
         const tag = embeddedTag.value;
 
@@ -116,7 +124,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           }
 
           case ReferenceTag: {
-            const { name, isArray } = tag.value;
+            const { name, isArray, hasGap } = tag.value;
 
             if (s.result.type === ReferenceTag) {
               throw new Error('A reference must have a non-reference value');
@@ -126,7 +134,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('A token node cannot contain a reference');
             }
 
-            returnValue = s.advance(buildReferenceTag(name, isArray));
+            returnValue = s.advance(buildReferenceTag(name, isArray, hasGap));
             break;
           }
 
@@ -178,7 +186,17 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
             returnValue = s.advance(
               buildNodeOpenTag(flags, language, type, attributes),
-              getEmbeddedExpression(options),
+              getEmbeddedExpression(advanceOptions),
+            );
+            break;
+          }
+
+          case OpenFragmentTag: {
+            const { flags } = tag.value;
+
+            returnValue = s.advance(
+              buildFragmentOpenTag(flags),
+              getEmbeddedExpression(advanceOptions),
             );
             break;
           }
@@ -190,11 +208,16 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
+          case CloseFragmentTag: {
+            returnValue = s.advance(buildFragmentCloseTag());
+            break;
+          }
+
           default:
             throw new Error();
         }
 
-        yield* s.emit();
+        yield* s.emit(options);
 
         break;
       }
@@ -214,10 +237,6 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
         if (key === 'span') throw new Error('too late');
 
-        if (key === 'balancedSpan') {
-          throw new Error('not implemented');
-        }
-
         // if (stateIsDifferent) {
         //   // we can't allow effects to cross state branches
         //   throw new Error();
@@ -258,7 +277,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
         }
 
         if (!unboundAttributes.size) {
-          yield* s.emit();
+          yield* s.emit(options);
         }
 
         returnValue = getRange(s.node);
@@ -277,7 +296,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
       case 'write': {
         if (options.emitEffects) {
-          yield buildWriteEffect(args[0], getEmbeddedExpression(args[1]));
+          yield buildWriteEffect(args[0], args[1].value);
         }
         break;
       }

package/lib/path.js

@@ -55,7 +55,7 @@ export const Path = class AgastPath extends WeakStackFrame {
   }
 
   get name() {
-    return this.reference?.value.name || '[anonymous]';
+    return this.reference?.value.name;
   }
 
   get isArray() {

package/lib/state.js

@@ -11,14 +11,15 @@ import {
   finalizeNode,
   getRoot,
   printType,
+  buildStubNode,
 } from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
 import {
   buildBeginningOfStreamToken,
   buildEmbeddedNode,
-  nodeFlags,
+  buildEffect,
+  buildYieldEffect,
 } from '@bablr/agast-vm-helpers/internal-builders';
-import * as sym from '@bablr/agast-helpers/symbols';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -29,45 +30,24 @@ import {
   NullTag,
   ArrayTag,
   LiteralTag,
+  OpenFragmentTag,
+  CloseFragmentTag,
 } from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
 import { Path } from './path.js';
+import { isArray } from 'iter-tools-es';
 
 const { hasOwn } = Object;
 
-const arrayLast = (arr) => arr[arr.length - 1];
-
-const createNodeWithState = (startTag, options = {}) => {
+const createNodeWithState = (openTag, options = {}) => {
   const { unboundAttributes } = options;
-  const node = createNode(startTag);
+  const node = createNode(openTag);
   nodeStates.set(node, {
     unboundAttributes: new Set(unboundAttributes || []),
   });
   return node;
 };
 
-const symbolTypeFor = (type) => {
-  // prettier-ignore
-  switch (type) {
-    case NullTag: return sym.null;
-    case GapTag: return sym.gap;
-    default: throw new Error();
-  }
-};
-
-const { freeze } = Object;
-
-const buildStubNode = (tag) => {
-  return freeze({
-    flags: nodeFlags,
-    language: null,
-    type: symbolTypeFor(tag.type),
-    children: freeze([tag]),
-    properties: freeze({}),
-    attributes: freeze({}),
-  });
-};
-
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
     facades.set(state, this);
@@ -110,11 +90,11 @@ export const StateFacade = class AgastStateFacade {
   }
 
   nodeForPath(path) {
-    return actuals.get(this).nodeForPath(path);
+    return actuals.get(this).nodeForPath(actuals.get(path));
   }
 
   pathForTag(tag) {
-    return actuals.get(this).pathForTag(tag);
+    return facades.get(actuals.get(this).pathForTag(tag));
   }
 
   nodeForTag(tag) {
@@ -170,7 +150,7 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get tagNodes() {
-    return this.internalContext.tagNodes;
+    return this.context.tagNodes;
   }
 
   get unboundAttributes() {
@@ -206,7 +186,7 @@ export const State = class AgastState extends WeakStackFrame {
         this.result?.type === ReferenceTag &&
         ![OpenNodeTag, GapTag, NullTag, ArrayTag].includes(tag.type)
       ) {
-        throw new Error(`${tag.type} is not a valid reference target`);
+        throw new Error(`${printType(tag.type)} is not a valid reference target`);
       }
 
       prevTags.set(tag, this.result);
@@ -224,28 +204,24 @@ export const State = class AgastState extends WeakStackFrame {
 
         case OpenNodeTag: {
           const openTag = tag;
-          const { type, flags } = tag.value;
+          const { flags } = tag.value;
           this.node = createNodeWithState(tag, options);
 
           const reference = this.result;
 
           this.node.children = btree.push(this.node.children, tag);
 
-          if (!type) {
-            this.node.attributes = this.result.value.attributes;
-          } else {
-            if (!flags.trivia && !flags.escape) {
-              if (
-                reference.type !== ReferenceTag &&
-                reference.type !== ShiftTag &&
-                reference.type !== OpenNodeTag &&
-                !reference.value.type
-              ) {
-                throw new Error('Invalid location for OpenNodeTag');
-              }
-            } else {
-              this.path = this.path.push(ctx, null, btree.getSum(this.node.children));
+          if (!flags.trivia && !flags.escape) {
+            if (
+              reference.type !== ReferenceTag &&
+              reference.type !== ShiftTag &&
+              reference.type !== OpenNodeTag &&
+              !reference.value.type
+            ) {
+              throw new Error('Invalid location for OpenNodeTag');
             }
+          } else {
+            this.path = this.path.push(ctx, null, btree.getSum(this.node.children));
           }
 
           this.pathNodes.set(this.node, this.path);
@@ -256,6 +232,25 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
+        case OpenFragmentTag: {
+          const openTag = tag;
+          this.node = createNodeWithState(tag, options);
+
+          const reference = this.result;
+
+          this.node.attributes = this.result.value.attributes;
+          this.node.children = btree.push(this.node.children, reference);
+
+          this.node.children = btree.push(this.node.children, tag);
+
+          this.pathNodes.set(this.node, this.path);
+          this.pathNodes.set(this.path, this.node);
+
+          this.tagNodes.set(openTag, this.node);
+          this.tagPaths.set(openTag, this.path);
+          break;
+        }
+
         case CloseNodeTag: {
           const openTag = getOpenTag(this.node);
           const { flags, type: openType } = openTag.value;
@@ -264,28 +259,41 @@ export const State = class AgastState extends WeakStackFrame {
 
           this.node.children = btree.push(this.node.children, tag);
 
-          if (openType) {
-            if (this.node.unboundAttributes?.size)
-              throw new Error('Grammar failed to bind all attributes');
+          if (this.node.unboundAttributes?.size)
+            throw new Error('Grammar failed to bind all attributes');
+
+          if (!type) throw new Error(`CloseNodeTag must have type`);
+
+          if (type !== openType)
+            throw new Error(
+              `Grammar close {type: ${printType(type)}} did not match open {type: ${printType(
+                openType,
+              )}}`,
+            );
+
+          if (!flags.escape && !flags.trivia) {
+            add(this.parentNode, this.path.reference, this.node);
+          } else if (this.parentNode) {
+            this.parentNode.children = btree.push(
+              this.parentNode.children,
+              buildEmbeddedNode(this.node),
+            );
+          }
 
-            if (!type) throw new Error(`CloseNodeTag must have type`);
+          this.tagNodes.set(closeTag, this.node);
+          this.tagPaths.set(closeTag, this.path);
 
-            if (type !== openType)
-              throw new Error(
-                `Grammar close {type: ${printType(type)}} did not match open {type: ${printType(
-                  openType,
-                )}}`,
-              );
+          finalizeNode(this.node);
 
-            if (!flags.escape && !flags.trivia) {
-              add(this.parentNode, this.path.reference, this.node);
-            } else {
-              this.parentNode.children = btree.push(
-                this.parentNode.children,
-                buildEmbeddedNode(this.node),
-              );
-            }
-          }
+          this.node = this.parentNode;
+          this.path = this.path.parent;
+          break;
+        }
+
+        case CloseFragmentTag: {
+          const closeTag = tag;
+
+          this.node.children = btree.push(this.node.children, tag);
 
           this.tagNodes.set(closeTag, this.node);
           this.tagPaths.set(closeTag, this.path);
@@ -300,7 +308,11 @@ export const State = class AgastState extends WeakStackFrame {
         case ReferenceTag: {
           this.node.children = btree.push(this.node.children, tag);
 
-          const { isArray, name } = tag.value;
+          const { isArray, name, hasGap } = tag.value;
+
+          if (hasGap && !this.node.flags.hasGap) {
+            throw new Error('gap reference in gapless node');
+          }
 
           if (isArray && !hasOwn(this.node.properties, name)) {
             this.node.properties[name] = [];
@@ -324,14 +336,32 @@ export const State = class AgastState extends WeakStackFrame {
             target = this.held.node;
 
             this.held = null;
-          } else if (this.expressions.size) {
-            const expression = this.expressions.value;
-            target = expression != null ? getRoot(expression) : buildStubNode(tag);
-            this.expressions = this.expressions.pop();
           } else {
-            target = buildStubNode(tag);
+            if (!this.node.flags.hasGap) throw new Error('Node must allow gaps');
+
+            if (this.expressions.size) {
+              const expression = this.expressions.value;
+
+              if (isArray(expression)) {
+                throw new Error('Invalid array interpolation');
+              } else {
+                target = expression != null ? getRoot(expression) : buildStubNode(tag);
+
+                this.expressions = this.expressions.pop();
+              }
+
+              // const range = ctx.buildRange(streamFromTree(target));
+
+              // this node is only interpolated into the tree, not the stream
+              // the stream still contains a gap token, even if expressions were specified
+              // get rid of the gap token in the stream!
+            } else {
+              target = buildStubNode(tag);
+            }
           }
 
+          this.tagNodes.set(tag, target);
+
           this.pathNodes.set(this.pathForTag(ref), target);
           add(this.node, ref, target);
 
@@ -380,11 +410,7 @@ export const State = class AgastState extends WeakStackFrame {
           break;
         }
 
-        case LiteralTag: {
-          this.node.children = btree.push(this.node.children, tag);
-          break;
-        }
-
+        case LiteralTag:
         case ArrayTag:
           this.node.children = btree.push(this.node.children, tag);
           break;
@@ -399,7 +425,7 @@ export const State = class AgastState extends WeakStackFrame {
     return tag;
   }
 
-  *emit() {
+  *emit(options) {
     const { nextTags } = this.context;
     if (!this.depth) {
       let emittable = this.emitted ? nextTags.get(this.emitted) : this.result;
@@ -412,7 +438,8 @@ export const State = class AgastState extends WeakStackFrame {
           nodeStates.get(this.nodeForTag(emittable)).unboundAttributes?.size
         )
       ) {
-        yield emittable;
+        yield options.emitEffects ? buildYieldEffect(emittable) : emittable;
+
         this.emitted = emittable;
         emittable = nextTags.get(this.emitted);
       }
@@ -424,7 +451,7 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get isGap() {
-    return this.tag.type === 'NodeGapTag';
+    return this.tag.type === GapTag;
   }
 
   get speculative() {

package/package.json

@@ -1,19 +1,17 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
-  "files": [
-    "lib"
-  ],
+  "files": ["lib"],
   "exports": {
     ".": "./lib/index.js"
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.4.0",
-    "@bablr/agast-vm-helpers": "0.4.0",
+    "@bablr/agast-helpers": "^0.5.0",
+    "@bablr/agast-vm-helpers": "^0.5.0",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0"

package/lib/node.js

@@ -1,36 +0,0 @@
-import { getRange, getOpenTag, getCloseTag } from '@bablr/agast-helpers/tree';
-import { facades, actuals } from './facades.js';
-
-export const NodeFacade = class AgastNodeFacade {
-  constructor(path) {
-    facades.set(path, this);
-  }
-
-  get language() {
-    return actuals.get(this).language;
-  }
-
-  get type() {
-    return actuals.get(this).type;
-  }
-
-  get range() {
-    return getRange(actuals.get(this));
-  }
-
-  get openTag() {
-    return getOpenTag(actuals.get(this));
-  }
-
-  get closeTag() {
-    return getCloseTag(actuals.get(this));
-  }
-
-  get flags() {
-    return actuals.get(this).flags;
-  }
-
-  get attributes() {
-    return actuals.get(this).attributes;
-  }
-};