ohm-js 17.2.1 → 17.4.0

package/extras/recoverSourceOrder.js

@@ -0,0 +1,48 @@
+/*
+  To find iter nodes that are derived from the same repetition expression, we
+  look for adjacent iter nodes that have the same source interval and the same
+  number of children.
+
+  A few things to note:
+  - The children of `*` and `+` nodes can't be nullable, so the associated iter
+    nodes always consume some input, and therefore consecutive nodes that have
+    the same interval must come from the same repetition expression.
+  - We *could* mistake `a? b?` for (a b)?`, if neither of them comsume any input.
+    However, for the purposes of this module, those two cases are equivalent
+    anyways, since we only care about finding the correct order of the non-iter
+    nodes, and both interpretations yield the same order.
+ */
+const isIterSibling = (refNode, n) => {
+  return (
+    n.isIteration() &&
+    n.source.startIdx === refNode.source.startIdx &&
+    n.source.endIdx === refNode.source.endIdx &&
+    n.children.length === refNode.children.length
+  );
+};
+
+export function recoverSourceOrder(nodes, depth = 0) {
+  const ans = [];
+  for (let i = 0; i < nodes.length; i++) {
+    const n = nodes[i];
+    if (!n.isIteration()) {
+      ans.push(n);
+      continue;
+    }
+
+    // We found an iter node, now find its siblings.
+    const siblings = [n];
+    // Find the first node that's *not* part of the current list.
+    for (let j = i + 1; j < nodes.length && isIterSibling(n, nodes[j]); j++) {
+      siblings.push(nodes[j]);
+      i = j;
+    }
+    const cousins = [];
+    const numRows = siblings[0].children.length;
+    for (let row = 0; row < numRows; row++) {
+      cousins.push(...siblings.map(sib => sib.children[row]));
+    }
+    ans.push(...recoverSourceOrder(cousins, depth + 1));
+  }
+  return ans;
+}

package/extras/semantics-toAST.js

