@bablr/boot 0.9.0 → 0.11.0

package/lib/miniparser.js

@@ -4,25 +4,33 @@ import isString from 'iter-tools-es/methods/is-string';
 import isObject from 'iter-tools-es/methods/is-object';
 import find from 'iter-tools-es/methods/find';
 import every from 'iter-tools-es/methods/every';
-import * as sym from '@bablr/agast-vm-helpers/symbols';
 import { Match } from './match.js';
 import { isRegex, isArray, getPrototypeOf } from './utils.js';
 import { ReferenceTag, LiteralTag } from '@bablr/agast-helpers/symbols';
 import {
   buildCloseNodeTag,
   buildLiteralTag,
+  buildNullTag,
   buildOpenNodeTag,
   buildReferenceTag,
+  buildShiftTag,
   nodeFlags,
 } from '@bablr/agast-helpers/builders';
-import { add, buildToken, shift } from '@bablr/agast-helpers/tree';
-import * as sumtree from '@bablr/agast-helpers/children';
-import { buildPathSegment, get } from '@bablr/agast-helpers/path';
+import { buildToken } from '@bablr/agast-helpers/tree';
+import * as Tags from '@bablr/agast-helpers/tags';
+import {
+  buildNode,
+  buildNullNode,
+  buildPathSegment,
+  get,
+  getTags,
+  Path,
+} from '@bablr/agast-helpers/path';
 import { parseReference } from '@bablr/agast-helpers/shorthand';
 
-const Escape = Symbol.for('Escape');
+let Escape = Symbol.for('Escape');
 
