@bablr/bablr-vm 0.15.0 → 0.16.0

package/lib/spans.js

@@ -10,7 +10,7 @@ export function updateSpans(ctx, s, node, phase) {
 
       if (flags.intrinsic) {
         if (s.path && balanced) {
-            s.spans = s.spans.push({
+          s.spans = s.spans.push({
             type: 'Lexical',
             name: balancedSpan || s.span.name,
             path: s.path,
@@ -37,7 +37,7 @@ export function updateSpans(ctx, s, node, phase) {
 
         if (!s.balanced.size) throw new Error();
 
-        if (!balancedNode.openTag.value.attributes.balanced) {
+        if (!balancedNode.children[0].value.attributes.balanced) {
           throw new Error();
         }
 
@@ -47,7 +47,7 @@ export function updateSpans(ctx, s, node, phase) {
       }
 
       if (balanced) {
-        s.balanced = s.balanced.push(ctx.nodeForTag(s.result));
+        s.balanced = s.balanced.push(s.nodeForTag(s.result));
       }
 
       if (innerSpan) {
@@ -63,8 +63,7 @@ export function updateSpans(ctx, s, node, phase) {
     }
 
     case 'close': {
-      const { openTag, flags } = node;
-      const { attributes } = openTag.value;
+      const { flags, attributes } = node;
       const { balancedSpan, span: innerSpan, closeSpan, balanced } = attributes || {};
 
       if (balanced && !flags.intrinsic) {

package/lib/state.js

@@ -3,6 +3,7 @@ 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 { reifyExpression } from '@bablr/agast-vm-helpers';
 
 export const StateFacade = class BABLRStateFacade {
   constructor(state) {
@@ -48,6 +49,18 @@ export const StateFacade = class BABLRStateFacade {
   get status() {
     return actuals.get(this).status;
   }
+
+  nodeForPath(path) {
+    return actuals.get(this).nodeForPath(path);
+  }
+
+  pathForTag(tag) {
+    return actuals.get(this).pathForTag(tag);
+  }
+
+  nodeForTag(tag) {
+    return actuals.get(this).nodeForTag(tag);
+  }
 };
 
 export const State = class BABLRState extends WeakStackFrame {
@@ -109,10 +122,37 @@ export const State = class BABLRState extends WeakStackFrame {
     return !!this.parent;
   }
 
+  nodeForPath(path) {
+    return this.agast.nodeForPath(path);
+  }
+
+  pathForTag(tag) {
+    return this.agast.pathForTag(tag);
+  }
+
+  nodeForTag(tag) {
+    return this.agast.nodeForTag(tag);
+  }
+
   guardedMatch(pattern) {
-    let { span, spans, source } = this;
+    let { span, spans, source, node } = this;
     let { guard } = span;
 
+    if (pattern.type === 'EmbeddedNode') {
+      pattern = reifyExpression(pattern.value);
+    }
+
+    if (
+      span.type === 'Lexical' &&
+      (node.flags.token
+        ? node.attributes.balancer || node.attributes.balanced
+        : pattern.attributes?.balancer)
+    ) {
+      // also check that the open node starts a lexical span?
+      span = spans.prev.value;
+      ({ guard } = span);
+    }
+
     if (pattern?.intrinsicValue) {
       // if (pattern.type === 'OpenNodeTag') {
 
@@ -120,15 +160,11 @@ export const State = class BABLRState extends WeakStackFrame {
       //   pattern = pattern.value;
       // }
 
-      ({ guard } = span);
+      pattern = pattern.intrinsicValue || getCooked(pattern.children);
 
-      if (span.type === 'Lexical' && pattern.attributes.balancer) {
-        // also check that the open node starts a lexical span?
-        span = spans.prev.value;
-        ({ guard } = span);
+      if (pattern.type === 'String') {
+        pattern = reifyExpression(pattern);
       }
-
-      pattern = pattern.intrinsicValue || getCooked(pattern.children);
     }
 
     return match(pattern, guard ? guardWithPattern(guard, source) : source);

package/lib/strategy.js

@@ -1,12 +1,20 @@
 import { Coroutine } from '@bablr/coroutine';
-import { buildCall, buildNull, buildReference, reifyExpression } from '@bablr/agast-vm-helpers';
+import {
+  buildCall,
+  buildReference,
+  buildNull,
+  buildEmbeddedTag,
+} from '@bablr/agast-helpers/builders';
 import { StreamGenerator } from '@bablr/agast-helpers/stream';
+import { getOpenTag } from '@bablr/agast-helpers/tree';
 import { buildTokens } from './utils/token.js';
 import { formatType } from './utils/format.js';
 import { facades } from './facades.js';
 import { State } from './state.js';
 import { updateSpans } from './spans.js';
 
+const { hasOwn } = Object;
+
 export const createBablrStrategy = (rootSource, strategy) => {
   return (ctx, agastState) => {
     return new StreamGenerator(__strategy(ctx, rootSource, agastState, strategy));
@@ -39,53 +47,32 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
 
     if (co.done) break;
 
-    const sourceInstr = co.value;
-    const instr = reifyExpression(sourceInstr);
+    const instr = co.value;
     let returnValue = undefined;
 
     const { verb } = instr;
 
     switch (verb) {
       case 'advance': {
-        const {
-          arguments: { 0: terminal = [] },
-        } = instr;
+        const { arguments: { 0: embeddedTerminal } = [] } = instr;
+
+        const terminal = embeddedTerminal.value;
 
         switch (terminal?.type || 'Null') {
           case 'DoctypeTag': {
-            const doctypeTag = yield sourceInstr;
+            const doctypeTag = yield instr;
 
             returnValue = doctypeTag;
             break;
           }
 
           case 'OpenNodeTag': {
-            const { type, intrinsicValue } = terminal.value;
+            const { type } = terminal.value;
 
-            const openTag = yield sourceInstr;
+            const openTag = yield instr;
 
             if (type) {
-              let intrinsicResult = intrinsicValue && s.guardedMatch(terminal.value);
-
-              if (intrinsicResult instanceof Promise) {
-                intrinsicResult = yield intrinsicResult;
-              }
-
-              updateSpans(ctx, s, ctx.nodeForTag(openTag), 'open');
-
-              if (intrinsicValue) {
-                if (!intrinsicResult) {
-                  throw new Error('advance failed to match an intrinsic node');
-                }
-
-                const sourceStep = s.source.advance(intrinsicResult.length);
-
-                if (sourceStep instanceof Promise) {
-                  yield sourceStep;
-                }
-
-                updateSpans(ctx, s, ctx.nodeForTag(openTag), 'close');
-              }
+              updateSpans(ctx, s, s.node, 'open');
             }
 
             returnValue = openTag;
@@ -95,7 +82,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           case 'CloseNodeTag': {
             const { node } = s;
 
-            const endTag = yield sourceInstr;
+            const endTag = yield instr;
 
             if (s.path) {
               updateSpans(ctx, s, node, 'close');
@@ -129,7 +116,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
                 sourceStep = yield sourceStep;
               }
 
-              returnValue = yield sourceInstr;
+              returnValue = yield instr;
             } else {
               throw new Error('Failed to advance literal');
             }
@@ -148,7 +135,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
                 }
               }
 
-              returnValue = yield sourceInstr;
+              returnValue = yield instr;
             } else {
               throw new Error('Failed to advance gap');
             }
@@ -158,12 +145,12 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           case 'Shift': {
             s.source.shift();
 
-            returnValue = yield sourceInstr;
+            returnValue = yield instr;
             break;
           }
 
           default: {
-            returnValue = yield sourceInstr;
+            returnValue = yield instr;
             break;
           }
         }
@@ -180,7 +167,9 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
           result = yield result;
         }
 
-        returnValue = result && ctx.buildRange(buildTokens(result));
+        const tokens = result && ctx.buildRange(buildTokens(result));
+
+        returnValue = tokens || null;
         break;
       }
 
@@ -188,7 +177,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
         const baseState = s;
         let { source, agast, balanced, spans, node } = baseState;
 
-        agast = yield sourceInstr;
+        agast = yield instr;
 
         s = s.push(source.branch(), agast, balanced, spans);
 
@@ -205,7 +194,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
 
         s.status = 'accepted';
 
-        const agastState = yield sourceInstr;
+        const agastState = yield instr;
 
         s = s.parent;
 
@@ -228,27 +217,37 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
 
         s.status = 'rejected';
 
-        yield sourceInstr;
+        yield instr;
 
         s = s.parent;
 
         if (s.path.depth && rejectedState.path.depth > s.path.depth) {
           // const didShift = rejectedState.node.at(sNodeDepth) === s.node;
           const didShift =
-            ctx.nodeForPath(s.path) && !ctx.nodeForPath(rejectedState.path.at(s.path.depth));
+            s.nodeForPath(s.path) && !s.nodeForPath(rejectedState.path.at(s.path.depth));
           const lowPath = rejectedState.path.at(
-            Math.min(s.path.depth + (didShift ? 0 : 1), rejectedState.path.depth),
+            Math.min(
+              s.path.depth + (didShift || s.result.type === 'Reference' ? 0 : 1),
+              rejectedState.path.depth,
+            ),
           );
           const lowNode = s.node || s.parentNode;
 
           const { name, isArray } = lowPath.reference?.value || {};
 
-          if (!didShift && !lowNode.resolver.counters.has(name)) {
-            if (!lowNode.openTag?.value.flags.trivia && !lowNode.openTag?.value.flags.escape) {
-              yield buildCall('advance', buildReference(name, isArray));
+          if (
+            !didShift &&
+            !hasOwn(lowNode.properties, name) &&
+            !(s.result.type === 'Reference' && s.result.value.name === name)
+          ) {
+            if (
+              !getOpenTag(lowNode)?.value.flags.trivia &&
+              !getOpenTag(lowNode)?.value.flags.escape
+            ) {
+              yield buildCall('advance', buildEmbeddedTag(buildReference(name, isArray)));
             }
 
-            yield buildCall('advance', buildNull());
+            yield buildCall('advance', buildEmbeddedTag(buildNull()));
           }
         }
 
@@ -262,7 +261,7 @@ const __strategy = function* bablrStrategy(ctx, rootSource, agastState, strategy
 
       case 'write':
       case 'bindAttribute': {
-        returnValue = yield sourceInstr;
+        returnValue = yield instr;
         break;
       }
 

package/package.json

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