@bablr/helpers 0.22.1 → 0.24.0

package/lib/decorators.js

@@ -1,4 +1,3 @@
-import { printType } from '@bablr/agast-helpers/print';
 import * as sym from './symbols.js';
 
 export const AllowEmpty = (desc, context) => {
@@ -27,8 +26,6 @@ export const Literal = (desc, context) => {
 
 export const CoveredBy = (type) => {
   return (desc, context) => {
-    if (!/^[a-zA-Z]+$/.test(printType(type))) throw new Error();
-
     context.addInitializer(function () {
       let covers = this.covers;
 

package/lib/enhancers.js

@@ -1,7 +1,4 @@
-import {
-  enhanceStrategyBuilderWithDebugLogging as logStrategy,
-  enhanceStrategyBuilderWithEmittedLogging as logEmitted,
-} from '@bablr/strategy_enhancer-debug-log';
+import { enhanceStrategyBuilderWithDebugLogging as logStrategy } from '@bablr/strategy_enhancer-debug-log';
 import { enhanceProductionWithDebugLogging as createProductionLogger } from '@bablr/language_enhancer-debug-log';
 import { mapProductions } from './grammar.js';
 
@@ -40,8 +37,8 @@ export const compose = (functions) => {
 
 export const debugEnhancers = {
   // bablr: (strategy) => logStrategy(strategy, '<<< '),
-  createBablrStrategy: (strategy) => (matcher, props) =>
-    logStrategy(strategy(matcher, props), '    >>> '),
+  createBablrStrategy: (strategy) => (language, matcher, props) =>
+    logStrategy(strategy(language, matcher, props), '    >>> '),
   bablrProduction: createProductionLogger('>>> '),
 };
 

package/lib/grammar.js

@@ -2,7 +2,6 @@ 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 { buildExpression } from './builders.js';
 import { buildEmbeddedObject } from '@bablr/agast-vm-helpers/builders';
 
 export * from './decorators.js';
@@ -17,6 +16,21 @@ export const notNull = (facade) => {
   return facade && (facade.type !== null || facade.openTag.type !== NullTag);
 };
 
+export const mapOwnProductions = (fn, Grammar) => {
+  let { prototype } = Grammar;
+
+  class MappedGrammar extends Grammar {}
+
+  const mapped = MappedGrammar.prototype;
+
+  for (const key of [...getOwnPropertyNames(prototype), ...getOwnPropertySymbols(prototype)]) {
+    if (!hasOwn(mapped, key)) {
+      mapped[key] = fn(prototype[key], key);
+    }
+  }
+  return MappedGrammar;
+};
+
 export const mapProductions = (fn, Grammar) => {
   let { prototype } = Grammar;
 
@@ -81,30 +95,6 @@ export const resolveLanguage = (context, language, path) => {
   return l;
 };
 
-export const unresolveLanguage = (context, baseLanguage, absoluteLanguage) => {
-  if (absoluteLanguage == null || absoluteLanguage === baseLanguage.canonicalURL) {
-    return null;
-  }
-
-  for (const { 0: key, 1: value } of objectEntries(baseLanguage.dependencies)) {
-    if (value.canonicalURL === absoluteLanguage) {
-      return [key];
-    }
-  }
-
-  // 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) => {
   for (const type of types) {
     const explodedTypes = aliases.get(type);
@@ -206,14 +196,6 @@ export function* zipLanguages(tags, rootLanguage) {
   }
 }
 
-const safeShallowEmbed = (value) => {
-  if (typeof value !== 'object') {
-    return buildExpression(value);
-  } else {
-    return value;
-  }
-};
-
 const __buildCall = (verb, ...args) => {
   while (args.length && args[args.length - 1] === undefined) {
     args.pop();
@@ -238,8 +220,8 @@ export const guard = (matcher, value, options) => {
   return __buildCall('guard', matcher, value, options);
 };
 
-export const holdForMatch = (matcher, value, options) => {
-  return __buildCall('holdForMatch', matcher, value, options);
+export const shiftMatch = (matcher, value, options) => {
+  return __buildCall('shiftMatch', matcher, value, options);
 };
 
 export const fail = () => {

package/lib/index.js

@@ -6,7 +6,6 @@ export * as object from './object.js';
 export * as productions from './productions.js';
 export * as shorthand from './shorthand.js';
 export * as source from './source.js';
-export * as stream from './stream.js';
 export * as symbols from './symbols.js';
 export * as tree from './tree.js';
 export * as trivia from './trivia.js';

package/lib/object.js

@@ -1,20 +1,22 @@
 import map from 'iter-tools-es/methods/map';
+export {
+  isObject,
+  isArray,
+  isPlainObject,
+  isFunction,
+  isSymbol,
+  isString,
+  isType,
+  isRegex,
+  isPattern,
+} from '@bablr/agast-helpers/object';
 
 export const { hasOwn, getOwnPropertySymbols, getPrototypeOf, fromEntries } = Object;
 
-export const isObject = (obj) => obj !== null && typeof obj === 'object';
-export const { isArray } = Array;
-export const isFunction = (obj) => typeof obj === 'function';
-export const isSymbol = (obj) => typeof obj === 'symbol';
-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 {
     *[Symbol.iterator]() {
+      if (obj == null) return;
       for (let key in obj) if (hasOwn(obj, key)) yield key;
       yield* getOwnPropertySymbols(obj);
     },
@@ -24,6 +26,7 @@ export const objectKeys = (obj) => {
 export const objectValues = (obj) => {
   return {
     *[Symbol.iterator]() {
+      if (obj == null) return;
       for (let key in obj) if (hasOwn(obj, key)) yield obj[key];
       yield* map((sym) => obj[sym], getOwnPropertySymbols(obj));
     },
@@ -33,6 +36,7 @@ export const objectValues = (obj) => {
 export const objectEntries = (obj) => {
   return {
     *[Symbol.iterator]() {
+      if (obj == null) return;
       for (let key in obj) if (hasOwn(obj, key)) yield [key, obj[key]];
       yield* map((sym) => [sym, obj[sym]], getOwnPropertySymbols(obj));
     },

package/lib/productions.js

@@ -1,13 +1,13 @@
 /* @macrome
  * @generatedby @bablr/macrome-generator-bablr
- * @generatedfrom ./productions.macro.js#1fc6c6c7f7c9fc7c43a69d9729301c75581c11ea
+ * @generatedfrom ./productions.macro.js#a661312b1d84c6cc48eac8794f36c3b607a57892
  * 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 { get, getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
-import { EmbeddedMatcher } from './symbols.js';
+import { Matcher } from './symbols.js';
 import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
 import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
@@ -20,10 +20,10 @@ export function* List({
     allowHoles = false,
     allowTrailingSeparator = true
   } = 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`[]`)));
+  if (getCooked(get(['refMatcher', 'name', 'content'], getEmbeddedMatcher(separator)))) {
+    yield eat(buildEmbeddedMatcher(buildPropertyMatcher(get('refMatcher', getEmbeddedMatcher(separator)), null, m.ArrayNodeMatcher`[]`)));
   }
-  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher?.node, m.ArrayNodeMatcher`[]`)));
+  yield eat(buildEmbeddedMatcher(buildPropertyMatcher(get('refMatcher', getEmbeddedMatcher(Array.isArray(element) ? element[0] : element)), null, m.ArrayNodeMatcher`[]`)));
   let sep,
     it,
     anySep = false;
@@ -46,7 +46,7 @@ export function* Any({
   for (const alternative of alternatives) {
     if (Array.isArray(alternative)) {
       if (yield eatMatch(...alternative)) break;
-    } else if (alternative.type === EmbeddedMatcher) {
+    } else if (alternative.type === Matcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -74,10 +74,12 @@ export function* Optional({
   yield eatMatch(matcher);
 }
 export function* Literal({
-  intrinsicValue
+  ctx,
+  literalValue
 }) {
-  if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
-  yield eat(intrinsicValue);
+  if (!literalValue) throw new Error('Intrinsic productions must have value');
+  yield eat(ctx.sourceTextFor(literalValue.value));
 }
 export const Keyword = Literal;
-export const Punctuator = Literal;
+export const Punctuator = Literal;
+export const Space = Literal;

package/lib/productions.macro.js

@@ -1,7 +1,7 @@
 import { spam as m } from '@bablr/boot';
-import { getCooked } from '@bablr/agast-helpers/tree';
+import { get, getCooked } from '@bablr/agast-helpers/tree';
 import { eat, eatMatch } from './grammar.js';
-import { EmbeddedMatcher } from './symbols.js';
+import { Matcher } from './symbols.js';
 import { getEmbeddedMatcher } from '@bablr/agast-vm-helpers/deembed';
 import { buildPropertyMatcher } from './builders.js';
 import { buildEmbeddedMatcher } from '@bablr/agast-vm-helpers/builders';
@@ -9,18 +9,12 @@ 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.name.node.properties
-          .content.node,
-      ),
-    )
-  ) {
+  if (getCooked(get(['refMatcher', 'name', 'content'], getEmbeddedMatcher(separator)))) {
     yield eat(
       buildEmbeddedMatcher(
         buildPropertyMatcher(
-          getEmbeddedMatcher(separator).properties.refMatcher?.node,
+          get('refMatcher', getEmbeddedMatcher(separator)),
+          null,
           m.ArrayNodeMatcher`[]`,
         ),
       ),
@@ -30,8 +24,8 @@ export function* List({ props }) {
   yield eat(
     buildEmbeddedMatcher(
       buildPropertyMatcher(
-        getEmbeddedMatcher(Array.isArray(element) ? element[0] : element).properties.refMatcher
-          ?.node,
+        get('refMatcher', getEmbeddedMatcher(Array.isArray(element) ? element[0] : element)),
+        null,
         m.ArrayNodeMatcher`[]`,
       ),
     ),
@@ -56,7 +50,7 @@ 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) {
+    } else if (alternative.type === Matcher) {
       if (yield eatMatch(alternative)) break;
     } else {
       throw new Error();
@@ -78,11 +72,13 @@ export function* Optional({ props: { value: matcher } }) {
   yield eatMatch(matcher);
 }
 
-export function* Literal({ intrinsicValue }) {
-  if (!intrinsicValue) throw new Error('Intrinsic productions must have value');
+export function* Literal({ ctx, literalValue }) {
+  if (!literalValue) throw new Error('Intrinsic productions must have value');
 
-  yield eat(intrinsicValue);
+  yield eat(ctx.sourceTextFor(literalValue.value));
 }
 export const Keyword = Literal;
 
 export const Punctuator = Literal;
+
+export const Space = Literal;

package/lib/source.js

@@ -142,7 +142,7 @@ function* __sourceFromTokenStream(tags) {
     step = iter.next();
 
     if (step instanceof Promise) {
-      yield step;
+      step = yield step;
     }
 
     if (step.done) break;

package/lib/tree.js

@@ -1,8 +1,6 @@
 import { streamFromTree } from '@bablr/agast-helpers/tree';
-
-import { printPrettyCSTML as printPrettyCSTMLFromStream } from './stream.js';
+import { printPrettyCSTML as printPrettyCSTMLFromStream } from '@bablr/agast-helpers/stream';
 
 export const printPrettyCSTML = (rootNode, options = {}) => {
-  // i need a context-aware streamFromTree here to build a stream with linked Tags...?
   return printPrettyCSTMLFromStream(streamFromTree(rootNode), options);
 };

package/lib/trivia.js

@@ -1,16 +1,139 @@
+/* global WeakSet */
 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 { eat, eatMatch, mapOwnProductions, mapProductions, o } from './grammar.js';
+import {
+  Matcher,
+  Regex,
+  Node,
+  OpenNodeTag,
+  CloseNodeTag,
+  ReferenceTag,
+  Property,
+} 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 { get, getCooked } from '@bablr/agast-helpers/tree';
+import { buildPathSegment } from '@bablr/agast-helpers/path';
+
+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;
+};
+
+const matchedResults = new WeakSet();
+
+export const basicTriviaEnhancer = ({ triviaIsAllowed, triviaMatcher }, grammar) => {
+  let Wrapper_ = 'Wrapper';
+  let Literal_ = 'Literal';
+
+  while (grammar.prototype[Wrapper_]) Wrapper_ += '_';
+  while (grammar.prototype[Literal_]) Literal_ += '_';
+
+  const resultGrammar = mapOwnProductions((production) => {
+    return function* (props) {
+      const co = new Coroutine(production(props));
+      const { s, ctx, flags, isCover, isCovered } = props;
+
+      co.advance();
+
+      try {
+        while (!co.done) {
+          const instr = co.value;
+          const { verb, arguments: args = [] } = instr;
+          let returnValue = undefined;
+
+          switch (verb) {
+            case 'eat':
+            case 'eatMatch':
+            case 'match':
+            case 'guard': {
+              const { 0: matcher } = args;
+
+              if (
+                matcher &&
+                !isCovered &&
+                matcher.type === Matcher &&
+                getCooked(get(['refMatcher', 'type', 'value'], matcher.value)) !== '#'
+              ) {
+                const previous = lookbehind(ctx, s);
+                if (triviaIsAllowed(s) && (!previous || !matchedResults.has(previous))) {
+                  matchedResults.add(previous);
+                  yield eatMatch(triviaMatcher);
+                  matchedResults.add(s.resultPath);
+                }
+              }
+
+              returnValue = returnValue || (yield instr);
+              break;
+            }
+
+            default:
+              returnValue = yield instr;
+              break;
+          }
+
+          co.advance(returnValue);
+        }
+
+        if (co.value) {
+          let realMatcher = reifyExpression(get('nodeMatcher', co.value.arguments[0].value));
+          let { flags: matcherFlags } = realMatcher;
+
+          let isNode = matcherFlags && !matcherFlags.fragment;
+
+          if (
+            !flags.token &&
+            isNode &&
+            !isCover &&
+            (!s.depths.path || (co.value && ['shift', 'shiftMatch'].includes(co.value.verb)))
+          ) {
+            if (triviaIsAllowed(s)) {
+              yield eatMatch(triviaMatcher);
+            }
+          }
+
+          return co.value;
+        } else {
+          if (!s.depths.path && !flags.token && !isCovered) {
+            if (triviaIsAllowed(s)) {
+              yield eatMatch(triviaMatcher);
+            }
+          }
+        }
+      } catch (e) {
+        co.throw(e);
+        throw e;
+      }
+    };
+  }, grammar);
+
+  return class extends resultGrammar {
+    *[Wrapper_]({ value: wrapped }) {
+      for (const instr of wrapped) {
+        yield getEmbeddedInstruction(instr);
+      }
+    }
+
+    *[Literal_]({ value: matcher }) {
+      yield eat(matcher);
+    }
+  };
+};
 
 export const triviaEnhancer = (
   { triviaIsAllowed, triviaIsRequired = () => false, triviaMatcher },
   grammar,
 ) => {
+  if (!triviaMatcher) throw new Error();
+
   let Wrapper_ = 'Wrapper';
   let Literal_ = 'Literal';
 
@@ -18,9 +141,9 @@ export const triviaEnhancer = (
   while (grammar.prototype[Literal_]) Literal_ += '_';
 
   const resultGrammar = mapProductions((production) => {
-    return function* (props) {
-      const co = new Coroutine(production(props));
-      const { ctx, s, isCovered, isCover, flags } = props;
+    return function* (args) {
+      const co = new Coroutine(production(args));
+      const { ctx, s, isCovered, isCover, isCoverBoundary, flags, mergedReference } = args;
 
       co.advance();
 
@@ -38,9 +161,9 @@ export const triviaEnhancer = (
               const { 0: matcher, 1: props, 2: options } = args;
 
               if (
-                matcher.type === EmbeddedMatcher &&
+                matcher.type === Matcher &&
                 ['ArrayNodeMatcher', 'NullNodeMatcher'].includes(
-                  matcher.value.properties.nodeMatcher.node.type.description,
+                  get('nodeMatcher', matcher.value).type.description,
                 )
               ) {
                 returnValue = yield instr;
@@ -48,64 +171,90 @@ export const triviaEnhancer = (
               }
 
               if (
-                matcher.type === EmbeddedRegex ||
+                matcher.type === Regex ||
                 typeof matcher === 'string' ||
-                (matcher.type === EmbeddedNode && matcher.value.flags.token)
+                (matcher.type === Node && matcher.value.flags.token)
               ) {
                 if (triviaIsAllowed(s) && !flags.token) {
                   let isString = typeof matcher === 'string';
-                  let wrappedMatcher = m`value: <*Literal ${
+                  let wrappedMatcher = m`#: <*Literal ${
                     isString ? buildString(matcher) : matcher.value
                   } />`;
 
-                  let tmi = buildEmbeddedInstruction(
-                    triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
-                  );
+                  let tmi = buildEmbeddedInstruction(eatMatch(triviaMatcher));
 
-                  let result = yield buildCall(verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+                  let result = yield buildCall(verb, m`<__${buildIdentifier(Wrapper_)} />`, [
                     tmi,
                     buildEmbeddedInstruction(eat(wrappedMatcher, props, options)),
                   ]);
 
-                  returnValue = result?.get('value');
+                  let prop = null;
+
+                  if (result) {
+                    for (let child of result.tagsInner) {
+                      if (child.type === Property) prop = child.value;
+                    }
+                  }
+
+                  returnValue = prop?.node;
                 } else {
                   returnValue = yield instr;
                 }
                 break;
               }
 
-              let { name } = reifyExpression(matcher.value.properties.refMatcher?.node) || {};
-              let realMatcher = reifyExpression(matcher.value.properties.nodeMatcher?.node);
+              let { type: refType } = reifyExpression(get('refMatcher', matcher.value)) || {};
+              let realMatcher = reifyExpression(get('nodeMatcher', matcher.value));
               let { flags: matcherFlags } = realMatcher;
 
               let isNode = matcherFlags && !matcherFlags.fragment;
               let isCoverBoundary = matcherFlags && (matcherFlags.cover || (isNode && !isCovered));
               if (
                 matcher &&
-                (matcher.type !== EmbeddedMatcher || name !== '#') &&
+                (matcher.type !== Matcher || refType !== '#') &&
                 !s.holding &&
                 !flags.token &&
                 isCoverBoundary
               ) {
                 if (triviaIsAllowed(s)) {
+                  let { nodeMatcher } = reifyExpression(matcher.value);
+
                   let tmi = buildEmbeddedInstruction(
-                    triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
+                    triviaIsRequired(s, nodeMatcher) ? eat(triviaMatcher) : eatMatch(triviaMatcher),
                   );
 
                   let result = yield buildCall(
                     verb,
-                    m`<_${buildIdentifier(Wrapper_)} />`,
+                    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);
+                    if (isNode || isCoverBoundary) {
+                      let refMatcher = get('refMatcher', matcher.value);
+
+                      let name, isArray;
+
+                      if (!refMatcher) {
+                        ({ name, isArray } = mergedReference);
+                      } else {
+                        let name_ = get('name', refMatcher);
+                        let openIndexToken = get('openIndexToken', refMatcher);
+                        name = name_ && ctx.sourceTextFor(name_);
+                        isArray = !!openIndexToken;
+                      }
+
+                      if (name) {
+                        let pathSpec = name;
+
+                        if (isArray) {
+                          pathSpec = buildPathSegment(name, -1);
+                        }
+
+                        result = result.get([pathSpec]);
+                      }
                     }
 
                     result = result && result.merge(trivialResult);
@@ -128,14 +277,13 @@ export const triviaEnhancer = (
           co.advance(returnValue);
         }
 
-        if (!s.depths.path && !flags.token && !(isCovered || isCover)) {
+        if (!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 matcher = co.value.arguments[0];
+          let realMatcher = reifyExpression(get('nodeMatcher', matcher.value));
           let { flags: matcherFlags } = realMatcher;
 
           let isNode = matcherFlags && !matcherFlags.fragment;
@@ -145,16 +293,48 @@ export const triviaEnhancer = (
             isNode &&
             !isCover &&
             co.value &&
-            ['holdFor', 'holdForMatch'].includes(co.value.verb)
+            ['shift', 'shiftMatch'].includes(co.value.verb)
           ) {
             if (triviaIsAllowed(s)) {
               let tmi = buildEmbeddedInstruction(
                 triviaIsRequired() ? eat(triviaMatcher) : eatMatch(triviaMatcher),
               );
-              return buildCall(co.value.verb, m`<_${buildIdentifier(Wrapper_)} />`, [
+              let result = yield buildCall(co.value.verb, m`<__${buildIdentifier(Wrapper_)} />`, [
                 tmi,
                 buildEmbeddedInstruction(eat(co.value.arguments[0], co.value.arguments[1])),
               ]);
+
+              let trivialResult = result;
+
+              if (result && !result.isNull) {
+                if (isNode || isCoverBoundary) {
+                  let refMatcher = get('refMatcher', matcher.value);
+
+                  let name, isArray;
+
+                  if (!refMatcher) {
+                    ({ name, isArray } = mergedReference);
+                  } else {
+                    let name = get('name', refMatcher);
+                    let openIndexToken = get('openIndexToken', refMatcher);
+                    name = name && ctx.sourceTextFor(name);
+                    isArray = !!openIndexToken;
+                  }
+
+                  if (name) {
+                    let pathSpec = name;
+
+                    if (isArray) {
+                      pathSpec = buildPathSegment(name, -1);
+                    }
+
+                    result = result.get([pathSpec]);
+                  }
+                }
+
+                result = result && result.merge(trivialResult);
+              }
+              return result;
             }
           }
         }
@@ -194,8 +374,8 @@ export const triviaEnhancer = (
       }
     }
 
-    *[Literal_]({ intrinsicValue }) {
-      yield eat(intrinsicValue);
+    *[Literal_]({ literalValue }) {
+      yield eat(literalValue);
     }
   };
 };