@@ -55,7 +55,7 @@ const defaultOperation = {
     const node = {
       type: ctorName,
     };
-    // eslint-disable-next-line guard-for-in
+
     for (const prop in propMap) {
       const mappedProp = mapping[ctorName] && mapping[ctorName][prop];
       if (typeof mappedProp === 'number') {

package/index.d.ts

@@ -165,28 +165,48 @@ export interface Matcher {
  * Result of Grammar#match
  */
 export interface MatchResult {
+  matcher: Matcher;
+  input: string;
+
   /**
    * True iff match succeeded
    */
-  succeeded(): boolean;
+  succeeded(): this is SucceededMatchResult;
 
   /**
    * True iff match did not succeed
    */
-  failed(): boolean;
+  failed(): this is FailedMatchResult;
+}
+
+export interface SucceededMatchResult extends MatchResult {}
 
+export interface FailedMatchResult extends MatchResult {
   /**
    * If match failed contains an error message indicating where and
    * why the match failed. This message is suitable for end users of a
    * language (i.e., people who do not have access to the grammar source).
    */
-  message?: string;
+  message: string;
 
   /**
    * If match failed contains an abbreviated version of this.message that
    * does not include an excerpt from the invalid input.
    */
-  shortMessage?: string;
+  shortMessage: string;
+
+  /**
+   * Returns the position at which the error should be reported. This is used
+   * to construct `message` and `shortMessage`.
+   */
+  getRightmostFailurePosition(): number;
+
+  /**
+   * Return a string summarizing the expected contents of the input stream
+   * at the rightmost failure position. This is used to construct `message`
+   * and `shortMessage`.
+   */
+  getExpectedText(): string;
 
   /**
    * If this MatchResult is a failure, returns an Interval indicating

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ohm-js",
-  "version": "17.2.1",
+  "version": "17.4.0",
   "description": "An object-oriented language for parsing and pattern matching",
   "repository": "https://github.com/ohmjs/ohm",
   "keywords": [
@@ -79,6 +79,7 @@
     "James Meng <35415298+jamesmengo@users.noreply.github.com>",
     "Julien Gonzalez <hello@spinjs.com>",
     "Justin Chase <justin.m.chase@gmail.com>",
+    "Karl Weber <me@kow.fm>",
     "Leslie Ying <acetophore@users.noreply.github.com>",
     "Luca Guzzon <luca.guzzon@gmail.com>",
     "Mike Niebling <(none)>",
@@ -110,16 +111,15 @@
     "ava": "^6.0.0",
     "ava-spec": "^1.1.1",
     "dedent": "^0.7.0",
-    "husky": "^4.2.5",
     "jsdom": "^9.9.1",
     "json": "^9.0.6",
     "markscript": "^0.5.0",
     "node-static": "^0.7.11",
+    "prettier": "^3.6.2",
     "rollup": "^2.63.0",
     "terser": "^5.15.1",
     "uvu": "^0.5.6",
-    "walk-sync": "^2.2.0",
-    "watchlist": "^0.3.1"
+    "walk-sync": "^2.2.0"
   },
   "engines": {
     "node": ">=0.12.1"

package/src/Builder.js

@@ -21,7 +21,7 @@ export class Builder {
     if (superGrammar) {
       // `superGrammar` may be a recipe (i.e. an Array), or an actual grammar instance.
       gDecl.withSuperGrammar(
-        superGrammar instanceof Grammar ? superGrammar : this.fromRecipe(superGrammar),
+        superGrammar instanceof Grammar ? superGrammar : this.fromRecipe(superGrammar)
       );
     }
     if (defaultStartRule) {
@@ -45,8 +45,8 @@ export class Builder {
       let source;
       if (gDecl.source && metaInfo && metaInfo.sourceInterval) {
         source = gDecl.source.subInterval(
-            metaInfo.sourceInterval[0],
-            metaInfo.sourceInterval[1] - metaInfo.sourceInterval[0],
+          metaInfo.sourceInterval[0],
+          metaInfo.sourceInterval[1] - metaInfo.sourceInterval[0]
         );
       }
       gDecl[action](ruleName, formals, body, description, source);
@@ -141,7 +141,7 @@ export class Builder {
 
   app(ruleName, optParams) {
     if (optParams && optParams.length > 0) {
-      optParams = optParams.map(function(param) {
+      optParams = optParams.map(function (param) {
         return param instanceof pexprs.PExpr ? param : this.fromRecipe(param);
       }, this);
     }
@@ -153,10 +153,10 @@ export class Builder {
   // `this.currentDecl` and `this.currentRuleName` being set.
   splice(beforeTerms, afterTerms) {
     return new pexprs.Splice(
-        this.currentDecl.superGrammar,
-        this.currentRuleName,
-        beforeTerms.map(term => this.fromRecipe(term)),
-        afterTerms.map(term => this.fromRecipe(term)),
+      this.currentDecl.superGrammar,
+      this.currentRuleName,
+      beforeTerms.map(term => this.fromRecipe(term)),
+      afterTerms.map(term => this.fromRecipe(term))
     );
   }
 

package/src/CaseInsensitiveTerminal.js

@@ -48,9 +48,9 @@ export class CaseInsensitiveTerminal extends PExpr {
 
   toFailure(grammar) {
     return new Failure(
-        this,
-        this.obj.toFailure(grammar) + ' (case-insensitive)',
-        'description',
+      this,
+      this.obj.toFailure(grammar) + ' (case-insensitive)',
+      'description'
     );
   }
 

package/src/Grammar.js

@@ -12,8 +12,8 @@ const SPECIAL_ACTION_NAMES = ['_iter', '_terminal', '_nonterminal', '_default'];
 
 function getSortedRuleValues(grammar) {
   return Object.keys(grammar.rules)
-      .sort()
-      .map(name => grammar.rules[name]);
+    .sort()
+    .map(name => grammar.rules[name]);
 }
 
 // Until ES2019, JSON was not a valid subset of JavaScript because U+2028 (line separator)
@@ -34,11 +34,11 @@ export class Grammar {
     if (optDefaultStartRule) {
       if (!(optDefaultStartRule in rules)) {
         throw new Error(
-            "Invalid start rule: '" +
+          "Invalid start rule: '" +
             optDefaultStartRule +
             "' is not a rule in grammar '" +
             name +
-            "'",
+            "'"
         );
       }
       this.defaultStartRule = optDefaultStartRule;
@@ -109,7 +109,6 @@ export class Grammar {
   _checkTopDownActionDict(what, name, actionDict) {
     const problems = [];
 
-    // eslint-disable-next-line guard-for-in
     for (const k in actionDict) {
       const v = actionDict[k];
       const isSpecialAction = SPECIAL_ACTION_NAMES.includes(k);
@@ -139,10 +138,10 @@ export class Grammar {
     if (problems.length > 0) {
       const prettyProblems = problems.map(problem => '- ' + problem);
       const error = new Error(
-          [
-            `Found errors in the action dictionary of the '${name}' ${what}:`,
-            ...prettyProblems,
-          ].join('\n'),
+        [
+          `Found errors in the action dictionary of the '${name}' ${what}:`,
+          ...prettyProblems,
+        ].join('\n')
       );
       error.problems = problems;
       throw error;
@@ -155,9 +154,9 @@ export class Grammar {
     // All special actions have an expected arity of 0, though all but _terminal
     // are expected to use the rest parameter syntax (e.g. `_iter(...children)`).
     // This is considered to have arity 0, i.e. `((...args) => {}).length` is 0.
-    return SPECIAL_ACTION_NAMES.includes(actionName) ?
-      0 :
-      this.rules[actionName].body.getArity();
+    return SPECIAL_ACTION_NAMES.includes(actionName)
+      ? 0
+      : this.rules[actionName].body.getArity();
   }
 
   _inheritsFrom(grammar) {
@@ -248,7 +247,7 @@ export class Grammar {
     sb.append('{');
 
     let first = true;
-    // eslint-disable-next-line guard-for-in
+
     for (const ruleName in this.rules) {
       const {body} = this.rules[ruleName];
       if (first) {
@@ -295,10 +294,10 @@ export class Grammar {
     if (formals.length !== app.args.length) {
       const {source} = this.rules[app.ruleName];
       throw errors.wrongNumberOfParameters(
-          app.ruleName,
-          formals.length,
-          app.args.length,
-          source,
+        app.ruleName,
+        formals.length,
+        app.args.length,
+        source
       );
     }
     return app;
@@ -317,63 +316,63 @@ export class Grammar {
 // `digit`, and is implicitly the super-grammar of any grammar whose super-grammar
 // isn't specified.
 Grammar.ProtoBuiltInRules = new Grammar(
-    'ProtoBuiltInRules', // name
-    undefined, // supergrammar
-    {
-      any: {
-        body: pexprs.any,
-        formals: [],
-        description: 'any character',
-        primitive: true,
-      },
-      end: {
-        body: pexprs.end,
-        formals: [],
-        description: 'end of input',
-        primitive: true,
-      },
-
-      caseInsensitive: {
-        body: new pexprs.CaseInsensitiveTerminal(new pexprs.Param(0)),
-        formals: ['str'],
-        primitive: true,
-      },
-      lower: {
-        body: new pexprs.UnicodeChar('Ll'),
-        formals: [],
-        description: 'a lowercase letter',
-        primitive: true,
-      },
-      upper: {
-        body: new pexprs.UnicodeChar('Lu'),
-        formals: [],
-        description: 'an uppercase letter',
-        primitive: true,
-      },
-      // Union of Lt (titlecase), Lm (modifier), and Lo (other), i.e. any letter not in Ll or Lu.
-      unicodeLtmo: {
-        body: new pexprs.UnicodeChar('Ltmo'),
-        formals: [],
-        description: 'a Unicode character in Lt, Lm, or Lo',
-        primitive: true,
-      },
-
-      // These rules are not truly primitive (they could be written in userland) but are defined
-      // here for bootstrapping purposes.
-      spaces: {
-        body: new pexprs.Star(new pexprs.Apply('space')),
-        formals: [],
-      },
-      space: {
-        body: new pexprs.Range('\x00', ' '),
-        formals: [],
-        description: 'a space',
-      },
+  'ProtoBuiltInRules', // name
+  undefined, // supergrammar
+  {
+    any: {
+      body: pexprs.any,
+      formals: [],
+      description: 'any character',
+      primitive: true,
+    },
+    end: {
+      body: pexprs.end,
+      formals: [],
+      description: 'end of input',
+      primitive: true,
+    },
+
+    caseInsensitive: {
+      body: new pexprs.CaseInsensitiveTerminal(new pexprs.Param(0)),
+      formals: ['str'],
+      primitive: true,
+    },
+    lower: {
+      body: new pexprs.UnicodeChar('Ll'),
+      formals: [],
+      description: 'a lowercase letter',
+      primitive: true,
+    },
+    upper: {
+      body: new pexprs.UnicodeChar('Lu'),
+      formals: [],
+      description: 'an uppercase letter',
+      primitive: true,
     },
+    // Union of Lt (titlecase), Lm (modifier), and Lo (other), i.e. any letter not in Ll or Lu.
+    unicodeLtmo: {
+      body: new pexprs.UnicodeChar('Ltmo'),
+      formals: [],
+      description: 'a Unicode character in Lt, Lm, or Lo',
+      primitive: true,
+    },
+
+    // These rules are not truly primitive (they could be written in userland) but are defined
+    // here for bootstrapping purposes.
+    spaces: {
+      body: new pexprs.Star(new pexprs.Apply('space')),
+      formals: [],
+    },
+    space: {
+      body: new pexprs.Range('\x00', ' '),
+      formals: [],
+      description: 'a space',
+    },
+  }
 );
 
 // This method is called from main.js once Ohm has loaded.
-Grammar.initApplicationParser = function(grammar, builderFn) {
+Grammar.initApplicationParser = function (grammar, builderFn) {
   ohmGrammar = grammar;
   buildGrammar = builderFn;
 };

package/src/GrammarDecl.js

@@ -27,7 +27,7 @@ export class GrammarDecl {
         // TODO: The conditional expression below is an ugly hack. It's kind of ok because
         // I doubt anyone will ever try to declare a grammar called `BuiltInRules`. Still,
         // we should try to find a better way to do this.
-        this.name === 'BuiltInRules' ? Grammar.ProtoBuiltInRules : Grammar.BuiltInRules,
+        this.name === 'BuiltInRules' ? Grammar.ProtoBuiltInRules : Grammar.BuiltInRules
       );
     }
     return this.superGrammar;
@@ -95,10 +95,10 @@ export class GrammarDecl {
   // Creates a Grammar instance, and if it passes the sanity checks, returns it.
   build() {
     const grammar = new Grammar(
-        this.name,
-        this.ensureSuperGrammar(),
-        this.rules,
-        this.defaultStartRule,
+      this.name,
+      this.ensureSuperGrammar(),
+      this.rules,
+      this.defaultStartRule
     );
     // Initialize internal props that are inherited from the super grammar.
     grammar._matchStateInitializer = grammar.superGrammar._matchStateInitializer;

package/src/IndentationSensitive.js

@@ -125,12 +125,12 @@ const applyDedent = new pexprs.Apply('dedent');
 const newAnyBody = new pexprs.Splice(BuiltInRules, 'any', [applyIndent, applyDedent], []);
 
 export const IndentationSensitive = new Builder()
-    .newGrammar('IndentationSensitive')
-    .withSuperGrammar(BuiltInRules)
-    .define('indent', [], new Indentation(true), INDENT_DESCRIPTION, undefined, true)
-    .define('dedent', [], new Indentation(false), DEDENT_DESCRIPTION, undefined, true)
-    .extend('any', [], newAnyBody, 'any character', undefined)
-    .build();
+  .newGrammar('IndentationSensitive')
+  .withSuperGrammar(BuiltInRules)
+  .define('indent', [], new Indentation(true), INDENT_DESCRIPTION, undefined, true)
+  .define('dedent', [], new Indentation(false), DEDENT_DESCRIPTION, undefined, true)
+  .extend('any', [], newAnyBody, 'any character', undefined)
+  .build();
 
 Object.assign(IndentationSensitive, {
   _matchStateInitializer(state) {

package/src/InputStream.js

@@ -1,6 +1,7 @@
 import {Interval} from './Interval.js';
 
 const MAX_CHAR_CODE = 0xffff;
+export const MAX_CODE_POINT = 0x10ffff;
 
 export class InputStream {
   constructor(source) {
@@ -46,6 +47,8 @@ export class InputStream {
 
         This is intended to be a locale-invariant comparison, which means it may not obey
         locale-specific expectations (e.g. "i" => "İ").
+
+        See also https://unicode.org/faq/casemap_charprop.html#casemap
        */
       for (idx = 0; idx < s.length; idx++) {
         const actual = this.next();

package/src/Interval.js

@@ -8,11 +8,23 @@ import * as util from './util.js';
 
 export class Interval {
   constructor(sourceString, startIdx, endIdx) {
-    this.sourceString = sourceString;
+    // Store the full source in a non-enumerable property, so that when
+    // grammars and other objects are printed in the REPL, it's not
+    // cluttered with multiple copies of the same long string.
+    Object.defineProperty(this, '_sourceString', {
+      value: sourceString,
+      configurable: false,
+      enumerable: false,
+      writable: false,
+    });
     this.startIdx = startIdx;
     this.endIdx = endIdx;
   }
 
+  get sourceString() {
+    return this._sourceString;
+  }
+
   get contents() {
     if (this._contents === undefined) {
       this._contents = this.sourceString.slice(this.startIdx, this.endIdx);
@@ -78,13 +90,13 @@ export class Interval {
       throw errors.intervalSourcesDontMatch();
     }
     assert(
-        this.startIdx >= that.startIdx && this.endIdx <= that.endIdx,
-        'other interval does not cover this one',
+      this.startIdx >= that.startIdx && this.endIdx <= that.endIdx,
+      'other interval does not cover this one'
     );
     return new Interval(
-        this.sourceString,
-        this.startIdx - that.startIdx,
-        this.endIdx - that.startIdx,
+      this.sourceString,
+      this.startIdx - that.startIdx,
+      this.endIdx - that.startIdx
     );
   }
 
@@ -103,7 +115,7 @@ export class Interval {
   }
 }
 
-Interval.coverage = function(firstInterval, ...intervals) {
+Interval.coverage = function (firstInterval, ...intervals) {
   let {startIdx, endIdx} = firstInterval;
   for (const interval of intervals) {
     if (interval.sourceString !== firstInterval.sourceString) {

package/src/MatchResult.js

@@ -8,13 +8,13 @@ import {Interval} from './Interval.js';
 
 export class MatchResult {
   constructor(
-      matcher,
-      input,
-      startExpr,
-      cst,
-      cstOffset,
-      rightmostFailurePosition,
-      optRecordedFailures,
+    matcher,
+    input,
+    startExpr,
+    cst,
+    cstOffset,
+    rightmostFailurePosition,
+    optRecordedFailures
   ) {
     this.matcher = matcher;
     this.input = input;
@@ -25,22 +25,20 @@ export class MatchResult {
     this._rightmostFailures = optRecordedFailures;
 
     if (this.failed()) {
-      /* eslint-disable no-invalid-this */
-      common.defineLazyProperty(this, 'message', function() {
+      common.defineLazyProperty(this, 'message', function () {
         const detail = 'Expected ' + this.getExpectedText();
         return (
           util.getLineAndColumnMessage(this.input, this.getRightmostFailurePosition()) + detail
         );
       });
-      common.defineLazyProperty(this, 'shortMessage', function() {
+      common.defineLazyProperty(this, 'shortMessage', function () {
         const detail = 'expected ' + this.getExpectedText();
         const errorInfo = util.getLineAndColumn(
-            this.input,
-            this.getRightmostFailurePosition(),
+          this.input,
+          this.getRightmostFailurePosition()
         );
         return 'Line ' + errorInfo.lineNum + ', col ' + errorInfo.colNum + ': ' + detail;
       });
-      /* eslint-enable no-invalid-this */
     }
   }
 
@@ -69,9 +67,9 @@ export class MatchResult {
   }
 
   toString() {
-    return this.succeeded() ?
-      '[match succeeded]' :
-      '[match failed at position ' + this.getRightmostFailurePosition() + ']';
+    return this.succeeded()
+      ? '[match succeeded]'
+      : '[match failed at position ' + this.getRightmostFailurePosition() + ']';
   }
 
   // Return a string summarizing the expected contents of the input stream when

package/src/MatchState.js

@@ -66,8 +66,8 @@ export class MatchState {
     posInfo.exit();
 
     this.rightmostFailurePosition = Math.max(
-        this.rightmostFailurePosition,
-        this._rightmostFailurePositionStack.pop(),
+      this.rightmostFailurePosition,
+      this._rightmostFailurePositionStack.pop()
     );
 
     if (optNode) {
@@ -208,9 +208,9 @@ export class MatchState {
   }
 
   _getRightmostFailureOffset() {
-    return this.rightmostFailurePosition >= 0 ?
-      this.posToOffset(this.rightmostFailurePosition) :
-      -1;
+    return this.rightmostFailurePosition >= 0
+      ? this.posToOffset(this.rightmostFailurePosition)
+      : -1;
   }
 
   // Returns the memoized trace entry for `expr` at `pos`, if one exists, `null` otherwise.
@@ -267,8 +267,8 @@ export class MatchState {
     const memoRecRightmostFailurePosition =
       this.inputStream.pos + memoRec.rightmostFailureOffset;
     this.rightmostFailurePosition = Math.max(
-        this.rightmostFailurePosition,
-        memoRecRightmostFailurePosition,
+      this.rightmostFailurePosition,
+      memoRecRightmostFailurePosition
     );
     if (
       this.recordedFailures &&
@@ -279,8 +279,8 @@ export class MatchState {
     }
 
     this.inputStream.examinedLength = Math.max(
-        this.inputStream.examinedLength,
-        memoRec.examinedLength + origPos,
+      this.inputStream.examinedLength,
+      memoRec.examinedLength + origPos
     );
 
     if (memoRec.value) {
@@ -358,7 +358,7 @@ export class MatchState {
     let rightmostFailures;
     if (this.recordedFailures) {
       rightmostFailures = Object.keys(this.recordedFailures).map(
-          key => this.recordedFailures[key],
+        key => this.recordedFailures[key]
       );
     }
     const cst = this._bindings[0];
@@ -366,13 +366,13 @@ export class MatchState {
       cst.grammar = this.grammar;
     }
     return new MatchResult(
-        this.matcher,
-        this.input,
-        this.startExpr,
-        cst,
-        this._bindingOffsets[0],
-        this.rightmostFailurePosition,
-        rightmostFailures,
+      this.matcher,
+      this.input,
+      this.startExpr,
+      cst,
+      this._bindingOffsets[0],
+      this.rightmostFailurePosition,
+      rightmostFailures
     );
   }