-const getProduction = (grammar, type) => {
+let getProduction = (grammar, type) => {
   return getPrototypeOf(grammar)[type];
 };
 
@@ -82,11 +90,13 @@ export class TemplateParser {
   }
 
   get matchIsNode() {
-    return this.language.covers.get(sym.node).has(this.m.type) && !this.matchIsCover;
+    return (
+      this.language.covers.get(Symbol.for('@bablr/node')).has(this.m.name) && !this.matchIsCover
+    );
   }
 
   get matchIsCover() {
-    return this.language.covers.has(this.m.type);
+    return this.language.covers.has(this.m.name);
   }
 
   get matchIsFragment() {
@@ -102,27 +112,27 @@ export class TemplateParser {
   }
 
   get slicedQuasi() {
-    const { idx, quasi } = this;
+    let { idx, quasi } = this;
     return quasi.slice(idx);
   }
 
   get guardedSlicedQuasi() {
-    const { span, slicedQuasi } = this;
-    const { guard } = span;
+    let { span, slicedQuasi } = this;
+    let { guard } = span;
 
     if (!guard) return slicedQuasi;
 
-    const pat = new RegExp(escapeRegex(guard), 'y');
-    const res = pat.exec(slicedQuasi);
+    let pat = new RegExp(escapeRegex(guard), 'y');
+    let res = pat.exec(slicedQuasi);
 
     return res ? slicedQuasi.slice(0, pat.lastIndex - res[0].length) : slicedQuasi;
   }
 
   matchSticky(pattern, attrs) {
-    const { slicedQuasi, guardedSlicedQuasi } = this;
-    const { balancer } = attrs;
+    let { slicedQuasi, guardedSlicedQuasi } = this;
+    let { balancer } = attrs;
 
-    const source = balancer ? slicedQuasi : guardedSlicedQuasi;
+    let source = balancer ? slicedQuasi : guardedSlicedQuasi;
 
     if (isString(pattern)) {
       return source.startsWith(pattern) ? pattern : null;
@@ -130,7 +140,7 @@ export class TemplateParser {
       if (!pattern.sticky) throw new Error('be sticky!');
       pattern.lastIndex = 0;
 
-      const result = pattern.exec(source);
+      let result = pattern.exec(source);
 
       return result ? result[0] : null;
     } else {
@@ -138,10 +148,19 @@ export class TemplateParser {
     }
   }
 
-  eval(id, attrs = {}, props = {}, shift_ = null) {
-    const parentMatch = this.m;
-    const parentPath = this.path?.node ? this.path : this.path?.parent;
-    const { type } = id;
+  eatProduction(_id, attrs = {}, props = {}, shift_ = null) {
+    if (_id === null) {
+      let path_ = parseReference(attrs.path);
+
+      this.path.node = Path.from(this.node).advance(path_).advance(buildNullNode()).node;
+
+      return null;
+    }
+    let id = isObject(_id) ? _id : this.buildId(_id);
+
+    let parentMatch = this.m;
+    let parentPath = this.path?.node ? this.path : this.path?.parent;
+    let { name } = id;
 
     if (parentMatch && this.matchIsNode) {
       if (this.matchIsCover && Object.keys(attrs).length) {
@@ -155,39 +174,36 @@ export class TemplateParser {
       this.m = Match.from(this.rootLanguage, id, attrs);
     }
 
-    const { covers } = this.language;
-    const isNode = this.matchIsNode;
-    const isCover = this.matchIsCover;
-    const isEmbedded = this.language !== this.m.parent?.resolvedLanguage;
-    const { path, grammar } = this;
+    let { covers } = this.language;
+    let isNode = this.matchIsNode;
+    let isCover = this.matchIsCover;
+    let isEmbedded = this.language !== this.m.parent?.resolvedLanguage;
+    let { path, grammar } = this;
 
-    if (!type) throw new Error('eval requires a type');
+    if (!name) throw new Error('eval requires a type');
 
     if (parentPath?.node && this.atExpression && !attrs.noInterpolate && (isNode || isCover)) {
-      const { quasisDone } = this;
+      let { quasisDone } = this;
 
       if (quasisDone) throw new Error('there must be more quasis than expressions');
 
-      const result = this.expression;
+      let result = this.expression;
 
       this.expressionIdx++;
       this.quasiIdx++;
       this.idx = 0;
 
-      if (parentPath?.node && (isNode || covers.has(type))) {
-        const { node } = parentPath;
-        const path = parseReference(this.m.attrs.path);
+      if (!parentPath?.node || isNode || covers.has(name)) {
+        let path = parseReference(this.m.attrs.path);
 
         if (isArray(result)) {
-          for (const value of result) {
-            node.children = sumtree.push(node.children, path);
-
-            add(node, path, value);
+          for (let value of result) {
+            parentPath.node = Path.from(parentPath.node).advance(path).advance(value).node;
           }
         } else {
-          node.children = sumtree.push(node.children, path);
-
-          add(node, path, result);
+          parentPath.node = Path.from(parentPath.node)
+            .advance(path)
+            .advance(result ? result : buildNullTag()).node;
         }
       }
     } else {
@@ -195,42 +211,44 @@ export class TemplateParser {
         this.spans.push({ type: 'Bare', guard: null });
       }
 
-      if (!getProduction(grammar, type)) {
-        throw new Error(`Unknown production {type: ${type}}`);
+      if (!getProduction(grammar, name)) {
+        throw new Error(`Unknown production {type: ${name}}`);
       }
 
-      if (isNode) {
-        let { node } = this.path;
-        node.children = sumtree.push(node.children, buildOpenNodeTag(nodeFlags, node.type));
-      }
+      // if (isNode) {
+      //   let { node } = this.path;
+      //   this.path.node = Path.from(node).advance(buildOpenNodeTag(nodeFlags, node.type)).node;
+      // }
 
-      const result = getPrototypeOf(grammar)[type].call(grammar, this, props);
+      let result = getPrototypeOf(grammar)[name].call(grammar, this, props);
 
       if (isEmbedded) {
         this.spans.pop();
       }
 
-      if (isNode) {
-        const { node } = this.path;
+      if (isNode || !parentPath) {
         if (result?.attrs) {
-          node.attributes = result.attrs;
-          node.children = sumtree.replaceAt(
-            0,
-            node.children,
-            buildOpenNodeTag(nodeFlags, node.type, result.attrs),
-          );
+          this.path.node = Path.from(this.node).replaceWith(
+            buildNode(
+              Tags.replaceAt(
+                0,
+                this.path.node.value.tags,
+                buildOpenNodeTag(nodeFlags, this.path.name, isCover ? '_' : null, result.attrs),
+              ),
+            ),
+          ).node;
         }
 
-        node.children = sumtree.push(node.children, buildCloseNodeTag());
+        this.path.node = Path.from(this.node).advance(buildCloseNodeTag()).node;
 
-        if (parentPath?.node && !covers.has(type)) {
-          const path = parseReference(this.m.attrs.path);
+        if (parentPath?.node && !covers.has(name)) {
+          let path = this.m.attrs.path
+            ? parseReference(this.m.attrs.path)
+            : buildReferenceTag(parentPath.node.value.type === Symbol.for('_') ? '_' : '.');
 
-          if (shift_ == null) {
-            add(parentPath.node, path, node);
-          } else {
-            shift(parentPath.node, path, node);
-          }
+          parentPath.node = Path.from(parentPath.node)
+            .advance(shift_ == null ? path : buildShiftTag())
+            .advance(this.node).node;
         }
       }
 
@@ -242,11 +260,11 @@ export class TemplateParser {
     this.m = this.m.parent;
 
     if (this.path?.node) {
-      const isTag = (child) => [LiteralTag, Escape].includes(child.type);
+      let isTag = (child) => [LiteralTag, Escape].includes(child.type);
 
-      const { children } = this.path.node;
+      let tags = getTags(this.path.node);
 
-      if (find(isTag, sumtree.traverse(children)) && every(isTag, sumtree.traverse(children))) {
+      if (find(isTag, Tags.traverse(tags)) && every(isTag, Tags.traverse(tags))) {
         throw new Error('strings must be wrapped in nodes');
       }
     }
@@ -254,7 +272,7 @@ export class TemplateParser {
   }
 
   updateSpans(attrs) {
-    const { startSpan, endSpan, balanced, balancer } = attrs;
+    let { startSpan, endSpan, balanced, balancer } = attrs;
     if (endSpan || balancer) {
       if (!this.span.guard) {
         throw new Error('Only balanced spans can be closed with endSpan');
@@ -262,51 +280,50 @@ export class TemplateParser {
       this.popSpan();
     }
     if (startSpan || balanced) {
-      const type = startSpan || this.span.type;
+      let type = startSpan || this.span.type;
       this.pushSpan({ type, guard: balanced });
     }
   }
 
   buildId(id) {
-    let type;
+    let name;
     let language = this.language.name;
 
     if (id.includes(':')) {
-      ({ 0: language, 1: type } = id.split(':'));
+      ({ 0: language, 1: name } = id.split(':'));
     } else {
-      type = id;
+      name = id;
     }
 
-    return { type, language };
-  }
-
-  eatProduction(id, attrs = {}, props = {}) {
-    return this.eval(this.buildId(id), attrs, props);
+    return {
+      name,
+      language,
+    };
   }
 
-  eatHeldProduction(type, attrs) {
+  eatHeldProduction(name, attrs) {
     if (!this.held) {
       throw new Error();
     }
 
-    const { held, node } = this;
+    let { held, node } = this;
 
     this.held = null;
 
-    const path = parseReference(attrs.path);
+    let path = parseReference(attrs.path);
 
-    add(node, path, held);
+    this.path.node = Path.from(node).advance(path).advance(held).node;
 
     return held;
   }
 
   shiftProduction(id, attrs = {}, props = {}) {
-    const { node } = this;
+    let { node } = this;
     // don't push a new path onto the stack
 
     // get the most recently produced node and detach it from its parent
 
-    const ref = sumtree.getAt(-3, node.children);
+    let ref = Tags.getAt(-1, getTags(node)).value.tags[0];
 
     if (!ref.value.flags.expression) throw new Error();
 
@@ -316,22 +333,20 @@ export class TemplateParser {
 
     this.held = get(buildPathSegment(ref.value.name, -1), node);
 
-    let id_ = this.buildId(id);
-
-    const shifted = this.eval(id_, attrs, props, 1);
+    let shifted = this.eatProduction(id, attrs, props, 1);
 
     // shift(node, ref, shifted);
 
     return shifted;
   }
 
-  eat(pattern, type, attrs) {
-    if (!isString(type)) throw new Error('Cannot eat anonymous token');
+  eat(pattern, name, attrs) {
+    if (name && !isString(name)) throw new Error('bad name');
     if (!isObject(attrs) || !attrs.path) throw new Error('a node must have a path');
 
-    const { path, ..._attrs } = attrs;
+    let { path, ..._attrs } = attrs;
 
-    const result = this.matchSticky(pattern, attrs, this);
+    let result = this.matchSticky(pattern, attrs, this);
 
     if (!result) this.fail();
 
@@ -339,9 +354,11 @@ export class TemplateParser {
 
     this.updateSpans(attrs);
 
-    const path_ = parseReference(attrs.path);
+    let path_ = parseReference(attrs.path);
 
-    add(this.node, path_, buildToken(type, result, _attrs));
+    this.path.node = Path.from(this.node)
+      .advance(path_)
+      .advance(buildToken(name, result, _attrs)).node;
 
     return result;
   }
@@ -351,99 +368,111 @@ export class TemplateParser {
     return this.matchSticky(pattern, attrs, this);
   }
 
-  eatMatch(pattern, type, attrs) {
-    if (!isString(type)) throw new Error('Cannot eatMatch anonymous token');
+  eatMatch(pattern, name, attrs) {
+    if (name && !isString(name)) throw new Error('bad name');
     if (!isObject(attrs) || !attrs.path) throw new Error('a node must have a path');
 
-    const result = this.matchSticky(pattern, attrs, this);
+    let result = this.matchSticky(pattern, attrs, this);
 
     if (result) {
       this.updateSpans(attrs);
 
       this.idx += result.length;
 
-      const path = parseReference(attrs.path);
+      let { path, ..._attrs } = attrs;
+
+      let path_ = parseReference(path);
 
-      add(this.node, path, buildToken(type, result));
+      this.path.node = Path.from(this.node)
+        .advance(path_)
+        .advance(buildToken(name, result, _attrs)).node;
     }
     return result;
   }
 
   eatTrivia(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (!result) this.fail();
 
     this.idx += result.length;
 
-    add(this.node, buildReferenceTag('#'), buildToken('Space', result));
+    this.path.node = Path.from(this.node)
+      .advance(buildReferenceTag('#'))
+      .advance(buildToken('Space', result)).node;
 
     return result;
   }
 
   eatMatchTrivia(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (result) {
       this.idx += result.length;
 
-      add(this.node, buildReferenceTag('#'), buildToken('Space', result));
+      this.path.node = Path.from(this.node)
+        .advance(buildReferenceTag('#'))
+        .advance(buildToken('Space', result)).node;
     }
 
     return result;
   }
 
   eatEscape(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (!result) this.fail();
 
     this.idx += result.length;
 
-    const raw = result;
-    const cooked = this.language.cookEscape(result, this.span);
-    const attributes = { cooked };
+    let raw = result;
+    let cooked = this.language.cookEscape(result, this.span);
+    let attributes = { cooked };
 
-    add(this.node, buildReferenceTag('@'), buildToken('Escape', raw, attributes));
+    this.path.node = Path.from(this.node)
+      .advance(buildReferenceTag('@'))
+      .advance(buildToken('Escape', raw, attributes)).node;
 
     return result;
   }
 
   eatMatchEscape(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (result) {
       this.idx += result.length;
 
-      const raw = result;
-      const cooked = this.language.cookEscape(result, this.span);
-      const attributes = { cooked };
+      let raw = result;
+      let cooked = this.language.cookEscape(result, this.span);
+      let attributes = { cooked };
 
-      add(this.node, buildReferenceTag('@'), buildToken('Escape', raw, attributes));
+      this.path.node = Path.from(this.node)
+        .advance(buildReferenceTag('@'))
+        .advance(buildToken('Escape', raw, attributes)).node;
     }
 
     return result;
   }
 
   eatLiteral(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (!result) this.fail();
 
     this.idx += result.length;
 
-    this.node.children = sumtree.push(this.node.children, buildLiteralTag(result));
+    this.path.node = buildNode(Tags.push(this.node.value.tags, buildLiteralTag(result)));
 
     return result;
   }
 
   eatMatchLiteral(pattern) {
-    const result = this.matchSticky(pattern, {}, this);
+    let result = this.matchSticky(pattern, {}, this);
 
     if (result) {
       this.idx += result.length;
 
-      this.node.children = sumtree.push(this.node.children, buildLiteralTag(result));
+      this.path.node = buildNode(Tags.push(this.node.value.tags, buildLiteralTag(result)));
     }
 
     return result;
@@ -466,6 +495,6 @@ export class TemplateParser {
   }
 
   fail() {
-    throw new Error(`miniparser: parsing \`${this.quasis}\` failed`);
+    throw new Error(`miniparser: parsing \`${this.guardedSlicedQuasi}\` failed`);
   }
 }

package/lib/path.js

@@ -1,11 +1,9 @@
-const { hasOwn } = Object;
-const { isArray } = Array;
-
 export class Path {
   constructor(id, attributes, parent = null) {
     this.id = id;
     this.attributes = attributes;
     this.parent = parent;
+    this.depth = parent ? parent.depth + 1 : 0;
 
     this.node = null;
   }
@@ -26,6 +24,10 @@ export class Path {
     return this.id.type;
   }
 
+  get name() {
+    return this.id.name;
+  }
+
   generate(id, attrs) {
     return new Path(id, attrs, this);
   }
@@ -34,36 +36,3 @@ export class Path {
     return new Path(id, attrs);
   }
 }
-
-export class PathResolver {
-  constructor(node) {
-    this.node = node;
-    this.counters = {};
-  }
-
-  get(path) {
-    const { node, counters } = this;
-
-    const { isArray: pathIsArray, name } = path;
-
-    if (!hasOwn(node.properties, name)) {
-      throw new Error(`cannot resolve {path: ${name}}`);
-    }
-
-    let value = node.properties[name];
-
-    if (pathIsArray) {
-      if (!isArray(value)) {
-        throw new Error(`cannot resolve {path: ${name}}: not an array`);
-      }
-
-      const counter = counters[name] ?? 0;
-
-      counters[name] = counter + 1;
-
-      value = value[counter];
-    }
-
-    return value;
-  }
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bablr/boot",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Compile-time tools for bootstrapping BABLR VM",
   "engines": {
     "node": ">=12.0.0"
@@ -20,9 +20,9 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.8.0",
-    "@bablr/agast-vm-helpers": "0.8.0",
-    "@iter-tools/imm-stack": "1.1.0",
+    "@bablr/agast-helpers": "0.10.0",
+    "@bablr/agast-vm-helpers": "0.10.0",
+    "@iter-tools/imm-stack": "1.2.0",
     "escape-string-regexp": "5.0.0",
     "iter-tools-es": "^7.0.2"
   },
@@ -40,7 +40,10 @@
     "expect": "^29.6.2",
     "prettier": "^2.0.5"
   },
-  "repository": "git@github.com:bablr-lang/boot.git",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/bablr-lang/boot.git"
+  },
   "homepage": "https://github.com/bablr-lang/boot",
   "author": "Conrad Buck <conartist6@gmail.com>",
   "license": "MIT"