@bablr/agast-vm 0.5.0 → 0.6.0

package/lib/context.js

@@ -100,10 +100,8 @@ export const Context = class AgastContext {
     return this.nextTags.get(token);
   }
 
-  sourceTextFor(nodeOrRange) {
-    return isArray(nodeOrRange)
-      ? sourceTextForStream(this.allTagsFor(nodeOrRange))
-      : sourceTextForTree(nodeOrRange);
+  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';
@@ -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;
           }
 
@@ -183,6 +191,13 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
+          case OpenFragmentTag: {
+            const { flags } = tag.value;
+
+            returnValue = s.advance(buildFragmentOpenTag(flags), getEmbeddedExpression(options));
+            break;
+          }
+
           case CloseNodeTag: {
             const { type, language } = tag.value;
 
@@ -190,6 +205,11 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
+          case CloseFragmentTag: {
+            returnValue = s.advance(buildFragmentCloseTag());
+            break;
+          }
+
           default:
             throw new Error();
         }
@@ -214,10 +234,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();
@@ -277,7 +293,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,13 @@ import {
   finalizeNode,
   getRoot,
   printType,
+  buildStubNode,
 } from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
 import {
   buildBeginningOfStreamToken,
   buildEmbeddedNode,
-  nodeFlags,
 } from '@bablr/agast-vm-helpers/internal-builders';
-import * as sym from '@bablr/agast-helpers/symbols';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -29,45 +28,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 +88,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) {
@@ -206,7 +184,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 +202,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 +230,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 +257,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),
+            );
+          }
+
+          this.tagNodes.set(closeTag, this.node);
+          this.tagPaths.set(closeTag, this.path);
 
-            if (!type) throw new Error(`CloseNodeTag must have type`);
+          finalizeNode(this.node);
 
-            if (type !== openType)
-              throw new Error(
-                `Grammar close {type: ${printType(type)}} did not match open {type: ${printType(
-                  openType,
-                )}}`,
-              );
+          this.node = this.parentNode;
+          this.path = this.path.parent;
+          break;
+        }
 
-            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),
-              );
-            }
-          }
+        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 +306,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 +334,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 +408,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;
@@ -424,7 +448,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,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,8 +12,8 @@
   },
   "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;
-  }
-};