@bablr/agast-vm 0.2.0 → 0.3.0

package/lib/context.js

@@ -11,7 +11,8 @@ function* ownTerminalsFor(range, nextTerminals, tagNodes) {
 
   for (let term = start; term && term !== pastEnd; term = nextTerminals.get(term)) {
     if (!(term === range[0] || term === range[1]) && term.type === 'OpenNodeTag') {
-      term = nextTerminals.get(tagNodes.get(term).endTag);
+      term = tagNodes.get(term).closeTag;
+      continue;
     }
 
     yield term;
@@ -70,6 +71,14 @@ export const ContextFacade = class AgastContextFacade {
     return actuals.get(this).nodeForTag(tag);
   }
 
+  pathForTag(tag) {
+    return actuals.get(this).pathForTag(tag);
+  }
+
+  nodeForPath(path) {
+    return actuals.get(this).nodeForPath(path);
+  }
+
   unbox(value) {
     return actuals.get(this).unbox(value);
   }
@@ -84,6 +93,8 @@ export const Context = class AgastContext {
     this.prevTerminals = new WeakMap();
     this.nextTerminals = new WeakMap();
     this.tagNodes = new WeakMap();
+    this.tagPaths = new WeakMap();
+    this.pathNodes = new WeakMap();
     this.unboxedValues = new WeakMap();
     this.facade = new ContextFacade();
 
@@ -129,10 +140,26 @@ export const Context = class AgastContext {
     return ownTerminalsFor(range, this.prevTerminals, this.tagNodes);
   }
 
+  getPreviousTerminal(token) {
+    return this.prevTerminals.get(token);
+  }
+
+  getNextTerminal(token) {
+    return this.nextTerminals.get(token);
+  }
+
   nodeForTag(tag) {
     return this.tagNodes.get(tag);
   }
 
+  pathForTag(ref) {
+    return this.tagPaths.get(ref);
+  }
+
+  nodeForPath(path) {
+    return this.pathNodes.get(path);
+  }
+
   sourceTextFor(range) {
     return sourceTextFor(this.allTerminalsFor(range));
   }

package/lib/evaluate.js

@@ -13,7 +13,8 @@ import {
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { Path, Node } from './path.js';
+import { Path } from './path.js';
+import { Node } from './node.js';
 import { State } from './state.js';
 import { facades } from './facades.js';
 
@@ -84,7 +85,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
           case 'DoctypeTag': {
             const { attributes } = terminal.value;
             const doctypeTag = buildDoctypeTag(attributes);
-            const rootPath = Path.from(ctx);
+            const rootPath = Path.from(ctx, doctypeTag);
 
             if (s.path) {
               throw new Error();
@@ -124,17 +125,18 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               throw new Error('A reference must have a non-reference value');
             }
 
-            if (!s.path.depth) {
+            if (s.node?.flags.token) {
               throw new Error();
             }
 
-            if (s.node.flags.token) {
-              throw new Error();
+            if (s.path.depth) {
+              s.node.resolver.consume(tag);
             }
 
-            s.node.resolver.consume(tag);
-
             s.path = s.path.push(ctx, tag);
+            s.node = null;
+
+            ctx.tagPaths.set(tag, s.path);
 
             yield* s.emit(tag);
 
@@ -147,24 +149,47 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
             if (reference?.type !== 'Reference') throw new Error();
 
-            s.path = s.path.parent;
-
             const gapTag = buildGap();
 
             s.held = null;
 
+            ctx.tagPaths.set(gapTag, s.path);
+
+            s.node = s.parentNode;
+            s.path = s.path.parent;
+
             yield* s.emit(gapTag);
 
             returnValue = gapTag;
             break;
           }
 
+          case 'Null': {
+            const reference = s.result;
+
+            if (reference?.type !== 'Reference') throw new Error();
+
+            const null_ = buildNull();
+
+            ctx.tagPaths.set(null_, s.path);
+
+            s.node = s.parentNode;
+            s.path = s.path.parent;
+
+            yield* s.emit(null_);
+
+            returnValue = null_;
+            break;
+          }
+
           case 'Shift': {
-            const { tagNodes, prevTerminals } = ctx;
             const tag = buildShift();
 
-            const finishedNode = tagNodes.get(s.result);
-            const finishedPath = finishedNode.path;
+            const finishedNode = ctx.nodeForTag(s.result);
+            const ref = ctx.getPreviousTerminal(finishedNode.openTag);
+            const finishedPath = ctx.pathForTag(ref);
+
+            ctx.pathNodes.set(finishedPath, null);
 
             s.held = { node: finishedNode, path: finishedPath };
 
@@ -180,21 +205,6 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             break;
           }
 
-          case 'Null': {
-            const reference = s.result;
-
-            if (reference?.type !== 'Reference') throw new Error();
-
-            s.path = s.path.parent;
-
-            const null_ = buildNull();
-
-            yield* s.emit(null_);
-
-            returnValue = null_;
-            break;
-          }
-
           case 'OpenNodeTag': {
             const { flags, language, type, intrinsicValue, attributes } = terminal.value;
             const { unboundAttributes } = options || {};
@@ -202,10 +212,13 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
             const openTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
 
             if (!type) {
-              s.node = Node.from(s.path, openTag);
+              s.node = Node.from(openTag);
+              ctx.pathNodes.set(s.path, s.node);
+              ctx.pathNodes.set(s.node, s.path);
               ctx.tagNodes.set(openTag, s.node);
+              ctx.tagPaths.set(openTag, s.path);
             } else {
-              if (!flags.trivia && !flags.escape && s.node.type) {
+              if (!flags.trivia && !flags.escape) {
                 if (
                   reference.type !== 'Reference' &&
                   reference.type !== 'Shift' &&
@@ -215,37 +228,35 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
                 }
               }
 
-              const { flags: openFlags } = openTag.value;
-
-              if (!(openFlags.trivia || openFlags.escape) && !s.path.depth) {
-                const tag = buildReference('root', false);
-                s.path = s.path.push(ctx, tag);
-                s.node.resolver.consume(tag);
-              }
-
-              const newNode = s.node.push(s.path, openTag);
+              const newNode = new Node(openTag);
 
               newNode.unboundAttributes = new Set(unboundAttributes);
 
+              s.node = newNode;
+              if (flags.trivia || flags.escape) {
+                s.path = s.path.push(ctx, null);
+              }
+
+              ctx.pathNodes.set(newNode, s.path);
+              ctx.pathNodes.set(s.path, newNode);
               ctx.tagNodes.set(openTag, newNode);
+              ctx.tagPaths.set(openTag, s.path);
 
-              if (!intrinsicValue) {
-                s.node = newNode;
-              } else {
+              if (intrinsicValue) {
+                newNode.closeTag = newNode.openTag;
+                s.node = s.parentNode;
                 s.path = s.path.parent;
 
-                if (s.path.depth > 1) {
-                  const { properties } = s.node;
-                  const { name: refName, isArray } = reference.value;
-
-                  if (!isArray) {
-                    properties.set(refName, [openTag, openTag]);
-                  } else {
-                    if (!properties.has(refName)) {
-                      properties.set(refName, []);
-                    }
-                    properties.get(refName).push([openTag, openTag]);
+                const { properties } = s.node;
+                const { name: refName, isArray } = reference.value;
+
+                if (!isArray) {
+                  properties.set(refName, [openTag, openTag]);
+                } else {
+                  if (!properties.has(refName)) {
+                    properties.set(refName, []);
                   }
+                  properties.get(refName).push([openTag, openTag]);
                 }
               }
             }
@@ -269,7 +280,7 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
 
               if (!type) throw new Error(`CloseNodeTag must have type`);
 
-              if (s.path.depth > 1 && type !== openType)
+              if (type !== openType)
                 throw new Error(
                   `Grammar close {type: ${type}} did not match open {type: ${openType}}`,
                 );
@@ -277,30 +288,26 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
               if (!flags.escape && !flags.trivia) {
                 const { name: refName, isArray } = s.path.reference.value;
 
-                // is this right?
-                if (s.path.depth > 2) {
-                  const { properties } = s.node.parent;
-
-                  if (!isArray) {
-                    properties.set(refName, [openTag, closeTag]);
-                  } else {
-                    if (!properties.has(refName)) {
-                      properties.set(refName, []);
-                    }
-                    properties.get(refName).push([openTag, closeTag]);
+                const { properties } = ctx.nodeForPath(s.path.parent);
+
+                if (!isArray) {
+                  properties.set(refName, [openTag, closeTag]);
+                } else {
+                  if (!properties.has(refName)) {
+                    properties.set(refName, []);
                   }
+                  properties.get(refName).push([openTag, closeTag]);
                 }
               }
 
               ctx.tagNodes.set(closeTag, s.node);
+              ctx.tagPaths.set(closeTag, s.path);
 
               s.node.closeTag = closeTag;
 
-              s.node = s.node.parent;
+              s.node = s.parentNode;
 
-              if (!(flags.trivia || flags.escape)) {
-                s.path = s.path.parent;
-              }
+              s.path = s.path.parent;
             }
 
             yield* s.emit(closeTag, flags.expression);
@@ -347,25 +354,25 @@ const __evaluate = function* agast(ctx, strategy, options = {}) {
         if (value != null) {
           const { flags, language, type, intrinsicValue } = openTag.value;
           const attributes = { ...openTag.value.attributes, [key]: value };
-          const newStartTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
+          const newOpenTag = buildNodeOpenTag(flags, language, type, intrinsicValue, attributes);
 
-          let startNext = ctx.nextTerminals.get(openTag);
+          let openNext = ctx.nextTerminals.get(openTag);
           let startPrev = ctx.prevTerminals.get(openTag);
 
-          ctx.prevTerminals.set(newStartTag, startPrev);
-          ctx.nextTerminals.set(startPrev, newStartTag);
+          ctx.prevTerminals.set(newOpenTag, startPrev);
+          ctx.nextTerminals.set(startPrev, newOpenTag);
 
-          ctx.tagNodes.set(newStartTag, s.node);
+          ctx.tagNodes.set(newOpenTag, ctx.tagNodes.get(openTag));
 
-          if (startNext) {
-            ctx.nextTerminals.set(newStartTag, startNext);
-            ctx.prevTerminals.set(startNext, newStartTag);
+          if (openNext) {
+            ctx.nextTerminals.set(newOpenTag, openNext);
+            ctx.prevTerminals.set(openNext, newOpenTag);
           } else {
             // could this terminal be stored anywhere else?
-            s.result = newStartTag;
+            s.result = newOpenTag;
           }
 
-          s.node.openTag = newStartTag;
+          s.node.openTag = newOpenTag;
         }
 
         if (!unboundAttributes.size) {

package/lib/node.js

@@ -0,0 +1,99 @@
+import { Resolver } 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 actuals.get(this).range;
+  }
+
+  get openTag() {
+    return actuals.get(this).openTag;
+  }
+
+  get closeTag() {
+    return actuals.get(this).closeTag;
+  }
+
+  get flags() {
+    return actuals.get(this).flags;
+  }
+
+  get attributes() {
+    return actuals.get(this).attributes;
+  }
+};
+
+export const Node = class AgastNode {
+  static from(openTag) {
+    return new AgastNode(openTag);
+  }
+
+  constructor(
+    openTag,
+    closeTag = null,
+    properties = new Map(),
+    resolver = new Resolver(),
+    unboundAttributes = null,
+  ) {
+    this.openTag = openTag;
+    this.closeTag = closeTag;
+    this.properties = properties;
+    this.resolver = resolver;
+    this.unboundAttributes = unboundAttributes;
+  }
+
+  get language() {
+    return this.openTag.value?.language;
+  }
+
+  get type() {
+    return this.openTag.value?.type || null;
+  }
+
+  get flags() {
+    return this.openTag.value?.flags || {};
+  }
+
+  get attributes() {
+    return this.openTag.value?.attributes || {};
+  }
+
+  get range() {
+    return [this.openTag, this.closeTag];
+  }
+
+  branch() {
+    const { openTag, closeTag, properties, resolver, unboundAttributes } = this;
+
+    return new Node(
+      openTag,
+      closeTag,
+      new Map(properties), // there is probably a better way
+      resolver.branch(),
+      new Set(unboundAttributes),
+    );
+  }
+
+  accept(node) {
+    this.openTag = node.openTag;
+    this.closeTag = node.closeTag;
+    this.properties = node.properties;
+    this.unboundAttributes = node.unboundAttributes;
+
+    this.resolver.accept(node.resolver);
+
+    return this;
+  }
+};

package/lib/path.js

@@ -1,58 +1,7 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
-import { Resolver } from '@bablr/agast-helpers/tree';
 import { skipToDepth, buildSkips } from './utils/skip.js';
 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 path() {
-    return actuals.get(this).path;
-  }
-
-  get parent() {
-    return facades.get(actuals.get(this).parent);
-  }
-
-  get range() {
-    return actuals.get(this).range;
-  }
-
-  get openTag() {
-    return actuals.get(this).openTag;
-  }
-
-  get closeTag() {
-    return actuals.get(this).closeTag;
-  }
-
-  get depth() {
-    return actuals.get(this).depth;
-  }
-
-  get flags() {
-    return actuals.get(this).flags;
-  }
-
-  get attributes() {
-    return actuals.get(this).attributes;
-  }
-
-  at(depth) {
-    return facades.get(actuals.get(this).at(depth));
-  }
-};
-
 export const PathFacade = class AgastPathFacade {
   constructor(path) {
     facades.set(path, this);
@@ -83,85 +32,6 @@ export const PathFacade = class AgastPathFacade {
   }
 };
 
-export const Node = class AgastNode extends WeakStackFrame {
-  static from(path, openTag) {
-    return AgastNode.create(path, openTag);
-  }
-
-  constructor(
-    path,
-    openTag,
-    closeTag = null,
-    properties = new Map(),
-    resolver = new Resolver(),
-    unboundAttributes = null,
-  ) {
-    super();
-
-    this.path = path;
-    this.openTag = openTag;
-    this.closeTag = closeTag;
-    this.properties = properties;
-    this.resolver = resolver;
-    this.unboundAttributes = unboundAttributes;
-
-    buildSkips(this);
-  }
-
-  get language() {
-    return this.openTag.value?.language;
-  }
-
-  get type() {
-    return this.openTag.value?.type || null;
-  }
-
-  get flags() {
-    return this.openTag.value?.flags || {};
-  }
-
-  get attributes() {
-    return this.openTag.value?.attributes || {};
-  }
-
-  at(depth) {
-    return skipToDepth(depth, this);
-  }
-
-  *parents(includeSelf = false) {
-    if (includeSelf) yield this;
-    let parent = this;
-    while ((parent = parent.parent)) {
-      yield parent;
-    }
-  }
-
-  branch() {
-    const { path, openTag, closeTag, properties, resolver, unboundAttributes } = this;
-
-    return this.replace(
-      path,
-      openTag,
-      closeTag,
-      new Map(properties), // there is probably a better way
-      resolver.branch(),
-      new Set(unboundAttributes),
-    );
-  }
-
-  accept(node) {
-    this.path = node.path;
-    this.openTag = node.openTag;
-    this.closeTag = node.closeTag;
-    this.properties = node.properties;
-    this.unboundAttributes = node.unboundAttributes;
-
-    this.resolver.accept(node.resolver);
-
-    return this;
-  }
-};
-
 export const Path = class AgastPath extends WeakStackFrame {
   static from(context, tag) {
     return Path.create(context, tag);
@@ -170,7 +40,7 @@ export const Path = class AgastPath extends WeakStackFrame {
   constructor(context, reference) {
     super();
 
-    if (reference && reference.type !== 'Reference') {
+    if (reference && reference.type !== 'Reference' && reference.type !== 'DoctypeTag') {
       throw new Error('Invalid reference for path');
     }
 
@@ -182,6 +52,14 @@ export const Path = class AgastPath extends WeakStackFrame {
     new PathFacade(this);
   }
 
+  get name() {
+    return this.reference?.value.name || '[anonymous]';
+  }
+
+  get isArray() {
+    return this.reference?.value.isArray || false;
+  }
+
   at(depth) {
     return skipToDepth(depth, this);
   }

package/lib/state.js

@@ -28,6 +28,10 @@ export const StateFacade = class AgastStateFacade {
     return actuals.get(this).node;
   }
 
+  get parentNode() {
+    return actuals.get(this).parentNode;
+  }
+
   get holding() {
     return actuals.get(this).holding;
   }
@@ -73,7 +77,7 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   *emit(terminal, suppressEmit) {
-    const { prevTerminals, nextTerminals, tagNodes } = this.context;
+    const { prevTerminals, nextTerminals } = this.context;
 
     if (terminal) {
       if (prevTerminals.has(terminal)) {
@@ -107,7 +111,7 @@ export const State = class AgastState extends WeakStackFrame {
         !(
           emittable.type === 'OpenNodeTag' &&
           emittable.value.type &&
-          tagNodes.get(emittable).unboundAttributes?.size
+          this.context.nodeForTag(emittable).unboundAttributes?.size
         )
       ) {
         yield emittable;
@@ -131,20 +135,36 @@ export const State = class AgastState extends WeakStackFrame {
     return !!this.parent;
   }
 
+  get parentNode() {
+    return this.ctx.nodeForPath(this.path.parent);
+  }
+
   branch() {
     const { context, path, node, result, emitted, held } = this;
 
-    return this.push(context, path, node.branch(), result, emitted, held);
+    const newNode = node && node.branch();
+
+    if (newNode?.openTag) context.tagNodes.set(newNode.openTag, newNode);
+    if (newNode?.closeTag) context.tagNodes.set(newNode.closeTag, newNode);
+
+    return this.push(context, path, newNode, result, emitted, held);
   }
 
   accept() {
-    const { parent } = this;
+    const { parent, context } = this;
 
     if (!parent) {
       return null;
     }
 
-    parent.node.accept(this.node);
+    if (this.node && parent.node) {
+      parent.node.accept(this.node, context);
+    } else {
+      parent.node = this.node;
+    }
+
+    if (this.node?.openTag) context.tagNodes.set(parent.node.openTag, parent.node);
+    if (this.node?.closeTag) context.tagNodes.set(parent.node.closeTag, parent.node);
 
     // emitted isn't used here and probably doesn't need to be part of state
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -11,24 +11,19 @@
     ".": "./lib/index.js"
   },
   "sideEffects": false,
-  "scripts": {
-    "test": "node ./test/runner.js"
-  },
   "dependencies": {
-    "@bablr/agast-helpers": "0.1.6",
-    "@bablr/agast-vm-helpers": "0.1.5",
+    "@bablr/agast-helpers": "0.2.0",
+    "@bablr/agast-vm-helpers": "0.2.0",
     "@bablr/coroutine": "0.1.0",
     "@bablr/weak-stack": "0.1.0"
   },
   "devDependencies": {
     "@bablr/agast-vm-strategy-passthrough": "github:bablr-lang/agast-vm-strategy-passthrough#2bd3a0c7311037af92c5b81941c79161499f6c9e",
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
-    "@bablr/strategy_enhancer-debug-log": "0.1.1",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",
     "eslint-plugin-import": "^2.27.5",
-    "expect": "29.7.0",
     "iter-tools-es": "^7.3.1",
     "prettier": "^2.6.2"
   },