wasm: Implement MatchResult and return that from match()

Author: pdubroy

packages/miniohm-js/index.js

@@ -156,7 +156,14 @@ export class WasmMatcher {
 
   match() {
     if (process.env.OHM_DEBUG === '1') debugger; // eslint-disable-line no-debugger
-    return this._instance.exports.match(0);
+    const succeeded = this._instance.exports.match(0);
+    return new MatchResult(
+        this,
+        this._input,
+        this._ruleNames[0],
+      succeeded ? this.getCstRoot() : null,
+      this.getRightmostFailurePosition(),
+    );
   }
 
   getMemorySizeBytes() {
@@ -288,3 +295,54 @@ class CstNode {
     return `CstNode {ctorName: ${ctorName}, sourceString: ${sourceString}, startIdx: ${startIdx} }`;
   }
 }
+
+export class MatchResult {
+  constructor(matcher, input, startExpr, cst, rightmostFailurePosition, optRecordedFailures) {
+    this.matcher = matcher;
+    this.input = input;
+    this.startExpr = startExpr;
+    this._cst = cst;
+    this._rightmostFailurePosition = rightmostFailurePosition;
+    this._rightmostFailures = optRecordedFailures;
+
+    // TODO: Define these as lazy properties, like in the JS implementation.
+    if (this.failed()) {
+      this.shortMessage = this.message = `Match failed at pos ${rightmostFailurePosition}`;
+    }
+  }
+
+  succeeded() {
+    return !!this._cst;
+  }
+
+  failed() {
+    return !this.succeeded();
+  }
+
+  getRightmostFailurePosition() {
+    return this._rightmostFailurePosition;
+  }
+
+  getRightmostFailures() {
+    throw new Error('Not implemented yet: getRightmostFailures');
+  }
+
+  toString() {
+    return this.succeeded() ?
+      '[match succeeded]' :
+      '[match failed at position ' + this.getRightmostFailurePosition() + ']';
+  }
+
+  // Return a string summarizing the expected contents of the input stream when
+  // the match failure occurred.
+  getExpectedText() {
+    if (this.succeeded()) {
+      throw new Error('cannot get expected text of a successful MatchResult');
+    }
+    throw new Error('Not implemented yet: getExpectedText');
+  }
+
+  getInterval() {
+    throw new Error('Not implemented yet: getInterval');
+  }
+}

packages/miniohm-js/toAST.js

@@ -43,7 +43,7 @@ class Visitor {
   }
 
   visitTerminal(node, offset) {
-    return node.sourceString(offset);
+    return node.sourceString;
   }
 
   visitNonterminal(node, offset) {

packages/wasm/scripts/parseLiquid.js

@@ -17,7 +17,7 @@ import process from 'node:process';
 import {fileURLToPath} from 'node:url';
 import * as ohm from 'ohm-js';
 
-import {unparse, wasmMatcherForGrammar} from '../test/_helpers.js';
+import {matchWithInput, unparse, wasmMatcherForGrammar} from '../test/_helpers.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const datadir = join(__dirname, '../test/data');
@@ -27,8 +27,6 @@ const liquid = ohm.grammars(readFileSync(join(datadir, 'liquid-html.ohm'), 'utf8
 // Get pattern from command line arguments
 const pattern = process.argv[2];
 
-const matchWithInput = (m, str) => (m.setInput(str), m.match());
-
 (async function main() {
   const parsedPaths = new Set();
   const jsTimes = [];

packages/wasm/test/_helpers.js

@@ -46,3 +46,9 @@ export function unparse(m) {
 }
 
 export const scriptRel = relPath => new URL(relPath, import.meta.url);
+
+// TODO: Consider refactoring this to return true/false.
+export function matchWithInput(m, str) {
+  m.setInput(str);
+  return m.match().succeeded() ? 1 : 0;
+}

packages/wasm/test/test-es5.js

@@ -5,16 +5,14 @@ import {performance} from 'node:perf_hooks';
 import {fileURLToPath} from 'node:url';
 
 import es5js from '../../../examples/ecmascript/index.js';
-import {wasmMatcherForGrammar} from './_helpers.js';
+import {matchWithInput, unparse, wasmMatcherForGrammar} from './_helpers.js';
 import es5 from './data/_es5.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const datadir = join(__dirname, 'data');
 
 const html5shivPath = join(datadir, '_html5shiv-3.7.3.js');
 
-const matchWithInput = (m, str) => (m.setInput(str), m.match());
-
 test('basic es5 examples', async t => {
   const m = await wasmMatcherForGrammar(es5);
   t.is(matchWithInput(m, 'x = 3;'), 1);
@@ -34,8 +32,9 @@ test('html5shiv', async t => {
 });
 
 test('unparsing', async t => {
+  // TODO: Change it back to "Müller" once any properly matches code points.
   const source = String.raw`
-    var obj = {_nm: "Thomas", "full-name": "Thomas Müller", name: function() { return this._nm; }};
+    var obj = {_nm: "Thomas", "full-name": "Thomas Mueller", name: function() { return this._nm; }};
     var arr = [1, "hello", true, null, {x: 2}];
     function Car(brand) { this.brand = brand; }
     Car.prototype.start = function() { return this.brand + " started"; };
@@ -54,19 +53,5 @@ test('unparsing', async t => {
 
   const m = await wasmMatcherForGrammar(es5);
   t.is(matchWithInput(m, source), 1);
-
-  let unparsed = '';
-
-  let pos = 0;
-  function walk(node) {
-    if (node.isTerminal()) {
-      unparsed += source.slice(pos, pos + node.matchLength);
-      pos += node.matchLength;
-    }
-    for (const child of node.children) {
-      walk(child);
-    }
-  }
-  walk(m.getCstRoot());
-  t.is(unparsed, source);
+  t.is(unparse(m), source);
 });

packages/wasm/test/test-failurePos.js

@@ -12,11 +12,6 @@ const ns = ohm.grammars(grammarSource);
 function failurePos(matcher, input) {
   matcher.setInput(input);
   const result = matcher.match();
-  // TODO: Unify the APIs.
-  if (typeof result === 'number') {
-    assert.equal(result, 0);
-    return matcher.getRightmostFailurePosition();
-  }
   assert.equal(result.failed(), true, 'expected match failure');
   return result.getRightmostFailurePosition();
 }
@@ -76,7 +71,7 @@ function arbitraryEdit(input) {
 function sameFailurePos(wasmMatcher) {
   return fc.property(arbitraryEdit(validInput), input => {
     wasmMatcher.setInput(input);
-    fc.pre(wasmMatcher.match() === 0);
+    fc.pre(wasmMatcher.match().succeeded());
     assert.equal(
         ns.LiquidHTML.match(input).getRightmostFailurePosition(),
         wasmMatcher.getRightmostFailurePosition(),

packages/wasm/test/test-liquid-html.js

@@ -5,9 +5,7 @@ import fs from 'node:fs';
 import * as ohm from 'ohm-js';
 import {performance} from 'perf_hooks';
 
-import {unparse, wasmMatcherForGrammar} from './_helpers.js';
-
-const matchWithInput = (m, str) => (m.setInput(str), m.match());
+import {matchWithInput, unparse, wasmMatcherForGrammar} from './_helpers.js';
 
 const scriptRel = relPath => new URL(relPath, import.meta.url);
 const grammarSource = fs.readFileSync(scriptRel('data/liquid-html.ohm'), 'utf8');

packages/wasm/test/test-toAST.js

@@ -2,9 +2,7 @@ import {toAST} from '@ohm-js/miniohm-js/toAST.js';
 import test from 'ava';
 import * as ohm from 'ohm-js';
 
-import {wasmMatcherForGrammar} from './_helpers.js';
-
-const matchWithInput = (m, str) => (m.setInput(str), m.match());
+import {matchWithInput, wasmMatcherForGrammar} from './_helpers.js';
 
 const arithmetic = ohm.grammar(`
   Arithmetic {

packages/wasm/test/test-wasm.js

@@ -5,9 +5,7 @@ import * as ohm from 'ohm-js';
 import {performance} from 'perf_hooks';
 
 import {Compiler, ConstantsForTesting as Constants} from '../src/index.js';
-import {unparse, wasmMatcherForGrammar} from './_helpers.js';
-
-const matchWithInput = (m, str) => (m.setInput(str), m.match());
+import {matchWithInput, unparse, wasmMatcherForGrammar} from './_helpers.js';
 
 const SIZEOF_UINT32 = 4;
 
@@ -949,8 +947,7 @@ test('unicode built-ins: non-ASII (fast-check)', async t => {
   const m = await wasmMatcherForGrammar(g);
   const hasExpectedResult = wasmMatcher => {
     return fc.property(arbitraryStringMatching(/^\p{L}\p{L}$/u), str => {
-      wasmMatcher.setInput(str);
-      assert.equal(wasmMatcher.match(), 1);
+      assert.equal(matchWithInput(wasmMatcher, str), 1);
     });
   };
   const details = fc.check(hasExpectedResult(m), {
@@ -975,3 +972,10 @@ test('caseInsensitive', async t => {
 
   t.is(matchWithInput(m, '.BLAH!'), 1);
 });
+
+test.failing('unicode', async t => {
+  const source = 'Nöö';
+  const m = await wasmMatcherForGrammar(ohm.grammar('G { Start = any* }'));
+  t.is(matchWithInput(m, source), 1);
+  t.is(unparse(m), source);
+});