@ohm-js/wasm 0.7.3 → 0.7.5

package/dist/src/Compiler.d.ts

@@ -7,7 +7,7 @@ export class Compiler {
         paramTypes: any[];
         resultTypes: any[];
     }[];
-    ruleIdByName: any;
+    ruleIdByName: StringTable;
     _failureDescriptions: StringTable;
     _endOfInputFailureId: any;
     _deferredRuleIds: Set<any>;

package/dist/src/Compiler.js

@@ -1,11 +1,11 @@
-/* global process */
 import * as w from '@wasmgroundup/emit';
 import * as ohm from 'ohm-js';
 // import wabt from 'wabt';
 import * as ir from "./ir.js";
 import * as prebuilt from "../build/ohmRuntime.wasm_sections.js";
 const WASM_PAGE_SIZE = 64 * 1024;
-const DEBUG = process.env.OHM_DEBUG === '1';
+// eslint-disable-next-line no-undef
+const DEBUG = typeof process !== 'undefined' && process.env.OHM_DEBUG === '1';
 const FAST_SAVE_BINDINGS = true;
 const FAST_RESTORE_BINDINGS = true;
 const IMPLICIT_SPACE_SKIPPING = true;
@@ -718,7 +718,7 @@ export class Compiler {
                 return JSON.stringify(exp.value);
             case 'End':
                 return 'end of input';
-            case 'Apply':
+            case 'Apply': {
                 if (exp.descriptionId != null && exp.descriptionId >= 0) {
                     return this._failureDescriptions.getStr(exp.descriptionId);
                 }
@@ -726,7 +726,15 @@ export class Compiler {
                     return 'end of input';
                 if (exp.ruleName === 'any')
                     return 'any character';
-                return null;
+                // For lifted rules, expand their body to get a meaningful description.
+                if (exp.ruleName.startsWith('$lifted')) {
+                    const ruleInfo = this.rules.get(exp.ruleName);
+                    if (ruleInfo)
+                        return this.toFailureDescription(ruleInfo.body);
+                }
+                const article = /^[aeiouAEIOU]/.test(exp.ruleName) ? 'an' : 'a';
+                return article + ' ' + exp.ruleName;
+            }
             case 'Alt': {
                 const strs = exp.children.map(c => this.toFailureDescription(c));
                 if (strs.some(s => s == null))

package/dist/src/createToAst.js

@@ -108,10 +108,10 @@ export class AstBuilder {
     }
     toAst(nodeOrResult) {
         let node = nodeOrResult;
-        if (typeof nodeOrResult.succeeded === 'function') {
+        if (typeof nodeOrResult._succeeded === 'boolean') {
             const matchResult = nodeOrResult;
-            assert(matchResult.succeeded(), 'Cannot convert failed match result to AST');
-            node = matchResult.grammar.getCstRoot();
+            assert(matchResult._succeeded, 'Cannot convert failed match result to AST');
+            node = matchResult.getCstRoot();
         }
         let ans;
         this._depth++;

package/dist/src/miniohm.d.ts

@@ -30,7 +30,6 @@ export declare class WasmGrammar {
     private _input;
     _failureDescriptions: string[];
     private _resultStack;
-    private _managedResultCount;
     /**
      * Create a new WasmGrammar object.
      * If `bytes` is specified, the WebAssembly module will be synchronously
@@ -39,15 +38,14 @@ export declare class WasmGrammar {
      */
     constructor(bytes?: BufferSource);
     private _init;
-    _beginUse(result: MatchResult): void;
-    _endUse(result: MatchResult): void;
+    _manage(result: MatchResult): void;
+    _dispose(result: MatchResult): void;
     static instantiate(source: BufferSource): Promise<WasmGrammar>;
     static instantiateStreaming(source: Response | Promise<Response>): Promise<WasmGrammar>;
     _instantiate(source: BufferSource, debugImports?: any): Promise<this>;
     _instantiateStreaming(source: Response | Promise<Response>, debugImports?: any): Promise<WasmGrammar>;
     private _getGrammarName;
     private _extractStrings;
-    private _detachMatchResult;
     match<T>(input: string, ruleName?: string): MatchResult;
     recordFailures(): number[];
     getFailureDescription(id: number): string;
@@ -214,10 +212,11 @@ export declare class MatchResult {
     _ctx: MatchContext;
     _succeeded: boolean;
     _attached: boolean;
+    _managed: boolean;
     constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
     get input(): string;
-    [Symbol.dispose](): void;
-    detach(): void;
+    get [Symbol.dispose](): () => void;
+    dispose(): void;
     succeeded(): this is SucceededMatchResult;
     failed(): this is FailedMatchResult;
     toString(): string;
@@ -226,6 +225,7 @@ export declare class MatchResult {
 export declare class SucceededMatchResult extends MatchResult {
     _cst: CstNode;
     constructor(grammar: WasmGrammar, startExpr: string, ctx: MatchContext, succeeded: boolean);
+    getCstRoot(): CstNode;
 }
 export declare class FailedMatchResult extends MatchResult {
     _rightmostFailurePosition: number;

package/dist/src/miniohm.js

@@ -155,7 +155,6 @@ export class WasmGrammar {
     _input = '';
     _failureDescriptions = []; // Should be treated as package private
     _resultStack = [];
-    _managedResultCount = 0;
     /**
      * Create a new WasmGrammar object.
      * If `bytes` is specified, the WebAssembly module will be synchronously
@@ -175,20 +174,16 @@ export class WasmGrammar {
         this.name = this._getGrammarName(module);
         return this;
     }
-    _beginUse(result) {
-        assert(this._resultStack.at(-1) === result, `You can only use() the most recent MatchResult`);
-        result.detach = () => {
-            throw new Error("MatchResult shouldn't be detached inside use()");
-        };
-        this._managedResultCount++;
+    _manage(result) {
+        result._managed = true;
     }
-    _endUse(result) {
-        const r = this._resultStack.pop();
-        assert(r === result, 'Mismatched _endUse');
-        this._managedResultCount--;
+    _dispose(result) {
+        assert(this._resultStack.at(-1) === result, `You can only dispose() the most recent MatchResult`);
+        this._resultStack.pop();
         if (this._resultStack.length === 0) {
             this._instance.exports.resetHeap();
         }
+        result._attached = false;
     }
     static async instantiate(source) {
         return new WasmGrammar()._instantiate(source);
@@ -232,16 +227,11 @@ export class WasmGrammar {
             this._failureDescriptions.push(str);
         }
     }
-    _detachMatchResult(result) {
-        assert(this._resultStack.at(-1) === result, `You can only detach() the most recent MatchResult`);
-        this._beginUse(result);
-        this._endUse(result);
-        result._attached = false;
-    }
     match(input, ruleName) {
-        assert(this._resultStack.length === this._managedResultCount, 'Cannot match while there are unmanaged MatchResults');
+        assert(this._resultStack.every(r => r._managed), 'Cannot match while there are unmanaged MatchResults. ' +
+            'Use `using` or `.use()` to manage the MatchResult lifecycle.');
         this._input = input;
-        if (process.env.OHM_DEBUG === '1')
+        if (typeof process !== 'undefined' && process.env.OHM_DEBUG === '1')
             debugger; // eslint-disable-line no-debugger
         const ruleId = checkNotNull(this._ruleIds.get(ruleName || this._ruleNames[0]), `unknown rule: '${ruleName}'`);
         const succeeded = this._instance.exports.match(input, ruleId);
@@ -251,7 +241,7 @@ export class WasmGrammar {
             input: this._instance.exports.input.value,
         };
         const result = createMatchResult(this, ruleName || this._ruleNames[0], ctx, !!succeeded);
-        result.detach = this._detachMatchResult.bind(this, result);
+        result.dispose = this._dispose.bind(this, result);
         this._resultStack.push(result);
         return result;
     }
@@ -598,6 +588,7 @@ export class MatchResult {
     _ctx;
     _succeeded;
     _attached = true;
+    _managed = false;
     constructor(grammar, startExpr, ctx, succeeded) {
         this.grammar = grammar;
         this.startExpr = startExpr;
@@ -607,10 +598,13 @@ export class MatchResult {
     get input() {
         return this.grammar._input;
     }
-    [Symbol.dispose]() {
-        this.detach();
+    // `using` accesses [Symbol.dispose] at declaration time to get the
+    // disposal method. We use this as the signal that the result is managed.
+    get [Symbol.dispose]() {
+        this.grammar._manage(this);
+        return () => this.dispose();
     }
-    detach() {
+    dispose() {
         throw new Error('MatchResult is not attached to any grammar');
     }
     succeeded() {
@@ -625,12 +619,12 @@ export class MatchResult {
             : '[match succeeded]';
     }
     use(cb) {
+        this.grammar._manage(this);
         try {
-            this.grammar._beginUse(this);
             return cb(this);
         }
         finally {
-            this.grammar._endUse(this);
+            this.dispose();
         }
     }
 }
@@ -645,6 +639,9 @@ export class SucceededMatchResult extends MatchResult {
         super(grammar, startExpr, ctx, succeeded);
         this._cst = grammar.getCstRoot();
     }
+    getCstRoot() {
+        return this._cst;
+    }
 }
 export class FailedMatchResult extends MatchResult {
     _rightmostFailurePosition;
@@ -656,8 +653,8 @@ export class FailedMatchResult extends MatchResult {
     }
     _assertAttached(property) {
         if (!this._attached) {
-            throw new Error(`Cannot access '${property}' after MatchResult has been detached. ` +
-                `Access failure information before calling detach(), or use result.use().`);
+            throw new Error(`Cannot access '${property}' after MatchResult has been disposed. ` +
+                `Access failure information before calling dispose(), or use result.use().`);
         }
     }
     getRightmostFailurePosition() {

package/package.json

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