@bablr/helpers 0.23.0 → 0.25.0

package/lib/decorators.js

@@ -53,20 +53,9 @@ export const InjectFrom = (obj) => (_stub, context) => {
   return obj[context.name];
 };
 
-export const Node = (desc, context) => {
-  return CoveredBy(sym.node)(desc, context);
-};
-
 export const Attributes = (attributes) => (desc, context) => {
   context.addInitializer(function () {
     this.attributes = this.attributes || new Map();
     this.attributes.set(context.name, attributes);
   });
 };
-
-export const UndefinedAttributes = (attributes) => (desc, context) => {
-  context.addInitializer(function () {
-    this.undefinedAttributes = this.undefinedAttributes || new Map();
-    this.undefinedAttributes.set(context.name, attributes);
-  });
-};

package/lib/grammar.js

@@ -1,13 +1,35 @@
 import every from 'iter-tools-es/methods/every';
 import isString from 'iter-tools-es/methods/is-string';
-import { getOwnPropertySymbols, getPrototypeOf, objectEntries, objectValues } from './object.js';
-import { OpenNodeTag, CloseNodeTag, NullTag } from './symbols.js';
-import { buildEmbeddedObject } from '@bablr/agast-vm-helpers/builders';
+import { getOwnPropertySymbols, getPrototypeOf, objectEntries } from './object.js';
+import * as BTree from '@bablr/agast-helpers/btree';
+import { OpenNodeTag, CloseNodeTag, NullTag, Matcher } from './symbols.js';
+import {
+  buildCall,
+  buildEmbeddedMatcher,
+  buildEmbeddedObject,
+} from '@bablr/agast-vm-helpers/builders';
+import { freeze, isObject, isPlainObject } from '@bablr/agast-helpers/object';
+import { StreamIterable, wait } from '@bablr/stream-iterator';
+import { get } from '@bablr/agast-helpers/path';
+import { buildBindingMatchers, buildBoundNodeMatcher, buildPropertyMatcher } from './builders.js';
+import { reifyExpression } from '@bablr/agast-vm-helpers';
 
 export * from './decorators.js';
 
+import { EmbeddedObject } from '@bablr/agast-vm-helpers/symbols';
+
+export const normalizeProps = (value) => {
+  return isPlainObject(value) && value.type === EmbeddedObject && isPlainObject(value.value)
+    ? value.value
+    : value === undefined
+    ? {}
+    : { value: value?.type === EmbeddedObject ? value.value : value };
+};
+
 const { getOwnPropertyNames, hasOwn } = Object;
 
+const matchVerbs = new Set(['eat', 'match', 'eatMatch', 'shift', 'shiftMatch']);
+
 const { isArray } = Array;
 const isSymbol = (value) => typeof value === 'symbol';
 const isType = (value) => isString(value) || isSymbol(value);
@@ -62,39 +84,6 @@ export function* generateProductions(Grammar) {
   }
 }
 
