@bablr/agast-vm-helpers 0.7.0 → 0.8.0

package/lib/builders.js

@@ -20,6 +20,11 @@ export const buildEmbeddedObject = (obj) => {
   return freeze({ type: EmbeddedObject, value: freeze(obj) });
 };
 
+export const buildEmbeddedNode = (node) => {
+  if (!isObject(node)) throw new Error();
+  return freeze({ type: EmbeddedNode, value: freeze(node) });
+};
+
 export const buildEmbeddedMatcher = (matcher) => {
   if (!isObject(matcher)) throw new Error();
   return freeze({ type: EmbeddedMatcher, value: matcher });

package/lib/embed.js

@@ -1,4 +1,4 @@
-import { buildEmbeddedObject } from './internal-builders.js';
+import { buildEmbeddedObject } from './builders';
 
 const { isArray } = Array;
 const isString = (val) => typeof val === 'string';

package/lib/index.js

@@ -3,44 +3,49 @@ import {
   getCooked,
   isNull,
   nodeFlags,
-  printType,
-  buildGapTag,
   isNullNode,
-  buildNullTag,
   buildStubNode,
   isFragmentNode,
   buildReferenceTag,
+  getRoot,
+  buildChild,
 } from '@bablr/agast-helpers/tree';
 import * as btree from '@bablr/agast-helpers/btree';
-import * as sumtree from '@bablr/agast-helpers/sumtree';
+import * as sumtree from '@bablr/agast-helpers/children';
 import {
+  buildGapTag,
+  buildNullTag,
+  buildOpenNodeTag,
+  buildBindingTag,
+  buildInitializerTag,
+  buildShiftTag,
   buildCloseNodeTag,
   buildLiteralTag,
   buildDoctypeTag,
   referenceFlags,
+  buildProperty,
 } from '@bablr/agast-helpers/builders';
+import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
 import {
-  DoctypeTag,
-  OpenNodeTag,
-  CloseNodeTag,
-  ShiftTag,
+  AttributeDefinition,
   GapTag,
-  NullTag,
   InitializerTag,
   LiteralTag,
-} from '@bablr/agast-helpers/symbols';
-import { buildEmbeddedMatcher, buildEmbeddedRegex } from './builders.js';
+  NullTag,
+  Property,
+} from './symbols.js';
+import { isStubNode } from '@bablr/agast-helpers/path';
 
 const { freeze } = Object;
 
 export const effectsFor = (verb) => {
   switch (verb) {
     case 'eat':
-    case 'holdFor':
+    case 'shift':
       return { success: 'eat', failure: 'fail' };
 
     case 'eatMatch':
-    case 'holdForMatch':
+    case 'shiftMatch':
       return { success: 'eat', failure: 'none' };
 
     case 'match':
@@ -78,63 +83,32 @@ export const reifyReferenceFlags = (flags) => {
   };
 };
 
-export const reifyLanguage = (language) => {
-  const value = reifyExpression(language);
-
-  return typeof value === 'string' && !value.startsWith('https://') ? [value] : value;
-};
-
-export const reifyProperties = (properties = []) => {
+export const reifyProperties = (properties = { node: [] }) => {
   const built = {};
-  for (const property of btree.traverse(properties)) {
+  for (const property of btree.traverse(properties.node)) {
     switch (property.node.type) {
       case Symbol.for('Property'): {
         let { reference, value: node } = property.node.properties;
 
-        reference = reifyExpression(reference.node);
+        reference = reference ? reifyExpression(reference.node) : buildReferenceTag('.');
         node = reifyExpression(node.node);
 
-        if (reference.value.isArray) {
-          built[reference.value.name] ||= [];
-          built[reference.value.name].push({ reference, node });
-        } else {
-          built[reference.value.name] = { reference, node };
+        let { name, isArray } = reference.value;
+        if (name) {
+          if (isArray) {
+            built[name] ||= [];
+            built[name].push({ reference, node });
+          } else {
+            built[name] = { reference, node };
+          }
         }
         break;
       }
-      default:
-        throw new Error();
     }
   }
   return built;
 };
 
-export const buildFragmentChildren = (node) => {
-  let { open, children = [], close } = node.properties;
-
-  let built = [];
-
-  open = reifyExpression(open.node);
-  close = reifyExpression(close.node);
-
-  built = sumtree.push(built, open);
-
-  for (const child of sumtree.traverse(children)) {
-    if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
-
-    let { reference } = child.node.properties;
-
-    reference = reifyExpression(reference.node);
-
-    built = sumtree.push(built, reference);
-    built = sumtree.push(built, buildGapTag());
-  }
-
-  built = sumtree.push(built, close);
-
-  return built;
-};
-
 export const buildChildren = (node) => {
   let { open, children = [], close } = node.properties;
 
@@ -148,20 +122,42 @@ export const buildChildren = (node) => {
   if (selfClosing) {
     built = sumtree.push(built, open);
     if (!isNull(intrinsicValue?.node)) {
-      built = sumtree.push(built, buildLiteralTag(intrinsicValue.node));
+      built = sumtree.push(built, buildLiteralTag(reifyExpression(intrinsicValue.node)));
     }
     built = sumtree.push(built, buildCloseNodeTag());
   } else {
     built = sumtree.push(built, open);
-    for (const child of sumtree.traverse(children)) {
+    for (const child of sumtree.traverse(children.node)) {
+      if ([AttributeDefinition, LiteralTag].includes(child.node.type)) {
+        built = sumtree.push(built, reifyExpression(child.node));
+        continue;
+      }
+
       if (child.node.type !== Symbol.for('Property')) throw new Error('umimplemented');
 
-      let { reference } = child.node.properties;
+      let { reference, binding, value } = child.node.properties;
+
+      let referenceTag = reference ? reifyExpression(reference.node) : buildReferenceTag('.');
+      let bindingTag = binding
+        ? reifyExpression(binding.node)
+        : buildBindingTag(isStubNode(value.node) ? null : []);
 
-      reference = reifyExpression(reference.node);
+      value = reifyExpression(value.node);
+
+      if (value.type === NullTag || value.type === GapTag) {
+        value = buildStubNode(value);
+      }
 
-      built = sumtree.push(built, reference);
-      built = sumtree.push(built, buildGapTag());
+      built = sumtree.push(built, referenceTag);
+      if (value.type === InitializerTag) {
+        built = sumtree.push(built, value);
+      } else {
+        built = sumtree.push(built, bindingTag);
+        built = sumtree.push(
+          built,
+          buildChild(Property, buildProperty(referenceTag.value, buildBindingTag().value, value)),
+        );
+      }
     }
 
     built = sumtree.push(built, close);
@@ -177,167 +173,126 @@ export const reifyExpression = (node) => {
   if (isNullNode(node)) return null;
 
   if (isFragmentNode(node)) {
-    node = node.properties['.'].node;
+    node = getRoot(node);
   }
 
-  if (node.language === 'https://bablr.org/languages/core/en/cstml') {
-    switch (node.type?.description || node.type) {
-      case 'Document': {
-        let { doctype, tree } = node.properties;
-
-        doctype = reifyExpression(doctype.node);
-        tree = reifyExpression(tree.node);
-
-        let { attributes } = doctype.value;
-        let { properties } = tree;
-
-        return {
-          flags: nodeFlags,
-          language: attributes.bablrLanguage,
-          type: null,
-          children: sumtree.addAt(
-            0,
-            buildFragmentChildren(node.properties.tree.node),
-            buildDoctypeTag(attributes),
-          ),
-          properties,
-          attributes,
-        };
-      }
-
-      case 'Node': {
-        let { open, children } = node.properties;
+  switch (node.type?.description || node.type) {
+    case 'Document': {
+      let { doctype, tree } = node.properties;
 
-        open = reifyExpression(open.node);
+      doctype = reifyExpression(doctype.node);
+      tree = reifyExpression(tree.node);
 
-        let { flags, language, type, attributes } = open.value;
+      let { attributes } = doctype.value;
+      let { properties } = tree;
 
-        const properties = reifyProperties(children);
-
-        return {
-          flags,
-          language,
-          type,
-          children: buildChildren(node),
-          properties,
-          attributes,
-        };
-      }
+      return Object.freeze({
+        flags: nodeFlags,
+        type: null,
+        children: sumtree.addAt(
+          0,
+          buildChildren(node.properties.tree.node),
+          buildDoctypeTag(attributes),
+        ),
+        properties,
+        attributes,
+      });
+    }
 
-      case 'Fragment': {
-        let { open, children } = node.properties;
+    case 'Node': {
+      let { open, children } = node.properties;
 
-        open = reifyExpression(open.node);
+      open = reifyExpression(open.node);
 
-        let { flags } = open.value;
+      let { flags, type, attributes } = open.value;
 
-        const properties = reifyProperties(children);
+      const properties = reifyProperties(children);
 
-        return {
-          flags,
-          language: null,
-          type: null,
-          children: buildChildren(node),
-          properties,
-          attributes: {},
-        };
-      }
+      return Object.freeze({
+        flags,
+        type,
+        children: buildChildren(node),
+        properties,
+        attributes,
+      });
+    }
 
-      case 'DoctypeTag': {
-        let { doctypeToken, version, attributes } = node.properties;
-        return {
-          type: DoctypeTag,
-          value: {
-            doctypeToken: getCooked(doctypeToken?.node),
-            version: parseInt(sourceTextFor(version.node), 10),
-            attributes: reifyExpression(attributes.node),
-          },
-        };
-      }
+    case 'DoctypeTag': {
+      let { version, attributes } = node.properties;
+      return buildDoctypeTag(
+        attributes && reifyExpression(attributes.node),
+        parseInt(sourceTextFor(version.node), 10),
+      );
+    }
 
-      case 'ReferenceTag': {
-        let { name, arrayOperatorToken, flags } = node.properties;
+    case 'ReferenceTag': {
+      let { type, name, arrayOperatorToken, flags } = node.properties;
 
-        name = reifyExpression(name.node);
-        flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
+      name = name && reifyExpression(name.node);
+      type = type && reifyExpression(type.node);
+      flags = freeze({ expression: !!flags?.expressionToken, hasGap: !!flags?.hasGapToken });
 
-        return buildReferenceTag(name, !isNull(arrayOperatorToken?.node), flags);
-      }
+      return buildReferenceTag(type, name, !isNull(arrayOperatorToken?.node), flags);
+    }
 
-      case 'LiteralTag': {
-        let { value } = node.properties;
+    case 'LiteralTag': {
+      let { value } = node.properties;
 
-        return { type: LiteralTag, value: getCooked(value.properties.content) };
-      }
+      return buildLiteralTag(getCooked(value.node.properties.content.node));
+    }
 
-      case 'Identifier': {
-        return getCooked(node.properties.content.node);
-      }
+    case 'Identifier': {
+      return getCooked(node.properties.content.node);
+    }
 
-      case 'IdentifierPath': {
-        return node.properties.segments.map((segment) => reifyExpression(segment.node));
-      }
+    case 'IdentifierPath': {
+      return node.properties.segments.node.map((segment) => reifyExpression(segment.node));
+    }
 
-      case 'OpenNodeTag': {
-        let { flags, language, type, attributes } = node.properties;
+    case 'OpenNodeTag': {
+      let { flags, type, attributes } = node.properties;
 
-        flags = reifyNodeFlags(flags.node);
-        language = reifyLanguage(language?.node);
-        type = reifyExpression(type?.node);
-        attributes = reifyExpression(attributes?.node);
+      flags = reifyNodeFlags(flags.node);
+      type = reifyExpression(type?.node);
+      attributes = reifyExpression(attributes?.node);
 
-        return {
-          type: OpenNodeTag,
-          value: { flags, language, type, attributes },
-        };
-      }
+      return buildOpenNodeTag(flags, type, attributes);
+    }
 
-      case 'CloseNodeTag': {
-        return { type: CloseNodeTag, value: undefined };
-      }
+    case 'CloseNodeTag': {
+      return buildCloseNodeTag();
+    }
 
-      case 'Integer': {
-        let { digits } = node.properties;
-        return parseInt(digits.map((digit) => getCooked(digit.node)).join(''), 10);
-      }
+    case 'Integer': {
+      let { digits } = node.properties;
+      return parseInt(digits.map((digit) => getCooked(digit.node)).join(''), 10);
+    }
 
-      case 'Infinity': {
-        return getCooked(node.properties.sign.node) === '-' ? -Infinity : Infinity;
-      }
+    case 'Infinity': {
+      return getCooked(node.properties.sign.node) === '-' ? -Infinity : Infinity;
+    }
 
-      case 'Punctuator': {
-        return getCooked(node);
-      }
+    case 'Punctuator': {
+      return getCooked(node);
+    }
 
-      case 'GapTag':
-        return { type: GapTag, value: undefined };
+    case 'GapTag':
+      return buildGapTag();
 
-      case 'InitializerTag':
-        return { type: InitializerTag, value: undefined };
+    case 'InitializerTag':
+      return buildInitializerTag();
 
-      case 'NullTag':
-        return { type: NullTag, value: undefined };
+    case 'BindingTag':
+      let { languagePath } = node.properties;
 
-      case 'ShiftTag':
-        return { type: ShiftTag, value: undefined };
+      return buildBindingTag(reifyExpression(languagePath));
 
-      default:
-        throw new Error();
-    }
-  }
+    case 'NullTag':
+      return buildNullTag();
 
-  if (
-    ![
-      'https://bablr.org/languages/core/en/bablr-vm-instruction',
-      'https://bablr.org/languages/core/en/cstml-json',
-      'https://bablr.org/languages/core/en/cstml',
-      'https://bablr.org/languages/core/en/spamex',
-    ].includes(node.language)
-  ) {
-    return node;
-  }
+    case 'ShiftTag':
+      return buildShiftTag();
 
-  switch (printType(node.type)) {
     case 'String':
       return node.properties.content.node ? getCooked(node.properties.content.node) : '';
 
@@ -350,10 +305,9 @@ export const reifyExpression = (node) => {
     }
 
     case 'OpenNodeMatcher': {
-      let { flags, language, type, attributes, intrinsicValue } = node.properties;
+      let { flags, type, attributes, intrinsicValue } = node.properties;
 
       flags = (flags && reifyNodeFlags(flags.node)) || {};
-      language = language && reifyLanguage(language.node);
       type =
         type.node.type === Symbol.for('String')
           ? getCooked(type.node.properties.content.node)
@@ -361,7 +315,7 @@ export const reifyExpression = (node) => {
       attributes = attributes ? reifyExpression(attributes.node) : {};
       intrinsicValue = intrinsicValue && reifyExpression(intrinsicValue.node);
 
-      return { flags, language, type, intrinsicValue, attributes };
+      return { flags, type, intrinsicValue, attributes };
     }
 
     case 'FragmentMatcher': {
@@ -371,7 +325,6 @@ export const reifyExpression = (node) => {
 
       return {
         flags,
-        language: null,
         type: Symbol.for('@bablr/fragment'),
         intrinsicValue: null,
         attributes: null,
@@ -385,22 +338,32 @@ export const reifyExpression = (node) => {
     }
 
     case 'PropertyMatcher': {
-      let { refMatcher, nodeMatcher } = node.properties;
+      let { refMatcher, bindingMatcher, nodeMatcher } = node.properties;
 
       refMatcher = refMatcher ? reifyExpression(refMatcher.node) : null;
+      bindingMatcher = bindingMatcher ? reifyExpression(bindingMatcher.node) : null;
       nodeMatcher = reifyExpression(nodeMatcher.node);
 
-      return { refMatcher, nodeMatcher };
+      return { refMatcher, bindingMatcher, nodeMatcher };
     }
 
     case 'ReferenceMatcher': {
-      let { name, openIndexToken, flags } = node.properties;
+      let { type, name, openIndexToken, flags } = node.properties;
 
+      type = type && reifyExpression(type.node);
       name = name && reifyExpression(name.node);
       let isArray = !isNull(openIndexToken?.node);
       flags = (flags && reifyReferenceFlags(flags?.node)) || referenceFlags;
 
-      return { name, isArray, flags };
+      return { type, name, isArray, flags };
+    }
+
+    case 'BindingMatcher': {
+      let { languagePath } = node.properties;
+
+      languagePath = languagePath && reifyExpression(languagePath.node);
+
+      return { languagePath };
     }
 
     case 'GapNodeMatcher':
@@ -415,7 +378,7 @@ export const reifyExpression = (node) => {
     case 'Call': {
       const { verb, arguments: args } = node.properties;
 
-      const args_ = [...btree.traverse(args)].map((el) => reifyExpression(el.node));
+      const args_ = [...btree.traverse(args.node)].map((el) => reifyExpression(el.node));
 
       return { verb: reifyExpression(verb.node), arguments: args_ };
     }
@@ -424,7 +387,7 @@ export const reifyExpression = (node) => {
       const { properties } = node.properties;
 
       return Object.fromEntries(
-        [...btree.traverse(properties)].map((property) => {
+        [...btree.traverse(properties.node)].map((property) => {
           const {
             node: {
               properties: { key, value },
@@ -438,16 +401,13 @@ export const reifyExpression = (node) => {
     case 'Array': {
       const { elements = [] } = node.properties;
 
-      return [...btree.traverse(elements)].map((el) => reifyExpression(el.node));
+      return [...btree.traverse(elements.node)].map((el) => reifyExpression(el.node));
     }
 
     case 'Punctuator':
     case 'Keyword':
       return getCooked(node);
 
-    case 'Identifier':
-      return getCooked(node.properties.content.node);
-
     case 'Boolean': {
       // prettier-ignore
       switch (getCooked(node.properties.sigilToken.node)) {
@@ -467,61 +427,6 @@ export const reifyExpression = (node) => {
       return undefined;
 
     default:
-      throw new Error('bad expression');
-  }
-};
-
-export const reifyExpressionShallow = (node) => {
-  if (!node || isNullNode(node)) return null;
-
-  if (
-    ![
-      'https://bablr.org/languages/core/en/bablr-vm-instruction',
-      'https://bablr.org/languages/core/en/cstml',
-      'https://bablr.org/languages/core/en/cstml-json',
-      'https://bablr.org/languages/core/en/spamex',
-    ].includes(node.language)
-  ) {
-    return node;
-  }
-
-  switch (printType(node.type)) {
-    case 'String':
-    case 'SpamexString':
-    case 'RegexString': {
-      return reifyExpression(node);
-    }
-
-    case 'Object': {
-      const { properties } = node.properties;
-
-      return Object.fromEntries(
-        [...btree.traverse(properties)].map(
-          ({
-            node: {
-              properties: { key, value },
-            },
-          }) => [getCooked(key.node), value.node],
-        ),
-      );
-    }
-
-    case 'Array':
-      return [...btree.traverse(node.properties.elements)].map((prop) => prop.node);
-
-    case 'Boolean': {
-      // prettier-ignore
-      switch (getCooked(node.properties.sigilToken.node)) {
-        case 'true': return true;
-        case 'false': return false;
-        default: throw new Error();
-      }
-    }
-
-    case 'Null':
-      return null;
-
-    default:
-      return reifyExpression(node);
+      return node;
   }
 };

package/lib/symbols.js

@@ -5,6 +5,7 @@ export const fragment = Symbol.for('@bablr/fragment');
 
 export const EmbeddedInstruction = Symbol.for('EmbeddedInstruction');
 export const EmbeddedMatcher = Symbol.for('EmbeddedMatcher');
+export const EmbeddedNode = Symbol.for('EmbeddedNode');
 export const EmbeddedRegex = Symbol.for('EmbeddedRegex');
 export const EmbeddedTag = Symbol.for('EmbeddedTag');
 export const EmbeddedObject = Symbol.for('EmbeddedObject');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/agast-vm-helpers",
   "description": "Helper functions for working with the BABLR VM",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -22,11 +22,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.7.0",
+    "@bablr/agast-helpers": "0.8.0",
     "@bablr/coroutine": "0.1.0"
   },
   "devDependencies": {
-    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#49f5952efed27f94ee9b94340eb1563c440bf64e",
+    "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#c97bfa4b3663f8378e9b3e42bb5a41e685406cf9",
     "enhanced-resolve": "^5.12.0",
     "eslint": "^8.32.0",
     "eslint-import-resolver-enhanced-resolve": "^1.0.5",