ohm-js 17.2.1 → 17.4.0

package/src/PosInfo.js

@@ -29,14 +29,14 @@ export class PosInfo {
     const indexOfFirstInvolvedRule =
       applicationMemoKeyStack.indexOf(headApplication.toMemoKey()) + 1;
     const involvedApplicationMemoKeys = applicationMemoKeyStack.slice(
-        indexOfFirstInvolvedRule,
+      indexOfFirstInvolvedRule
     );
 
-    memoRec.isInvolved = function(applicationMemoKey) {
+    memoRec.isInvolved = function (applicationMemoKey) {
       return involvedApplicationMemoKeys.indexOf(applicationMemoKey) >= 0;
     };
 
-    memoRec.updateInvolvedApplicationMemoKeys = function() {
+    memoRec.updateInvolvedApplicationMemoKeys = function () {
       for (let idx = indexOfFirstInvolvedRule; idx < applicationMemoKeyStack.length; idx++) {
         const applicationMemoKey = applicationMemoKeyStack[idx];
         if (!this.isInvolved(applicationMemoKey)) {
@@ -70,8 +70,8 @@ export class PosInfo {
     this.memo[memoKey] = memoRec;
     this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);
     this.maxRightmostFailureOffset = Math.max(
-        this.maxRightmostFailureOffset,
-        memoRec.rightmostFailureOffset,
+      this.maxRightmostFailureOffset,
+      memoRec.rightmostFailureOffset
     );
     return memoRec;
   }
@@ -93,8 +93,8 @@ export class PosInfo {
       } else {
         this.maxExaminedLength = Math.max(this.maxExaminedLength, memoRec.examinedLength);
         this.maxRightmostFailureOffset = Math.max(
-            this.maxRightmostFailureOffset,
-            memoRec.rightmostFailureOffset,
+          this.maxRightmostFailureOffset,
+          memoRec.rightmostFailureOffset
         );
       }
     });

package/src/Semantics.js

@@ -179,11 +179,11 @@ export class Semantics {
     if (superSemantics) {
       if (!(grammar.equals(this.super.grammar) || grammar._inheritsFrom(this.super.grammar))) {
         throw new Error(
-            "Cannot extend a semantics for grammar '" +
+          "Cannot extend a semantics for grammar '" +
             this.super.grammar.name +
             "' for use with grammar '" +
             grammar.name +
-            "' (not a sub-grammar)",
+            "' (not a sub-grammar)"
         );
       }
       this.operations = Object.create(this.super.operations);
@@ -192,7 +192,7 @@ export class Semantics {
 
       // Assign unique symbols for each of the attributes inherited from the super-semantics so that
       // they are memoized independently.
-      // eslint-disable-next-line guard-for-in
+
       for (const attributeName in this.attributes) {
         Object.defineProperty(this.attributeKeys, attributeName, {
           value: util.uniqueId(attributeName),
@@ -221,11 +221,11 @@ export class Semantics {
   // Throws an exception if one or more of them doesn't.
   checkActionDicts() {
     let name;
-    // eslint-disable-next-line guard-for-in
+
     for (name in this.operations) {
       this.operations[name].checkActionDict(this.grammar);
     }
-    // eslint-disable-next-line guard-for-in
+
     for (name in this.attributes) {
       this.attributes[name].checkActionDict(this.grammar);
     }
@@ -325,9 +325,9 @@ export class Semantics {
     });
 
     const entry =
-      type === 'operation' ?
-        new Operation(name, formals, realActionDict, builtInDefault) :
-        new Attribute(name, realActionDict, builtInDefault);
+      type === 'operation'
+        ? new Operation(name, formals, realActionDict, builtInDefault)
+        : new Attribute(name, realActionDict, builtInDefault);
 
     // The following check is not strictly necessary (it will happen later anyway) but it's better
     // to catch errors early.
@@ -343,7 +343,7 @@ export class Semantics {
       // Check that the caller passed the correct number of arguments.
       if (arguments.length !== thisThing.formals.length) {
         throw new Error(
-            'Invalid number of arguments passed to ' +
+          'Invalid number of arguments passed to ' +
             name +
             ' ' +
             type +
@@ -351,7 +351,7 @@ export class Semantics {
             thisThing.formals.length +
             ', got ' +
             arguments.length +
-            ')',
+            ')'
         );
       }
 
@@ -372,7 +372,7 @@ export class Semantics {
 
     if (type === 'operation') {
       this.Wrapper.prototype[name] = doIt;
-      this.Wrapper.prototype[name].toString = function() {
+      this.Wrapper.prototype[name].toString = function () {
         return '[' + name + ' operation]';
       };
     } else {
@@ -394,13 +394,13 @@ export class Semantics {
 
     if (!(this.super && name in this.super[typePlural])) {
       throw new Error(
-          'Cannot extend ' +
+        'Cannot extend ' +
           type +
           " '" +
           name +
           "': did not inherit an " +
           type +
-          ' with that name',
+          ' with that name'
       );
     }
     if (hasOwnProperty(this[typePlural], name)) {
@@ -417,9 +417,9 @@ export class Semantics {
     });
 
     this[typePlural][name] =
-      type === 'operation' ?
-        new Operation(name, inheritedFormals, newActionDict) :
-        new Attribute(name, newActionDict);
+      type === 'operation'
+        ? new Operation(name, inheritedFormals, newActionDict)
+        : new Attribute(name, newActionDict);
 
     // The following check is not strictly necessary (it will happen later anyway) but it's better
     // to catch errors early.
@@ -432,12 +432,12 @@ export class Semantics {
     }
     if (name in this.operations) {
       throw new Error(
-          'Cannot add ' + type + " '" + name + "': an operation with that name already exists",
+        'Cannot add ' + type + " '" + name + "': an operation with that name already exists"
       );
     }
     if (name in this.attributes) {
       throw new Error(
-          'Cannot add ' + type + " '" + name + "': an attribute with that name already exists",
+        'Cannot add ' + type + " '" + name + "': an attribute with that name already exists"
       );
     }
   }
@@ -463,8 +463,8 @@ function parseSignature(signature, type) {
   }
 
   const r = Semantics.prototypeGrammar.match(
-      signature,
-    type === 'operation' ? 'OperationSignature' : 'AttributeSignature',
+    signature,
+    type === 'operation' ? 'OperationSignature' : 'AttributeSignature'
   );
   if (r.failed()) {
     throw new Error(r.message);
@@ -474,7 +474,7 @@ function parseSignature(signature, type) {
 }
 
 function newDefaultAction(type, name, doIt) {
-  return function(...children) {
+  return function (...children) {
     const thisThing = this._semantics.operations[name] || this._semantics.attributes[name];
     const args = thisThing.formals.map(formal => this.args[formal]);
 
@@ -498,12 +498,12 @@ function newDefaultAction(type, name, doIt) {
 // Semantics instance. When that function is invoked with a CST node as an argument, it returns
 // a wrapper for that node which gives access to the operations and attributes provided by this
 // semantics.
-Semantics.createSemantics = function(grammar, optSuperSemantics) {
+Semantics.createSemantics = function (grammar, optSuperSemantics) {
   const s = new Semantics(
-      grammar,
-    optSuperSemantics !== undefined ?
-      optSuperSemantics :
-      Semantics.BuiltInSemantics._getSemantics(),
+    grammar,
+    optSuperSemantics !== undefined
+      ? optSuperSemantics
+      : Semantics.BuiltInSemantics._getSemantics()
   );
 
   // To enable clients to invoke a semantics like a function, return a function that acts as a proxy
@@ -511,8 +511,8 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   const proxy = function ASemantics(matchResult) {
     if (!(matchResult instanceof MatchResult)) {
       throw new TypeError(
-          'Semantics expected a MatchResult, but got ' +
-          common.unexpectedObjToString(matchResult),
+        'Semantics expected a MatchResult, but got ' +
+          common.unexpectedObjToString(matchResult)
       );
     }
     if (matchResult.failed()) {
@@ -522,11 +522,11 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
     const cst = matchResult._cst;
     if (cst.grammar !== grammar) {
       throw new Error(
-          "Cannot use a MatchResult from grammar '" +
+        "Cannot use a MatchResult from grammar '" +
           cst.grammar.name +
           "' with a semantics for '" +
           grammar.name +
-          "'",
+          "'"
       );
     }
     const inputStream = new InputStream(matchResult.input);
@@ -534,38 +534,38 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   };
 
   // Forward public methods from the proxy to the semantics instance.
-  proxy.addOperation = function(signature, actionDict) {
+  proxy.addOperation = function (signature, actionDict) {
     s.addOperationOrAttribute('operation', signature, actionDict);
     return proxy;
   };
-  proxy.extendOperation = function(name, actionDict) {
+  proxy.extendOperation = function (name, actionDict) {
     s.extendOperationOrAttribute('operation', name, actionDict);
     return proxy;
   };
-  proxy.addAttribute = function(name, actionDict) {
+  proxy.addAttribute = function (name, actionDict) {
     s.addOperationOrAttribute('attribute', name, actionDict);
     return proxy;
   };
-  proxy.extendAttribute = function(name, actionDict) {
+  proxy.extendAttribute = function (name, actionDict) {
     s.extendOperationOrAttribute('attribute', name, actionDict);
     return proxy;
   };
-  proxy._getActionDict = function(operationOrAttributeName) {
+  proxy._getActionDict = function (operationOrAttributeName) {
     const action =
       s.operations[operationOrAttributeName] || s.attributes[operationOrAttributeName];
     if (!action) {
       throw new Error(
-          '"' +
+        '"' +
           operationOrAttributeName +
           '" is not a valid operation or attribute ' +
           'name in this semantics for "' +
           grammar.name +
-          '"',
+          '"'
       );
     }
     return action.actionDict;
   };
-  proxy._remove = function(operationOrAttributeName) {
+  proxy._remove = function (operationOrAttributeName) {
     let semantic;
     if (operationOrAttributeName in s.operations) {
       semantic = s.operations[operationOrAttributeName];
@@ -577,16 +577,16 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
     delete s.Wrapper.prototype[operationOrAttributeName];
     return semantic;
   };
-  proxy.getOperationNames = function() {
+  proxy.getOperationNames = function () {
     return Object.keys(s.operations);
   };
-  proxy.getAttributeNames = function() {
+  proxy.getAttributeNames = function () {
     return Object.keys(s.attributes);
   };
-  proxy.getGrammar = function() {
+  proxy.getGrammar = function () {
     return s.grammar;
   };
-  proxy.toRecipe = function(semanticsOnly) {
+  proxy.toRecipe = function (semanticsOnly) {
     return s.toRecipe(semanticsOnly);
   };
 
@@ -594,7 +594,7 @@ Semantics.createSemantics = function(grammar, optSuperSemantics) {
   proxy.toString = s.toString.bind(s);
 
   // Returns the semantics for the proxy.
-  proxy._getSemantics = function() {
+  proxy._getSemantics = function () {
     return s;
   };
 

package/src/Trace.js

@@ -43,10 +43,10 @@ function asEscapedString(obj) {
   if (typeof obj === 'string') {
     // Replace non-printable characters with visible symbols.
     return obj
-        .replace(/ /g, DOT_OPERATOR)
-        .replace(/\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION)
-        .replace(/\n/g, SYMBOL_FOR_LINE_FEED)
-        .replace(/\r/g, SYMBOL_FOR_CARRIAGE_RETURN);
+      .replace(/ /g, DOT_OPERATOR)
+      .replace(/\t/g, SYMBOL_FOR_HORIZONTAL_TABULATION)
+      .replace(/\n/g, SYMBOL_FOR_LINE_FEED)
+      .replace(/\r/g, SYMBOL_FOR_CARRIAGE_RETURN);
   }
   return String(obj);
 }
@@ -77,13 +77,13 @@ export class Trace {
 
   cloneWithExpr(expr) {
     const ans = new Trace(
-        this.input,
-        this.pos,
-        this.pos2,
-        expr,
-        this.succeeded,
-        this.bindings,
-        this.children,
+      this.input,
+      this.pos,
+      this.pos2,
+      expr,
+      this.succeeded,
+      this.bindings,
+      this.children
     );
 
     ans.isHeadOfLeftRecursion = this.isHeadOfLeftRecursion;
@@ -98,13 +98,13 @@ export class Trace {
   // Record the trace information for the terminating condition of the LR loop.
   recordLRTermination(ruleBodyTrace, value) {
     this.terminatingLREntry = new Trace(
-        this.input,
-        this.pos,
-        this.pos2,
-        this.expr,
-        false,
-        [value],
-        [ruleBodyTrace],
+      this.input,
+      this.pos,
+      this.pos2,
+      this.expr,
+      false,
+      [value],
+      [ruleBodyTrace]
     );
     this.terminatingLREntry.terminatesLR = true;
   }
@@ -164,7 +164,7 @@ export class Trace {
       const ctorName = node.expr.constructor.name;
       // Don't print anything for Alt nodes.
       if (ctorName === 'Alt') {
-        return; // eslint-disable-line consistent-return
+        return;
       }
       sb.append(getInputExcerpt(node.input, node.pos, 10) + spaces(depth * 2 + 1));
       sb.append((node.succeeded ? CHECK_MARK : BALLOT_X) + ' ' + node.displayString);

package/src/buildGrammar.js

@@ -108,10 +108,10 @@ export function buildGrammar(match, namespace, optOhmGrammarForTesting) {
         });
 
         return new pexprs.Splice(
-            decl.superGrammar,
-            currentRuleName,
-            beforeTerms,
-            afterTerms,
+          decl.superGrammar,
+          currentRuleName,
+          beforeTerms,
+          afterTerms
         ).withSource(this.source);
       } else {
         return builder.alt(...args).withSource(this.source);

package/src/common.js

@@ -24,14 +24,14 @@ escapeStringFor['\u000b'.charCodeAt(0)] = '\\v';
 
 export function abstract(optMethodName) {
   const methodName = optMethodName || '';
-  return function() {
+  return function () {
     throw new Error(
-        'this method ' +
+      'this method ' +
         methodName +
         ' is abstract! ' +
         '(it has no implementation in class ' +
         this.constructor.name +
-        ')',
+        ')'
     );
   };
 }
@@ -124,11 +124,11 @@ export function StringBuffer() {
   this.strings = [];
 }
 
-StringBuffer.prototype.append = function(str) {
+StringBuffer.prototype.append = function (str) {
   this.strings.push(str);
 };
 
-StringBuffer.prototype.contents = function() {
+StringBuffer.prototype.contents = function () {
   return this.strings.join('');
 };
 
@@ -152,9 +152,9 @@ export function unescapeCodePoint(s) {
       case 'x':
         return escapeUnicode(s.slice(2, 4));
       case 'u':
-        return s.charAt(2) === '{' ?
-          escapeUnicode(s.slice(3, -1)) :
-          escapeUnicode(s.slice(2, 6));
+        return s.charAt(2) === '{'
+          ? escapeUnicode(s.slice(3, -1))
+          : escapeUnicode(s.slice(2, 6));
       default:
         return s.charAt(1);
     }
@@ -180,7 +180,7 @@ export function unexpectedObjToString(obj) {
       typeName = typeof obj;
     }
     return typeName + ': ' + JSON.stringify(String(obj));
-  } catch (e) {
+  } catch {
     return baseToString;
   }
 }

package/src/errors.js

@@ -48,9 +48,9 @@ export function grammarSyntaxError(matchFailure) {
 // Undeclared grammar
 
 export function undeclaredGrammar(grammarName, namespace, interval) {
-  const message = namespace ?
-    `Grammar ${grammarName} is not declared in namespace '${namespace}'` :
-    'Undeclared grammar ' + grammarName;
+  const message = namespace
+    ? `Grammar ${grammarName} is not declared in namespace '${namespace}'`
+    : 'Undeclared grammar ' + grammarName;
   return createError(message, interval);
 }
 
@@ -70,8 +70,8 @@ export function grammarDoesNotSupportIncrementalParsing(grammar) {
 
 export function undeclaredRule(ruleName, grammarName, optInterval) {
   return createError(
-      'Rule ' + ruleName + ' is not declared in grammar ' + grammarName,
-      optInterval,
+    'Rule ' + ruleName + ' is not declared in grammar ' + grammarName,
+    optInterval
   );
 }
 
@@ -79,8 +79,8 @@ export function undeclaredRule(ruleName, grammarName, optInterval) {
 
 export function cannotOverrideUndeclaredRule(ruleName, grammarName, optSource) {
   return createError(
-      'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName,
-      optSource,
+    'Cannot override rule ' + ruleName + ' because it is not declared in ' + grammarName,
+    optSource
   );
 }
 
@@ -88,8 +88,8 @@ export function cannotOverrideUndeclaredRule(ruleName, grammarName, optSource) {
 
 export function cannotExtendUndeclaredRule(ruleName, grammarName, optSource) {
   return createError(
-      'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName,
-      optSource,
+    'Cannot extend rule ' + ruleName + ' because it is not declared in ' + grammarName,
+    optSource
   );
 }
 
@@ -108,14 +108,14 @@ export function duplicateRuleDeclaration(ruleName, grammarName, declGrammarName,
 
 export function wrongNumberOfParameters(ruleName, expected, actual, source) {
   return createError(
-      'Wrong number of parameters for rule ' +
+    'Wrong number of parameters for rule ' +
       ruleName +
       ' (expected ' +
       expected +
       ', got ' +
       actual +
       ')',
-      source,
+    source
   );
 }
 
@@ -123,14 +123,14 @@ export function wrongNumberOfParameters(ruleName, expected, actual, source) {
 
 export function wrongNumberOfArguments(ruleName, expected, actual, expr) {
   return createError(
-      'Wrong number of arguments for rule ' +
+    'Wrong number of arguments for rule ' +
       ruleName +
       ' (expected ' +
       expected +
       ', got ' +
       actual +
       ')',
-      expr,
+    expr
   );
 }
 
@@ -138,8 +138,8 @@ export function wrongNumberOfArguments(ruleName, expected, actual, expr) {
 
 export function duplicateParameterNames(ruleName, duplicates, source) {
   return createError(
-      'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(', '),
-      source,
+    'Duplicate parameter names in rule ' + ruleName + ': ' + duplicates.join(', '),
+    source
   );
 }
 
@@ -147,14 +147,14 @@ export function duplicateParameterNames(ruleName, duplicates, source) {
 
 export function invalidParameter(ruleName, expr) {
   return createError(
-      'Invalid parameter to rule ' +
+    'Invalid parameter to rule ' +
       ruleName +
       ': ' +
       expr +
       ' has arity ' +
       expr.getArity() +
       ', but parameter expressions must have arity 1',
-      expr.source,
+    expr.source
   );
 }
 
@@ -166,8 +166,8 @@ const syntacticVsLexicalNote =
 
 export function applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr) {
   return createError(
-      'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)',
-      applyExpr.source,
+    'Cannot apply syntactic rule ' + ruleName + ' from here (inside a lexical context)',
+    applyExpr.source
   );
 }
 
@@ -176,9 +176,9 @@ export function applicationOfSyntacticRuleFromLexicalContext(ruleName, applyExpr
 export function applySyntacticWithLexicalRuleApplication(applyExpr) {
   const {ruleName} = applyExpr;
   return createError(
-      `applySyntactic is for syntactic rules, but '${ruleName}' is a lexical rule. ` +
+    `applySyntactic is for syntactic rules, but '${ruleName}' is a lexical rule. ` +
       syntacticVsLexicalNote,
-      applyExpr.source,
+    applyExpr.source
   );
 }
 
@@ -186,8 +186,8 @@ export function applySyntacticWithLexicalRuleApplication(applyExpr) {
 
 export function unnecessaryExperimentalApplySyntactic(applyExpr) {
   return createError(
-      'applySyntactic is not required here (in a syntactic context)',
-      applyExpr.source,
+    'applySyntactic is not required here (in a syntactic context)',
+    applyExpr.source
   );
 }
 
@@ -213,8 +213,8 @@ export function invalidCodePoint(applyWrapper) {
   const digitIntervals = applyWrapper.children.slice(1, -1).map(d => d.source);
   const fullInterval = digitIntervals[0].coverageWith(...digitIntervals.slice(1));
   return createError(
-      `U+${fullInterval.contents} is not a valid Unicode code point`,
-      fullInterval,
+    `U+${fullInterval.contents} is not a valid Unicode code point`,
+    fullInterval
   );
 }
 
@@ -232,8 +232,8 @@ export function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
     "' (possible infinite loop)";
   if (applicationStack.length > 0) {
     const stackTrace = applicationStack
-        .map(app => new pexprs.Apply(app.ruleName, app.args))
-        .join('\n');
+      .map(app => new pexprs.Apply(app.ruleName, app.args))
+      .join('\n');
     message += '\nApplication stack (most recent application last):\n' + stackTrace;
   }
   return createError(message, kleeneExpr.expr.source);
@@ -243,7 +243,7 @@ export function kleeneExprHasNullableOperand(kleeneExpr, applicationStack) {
 
 export function inconsistentArity(ruleName, expected, actual, expr) {
   return createError(
-      'Rule ' +
+    'Rule ' +
       ruleName +
       ' involves an alternation which has inconsistent arity ' +
       '(expected ' +
@@ -251,7 +251,7 @@ export function inconsistentArity(ruleName, expected, actual, expr) {
       ', got ' +
       actual +
       ')',
-      expr.source,
+    expr.source
   );
 }
 
@@ -265,7 +265,7 @@ export function duplicatePropertyNames(duplicates) {
 
 export function invalidConstructorCall(grammar, ctorName, children) {
   return createError(
-      'Attempt to invoke constructor ' + ctorName + ' with invalid or unexpected arguments',
+    'Attempt to invoke constructor ' + ctorName + ' with invalid or unexpected arguments'
   );
 }
 
@@ -280,12 +280,12 @@ export function multipleErrors(errors) {
 
 export function missingSemanticAction(ctorName, name, type, stack) {
   let stackTrace = stack
-      .slice(0, -1)
-      .map(info => {
-        const ans = '  ' + info[0].name + ' > ' + info[1];
-        return info.length === 3 ? ans + " for '" + info[2] + "'" : ans;
-      })
-      .join('\n');
+    .slice(0, -1)
+    .map(info => {
+      const ans = '  ' + info[0].name + ' > ' + info[1];
+      return info.length === 3 ? ans + " for '" + info[2] + "'" : ans;
+    })
+    .join('\n');
   stackTrace += '\n  ' + name + ' > ' + ctorName;
 
   let moreInfo = '';

package/src/main.js

@@ -35,8 +35,8 @@ export function grammar(source, optNamespace) {
     const secondGrammar = ns[grammarNames[1]];
     const interval = secondGrammar.source;
     throw new Error(
-        util.getLineAndColumnMessage(interval.sourceString, interval.startIdx) +
-        'Found more than one grammar definition -- use ohm.grammars() instead.',
+      util.getLineAndColumnMessage(interval.sourceString, interval.startIdx) +
+        'Found more than one grammar definition -- use ohm.grammars() instead.'
     );
   }
   return ns[grammarNames[0]]; // Return the one and only grammar.
@@ -50,7 +50,7 @@ export function grammars(source, optNamespace) {
       source = source.toString();
     } else {
       throw new TypeError(
-          'Expected string as first argument, got ' + common.unexpectedObjToString(source),
+        'Expected string as first argument, got ' + common.unexpectedObjToString(source)
       );
     }
   }