@bablr/bablr-vm 0.17.0 → 0.18.0

package/lib/context.js

@@ -0,0 +1,75 @@
+import { buildDependentLanguages } from '@bablr/helpers/grammar';
+import { facades, actuals } from '../../bablr-vm-strategy-parse/lib/facades.js';
+import { getPrototypeOf } from '@bablr/helpers/object';
+import { actuals as nodeActuals } from './node.js';
+
+export const ContextFacade = class BABLRContextFacade {
+  get languages() {
+    return actuals.get(this).languages;
+  }
+
+  get grammars() {
+    return actuals.get(this).grammars;
+  }
+
+  get productionEnhancer() {
+    return actuals.get(this).productionEnhancer;
+  }
+
+  get agast() {
+    return actuals.get(this).agast;
+  }
+
+  getPreviousTag(token) {
+    return actuals.get(this).agast.getPreviousTag(token);
+  }
+
+  allTagsFor(range) {
+    return actuals.get(this).agast.allTagsFor(range);
+  }
+
+  ownTagsFor(range) {
+    return actuals.get(this).agast.ownTagsFor(range);
+  }
+
+  getCooked(node) {
+    return actuals.get(this).agast.getCooked(actuals.get(node));
+  }
+
+  reifyExpression(value) {
+    return actuals.get(this).agast.reifyExpression(value);
+  }
+
+  sourceTextFor(node) {
+    return actuals.get(this).agast.sourceTextFor(nodeActuals.get(node));
+  }
+
+  unbox(value) {
+    return actuals.get(this).agast.unbox(value);
+  }
+};
+
+export const Context = class BABLRContext {
+  static from(agastContext, language, productionEnhancer) {
+    return new Context(agastContext, buildDependentLanguages(language), productionEnhancer);
+  }
+
+  constructor(agastContext, languages, productionEnhancer) {
+    this.agast = agastContext;
+    this.languages = languages;
+    this.productionEnhancer = productionEnhancer;
+
+    this.grammars = new WeakMap();
+    this.facade = new ContextFacade();
+
+    for (const { 1: language } of this.languages) {
+      let { prototype } = language.grammar;
+      while (prototype && prototype !== Object.prototype) {
+        prototype = getPrototypeOf(prototype);
+      }
+      this.grammars.set(language, new language.grammar());
+    }
+
+    facades.set(this, this.facade);
+  }
+};

package/lib/index.js

@@ -1,3 +1,5 @@
 export { createBablrStrategy } from './strategy.js';
 
 export { Source } from './source.js';
+
+export { Context } from './context.js';

package/lib/node.js

@@ -0,0 +1,97 @@
+import { parsePath } from '@bablr/agast-helpers/path';
+import { ReferenceTag } from '@bablr/agast-helpers/symbols';
+import {
+  buildGapTag,
+  buildStubNode,
+  get,
+  getCloseTag,
+  getOpenTag,
+} from '@bablr/agast-helpers/tree';
+import * as btree from '@bablr/agast-helpers/btree';
+
+const { hasOwn } = Object;
+
+export const contexts = new WeakMap();
+export const actuals = new WeakMap();
+// eslint-disable-next-line no-undef
+export const transparentFacades = new WeakSet();
+
+export const NodeFacade = class BABLRNodeFacade {
+  static wrap(node, context, transparent) {
+    if (!node || !context) throw new Error();
+    return node && new NodeFacade(node, context, transparent);
+  }
+
+  constructor(node, context, transparent) {
+    actuals.set(this, node);
+    contexts.set(this, context);
+    if (transparent) {
+      transparentFacades.add(this);
+    }
+  }
+
+  get isTransparent() {
+    return transparentFacades.has(this);
+  }
+
+  get children() {
+    const node = actuals.get(this);
+    const isTransparent = transparentFacades.has(this);
+    return {
+      *[Symbol.iterator]() {
+        if (isTransparent) {
+          yield* btree.traverse(node.children);
+        } else {
+          for (const child of btree.traverse(node.children)) {
+            const interpolated = false; // TODO
+            if (!interpolated) {
+              yield child;
+            }
+          }
+        }
+      },
+    };
+  }
+
+  get flags() {
+    return actuals.get(this).flags;
+  }
+
+  get language() {
+    return actuals.get(this).language;
+  }
+
+  get type() {
+    return actuals.get(this).type;
+  }
+
+  get attributes() {
+    return actuals.get(this).attributes;
+  }
+
+  get openTag() {
+    return getOpenTag(actuals.get(this));
+  }
+
+  get closeTag() {
+    return getCloseTag(actuals.get(this));
+  }
+
+  get(path) {
+    const context = contexts.get(this);
+    const node = get(actuals.get(this), path);
+    const isTransparent = transparentFacades.has(this);
+
+    const ref = node && context.agast.getPreviousTag(btree.getAt(0, node.children));
+    const node_ =
+      (ref && ref.type === ReferenceTag && !ref.value.hasGap) || isTransparent
+        ? node
+        : buildStubNode(buildGapTag());
+
+    return node && NodeFacade.wrap(node_, context, isTransparent);
+  }
+
+  has(path) {
+    return hasOwn(actuals.get(this).properties, parsePath(path).name);
+  }
+};

