compiler: add v18 mode for arity checks (#592)

Author: pdubroy

packages/compiler/src/buildGrammar.ts

@@ -130,7 +130,7 @@ export function buildGrammars(
           visit(s.children[0]!);
         }
         rules.children.map((c: CstNode) => visit(c));
-        const g = decl.build();
+        const g = decl.build({v18: true});
         g.source = interval(node).trimmed();
         if (namespaceHas(namespace, grammarName)) {
           throw errors.duplicateGrammarDeclaration(g, namespace);

packages/ohm-js/src/GrammarDecl.js

@@ -93,7 +93,7 @@ export class GrammarDecl {
   }
 
   // Creates a Grammar instance, and if it passes the sanity checks, returns it.
-  build() {
+  build({v18 = false} = {}) {
     const grammar = new Grammar(
       this.name,
       this.ensureSuperGrammar(),
@@ -114,7 +114,7 @@ export class GrammarDecl {
     Object.keys(grammar.rules).forEach(ruleName => {
       const {body} = grammar.rules[ruleName];
       try {
-        body.assertChoicesHaveUniformArity(ruleName);
+        body.assertChoicesHaveUniformArity(ruleName, v18);
       } catch (e) {
         grammarErrors.push(e);
       }

packages/ohm-js/src/pexprs-assertChoicesHaveUniformArity.js

@@ -6,6 +6,8 @@ import * as pexprs from './pexprs-main.js';
 // Operations
 // --------------------------------------------------------------------
 
+// v18 (boolean, default false) is passed through to getArity().
+
 pexprs.PExpr.prototype.assertChoicesHaveUniformArity = abstract(
   'assertChoicesHaveUniformArity'
 );
@@ -17,54 +19,54 @@ pexprs.any.assertChoicesHaveUniformArity =
   pexprs.Param.prototype.assertChoicesHaveUniformArity =
   pexprs.Lex.prototype.assertChoicesHaveUniformArity =
   pexprs.UnicodeChar.prototype.assertChoicesHaveUniformArity =
-    function (ruleName) {
+    function (ruleName, v18 = false) {
       // no-op
     };
 
-pexprs.Alt.prototype.assertChoicesHaveUniformArity = function (ruleName) {
+pexprs.Alt.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
   if (this.terms.length === 0) {
     return;
   }
-  const arity = this.terms[0].getArity();
+  const arity = this.terms[0].getArity(v18);
   for (let idx = 0; idx < this.terms.length; idx++) {
     const term = this.terms[idx];
-    term.assertChoicesHaveUniformArity();
-    const otherArity = term.getArity();
+    term.assertChoicesHaveUniformArity(ruleName, v18);
+    const otherArity = term.getArity(v18);
     if (arity !== otherArity) {
       throw errors.inconsistentArity(ruleName, arity, otherArity, term);
     }
   }
 };
 
-pexprs.Extend.prototype.assertChoicesHaveUniformArity = function (ruleName) {
+pexprs.Extend.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
   // Extend is a special case of Alt that's guaranteed to have exactly two
   // cases: [extensions, origBody].
-  const actualArity = this.terms[0].getArity();
-  const expectedArity = this.terms[1].getArity();
+  const actualArity = this.terms[0].getArity(v18);
+  const expectedArity = this.terms[1].getArity(v18);
   if (actualArity !== expectedArity) {
     throw errors.inconsistentArity(ruleName, expectedArity, actualArity, this.terms[0]);
   }
 };
 
-pexprs.Seq.prototype.assertChoicesHaveUniformArity = function (ruleName) {
+pexprs.Seq.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
   for (let idx = 0; idx < this.factors.length; idx++) {
-    this.factors[idx].assertChoicesHaveUniformArity(ruleName);
+    this.factors[idx].assertChoicesHaveUniformArity(ruleName, v18);
   }
 };
 
-pexprs.Iter.prototype.assertChoicesHaveUniformArity = function (ruleName) {
-  this.expr.assertChoicesHaveUniformArity(ruleName);
+pexprs.Iter.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
+  this.expr.assertChoicesHaveUniformArity(ruleName, v18);
 };
 
-pexprs.Not.prototype.assertChoicesHaveUniformArity = function (ruleName) {
+pexprs.Not.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
   // no-op (not required b/c the nested expr doesn't show up in the CST)
 };
 
-pexprs.Lookahead.prototype.assertChoicesHaveUniformArity = function (ruleName) {
-  this.expr.assertChoicesHaveUniformArity(ruleName);
+pexprs.Lookahead.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
+  this.expr.assertChoicesHaveUniformArity(ruleName, v18);
 };
 
-pexprs.Apply.prototype.assertChoicesHaveUniformArity = function (ruleName) {
+pexprs.Apply.prototype.assertChoicesHaveUniformArity = function (ruleName, v18 = false) {
   // The arities of the parameter expressions is required to be 1 by
   // `assertAllApplicationsAreValid()`.
 };

packages/ohm-js/src/pexprs-getArity.js

@@ -5,6 +5,9 @@ import * as pexprs from './pexprs-main.js';
 // Operations
 // --------------------------------------------------------------------
 
+// In v18, iteration expressions (*, +, ?) always have arity 1.
+// In v17, they have the same arity as their inner expression.
+
 pexprs.PExpr.prototype.getArity = abstract('getArity');
 
 pexprs.any.getArity =
@@ -14,32 +17,35 @@ pexprs.any.getArity =
   pexprs.Param.prototype.getArity =
   pexprs.Apply.prototype.getArity =
   pexprs.UnicodeChar.prototype.getArity =
-    function () {
+    function (v18 = false) {
       return 1;
     };
 
-pexprs.Alt.prototype.getArity = function () {
+pexprs.Alt.prototype.getArity = function (v18 = false) {
   // This is ok b/c all terms must have the same arity -- this property is
   // checked by the Grammar constructor.
-  return this.terms.length === 0 ? 0 : this.terms[0].getArity();
+  return this.terms.length === 0 ? 0 : this.terms[0].getArity(v18);
 };
 
-pexprs.Seq.prototype.getArity = function () {
+pexprs.Seq.prototype.getArity = function (v18 = false) {
   let arity = 0;
   for (let idx = 0; idx < this.factors.length; idx++) {
-    arity += this.factors[idx].getArity();
+    arity += this.factors[idx].getArity(v18);
   }
   return arity;
 };
 
-pexprs.Iter.prototype.getArity = function () {
-  return this.expr.getArity();
+pexprs.Iter.prototype.getArity = function (v18 = false) {
+  if (v18) {
+    return 1;
+  }
+  return this.expr.getArity(v18);
 };
 
-pexprs.Not.prototype.getArity = function () {
+pexprs.Not.prototype.getArity = function (v18 = false) {
   return 0;
 };
 
-pexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = function () {
-  return this.expr.getArity();
+pexprs.Lookahead.prototype.getArity = pexprs.Lex.prototype.getArity = function (v18 = false) {
+  return this.expr.getArity(v18);
 };