@bablr/helpers 0.21.4 → 0.22.0

package/lib/builders.js

@@ -7,6 +7,7 @@ import {
 } from '@bablr/agast-helpers/tree';
 import { buildLiteralTag as agastBuildLiteralTag } from '@bablr/agast-helpers/builders';
 import * as t from '@bablr/agast-helpers/shorthand';
+import * as sumtree from '@bablr/agast-helpers/sumtree';
 import * as l from '@bablr/agast-vm-helpers/languages';
 import { concat } from '@bablr/agast-vm-helpers/iterable';
 
@@ -145,7 +146,13 @@ export const buildOpenNodeMatcher = (flags, language, type, intrinsicValue, attr
       yield t.ref`languageSeparator`;
       yield gap(language_ && type ? buildToken(l.CSTML, 'Punctuator', ':') : buildNullNode());
       yield t.ref`type`;
-      yield gap(typeof type === 'string' ? buildIdentifier(type) : type);
+      yield gap(
+        typeof type === 'string'
+          ? ['.', '#', '@'].includes(type)
+            ? buildKeyword(type)
+            : buildIdentifier(type)
+          : type,
+      );
 
       yield* when(intrinsicValue, [t.ref`#`, ...buildSpace().children]);
 
@@ -185,7 +192,7 @@ export const buildReferenceMatcher = (name, isArray, flags) => {
     (function* () {
       yield t.nodeOpen(t.nodeFlags, l.Spamex, 'ReferenceMatcher');
       yield t.ref`name`;
-      yield gap(buildToken(l.CSTML, 'Identifier', name));
+      yield gap(['#', '@', '.'].includes(name) ? buildKeyword(name) : buildIdentifier(name));
       yield* (function* () {
         if (isArray) {
           yield t.ref`openIndexToken`;
@@ -199,7 +206,7 @@ export const buildReferenceMatcher = (name, isArray, flags) => {
       yield t.ref`sigilToken`;
       yield gap(buildToken(l.CSTML, 'Punctuator', ':'));
       yield t.ref`#`;
-      yield* buildSpace().children;
+      yield* sumtree.traverse(buildSpace().children);
       yield t.nodeClose();
     })(),
     { expressions },
@@ -218,7 +225,7 @@ export const buildFragmentMatcher = (flags) => {
       yield t.ref`flags`;
       yield gap(flags);
       yield t.ref`#`;
-      yield* buildSpace().children;
+      yield* sumtree.traverse(buildSpace().children);
       yield t.ref`closeToken`;
       yield gap(buildToken(l.CSTML, 'Punctuator', '/>'));
       yield t.nodeClose();
@@ -374,9 +381,24 @@ export const buildSpace = () => {
 };
 
 export const buildIdentifier = (name) => {
-  if (!/^[a-zA-Z]+$/.test(name)) throw new Error();
+  if (!/^[a-zA-Z_]+$/.test(name)) throw new Error();
 
-  return buildToken(l.Instruction, 'Identifier', name);
+  const expressions = [];
+  const gap = buildFilledGapFunction(expressions);
+
+  return treeFromStream(
+    [
+      t.nodeOpen(t.nodeFlags, l.CSTML, 'Identifier'),
+      t.ref`content`,
+      gap(buildIdentifierContent(name)),
+      t.nodeClose(),
+    ],
+    { expressions },
+  );
+};
+
+export const buildIdentifierContent = (value) => {
+  return buildToken(l.CSTML, 'IdentifierContent', value);
 };
 
 export const buildKeyword = (name) => {

package/lib/decorators.js

@@ -13,6 +13,18 @@ export const AllowEmpty = (desc, context) => {
   });
 };
 
+export const Literal = (desc, context) => {
+  context.addInitializer(function () {
+    let literals = this.literals;
+
+    if (!literals) {
+      literals = this.literals = new Set();
+    }
+
+    literals.add(context.name);
+  });
+};
+
 export const CoveredBy = (type) => {
   return (desc, context) => {
     if (!/^[a-zA-Z]+$/.test(printType(type))) throw new Error();
@@ -55,9 +67,9 @@ export const Attributes = (attributes) => (desc, context) => {
   });
 };
 
-export const UnboundAttributes = (attributes) => (desc, context) => {
+export const UndefinedAttributes = (attributes) => (desc, context) => {
   context.addInitializer(function () {
-    this.unboundAttributes = this.unboundAttributes || new Map();
-    this.unboundAttributes.set(context.name, attributes);
+    this.undefinedAttributes = this.undefinedAttributes || new Map();
+    this.undefinedAttributes.set(context.name, attributes);
   });
 };

package/lib/grammar.js

@@ -1,9 +1,9 @@
 import every from 'iter-tools-es/methods/every';
 import isString from 'iter-tools-es/methods/is-string';
-import { getOwnPropertySymbols, getPrototypeOf, objectEntries } from './object.js';
+import { getOwnPropertySymbols, getPrototypeOf, objectEntries, objectValues } from './object.js';
 import { OpenNodeTag, CloseNodeTag, NullTag } from './symbols.js';
 import { buildExpression } from './builders.js';
-import { buildEmbeddedObject } from '@bablr/agast-helpers/tree';
+import { buildEmbeddedObject } from '@bablr/agast-vm-helpers/builders';
 
 export * from './decorators.js';
 
@@ -92,7 +92,17 @@ export const unresolveLanguage = (context, baseLanguage, absoluteLanguage) => {
     }
   }
 
-  throw new Error('Cannot currently unresolve nested deps');
+  // TODO wow I am lazy I literally just hardcoded this to depth two yep
+  // I really want to do a BFS with handling for dep cycles
+  for (const lang of objectValues(baseLanguage.dependencies)) {
+    for (const { 0: key, 1: value } of objectEntries(lang.dependencies)) {
+      if (value.canonicalURL === absoluteLanguage) {
+        return [key];
+      }
+    }
+  }
+
+  throw new Error('Cannot currently unresolve more deeply nested deps');
 };
 
 export const explodeSubtypes = (aliases, exploded, types) => {
@@ -236,8 +246,8 @@ export const fail = () => {
   return __buildCall('fail');
 };
 
-export const bindAttribute = (key, value) => {
-  return __buildCall('bindAttribute', key, value);
+export const defineAttribute = (key, value) => {
+  return __buildCall('defineAttribute', key, value);
 };
 
 export const write = (value) => {

package/lib/object.js

@@ -10,6 +10,7 @@ export const isString = (obj) => typeof obj === 'string';
 export const isRegex = (obj) => obj instanceof RegExp;
 export const isPattern = (obj) => isString(obj) || isRegex(obj);
 export const isType = (obj) => isSymbol(obj) || isString(obj);
+export const isPlainObject = (val) => val && getPrototypeOf(val) === Object.prototype;
 
 export const objectKeys = (obj) => {
   return {

package/lib/productions.js

@@ -1,33 +1,34 @@
 /* @macrome
  * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./productions.macro.js#b39a819f59f161409dfbc86e5266dade96b58b55
+ * @generatedfrom ./productions.macro.js#1fc6c6c7f7c9fc7c43a69d9729301c75581c11ea
  * This file is autogenerated. Please do not edit it directly.
  * When editing run `npx macrome watch` then change the file this is generated from.
  */
 import { spam as m } from '@bablr/boot';
-import { buildEmbeddedMatcher, getCooked } from '@bablr/agast-helpers/tree';
+import { getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
 import { EmbeddedMatcher } from './symbols.js';
-import { getEmbeddedMatcher, getEmbeddedObject } from '@bablr/agast-vm-helpers/deembed';
+import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
+import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
 export function* List({
-  value: props
+  props
 }) {
   const {
     element,
     separator,
     allowHoles = false,
     allowTrailingSeparator = true
-  } = getEmbeddedObject(props);
-  if (!['#', '@'].includes(getCooked(getEmbeddedMatcher(separator).properties.refMatcher.node.properties.name.node))) {
-    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(separator).properties.refMatcher.node, m.ArrayNodeMatcher`[]`)));
+  } = props;
+  if (!['#', '@'].includes(getCooked(getEmbeddedMatcher(separator).properties.refMatcher?.node.properties.name.node.properties.content.node))) {
+    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(separator).properties.refMatcher?.node, m.ArrayNodeMatcher`[]`)));
   }
-  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(element).properties.refMatcher.node, m.ArrayNodeMatcher`[]`)));
+  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher?.node, m.ArrayNodeMatcher`[]`)));
   let sep,
     it,
     anySep = false;
   for (;;) {
-    it = yield eatMatch(element);
+    it = yield eatMatch(...(Array.isArray(element) ? element : [element]));
     if (it || allowTrailingSeparator) {
       sep = yield eatMatch(separator);
       anySep ||= sep;
@@ -38,10 +39,14 @@ export function* List({
   }
 }
 export function* Any({
-  value: alternatives
+  props: {
+    value: alternatives
+  }
 }) {
   for (const alternative of alternatives) {
-    if (alternative.type === EmbeddedMatcher) {
+    if (Array.isArray(alternative)) {
+      if (yield eatMatch(...alternative)) break;
+    } else if (alternative.type === EmbeddedMatcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -49,16 +54,30 @@ export function* Any({
   }
 }
 export function* All({
-  value: matchers
+  props: {
+    value: matchers
+  }
 }) {
   for (const matcher of matchers) {
-    yield eat(matcher);
+    if (Array.isArray(matcher)) {
+      yield eat(...matcher);
+    } else {
+      yield eat(matcher);
+    }
   }
 }
-export function* Punctuator({
+export function* Optional({
+  props: {
+    value: matcher
+  }
+}) {
+  yield eatMatch(matcher);
+}
+export function* Literal({
   intrinsicValue
 }) {
   if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
   yield eat(intrinsicValue);
 }
-export const Keyword = Punctuator;
+export const Keyword = Literal;
+export const Punctuator = Literal;

package/lib/productions.macro.js

@@ -1,27 +1,26 @@
 import { spam as m } from '@bablr/boot';
-import { buildEmbeddedMatcher, getCooked } from '@bablr/agast-helpers/tree';
+import { getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
 import { EmbeddedMatcher } from './symbols.js';
-import { getEmbeddedMatcher, getEmbeddedObject } from '@bablr/agast-vm-helpers/deembed';
+import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
+import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
 
-export function* List({ value: props }) {
-  const {
-    element,
-    separator,
-    allowHoles = false,
-    allowTrailingSeparator = true,
-  } = getEmbeddedObject(props);
+export function* List({ props }) {
+  const { element, separator, allowHoles = false, allowTrailingSeparator = true } = props;
 
   if (
     !['#', '@'].includes(
-      getCooked(getEmbeddedMatcher(separator).properties.refMatcher.node.properties.name.node),
+      getCooked(
+        getEmbeddedMatcher(separator).properties.refMatcher?.node.properties.name.node.properties
+          .content.node,
+      ),
     )
   ) {
     yield eat(
       buildEmbeddedMatcher(
         buildPropertyMatcher(
-          getEmbeddedMatcher(separator).properties.refMatcher.node,
+          getEmbeddedMatcher(separator).properties.refMatcher?.node,
           m.ArrayNodeMatcher`[]`,
         ),
       ),
@@ -31,7 +30,8 @@ export function* List({ value: props }) {
   yield eat(
     buildEmbeddedMatcher(
       buildPropertyMatcher(
-        getEmbeddedMatcher(element).properties.refMatcher.node,
+        getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher
+          ?.node,
         m.ArrayNodeMatcher`[]`,
       ),
     ),
@@ -41,7 +41,7 @@ export function* List({ value: props }) {
     it,
     anySep = false;
   for (;;) {
-    it = yield eatMatch(element);
+    it = yield eatMatch(...(Array.isArray(element) ? element : [element]));
     if (it || allowTrailingSeparator) {
       sep = yield eatMatch(separator);
       anySep ||= sep;
@@ -52,9 +52,11 @@ export function* List({ value: props }) {
   }
 }
 
-export function* Any({ value: alternatives }) {
+export function* Any({ props: { value: alternatives } }) {
   for (const alternative of alternatives) {
-    if (alternative.type === EmbeddedMatcher) {
+    if (Array.isArray(alternative)) {
+      if (yield eatMatch(...alternative)) break;
+    } else if (alternative.type === EmbeddedMatcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -62,16 +64,25 @@ export function* Any({ value: alternatives }) {
   }
 }
 
-export function* All({ value: matchers }) {
+export function* All({ props: { value: matchers } }) {
   for (const matcher of matchers) {
-    yield eat(matcher);
+    if (Array.isArray(matcher)) {
+      yield eat(...matcher);
+    } else {
+      yield eat(matcher);
+    }
   }
 }
 
-export function* Punctuator({ intrinsicValue }) {
+export function* Optional({ props: { value: matcher } }) {
+  yield eatMatch(matcher);
+}
+
+export function* Literal({ intrinsicValue }) {
   if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
 
   yield eat(intrinsicValue);
 }
+export const Keyword = Literal;
 
-export const Keyword = Punctuator;
+export const Punctuator = Literal;

package/lib/symbols.js

@@ -1 +1 @@
-export * from '@bablr/agast-helpers/symbols';
+export * from '@bablr/agast-vm-helpers/symbols';

package/lib/trivia.js

@@ -1,28 +1,26 @@
+import { spam as m } from '@bablr/boot';
 import { Coroutine } from '@bablr/coroutine';
+import { eat, eatMatch, mapProductions, o, resolveLanguage } from './grammar.js';
+import { EmbeddedMatcher, EmbeddedRegex, EmbeddedNode } from './symbols.js';
+import { buildIdentifier, buildString } from './builders.js';
+import { buildCall, buildEmbeddedInstruction } from '@bablr/agast-vm-helpers/builders';
+import { getEmbeddedInstruction } from '@bablr/agast-vm-helpers/deembed';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { mapProductions } from './grammar.js';
-import { OpenNodeTag, CloseNodeTag, ReferenceTag, EmbeddedMatcher } from './symbols.js';
-import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
-import { getCooked, isFragmentNode } from '@bablr/agast-helpers/tree';
-
-const lookbehind = (context, s) => {
-  let token = s.resultPath;
-  while (token && [OpenNodeTag, CloseNodeTag, ReferenceTag].includes(token.type)) {
-    const prevToken = context.getPreviousTagPath(token);
-    if (!prevToken) break;
-    token = prevToken;
-  }
-  return token;
-};
 
-// eslint-disable-next-line no-undef
-const matchedResults = new WeakSet();
+export const triviaEnhancer = (
+  { triviaIsAllowed, triviaIsRequired = () => false, triviaMatcher },
+  grammar,
+) => {
+  let Wrapper_ = 'Wrapper';
+  let Literal_ = 'Literal';
+
+  while (grammar.prototype[Wrapper_]) Wrapper_ += '_';
+  while (grammar.prototype[Literal_]) Literal_ += '_';
 
-export const triviaEnhancer = ({ triviaIsAllowed, eatMatchTrivia }, grammar) => {
-  return mapProductions((production) => {
+  const resultGrammar = mapProductions((production) => {
     return function* (props) {
       const co = new Coroutine(production(props));
-      const { s, ctx } = props;
+      const { ctx, s, isCovered, isCover, flags } = props;
 
       co.advance();
 
@@ -38,20 +36,87 @@ export const triviaEnhancer = ({ triviaIsAllowed, eatMatchTrivia }, grammar) =>
             case 'match':
             case 'guard': {
               const { 0: matcher, 1: props, 2: options } = args;
+
               if (
-                matcher &&
                 matcher.type === EmbeddedMatcher &&
-                getCooked(matcher.value.properties.refMatcher?.node.properties.name.node) !== '#'
+                ['ArrayNodeMatcher', 'NullNodeMatcher'].includes(
+                  matcher.value.properties.nodeMatcher.node.type.description,
+                )
               ) {
-                const previous = lookbehind(ctx, s);
-                if (triviaIsAllowed(s) && (!previous || !matchedResults.has(previous))) {
-                  matchedResults.add(previous);
-                  yield* eatMatchTrivia();
-                  matchedResults.add(s.resultPath);
+                returnValue = yield instr;
+                break;
+              }
+
+              if (
+                matcher.type === EmbeddedRegex ||
+                typeof matcher === 'string' ||
+                (matcher.type === EmbeddedNode && matcher.value.flags.token)
+              ) {
+                if (triviaIsAllowed(s) && !flags.token) {
+                  let isString = typeof matcher === 'string';
+                  let wrappedMatcher = m`value: <*Literal ${
+                    isString ? buildString(matcher) : matcher.value
+                  } />`;
+
+                  let tmi = buildEmbeddedInstruction(
+                    triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
+                  );
+
+                  let result = yield buildCall(verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+                    tmi,
+                    buildEmbeddedInstruction(eat(wrappedMatcher, props, options)),
+                  ]);
+
+                  returnValue = result?.get('value');
+                } else {
+                  returnValue = yield instr;
                 }
+                break;
               }
 
-              returnValue = returnValue || (yield instr);
+              let { name } = reifyExpression(matcher.value.properties.refMatcher?.node) || {};
+              let realMatcher = reifyExpression(matcher.value.properties.nodeMatcher?.node);
+              let { flags: matcherFlags } = realMatcher;
+
+              let isNode = matcherFlags && !matcherFlags.fragment;
+              let isCoverBoundary = matcherFlags && (matcherFlags.cover || (isNode && !isCovered));
+              if (
+                matcher &&
+                (matcher.type !== EmbeddedMatcher || name !== '#') &&
+                !s.holding &&
+                !flags.token &&
+                isCoverBoundary
+              ) {
+                if (triviaIsAllowed(s)) {
+                  let tmi = buildEmbeddedInstruction(
+                    triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
+                  );
+
+                  let result = yield buildCall(
+                    verb,
+                    m`<_${buildIdentifier(Wrapper_)} />`,
+                    [tmi, buildEmbeddedInstruction(eat(matcher, props, options))],
+                    o({ bind: options?.value.bind ?? false }),
+                  );
+                  let trivialResult = result;
+
+                  if (result && !result.isNull) {
+                    if (matcher.value.properties.refMatcher) {
+                      let path = ctx
+                        .sourceTextFor(matcher.value.properties.refMatcher.node)
+                        .slice(0, -1);
+                      result = result.get(path);
+                    }
+
+                    result = result && result.merge(trivialResult);
+                  }
+                  returnValue = result;
+                } else {
+                  returnValue = yield instr;
+                }
+              } else {
+                returnValue = yield instr;
+              }
               break;
             }
 
@@ -63,12 +128,34 @@ export const triviaEnhancer = ({ triviaIsAllowed, eatMatchTrivia }, grammar) =>
           co.advance(returnValue);
         }
 
-        if (!s.node?.flags.token && s.node.isFragmentNode) {
-          const previous = lookbehind(ctx, s);
-          if (triviaIsAllowed(s) && !matchedResults.has(previous)) {
-            matchedResults.add(previous);
-            yield* eatMatchTrivia();
-            matchedResults.add(s.resultPath);
+        if (!s.depths.path && !flags.token && !(isCovered || isCover)) {
+          if (triviaIsAllowed(s)) {
+            yield eatMatch(triviaMatcher);
+          }
+        } else if (co.value) {
+          let realMatcher = reifyExpression(
+            co.value.arguments[0].value.properties.nodeMatcher.node,
+          );
+          let { flags: matcherFlags } = realMatcher;
+
+          let isNode = matcherFlags && !matcherFlags.fragment;
+
+          if (
+            !flags.token &&
+            isNode &&
+            !isCover &&
+            co.value &&
+            ['holdFor', 'holdForMatch'].includes(co.value.verb)
+          ) {
+            if (triviaIsAllowed(s)) {
+              let tmi = buildEmbeddedInstruction(
+                triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
+              );
+              return buildCall(co.value.verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+                tmi,
+                buildEmbeddedInstruction(eat(co.value.arguments[0], co.value.arguments[1])),
+              ]);
+            }
           }
         }
 
@@ -79,4 +166,36 @@ export const triviaEnhancer = ({ triviaIsAllowed, eatMatchTrivia }, grammar) =>
       }
     };
   }, grammar);
+
+  return class extends resultGrammar {
+    constructor() {
+      super();
+
+      if (!this.emptyables) {
+        this.emptyables = new Set();
+      }
+
+      if (!this.covers) {
+        this.covers = new Map();
+      }
+
+      if (!this.covers.get(Symbol.for('@bablr/node'))) {
+        this.covers.set(Symbol.for('@bablr/node'), new Set());
+      }
+
+      this.covers.get(Symbol.for('@bablr/node')).add(Literal_);
+
+      this.emptyables.add(Wrapper_);
+    }
+
+    *[Wrapper_]({ props: { value: wrapped } }) {
+      for (const instr of wrapped) {
+        yield getEmbeddedInstruction(instr);
+      }
+    }
+
+    *[Literal_]({ intrinsicValue }) {
+      yield eat(intrinsicValue);
+    }
+  };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/helpers",
   "description": "Command helpers for use in writing BABLR grammars",
-  "version": "0.21.4",
+  "version": "0.22.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -30,16 +30,16 @@
     "clean": "macrome clean"
   },
   "dependencies": {
-    "@bablr/language_enhancer-debug-log": "0.8.1",
-    "@bablr/strategy_enhancer-debug-log": "0.7.2",
-    "@bablr/agast-helpers": "0.6.1",
-    "@bablr/agast-vm-helpers": "0.6.1",
+    "@bablr/language_enhancer-debug-log": "0.9.0",
+    "@bablr/strategy_enhancer-debug-log": "0.8.0",
+    "@bablr/agast-helpers": "0.7.0",
+    "@bablr/agast-vm-helpers": "0.7.0",
     "@bablr/coroutine": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0",
     "iter-tools-es": "^7.5.3"
   },
   "devDependencies": {
-    "@bablr/boot": "0.7.2",
+    "@bablr/boot": "0.8.0",
     "@bablr/eslint-config-base": "github:bablr-lang/eslint-config-base#d834ccc52795d6c3b96ecc6c419960fceed221a6",
     "@bablr/macrome": "0.1.3",
     "@bablr/macrome-generator-bablr": "0.3.2",