package/lib/source.js

@@ -1,6 +1,6 @@
 import { WeakStackFrame } from '@bablr/weak-stack';
 import { maybeWait, getStreamIterator, emptyStreamIterator } from '@bablr/agast-helpers/stream';
-import { facades, actuals } from './facades.js';
+import { facades, actuals } from '../../bablr-vm-strategy-parse/lib/facades.js';
 
 // Queue item instances are shared between all forks.
 class QueueItem {

package/lib/spans.js

@@ -1,30 +1,24 @@
-import { getAt } from '@bablr/agast-helpers/btree';
+import { ReferenceTag } from '@bablr/agast-helpers/symbols';
 import { getOpenTag } from '@bablr/agast-helpers/tree';
 
 export function updateSpans(ctx, s, node, phase) {
+  const { flags, attributes } = node;
+
+  const openTag = getOpenTag(node);
+
+  const ref = ctx.agast.getPreviousTag(openTag);
+
+  const intrinsic = ref.type === ReferenceTag && !ref.hasGap;
+
   switch (phase) {
     case 'open': {
-      const { attributes, flags } = node;
-      const { span: innerSpan, balanced, balancedSpan, balancer, openSpan } = attributes || {};
+      const { balancedSpan, span: innerSpan, balanced, balancer, openSpan } = attributes || {};
 
-      if (!flags.intrinsic && (balancer || balanced)) {
+      if (!intrinsic && (balancer || balanced)) {
         throw new Error('balanced tokens must be instrinsic');
       }
 
-      if (flags.intrinsic) {
-        if (s.path && balanced) {
-          s.spans = s.spans.push({
-            type: 'Lexical',
-            name: balancedSpan || s.span.name,
-            path: s.path,
-            guard: balanced,
-          });
-
-          if (innerSpan) {
-            throw new Error();
-          }
-        }
-      }
+      if (balancedSpan && !balanced) throw new Error();
 
       if (openSpan) {
         s.spans = s.spans.push({
@@ -40,7 +34,7 @@ export function updateSpans(ctx, s, node, phase) {
 
         if (!s.balanced.size) throw new Error();
 
-        if (!getOpenTag(balancedNode).value.attributes.balanced) {
+        if (!balancedNode.attributes.balanced) {
           throw new Error();
         }
 
@@ -49,10 +43,6 @@ export function updateSpans(ctx, s, node, phase) {
         s.spans = s.spans.pop();
       }
 
-      if (balanced) {
-        s.balanced = s.balanced.push(s.nodeForTag(s.result));
-      }
-
       if (innerSpan) {
         s.spans = s.spans.push({
           type: 'Inner',
@@ -66,15 +56,16 @@ export function updateSpans(ctx, s, node, phase) {
     }
 
     case 'close': {
-      const { flags, attributes } = node;
       const { balancedSpan, span: innerSpan, closeSpan, balanced } = attributes || {};
 
-      if (balanced && !flags.intrinsic) {
+      if (balanced) {
+        s.balanced = s.balanced.push(s.nodeForTag(s.result));
+
         s.spans = s.spans.push({
           type: 'Lexical',
           name: balancedSpan || s.span.name,
           path: s.path,
-          guard: balanced,
+          guard: balanced === true ? null : balanced,
         });
       }
 

package/lib/state.js

@@ -2,9 +2,10 @@ import emptyStack from '@iter-tools/imm-stack';
 import { WeakStackFrame } from '@bablr/weak-stack';
 import { getCooked } from '@bablr/agast-helpers/stream';
 import { match, guardWithPattern } from './utils/pattern.js';
-import { facades, actuals } from './facades.js';
+import { facades, actuals } from '../../bablr-vm-strategy-parse/lib/facades.js';
 import { reifyExpression } from '@bablr/agast-vm-helpers';
-import { EmbeddedNode } from '@bablr/agast-helpers/symbols';
+import { EmbeddedNode, GapTag } from '@bablr/agast-helpers/symbols';
+import { NodeFacade } from './node.js';
 
 export const StateFacade = class BABLRStateFacade {
   constructor(state) {
@@ -15,6 +16,10 @@ export const StateFacade = class BABLRStateFacade {
     return State.from(actuals.get(source));
   }
 
+  get ctx() {
+    return actuals.get(this).context;
+  }
+
   get span() {
     return actuals.get(this).span.name;
   }
@@ -32,11 +37,11 @@ export const StateFacade = class BABLRStateFacade {
   }
 
   get node() {
-    return actuals.get(this).node;
+    return NodeFacade.wrap(actuals.get(this).node, this.ctx);
   }
 
   get parentNode() {
-    return actuals.get(this).parentNode;
+    return NodeFacade.wrap(actuals.get(this).parentNode, this.ctx);
   }
 
   get source() {
@@ -52,7 +57,7 @@ export const StateFacade = class BABLRStateFacade {
   }
 
   nodeForPath(path) {
-    return actuals.get(this).nodeForPath(path);
+    return NodeFacade.wrap(actuals.get(this).nodeForPath(path), this.ctx);
   }
 
   pathForTag(tag) {
@@ -60,18 +65,25 @@ export const StateFacade = class BABLRStateFacade {
   }
 
   nodeForTag(tag) {
-    return actuals.get(this).nodeForTag(tag);
+    return NodeFacade.wrap(actuals.get(this).nodeForTag(tag), this.ctx);
   }
 };
 
 export const State = class BABLRState extends WeakStackFrame {
-  constructor(source, agast, balanced = emptyStack, spans = emptyStack.push({ name: 'Bare' })) {
+  constructor(
+    source,
+    agast,
+    context,
+    balanced = emptyStack,
+    spans = emptyStack.push({ name: 'Bare' }),
+  ) {
     super();
 
     if (!source || !agast) throw new Error('invalid args to State');
 
     this.source = source;
     this.agast = agast;
+    this.context = context;
     this.balanced = balanced;
     this.spans = spans;
 
@@ -80,8 +92,8 @@ export const State = class BABLRState extends WeakStackFrame {
     new StateFacade(this);
   }
 
-  static from(source, agast) {
-    return State.create(source, agast);
+  static from(source, agast, context) {
+    return State.create(source, agast, context);
   }
 
   get guardedSource() {
@@ -116,7 +128,7 @@ export const State = class BABLRState extends WeakStackFrame {
   }
 
   get isGap() {
-    return this.tag.type === 'NodeGapTag';
+    return this.tag.type === GapTag;
   }
 
   get speculative() {

package/lib/strategy.js

@@ -1,4 +1,3 @@
-import size from 'iter-tools-es/methods/size';
 import { Coroutine } from '@bablr/coroutine';
 import {
   buildCall,
@@ -8,9 +7,8 @@ import {
   buildArrayTag,
 } from '@bablr/agast-helpers/builders';
 import { StreamGenerator } from '@bablr/agast-helpers/stream';
-import { buildTokens } from './utils/token.js';
 import { formatType } from './utils/format.js';
-import { facades } from './facades.js';
+import { facades } from '../../bablr-vm-strategy-parse/lib/facades.js';
 import { State } from './state.js';
 import { updateSpans } from './spans.js';
 import {
@@ -23,11 +21,26 @@ import {
   NullTag,
   LiteralTag,
 } from '@bablr/agast-helpers/symbols';
+import { NodeFacade } from './node.js';
+import { treeFromStreamSync } from '@bablr/agast-helpers/tree';
+
+const getSourceLength = (tags) => {
+  let i = 0;
+  for (const tag of tags) {
+    if (tag.type === LiteralTag) {
+      i += tag.value.length;
+    } else if (tag.type === GapTag) {
+      i += 1;
+    }
+  }
+  return i;
+};
 
 const { hasOwn } = Object;
 
-export const createBablrStrategy = (rootSource, strategy) => {
-  return (ctx, agastState) => {
+export const createBablrStrategy = (ctx, rootSource, strategy) => {
+  return (agastCtx, agastState) => {
+    if (agastCtx !== ctx.agast.facade) throw new Error();
     return new StreamGenerator(__strategy(ctx, rootSource, agastState, strategy));
   };
 };
@@ -35,9 +48,9 @@ export const createBablrStrategy = (rootSource, strategy) => {
 const resolvedLanguages = new WeakMap();
 
 const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy) {
-  let s = State.from(rootSource, agastState);
+  let s = State.from(rootSource, agastState, ctx);
 
-  let co = new Coroutine(strategy(facades.get(s), ctx));
+  let co = new Coroutine(strategy(facades.get(s), facades.get(ctx)));
 
   co.advance();
 
@@ -93,7 +106,18 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           case CloseNodeTag: {
             const { node } = s;
 
-            const endTag = yield instr;
+            if (node.flags.escape) {
+              const cooked = node.flags.hasGap
+                ? null
+                : ctx.languages
+                    .get(node.language)
+                    .getCooked?.(NodeFacade.wrap(node, ctx, true), s.span.name, facades.get(ctx)) ||
+                  null;
+
+              yield buildCall('bindAttribute', 'cooked', cooked);
+            }
+
+            const closeTag = yield instr;
 
             if (s.path) {
               updateSpans(ctx, s, node, 'close');
@@ -107,7 +131,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
               }
             }
 
-            returnValue = endTag;
+            returnValue = closeTag;
             break;
           }
 
@@ -121,7 +145,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
             }
 
             if (result) {
-              let sourceStep = s.source.advance(size(result));
+              let sourceStep = s.source.advance(getSourceLength(result));
 
               if (sourceStep instanceof Promise) {
                 sourceStep = yield sourceStep;
@@ -178,19 +202,17 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           result = yield result;
         }
 
-        const tokens = result && ctx.buildRange(buildTokens(result));
-
-        returnValue = tokens || null;
+        returnValue = result && NodeFacade.wrap(treeFromStreamSync(result), ctx, true);
         break;
       }
 
       case 'branch': {
         const baseState = s;
-        let { source, agast, balanced, spans, node } = baseState;
+        let { source, agast, context, balanced, spans, node } = baseState;
 
         agast = yield instr;
 
-        s = s.push(source.branch(), agast, balanced, spans);
+        s = s.push(source.branch(), agast, context, balanced, spans);
 
         if (node) {
           resolvedLanguages.set(s.node, resolvedLanguages.get(node));
@@ -232,7 +254,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
 
         s = s.parent;
 
-        if (s.path.depth && rejectedState.path.depth > s.path.depth) {
+        if (s.path.depth && rejectedState.path.depth >= s.path.depth) {
           // const didShift = rejectedState.node.at(sNodeDepth) === s.node;
           const didShift =
             s.nodeForPath(s.path) && !s.nodeForPath(rejectedState.path.at(s.path.depth));
@@ -244,7 +266,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           );
           const lowNode = s.node || s.parentNode;
 
-          const { name, isArray } = lowPath.reference?.value || {};
+          const { name, isArray, hasGap } = lowPath.reference?.value || {};
 
           if (
             !didShift &&
@@ -252,10 +274,13 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
             !(s.result.type === ReferenceTag && s.result.value.name === name)
           ) {
             if (isArray) {
-              yield buildCall('advance', buildEmbeddedTag(buildReferenceTag(name, true)));
+              yield buildCall('advance', buildEmbeddedTag(buildReferenceTag(name, true, hasGap)));
               yield buildCall('advance', buildEmbeddedTag(buildArrayTag()));
             } else {
-              yield buildCall('advance', buildEmbeddedTag(buildReferenceTag(name)));
+              yield buildCall(
+                'advance',
+                buildEmbeddedTag(buildReferenceTag(name, isArray, hasGap)),
+              );
               yield buildCall('advance', buildEmbeddedTag(buildNullTag()));
             }
           }
@@ -269,6 +294,18 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
         break;
       }
 
+      case 'openSpan': {
+        let { arguments: { 0: name } = [] } = instr;
+        s.spans = s.spans.push({ guard: null, name, path: s.path, type: 'Instruction' });
+        break;
+      }
+
+      case 'closeSpan': {
+        if (s.spans.value.type !== 'Instruction') throw new Error();
+        s.spans = s.spans.pop();
+        break;
+      }
+
       case 'write':
       case 'bindAttribute': {
         returnValue = yield instr;

package/lib/utils/pattern.js

@@ -57,7 +57,7 @@ class GuardedIterator {
     const guardMatch = match(pattern, fork.clone());
 
     return maybeWait(guardMatch, (guardMatch) => {
-      if (guardMatch || this.done) {
+      if (guardMatch || fork.done) {
         this.done = true;
         return { value: undefined, done: true };
       } else {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bablr/bablr-vm",
   "description": "A VM for parsing using BABLR languages",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "author": "Conrad Buck<conartist6@gmail.com>",
   "type": "module",
   "files": [
@@ -12,11 +12,11 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@bablr/agast-helpers": "0.4.0",
-    "@bablr/agast-vm-helpers": "0.4.0",
+    "@bablr/agast-helpers": "^0.5.0",
+    "@bablr/agast-vm-helpers": "^0.5.0",
     "@bablr/coroutine": "0.1.0",
-    "@bablr/helpers": "0.19.0",
-    "@bablr/regex-vm": "0.8.1",
+    "@bablr/helpers": "^0.20.0",
+    "@bablr/regex-vm": "^0.9.0",
     "@bablr/weak-stack": "0.1.0",
     "@iter-tools/imm-stack": "1.1.0",
     "iter-tools-es": "^7.5.3"

package/lib/facades.js

@@ -1,3 +0,0 @@
-import { buildFacadeLayer } from '@bablr/agast-vm-helpers/facades';
-
-export const { facades, actuals } = buildFacadeLayer();