@bablr/agast-vm 0.7.0 → 0.8.0

package/lib/evaluate.js

@@ -8,11 +8,11 @@ import {
   buildDoctypeTag,
   buildOpenNodeTag,
   buildCloseNodeTag,
+  buildInitializerTag,
 } from '@bablr/agast-vm-helpers/internal-builders';
 import { getEmbeddedTag } from '@bablr/agast-vm-helpers/deembed';
 import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
 import { printExpression } from '@bablr/agast-helpers/print';
-import { buildArrayInitializerTag } from '@bablr/agast-helpers/tree';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -21,12 +21,14 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
 import { State } from './state.js';
 import { Context } from './context.js';
 import { facades } from './facades.js';
+import { add, TagPath } from '@bablr/agast-helpers/path';
+import { buildNullNode, defineAttribute } from '@bablr/agast-helpers/tree';
 
 export const agast = (strategy, options = {}) => {
   const ctx = Context.create();
@@ -112,13 +114,13 @@ function* __agast(ctx, s, instructions) {
             break;
           }
 
-          case ArrayInitializerTag: {
+          case InitializerTag: {
+            const { isArray } = tag.value;
             const { reference } = s;
 
             if (reference?.type !== ReferenceTag) throw new Error();
-            if (!reference.value.isArray) throw new Error();
 
-            returnValue = s.advance(buildArrayInitializerTag());
+            returnValue = s.advance(buildInitializerTag(isArray));
             break;
           }
 
@@ -126,7 +128,18 @@ function* __agast(ctx, s, instructions) {
             const { index } = tag.value;
             if (s.resultPath.tag.type !== GapTag) throw new Error();
 
-            const refPath = s.resultPath.previousSibling;
+            let prevRef = s.resultPath.previousSibling;
+
+            if (prevRef.tag.type === ShiftTag) {
+              if (prevRef.tag.value.index + 1 !== index) throw new Error('bad shift index');
+            }
+
+            const refPath = TagPath.from(
+              s.resultPath.path,
+              s.resultPath.childrenIndex - (index - 1) * 2 - 1,
+            );
+
+            if (refPath.tag.type !== ReferenceTag) throw new Error();
 
             if (!refPath.tag.value.flags.expression) {
               throw new Error();
@@ -148,6 +161,20 @@ function* __agast(ctx, s, instructions) {
           }
 
           case CloseNodeTag: {
+            for (const { 0: key, 1: value } of Object.entries(s.node.properties)) {
+              if (!Array.isArray(value)) {
+                if (value.node === undefined) {
+                  add(s.node, value.reference, buildNullNode());
+                }
+              }
+            }
+
+            for (const { 0: key, 1: value } of Object.entries(s.node.attributes)) {
+              if (value === undefined) {
+                defineAttribute(s.node, key, null);
+              }
+            }
+
             returnValue = s.advance(buildCloseNodeTag());
             break;
           }

package/lib/state.js

@@ -1,7 +1,6 @@
 import isArray from 'iter-tools-es/methods/is-array';
 import { WeakStackFrame } from '@bablr/weak-stack';
 import {
-  Resolver,
   add,
   finalizeNode,
   getRoot,
@@ -10,9 +9,15 @@ import {
   buildNullTag,
   treeFromStream,
   createNode,
+  buildReferenceTag,
 } from '@bablr/agast-helpers/tree';
-import * as btree from '@bablr/agast-helpers/btree';
-import { TagPath, updatePath } from '@bablr/agast-helpers/path';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
+import {
+  getInitializerChildrenIndex,
+  getPropertyChildrenIndex,
+  referencesAreEqual,
+  TagPath,
+} from '@bablr/agast-helpers/path';
 import {
   DoctypeTag,
   OpenNodeTag,
@@ -21,13 +26,15 @@ import {
   ShiftTag,
   GapTag,
   NullTag,
-  ArrayInitializerTag,
+  InitializerTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
 import { facades, actuals } from './facades.js';
 import { Path } from './path.js';
 import { Coroutine } from '@bablr/coroutine';
 
+const { hasOwn } = Object;
+
 export const StateFacade = class AgastStateFacade {
   constructor(state) {
     facades.set(state, this);
@@ -49,6 +56,10 @@ export const StateFacade = class AgastStateFacade {
     return actuals.get(this).referencePath;
   }
 
+  get unshiftedReferencePath() {
+    return actuals.get(this).unshiftedReferencePath;
+  }
+
   get context() {
     return facades.get(actuals.get(this).context);
   }
@@ -92,7 +103,6 @@ export const State = class AgastState extends WeakStackFrame {
     path = Path.from(createNode()),
     held = null,
     resultPath = null,
-    resolver = new Resolver(),
   ) {
     super(parent);
 
@@ -103,7 +113,7 @@ export const State = class AgastState extends WeakStackFrame {
     this.path = path;
     this.held = held;
     this.resultPath = resultPath;
-    this.resolver = resolver;
+    this.referencePath = null;
 
     if (!this.node) throw new Error();
 
@@ -118,71 +128,84 @@ export const State = class AgastState extends WeakStackFrame {
     return !!this.held;
   }
 
-  advance(tag) {
-    const ctx = this.context;
+  get atReference() {
+    return !![ReferenceTag, ShiftTag].includes(this.resultPath?.tag.type);
+  }
 
+  advance(tag) {
     if (!tag) throw new Error();
 
     let targetPath = this.path;
 
     switch (tag.type) {
       case DoctypeTag: {
-        const { path, node } = this;
+        let { path, node } = this;
 
-        node.children = btree.push(node.children, tag);
-        node.attributes = tag.value.attributes;
+        if (this.resultPath) throw new Error('invalid location for doctype');
 
-        this.resolver.advance(tag);
-        updatePath(this.path, tag);
+        node.children = sumtree.push(node.children, tag);
+        node.attributes = tag.value.attributes;
 
         targetPath = path;
         break;
       }
 
       case ReferenceTag: {
-        this.resolver.advance(tag);
+        let { name, isArray, flags } = tag.value;
+
+        if (this.atReference) throw new Error('invalid location for reference');
+        if (!name) throw new Error('missing reference name');
+        if (!/#|@|[.]|[a-zA-Z]+/.test(name)) throw new Error('invalid reference name');
 
-        this.node.children = btree.push(this.node.children, tag);
-        updatePath(this.path, tag);
+        if (this.node.properties[name] && this.node.properties[name]?.node === undefined) {
+          let existingReferenceIndex = getInitializerChildrenIndex(this.node, tag);
+          let existingReference = sumtree.getAt(existingReferenceIndex, this.node.children);
+          if (!referencesAreEqual(tag, existingReference)) {
+            throw new Error("reference didn't match initializer");
+          }
+        }
 
-        const { hasGap } = tag.value;
+        this.node.children = sumtree.push(this.node.children, tag);
 
-        if (hasGap && !this.node.flags.hasGap) {
+        if (flags.hasGap && !this.node.flags.hasGap) {
           throw new Error('gap reference in gapless node');
         }
 
+        this.referencePath = TagPath.from(this.path, -1);
+
         break;
       }
 
       case OpenNodeTag: {
-        const parentNode = this.node;
+        let parentNode = this.node;
 
         targetPath = this.path;
 
+        if (!this.atReference && this.parent) {
+          throw new Error('Invalid location for OpenNodeTag');
+        }
+
         if (!this.path.depth) {
           this.node.flags = tag.value.flags;
-          this.node.children = btree.push(this.node.children, tag);
+          this.node.children = sumtree.push(this.node.children, tag);
           this.node.type = tag.value.type;
           this.node.language = tag.value.language;
           this.node.attributes = tag.value.attributes || {};
         } else {
           let node = createNode(tag);
-          this.path = this.path.push(node, btree.getSum(parentNode.children) - 2);
+          this.path = this.path.push(node, sumtree.getSize(parentNode.children) - 2);
           add(parentNode, this.reference, node);
         }
 
-        this.resolver.advance(tag);
-        updatePath(this.path, tag);
-
         break;
       }
 
       case CloseNodeTag: {
-        this.resolver.advance(tag);
-        this.node.children = btree.push(this.node.children, tag);
-        updatePath(this.path, tag);
+        if (this.atReference) throw new Error('invalid location for close tag');
+
+        this.node.children = sumtree.push(this.node.children, tag);
 
-        if (this.node.unboundAttributes?.size)
+        if (this.node.undefinedAttributes?.size)
           throw new Error('Grammar failed to bind all attributes');
 
         finalizeNode(this.node);
@@ -194,21 +217,16 @@ export const State = class AgastState extends WeakStackFrame {
       case GapTag: {
         let target;
         let lastTagPath = TagPath.from(this.path, -1);
-        let refPath = lastTagPath;
 
-        while (refPath && refPath.tag.type !== ReferenceTag) {
-          refPath = refPath.previousSibling;
+        if (!this.atReference) {
+          throw new Error('Invalid location for GapTag');
         }
 
-        this.resolver.advance(tag);
-
-        let wasHeld = this.held;
-
         if (this.held && lastTagPath.tag.type !== ShiftTag) {
           target = this.held.node;
 
           this.held = null;
-        } else if (refPath) {
+        } else {
           this.expressions.advance();
 
           if (!this.expressions.done) {
@@ -230,57 +248,83 @@ export const State = class AgastState extends WeakStackFrame {
           }
 
           this.held = null;
-        } else {
-          this.node.language = null;
-          this.node.type = null;
-          target = this.node;
         }
 
         const range = getRange(target);
 
         this.resultPath = range ? range[1] : this.resultPath;
+        this.referencePath = null;
+
+        let lastRefPath = [ShiftTag, ReferenceTag].includes(lastTagPath.tag.type)
+          ? lastTagPath
+          : lastTagPath.previousSibling;
+
+        if (![ShiftTag, ReferenceTag].includes(lastRefPath.tag.type)) throw new Error();
+
+        let refTag = lastRefPath.tag;
+
+        if (refTag.type === ShiftTag) {
+          let refIndex = lastRefPath.childrenIndex - lastRefPath.tag.value.index * 2;
+          refTag = sumtree.getAt(refIndex, this.node.children);
+        }
 
-        if (refPath) {
-          add(this.path.node, refPath.tag, target, wasHeld);
+        if (refTag) {
+          add(
+            this.path.node,
+            refTag,
+            target,
+            lastRefPath.tag.type === ShiftTag
+              ? lastRefPath.tag.value.index
+              : refTag.value.flags.expression
+              ? 0
+              : null,
+          );
         }
 
-        updatePath(this.path, tag);
         break;
       }
 
       case NullTag: {
         const { node: parentNode, reference } = this;
-        const { name } = reference.value;
-
-        this.resolver.advance(tag);
-        updatePath(this.path, tag);
 
-        if (!name) throw new Error();
+        if (!this.atReference && this.parent) {
+          throw new Error('Invalid location for OpenNodeTag');
+        }
 
         let stubNode = buildStubNode(tag);
 
         add(parentNode, reference, stubNode);
 
-        targetPath = this.path.push(stubNode, btree.getSum(this.node.children) - 2);
+        targetPath = this.path.push(stubNode, sumtree.getSize(this.node.children) - 2);
         break;
       }
 
-      case ArrayInitializerTag: {
+      case InitializerTag: {
+        const { isArray } = tag.value;
         const { node, reference } = this;
-        this.resolver.advance(tag);
+        const { name } = reference.value;
 
-        add(node, reference, []);
-        updatePath(this.path, tag);
+        if (!this.atReference && this.parent) {
+          throw new Error('Invalid location for OpenNodeTag');
+        }
+
+        if (node.properties[name] && node.properties[name]?.node === undefined) {
+          throw new Error();
+        }
+
+        add(node, reference, isArray ? [] : undefined);
         break;
       }
 
       case ShiftTag: {
-        this.resolver.advance(tag);
-        updatePath(this.path, tag);
+        if (this.atReference) throw new Error('invalid location for shift');
 
         const finishedPath = this.resultPath.innerPath;
         const finishedNode = finishedPath.node;
-        const ref = this.resultPath.previousSibling.tag;
+        const ref = TagPath.from(
+          this.resultPath,
+          this.resultPath.childrenIndex - tag.value.index * 2 + 1,
+        ).tag;
 
         this.held = { node: finishedNode, path: finishedPath };
 
@@ -288,7 +332,9 @@ export const State = class AgastState extends WeakStackFrame {
 
         if (!ref.value.flags.expression) throw new Error();
 
-        this.node.children = btree.push(this.node.children, tag);
+        this.node.children = sumtree.push(this.node.children, tag);
+
+        this.referencePath = TagPath.from(this.path, -1);
 
         // this.path = finishedPath;
         targetPath = this.path;
@@ -296,9 +342,9 @@ export const State = class AgastState extends WeakStackFrame {
       }
 
       case LiteralTag:
-        this.resolver.advance(tag);
-        updatePath(this.path, tag);
-        this.node.children = btree.push(this.node.children, tag);
+        if (typeof tag.value !== 'string') throw new Error();
+
+        this.node.children = sumtree.push(this.node.children, tag);
         break;
 
       default:
@@ -327,11 +373,7 @@ export const State = class AgastState extends WeakStackFrame {
   }
 
   get reference() {
-    return this.resolver.reference;
-  }
-
-  get referencePath() {
-    return this.reference && this.path.referencePath;
+    return this.referencePath.tag;
   }
 
   get node() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm",
   "description": "A VM providing DOM-like guarantees about agAST trees",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,10 +12,10 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.6.0",
-    "@bablr/agast-vm-helpers": "0.6.0",
+    "@bablr/agast-helpers": "0.7.0",
+    "@bablr/agast-vm-helpers": "0.7.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/weak-stack": "0.1.0",
+    "@bablr/weak-stack": "1.0.0",
     "@iter-tools/imm-stack": "1.1.0"
   },
   "devDependencies": {