-export const resolveLanguage = (context, language, path) => {
-  const { languages } = context;
-  if (isString(path)) {
-    if (language.canonicalURL === path) {
-      return language;
-    } else {
-      throw new Error('absolute path resolution not implemented');
-    }
-  }
-
-  let l = language;
-
-  if (!l) {
-    throw new Error();
-  }
-
-  let segments = isString(path) ? [path] : isArray(path) ? path : null;
-
-  if (path == null) {
-    return language;
-  } else {
-    for (const segment of segments) {
-      if (isString(l.dependencies[segment])) {
-        l = languages.get(l.dependencies[segment]);
-      } else {
-        l = l.dependencies[segment];
-      }
-    }
-  }
-
-  return l;
-};
-
 export const explodeSubtypes = (aliases, exploded, types) => {
   for (const type of types) {
     const explodedTypes = aliases.get(type);
@@ -128,6 +117,10 @@ export const buildCovers = (rawAliases) => {
   return new Map(aliases);
 };
 
+export const buildReturnValue = (shift, value) => {
+  return freeze({ shift, value });
+};
+
 export const getProduction = (grammar, type) => {
   return getPrototypeOf(grammar)[type];
 };
@@ -136,16 +129,16 @@ const __buildDependentLanguages = (language, languages = new Map()) => {
   languages.set(language.canonicalURL, language);
 
   for (const dependentLanguage of Object.values(language.dependencies || {})) {
-    if (isString(dependentLanguage)) continue;
+    if (!isObject(dependentLanguage)) throw new Error();
 
-    const { canonicalURL } = dependentLanguage;
-    if (languages.has(canonicalURL) && dependentLanguage !== languages.get(canonicalURL)) {
-      throw new Error();
+    if (
+      languages.has(dependentLanguage.canonicalURL) &&
+      languages.get(dependentLanguage.canonicalURL) !== dependentLanguage
+    ) {
+      throw new Error('url clash');
     }
 
-    if (!languages.has(dependentLanguage)) {
-      __buildDependentLanguages(dependentLanguage, languages);
-    }
+    __buildDependentLanguages(dependentLanguage, languages);
   }
 
   return languages;
@@ -204,6 +197,138 @@ const __buildCall = (verb, ...args) => {
   return { verb, arguments: args };
 };
 
+export const getInstrMatcher = (instr) => {
+  if (matchVerbs.has(instr.verb) && instr.arguments[0].type === Matcher) {
+    return instr.arguments[0];
+  }
+  return null;
+};
+
+function* __wrapGenerator(generator, relativeMatcher) {
+  // Path.get quietly returns the first item when asked for an array...
+  let { bindingMatchers: relativeBindings } = reifyExpression(relativeMatcher.value);
+
+  if (!relativeBindings || !relativeBindings.length) {
+    return yield* generator;
+  }
+
+  let step;
+  let returnValue;
+  while (!(step = generator.next(returnValue)).done) {
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
+    let instr = step.value;
+    let { verb, arguments: args } = instr;
+
+    let isMatcher =
+      matchVerbs.has(verb) &&
+      args[0].type === Matcher &&
+      args[0].value.value.name?.description === 'PropertyMatcher';
+
+    if (isMatcher) {
+      let { 0: matcher, 1: props, 2: options } = args;
+      let { nodeMatcher, bindingMatchers } = reifyExpression(matcher.value);
+
+      if ((nodeMatcher.flags.token && !nodeMatcher.name) || !relativeBindings.length) {
+        returnValue = yield instr;
+        continue;
+      }
+
+      let newMatcher = buildPropertyMatcher(
+        get('refMatcher', matcher.value),
+        buildBoundNodeMatcher(
+          [...relativeBindings, ...bindingMatchers],
+          get(['valueMatcher', 'nodeMatcher'], matcher.value),
+        ),
+      );
+
+      let extraArgs = [];
+      if (props !== undefined || options !== undefined) extraArgs.push(props);
+      if (options !== undefined) extraArgs.push(options);
+
+      let newInstr = buildCall(verb, buildEmbeddedMatcher(newMatcher), ...extraArgs);
+      returnValue = yield newInstr;
+    } else {
+      returnValue = yield instr;
+    }
+  }
+}
+
+export const wrapGenerator = (generator, matcher) => {
+  return new StreamIterable(__wrapGenerator(generator, matcher));
+};
+
+export function resolveLanguage(languages, path) {
+  let languageIdx = BTree.getSize(languages) - 1;
+  let language = BTree.getAt(languageIdx, languages);
+
+  // TODO there may be more than one binding!
+  let path_ = Array.isArray(path)
+    ? path
+    : reifyExpression(path.value).bindingMatchers.flatMap((m) => m.segments);
+
+  for (let { name, type } of path_) {
+    if (name) {
+      language = language.dependencies[name];
+
+      if (!language) return null;
+    } else if (type) {
+      if (type !== '..') throw new Error();
+      languageIdx--;
+      language = BTree.getAt(languageIdx, languages);
+    } else {
+      throw new Error();
+    }
+  }
+
+  return language;
+}
+
+export function* exec(getState, matcher, value, getGrammar = (g) => g) {
+  let matcher_ = reifyExpression(matcher.value);
+  let { nodeMatcher } = matcher_;
+  let state = getState();
+
+  let language = resolveLanguage(state.languages, matcher);
+
+  let { productionEnhancer } = language;
+
+  let { grammar } = language;
+  let grammar_ = getGrammar(grammar);
+
+  let args = freeze({
+    type: nodeMatcher.type,
+    name: nodeMatcher.name,
+    props: normalizeProps(value),
+    getState,
+    s: getState,
+    flags: nodeMatcher.flags,
+    isCover: false,
+    isCoverBoundary: false,
+    allowEmpty: true,
+    grammar,
+    matcher: matcher.value,
+    literalValue: null,
+  });
+
+  let production = grammar_.prototype[nodeMatcher.name];
+
+  let enhancedProduction = production;
+
+  if (productionEnhancer) {
+    enhancedProduction = productionEnhancer(enhancedProduction, nodeMatcher.name);
+  }
+
+  // if (rootProductionEnhancer && !m.depth) {
+  //   enhancedProduction = rootProductionEnhancer(enhancedProduction, nodeMatcher.name);
+  // }
+
+  let generator = enhancedProduction(args);
+
+  yield* wrapGenerator(generator, matcher);
+}
+
 export const eat = (matcher, value, options) => {
   return __buildCall('eat', matcher, value, options);
 };
@@ -220,6 +345,10 @@ export const guard = (matcher, value, options) => {
   return __buildCall('guard', matcher, value, options);
 };
 
+export const shift = (matcher, value, options) => {
+  return __buildCall('shift', matcher, value, options);
+};
+
 export const shiftMatch = (matcher, value, options) => {
   return __buildCall('shiftMatch', matcher, value, options);
 };
@@ -228,6 +357,10 @@ export const fail = () => {
   return __buildCall('fail');
 };
 
+export const eatHeld = (matcher) => {
+  return __buildCall('eatHeld', matcher);
+};
+
 export const defineAttribute = (key, value) => {
   return __buildCall('defineAttribute', key, value);
 };
@@ -236,4 +369,14 @@ export const write = (value) => {
   return __buildCall('write', value);
 };
 
+export const startSpan = (name, guard) => {
+  return __buildCall('startSpan', name, guard);
+};
+
+export const endSpan = () => {
+  return __buildCall('endSpan');
+};
+
 export const o = buildEmbeddedObject;
+
+export const r = buildReturnValue;

package/lib/productions.js

@@ -1,85 +1,69 @@
-/* @macrome
- * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./productions.macro.js#b095c92e30507ebaab43cd0c2b1dcee55853950f
- * 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 { getCooked } from '@bablr/agast-helpers/tree';
-import { eat, eatMatch } from './grammar.js';
-import { EmbeddedMatcher } from './symbols.js';
-import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
-import { buildPropertyMatcher } from './builders.js';
+import { get, Path } from '@bablr/agast-helpers/path';
+import { eat, eatMatch, fail } from './grammar.js';
+import { Matcher } from './symbols.js';
 import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
-export function* List({
-  props
-}) {
-  const {
-    element,
-    separator,
-    allowHoles = false,
-    allowTrailingSeparator = true
-  } = props;
-  if (!['#', '@'].includes(getCooked(getEmbeddedMatcher(separator).properties.refMatcher?.node.properties.type?.node))) {
-    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(separator).properties.refMatcher?.node, null, m.ArrayNodeMatcher`[]`)));
+import { printSource } from '@bablr/agast-helpers/tree';
+
+const { isArray } = Array;
+
+export function* List(args) {
+  let { props, matcher } = args.element ? { props: args } : args;
+
+  const { element, separator, allowHoles = false, allowTrailingSeparator = true } = props;
+  let refMatcher = matcher && get('refMatcher', matcher);
+
+  let matcher_ = isArray(element) ? element[0] : element;
+  let props_ = isArray(element) ? element[1] : undefined;
+  let options = isArray(element) ? element[2] : undefined;
+
+  if (refMatcher && !get('refMatcher', matcher_.value)) {
+    matcher_ = buildEmbeddedMatcher(Path.set(matcher_.value, 'refMatcher', refMatcher));
   }
-  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher?.node, null, m.ArrayNodeMatcher`[]`)));
-  let sep,
-    it,
-    anySep = false;
+
+  let sep, it;
   for (;;) {
-    it = yield eatMatch(...(Array.isArray(element) ? element : [element]));
+    it = yield eatMatch(matcher_, props_, options);
     if (it || allowTrailingSeparator) {
       sep = yield eatMatch(separator);
-      anySep ||= sep;
     } else {
       sep = null;
     }
     if (!(sep || allowHoles)) break;
   }
 }
-export function* Any({
-  props: {
-    value: alternatives
-  }
-}) {
+
+export function* Any({ props: { value: alternatives } }) {
   for (const alternative of alternatives) {
-    if (Array.isArray(alternative)) {
-      if (yield eatMatch(...alternative)) break;
-    } else if (alternative.type === EmbeddedMatcher) {
-      if (yield eatMatch(alternative)) break;
+    if (isArray(alternative)) {
+      if (yield eatMatch(...alternative)) return;
+    } else if (alternative.type === Matcher) {
+      if (yield eatMatch(alternative)) return;
     } else {
       throw new Error();
     }
   }
+  yield fail();
 }
-export function* All({
-  props: {
-    value: matchers
-  }
-}) {
+
+export function* All({ props: { value: matchers } }) {
   for (const matcher of matchers) {
-    if (Array.isArray(matcher)) {
+    if (isArray(matcher)) {
       yield eat(...matcher);
     } else {
       yield eat(matcher);
     }
   }
 }
-export function* Optional({
-  props: {
-    value: matcher
-  }
-}) {
+
+export function* Optional({ props: { value: matcher } }) {
   yield eatMatch(matcher);
 }
-export function* Literal({
-  ctx,
-  intrinsicValue
-}) {
-  if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
-  yield eat(ctx.sourceTextFor(intrinsicValue.value));
+
+export function* Literal({ literalValue }) {
+  if (!literalValue) throw new Error('Intrinsic productions must have value');
+
+  yield eat(printSource(literalValue.value));
 }
 export const Keyword = Literal;
-export const Punctuator = Literal;
-export const Space = Literal;
+
+export const Space = Literal;

package/lib/shorthand.js

@@ -1 +1 @@
-export { i, re, spam } from '@bablr/boot';
+export { i, re, spam, t, cst } from '@bablr/boot';

package/lib/source.js

@@ -1,6 +1,6 @@
 import slice from 'iter-tools-es/methods/slice';
 import { streamFromTree } from '@bablr/agast-helpers/tree';
-import { StreamIterable, getStreamIterator } from '@bablr/agast-helpers/stream';
+import { StreamIterable, getStreamIterator, wait } from '@bablr/agast-helpers/stream';
 import { ShiftTag, GapTag, LiteralTag } from './symbols.js';
 
 const escapables = {
@@ -15,7 +15,7 @@ function* __readFromStream(stream) {
   let step;
 
   for (;;) {
-    step = yield iter.next();
+    step = yield wait(iter.next());
 
     if (step.done) break;
 
@@ -23,7 +23,10 @@ function* __readFromStream(stream) {
   }
 
   if (!step.done) {
-    iter?.return();
+    step = iter?.return();
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
   }
 }
 
@@ -42,7 +45,7 @@ function* __embeddedSourceFrom(iterable) {
     step = iter.next();
 
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     if (step.done) break;
@@ -86,7 +89,11 @@ function* __embeddedSourceFrom(iterable) {
   }
 
   if (!step.done) {
-    iter?.return();
+    step = iter?.return();
+
+    if (step instanceof Promise) {
+      step = yield wait(step);
+    }
   }
 }
 
@@ -101,7 +108,7 @@ function* __printEmbeddedSource(chrs) {
     step = iter.next();
 
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     if (step.done) break;
@@ -142,7 +149,7 @@ function* __sourceFromTokenStream(tags) {
     step = iter.next();
 
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     if (step.done) break;
@@ -168,7 +175,7 @@ function* __sourceFromQuasis(quasis) {
     step = iter.next();
 
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     if (step.done) break;
@@ -192,7 +199,7 @@ export function* fillGapsWith(expressions, iterable) {
     let step = iter.next();
 
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     if (step.done) break;
@@ -231,7 +238,7 @@ function* __stripTrailingNewline(iterable) {
 
   for (;;) {
     if (step instanceof Promise) {
-      step = yield step;
+      step = yield wait(step);
     }
 
     // TODO: handle \r\n line endings