@ohm-js/wasm 0.6.16 → 0.7.0

package/dist/src/ir.js

@@ -6,9 +6,10 @@ export const alt = (children) => ({
     outArity: outArity(children[0]),
 });
 export const any = () => ({ type: 'Any' });
-export const apply = (ruleName, children = []) => ({
+export const apply = (ruleName, descriptionId, children = []) => ({
     type: 'Apply',
     ruleName,
+    descriptionId,
     children,
 });
 export const applyGeneralized = (ruleName, caseIdx) => ({
@@ -47,7 +48,7 @@ export const seq = (children) => ({
     outArity: children.reduce((acc, child) => acc + outArity(child), 0),
 });
 export const star = (child) => ({ type: 'Star', child });
-export const terminal = (value, caseInsensitive = false) => ({
+export const terminal = (value) => ({
     type: 'Terminal',
     value,
 });
@@ -55,9 +56,10 @@ export const unicodeChar = (categoryOrProp) => ({
     type: 'UnicodeChar',
     categoryOrProp,
 });
-export const liftedTerminal = (terminalId) => ({
+export const liftedTerminal = (terminalId, failureId) => ({
     type: 'LiftedTerminal',
     terminalId,
+    failureId,
 });
 // Helpers
 // -------
@@ -119,7 +121,7 @@ export function substituteParams(exp, actuals) {
         case 'Apply':
             if (exp.children.length === 0)
                 return exp;
-            return apply(exp.ruleName, exp.children.map((c) => {
+            return apply(exp.ruleName, exp.descriptionId, exp.children.map((c) => {
                 const ans = substituteParams(c, actuals);
                 return checkApplyLike(ans);
             }));

package/dist/src/miniohm.d.ts

@@ -6,6 +6,21 @@ export declare const CstNodeType: {
     readonly SEQ: 4;
 };
 export type CstNodeType = (typeof CstNodeType)[keyof typeof CstNodeType];
+export declare class Interval {
+    startIdx: number;
+    endIdx: number;
+    private _sourceString;
+    constructor(sourceString: string, startIdx: number, endIdx: number);
+    get sourceString(): string;
+    get contents(): string;
+}
+export declare class Failure {
+    private _description;
+    private _fluffy;
+    constructor(description: string, fluffy: boolean);
+    isFluffy(): boolean;
+    toString(): string;
+}
 export declare class WasmGrammar {
     name: string;
     private _instance?;
@@ -13,6 +28,7 @@ export declare class WasmGrammar {
     private _ruleIds;
     private _ruleNames;
     private _input;
+    _failureDescriptions: string[];
     private _resultStack;
     private _managedResultCount;
     /**
@@ -30,9 +46,11 @@ export declare class WasmGrammar {
     _instantiate(source: BufferSource, debugImports?: any): Promise<this>;
     _instantiateStreaming(source: Response | Promise<Response>, debugImports?: any): Promise<WasmGrammar>;
     private _getGrammarName;
-    private _extractRuleIds;
+    private _extractStrings;
     private _detachMatchResult;
     match<T>(input: string, ruleName?: string): MatchResult;
+    recordFailures(): number[];
+    getFailureDescription(id: number): string;
     getMemorySizeBytes(): number;
     getCstRoot(): CstNode;
     private _fillInputBuffer;
@@ -196,27 +214,30 @@ export declare class MatchResult {
     _ctx: MatchContext;
     _succeeded: boolean;
     constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
+    get input(): string;
     [Symbol.dispose](): void;
     detach(): void;
     succeeded(): this is SucceededMatchResult;
     failed(): this is FailedMatchResult;
     toString(): string;
-    use<T>(cb: (r: MatchResult) => T): T;
+    use<T>(cb: (r: this) => T): T;
 }
 export declare class SucceededMatchResult extends MatchResult {
     _cst: CstNode;
     constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
 }
 export declare class FailedMatchResult extends MatchResult {
-    constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean, rightmostFailurePosition: number, optRecordedFailures?: any);
+    constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean, rightmostFailurePosition: number);
     _rightmostFailurePosition: number;
-    _rightmostFailures: any;
-    shortMessage: string;
-    message: string;
+    private _rightmostFailures;
+    private _failureDescriptions;
     getRightmostFailurePosition(): number;
-    getRightmostFailures(): any;
+    getRightmostFailures(): Failure[];
+    private _getFailureDescriptions;
     getExpectedText(): string;
-    getInterval(): void;
+    getInterval(): Interval;
+    get message(): string;
+    get shortMessage(): string;
 }
 export {};
 //# sourceMappingURL=miniohm.d.ts.map

package/dist/src/miniohm.js

@@ -1,4 +1,5 @@
 import { assert, checkNotNull } from "./assert.js";
+import { getLineAndColumn, getLineAndColumnMessage } from 'ohm-js/extras';
 const MATCH_RECORD_TYPE_MASK = 0b11;
 // A MatchRecord is the representation of a CstNode in Wasm linear memory.
 const MatchRecordType = {
@@ -30,6 +31,37 @@ const UnicodeCategoryNames = [
     'Lo', // Other_Letter
 ];
 const utf8 = new TextDecoder('utf-8');
+// Minimal implementation of Interval (for FailedMatchResult)
+export class Interval {
+    startIdx;
+    endIdx;
+    _sourceString;
+    constructor(sourceString, startIdx, endIdx) {
+        this._sourceString = sourceString;
+        this.startIdx = startIdx;
+        this.endIdx = endIdx;
+    }
+    get sourceString() {
+        return this._sourceString;
+    }
+    get contents() {
+        return this._sourceString.slice(this.startIdx, this.endIdx);
+    }
+}
+export class Failure {
+    _description;
+    _fluffy;
+    constructor(description, fluffy) {
+        this._description = description;
+        this._fluffy = fluffy;
+    }
+    isFluffy() {
+        return this._fluffy;
+    }
+    toString() {
+        return this._description;
+    }
+}
 function regexFromCategoryBitmap(bitmap) {
     const cats = [];
     for (let i = 0; i < 32; i++) {
@@ -40,6 +72,35 @@ function regexFromCategoryBitmap(bitmap) {
     return new RegExp(cats.map(cat => `\\p{${cat}}`).join('|'), 'uy' // u: unicode, y: sticky
     );
 }
+function parseStringTable(module, sectionName) {
+    const sections = WebAssembly.Module.customSections(module, sectionName);
+    assert(sections.length === 1, `Expected one ${sectionName} section, found ${sections.length}`);
+    const data = new Uint8Array(sections[0]);
+    const dataView = new DataView(data.buffer);
+    let offset = 0;
+    const parseU32 = () => {
+        // Quick 'n dirty ULeb128 parsing, assuming no more than 2 bytes.
+        const b1 = dataView.getUint8(offset++);
+        let value = b1 & 0x7f;
+        if (b1 & 0x80) {
+            const b2 = dataView.getUint8(offset++);
+            assert((b2 & 0x80) === 0, 'Expected max two bytes');
+            value |= (b2 & 0x7f) << 7;
+        }
+        return value;
+    };
+    const decoder = new TextDecoder('utf-8');
+    const numEntries = parseU32();
+    const ans = [];
+    for (let i = 0; i < numEntries; i++) {
+        const stringLen = parseU32();
+        const bytes = data.slice(offset, offset + stringLen);
+        offset += stringLen;
+        const name = decoder.decode(bytes);
+        ans.push(name);
+    }
+    return ans;
+}
 export class WasmGrammar {
     name = '';
     _instance = undefined;
@@ -92,6 +153,7 @@ export class WasmGrammar {
     _ruleIds = new Map();
     _ruleNames = [];
     _input = '';
+    _failureDescriptions = []; // Should be treated as package private
     _resultStack = [];
     _managedResultCount = 0;
     /**
@@ -109,7 +171,7 @@ export class WasmGrammar {
     }
     _init(module, instance) {
         this._instance = instance;
-        this._extractRuleIds(module);
+        this._extractStrings(module);
         this.name = this._getGrammarName(module);
         return this;
     }
@@ -159,32 +221,15 @@ export class WasmGrammar {
         const decoder = new TextDecoder('utf-8');
         return decoder.decode(data);
     }
-    _extractRuleIds(module) {
-        const sections = WebAssembly.Module.customSections(module, 'ruleNames');
-        assert(sections.length === 1, `Expected one ruleNames section, found ${sections.length}`);
-        const data = new Uint8Array(sections[0]);
-        const dataView = new DataView(data.buffer);
-        let offset = 0;
-        const parseU32 = () => {
-            // Quick 'n dirty ULeb128 parsing, assuming no more than 2 bytes.
-            const b1 = dataView.getUint8(offset++);
-            let value = b1 & 0x7f;
-            if (b1 & 0x80) {
-                const b2 = dataView.getUint8(offset++);
-                assert((b2 & 0x80) === 0, 'Expected max two bytes');
-                value |= (b2 & 0x7f) << 7;
-            }
-            return value;
-        };
-        const decoder = new TextDecoder('utf-8');
-        const numEntries = parseU32();
-        for (let i = 0; i < numEntries; i++) {
-            const stringLen = parseU32();
-            const bytes = data.slice(offset, offset + stringLen);
-            offset += stringLen;
-            const name = decoder.decode(bytes);
-            this._ruleIds.set(name, i);
-            this._ruleNames.push(name);
+    _extractStrings(module) {
+        assert(this._ruleNames.length === 0);
+        assert(this._ruleIds.size === 0);
+        for (const ruleName of parseStringTable(module, 'ruleNames')) {
+            this._ruleIds.set(ruleName, this._ruleIds.size);
+            this._ruleNames.push(ruleName);
+        }
+        for (const str of parseStringTable(module, 'failureDescriptions')) {
+            this._failureDescriptions.push(str);
         }
     }
     _detachMatchResult(result) {
@@ -209,6 +254,25 @@ export class WasmGrammar {
         this._resultStack.push(result);
         return result;
     }
+    recordFailures() {
+        const { exports } = this._instance;
+        exports.recordFailures(this._ruleIds.get(this._ruleNames[0]));
+        const ans = [];
+        for (let i = 0; i < exports.getRecordedFailuresLength(); i++) {
+            if (!exports.isFluffy(i)) {
+                // Filter out fluffy failures
+                ans.push(exports.recordedFailuresAt(i));
+            }
+        }
+        // Deduplicate
+        return [...new Set(ans)];
+    }
+    getFailureDescription(id) {
+        const isNot = (id & 0x80000000) !== 0;
+        const realId = id & 0x7fffffff;
+        const desc = this._failureDescriptions[realId];
+        return isNot ? 'not ' + desc : desc;
+    }
     getMemorySizeBytes() {
         return this._instance.exports.memory.buffer.byteLength;
     }
@@ -541,6 +605,9 @@ export class MatchResult {
         this._ctx = ctx;
         this._succeeded = succeeded;
     }
+    get input() {
+        return this.grammar._input;
+    }
     [Symbol.dispose]() {
         this.detach();
     }
@@ -581,31 +648,81 @@ export class SucceededMatchResult extends MatchResult {
     }
 }
 export class FailedMatchResult extends MatchResult {
-    constructor(grammar, startExpr, ctx, succeeded, rightmostFailurePosition, optRecordedFailures) {
+    constructor(grammar, startExpr, ctx, succeeded, rightmostFailurePosition) {
         super(grammar, startExpr, ctx, succeeded);
         this._rightmostFailurePosition = rightmostFailurePosition;
-        this._rightmostFailures = optRecordedFailures;
-        // TODO: Define these as lazy properties, like in the JS implementation.
-        this.shortMessage = this.message = `Match failed at pos ${rightmostFailurePosition}`;
     }
     _rightmostFailurePosition;
-    _rightmostFailures;
-    shortMessage;
-    message;
+    _rightmostFailures = null;
+    _failureDescriptions = null;
     getRightmostFailurePosition() {
         return this._rightmostFailurePosition;
     }
     getRightmostFailures() {
-        throw new Error('Not implemented yet: getRightmostFailures');
+        if (this._rightmostFailures === null) {
+            const { exports } = this.grammar._instance;
+            const ruleIds = this.grammar._ruleIds;
+            const ruleNames = this.grammar._ruleNames;
+            exports.recordFailures(ruleIds.get(ruleNames[0]));
+            // Use a Map to deduplicate by description while preserving fluffy status.
+            // A failure is only fluffy if ALL occurrences are fluffy.
+            const failureMap = new Map();
+            for (let i = 0; i < exports.getRecordedFailuresLength(); i++) {
+                const id = exports.recordedFailuresAt(i);
+                const desc = this.grammar.getFailureDescription(id);
+                const fluffy = exports.isFluffy(i);
+                if (failureMap.has(desc)) {
+                    // Only keep fluffy=true if both are fluffy
+                    failureMap.set(desc, failureMap.get(desc) && fluffy);
+                }
+                else {
+                    failureMap.set(desc, fluffy);
+                }
+            }
+            this._rightmostFailures = Array.from(failureMap.entries()).map(([desc, fluffy]) => new Failure(desc, fluffy));
+        }
+        return this._rightmostFailures;
+    }
+    // Get the non-fluffy failure descriptions.
+    _getFailureDescriptions() {
+        if (this._failureDescriptions === null) {
+            this._failureDescriptions = this.getRightmostFailures()
+                .filter(f => !f.isFluffy())
+                .map(f => f.toString());
+        }
+        return this._failureDescriptions;
     }
     // Return a string summarizing the expected contents of the input stream when
     // the match failure occurred.
     getExpectedText() {
         assert(!this._succeeded, 'cannot get expected text of a successful MatchResult');
-        throw new Error('Not implemented yet: getExpectedText');
+        const descriptions = this._getFailureDescriptions();
+        switch (descriptions.length) {
+            case 0:
+                return '';
+            case 1:
+                return descriptions[0];
+            case 2:
+                return descriptions[0] + ' or ' + descriptions[1];
+            default:
+                // For 3+ items: "a, b, or c"
+                return (descriptions.slice(0, -1).join(', ') +
+                    ', or ' +
+                    descriptions[descriptions.length - 1]);
+        }
     }
     getInterval() {
-        throw new Error('Not implemented yet: getInterval');
+        const pos = this.getRightmostFailurePosition();
+        return new Interval(this.input, pos, pos);
+    }
+    get message() {
+        const detail = 'Expected ' + this.getExpectedText();
+        return getLineAndColumnMessage(this.input, this.getRightmostFailurePosition()) + detail;
+    }
+    get shortMessage() {
+        const detail = 'expected ' + this.getExpectedText();
+        const errorInfo = getLineAndColumn(this.input, this.getRightmostFailurePosition());
+        return 'Line ' + errorInfo.lineNum + ', col ' + errorInfo.colNum + ': ' + detail;
     }
 }
 //# sourceMappingURL=miniohm.js.map

package/dist/src/util.d.ts

@@ -0,0 +1,16 @@
+export function awaitBuiltInRules(cb: any): void;
+export function announceBuiltInRules(grammar: any): void;
+export function getLineAndColumn(str: any, offset: any): {
+    offset: any;
+    lineNum: number;
+    colNum: number;
+    line: any;
+    prevLine: any;
+    nextLine: any;
+    toString: typeof lineAndColumnToMessage;
+};
+export function getLineAndColumnMessage(str: any, offset: any, ...ranges: any[]): any;
+export function uniqueId(prefix: any): string;
+declare function lineAndColumnToMessage(...ranges: any[]): any;
+export {};
+//# sourceMappingURL=util.d.ts.map

package/dist/src/util.js

@@ -0,0 +1,150 @@
+import * as common from './common.js';
+// --------------------------------------------------------------------
+// Private stuff
+// --------------------------------------------------------------------
+// Given an array of numbers `arr`, return an array of the numbers as strings,
+// right-justified and padded to the same length.
+function padNumbersToEqualLength(arr) {
+    let maxLen = 0;
+    const strings = arr.map(n => {
+        const str = n.toString();
+        maxLen = Math.max(maxLen, str.length);
+        return str;
+    });
+    return strings.map(s => common.padLeft(s, maxLen));
+}
+// Produce a new string that would be the result of copying the contents
+// of the string `src` onto `dest` at offset `offest`.
+function strcpy(dest, src, offset) {
+    const origDestLen = dest.length;
+    const start = dest.slice(0, offset);
+    const end = dest.slice(offset + src.length);
+    return (start + src + end).substr(0, origDestLen);
+}
+// Casts the underlying lineAndCol object to a formatted message string,
+// highlighting `ranges`.
+function lineAndColumnToMessage(...ranges) {
+    const lineAndCol = this;
+    const { offset } = lineAndCol;
+    const { repeatStr } = common;
+    const sb = new common.StringBuffer();
+    sb.append('Line ' + lineAndCol.lineNum + ', col ' + lineAndCol.colNum + ':\n');
+    // An array of the previous, current, and next line numbers as strings of equal length.
+    const lineNumbers = padNumbersToEqualLength([
+        lineAndCol.prevLine == null ? 0 : lineAndCol.lineNum - 1,
+        lineAndCol.lineNum,
+        lineAndCol.nextLine == null ? 0 : lineAndCol.lineNum + 1,
+    ]);
+    // Helper for appending formatting input lines to the buffer.
+    const appendLine = (num, content, prefix) => {
+        sb.append(prefix + lineNumbers[num] + ' | ' + content + '\n');
+    };
+    // Include the previous line for context if possible.
+    if (lineAndCol.prevLine != null) {
+        appendLine(0, lineAndCol.prevLine, '  ');
+    }
+    // Line that the error occurred on.
+    appendLine(1, lineAndCol.line, '> ');
+    // Build up the line that points to the offset and possible indicates one or more ranges.
+    // Start with a blank line, and indicate each range by overlaying a string of `~` chars.
+    const lineLen = lineAndCol.line.length;
+    let indicationLine = repeatStr(' ', lineLen + 1);
+    for (let i = 0; i < ranges.length; ++i) {
+        let startIdx = ranges[i][0];
+        let endIdx = ranges[i][1];
+        common.assert(startIdx >= 0 && startIdx <= endIdx, 'range start must be >= 0 and <= end');
+        const lineStartOffset = offset - lineAndCol.colNum + 1;
+        startIdx = Math.max(0, startIdx - lineStartOffset);
+        endIdx = Math.min(endIdx - lineStartOffset, lineLen);
+        indicationLine = strcpy(indicationLine, repeatStr('~', endIdx - startIdx), startIdx);
+    }
+    const gutterWidth = 2 + lineNumbers[1].length + 3;
+    sb.append(repeatStr(' ', gutterWidth));
+    indicationLine = strcpy(indicationLine, '^', lineAndCol.colNum - 1);
+    sb.append(indicationLine.replace(/ +$/, '') + '\n');
+    // Include the next line for context if possible.
+    if (lineAndCol.nextLine != null) {
+        appendLine(2, lineAndCol.nextLine, '  ');
+    }
+    return sb.contents();
+}
+// --------------------------------------------------------------------
+// Exports
+// --------------------------------------------------------------------
+let builtInRulesCallbacks = [];
+// Since Grammar.BuiltInRules is bootstrapped, most of Ohm can't directly depend it.
+// This function allows modules that do depend on the built-in rules to register a callback
+// that will be called later in the initialization process.
+export function awaitBuiltInRules(cb) {
+    builtInRulesCallbacks.push(cb);
+}
+export function announceBuiltInRules(grammar) {
+    builtInRulesCallbacks.forEach(cb => {
+        cb(grammar);
+    });
+    builtInRulesCallbacks = null;
+}
+// Return an object with the line and column information for the given
+// offset in `str`.
+export function getLineAndColumn(str, offset) {
+    let lineNum = 1;
+    let colNum = 1;
+    let currOffset = 0;
+    let lineStartOffset = 0;
+    let nextLine = null;
+    let prevLine = null;
+    let prevLineStartOffset = -1;
+    while (currOffset < offset) {
+        const c = str.charAt(currOffset++);
+        if (c === '\n') {
+            lineNum++;
+            colNum = 1;
+            prevLineStartOffset = lineStartOffset;
+            lineStartOffset = currOffset;
+        }
+        else if (c !== '\r') {
+            colNum++;
+        }
+    }
+    // Find the end of the target line.
+    let lineEndOffset = str.indexOf('\n', lineStartOffset);
+    if (lineEndOffset === -1) {
+        lineEndOffset = str.length;
+    }
+    else {
+        // Get the next line.
+        const nextLineEndOffset = str.indexOf('\n', lineEndOffset + 1);
+        nextLine =
+            nextLineEndOffset === -1
+                ? str.slice(lineEndOffset)
+                : str.slice(lineEndOffset, nextLineEndOffset);
+        // Strip leading and trailing EOL char(s).
+        nextLine = nextLine.replace(/^\r?\n/, '').replace(/\r$/, '');
+    }
+    // Get the previous line.
+    if (prevLineStartOffset >= 0) {
+        // Strip trailing EOL char(s).
+        prevLine = str.slice(prevLineStartOffset, lineStartOffset).replace(/\r?\n$/, '');
+    }
+    // Get the target line, stripping a trailing carriage return if necessary.
+    const line = str.slice(lineStartOffset, lineEndOffset).replace(/\r$/, '');
+    return {
+        offset,
+        lineNum,
+        colNum,
+        line,
+        prevLine,
+        nextLine,
+        toString: lineAndColumnToMessage,
+    };
+}
+// Return a nicely-formatted string describing the line and column for the
+// given offset in `str` highlighting `ranges`.
+export function getLineAndColumnMessage(str, offset, ...ranges) {
+    return getLineAndColumn(str, offset).toString(...ranges);
+}
+export const uniqueId = (() => {
+    let idCounter = 0;
+    return prefix => '' + prefix + idCounter++;
+})();
+//# sourceMappingURL=util.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohm-js/wasm",
-  "version": "0.6.16",
+  "version": "0.7.0",
   "description": "Compile Ohm.js grammars to WebAsssembly",
   "main": "dist/index.js",
   "exports": {

package/dist/src/AstBuilder.d.ts

@@ -1,22 +0,0 @@
-import type { CstNode, CstNodeChildren, MatchResult, NonterminalNode, TerminalNode } from './miniohm.ts';
-export type AstNodeTemplate<R> = {
-    [property: string]: number | string | boolean | object | null | ((this: AstBuilder, children: CstNodeChildren) => R);
-};
-export type AstMapping<R> = Record<string, AstNodeTemplate<R> | number | ((this: AstBuilder, ...children: CstNodeChildren) => R)>;
-export declare function createToAst<TNode = any>(mapping: AstMapping<TNode>, opts?: {
-    debug?: boolean;
-}): (nodeOrResult: MatchResult | CstNode) => TNode;
-export declare class AstBuilder<TNode = any> {
-    currNode?: CstNode;
-    private _mapping;
-    private _depth;
-    private _debug;
-    constructor(mapping: AstMapping<TNode>, opts?: {
-        debug?: boolean;
-    });
-    private _debugLog;
-    _visitTerminal(node: TerminalNode): string;
-    _visitNonterminal(node: NonterminalNode): unknown;
-    toAst(nodeOrResult: MatchResult | CstNode): TNode;
-}
-//# sourceMappingURL=AstBuilder.d.ts.map