parser-lr 0.8.2 → 0.8.3

package/bin/parser-lr.js

@@ -3781,7 +3781,7 @@ const {
   Help,
 } = commander;
 
-var version$1 = "0.8.2";
+var version$1 = "0.8.3";
 var packageDefinition = {
 	version: version$1};
 
@@ -7063,6 +7063,46 @@ function referenceSlotIndex(production, reference) {
     return null;
 }
 
+/**
+ * Returns whether a CST node was reduced by an empty right-hand side.
+ *
+ * @param node - CST node to test.
+ * @param table - Parse table supplying production metadata.
+ */
+function isEpsilonNode(node, table) {
+    if (node.isTerminal || node.children.length > 0 || node.productionId === null) {
+        return false;
+    }
+    const production = table.production(node.productionId);
+    return production !== null && production.rhs.length === 0;
+}
+/**
+ * Returns whether a CST node is an authored labeled empty alternative.
+ *
+ * @remarks
+ * Labeled epsilons such as `#absent` are first-class grammar alternatives.
+ * They keep identity through default transforms.
+ *
+ * @param node - CST node to test.
+ * @param table - Parse table supplying production metadata.
+ */
+function isAuthoredEpsilonNode(node, table) {
+    return isEpsilonNode(node, table) && node.variant !== null;
+}
+/**
+ * Returns whether a CST node is synthetic unlabeled epsilon scaffolding.
+ *
+ * @remarks
+ * Unlabeled empty productions come from `{…}` / `[…]` desugaring. They are
+ * not authored alternatives and should disappear from AST construction.
+ *
+ * @param node - CST node to test.
+ * @param table - Parse table supplying production metadata.
+ */
+function isSyntheticEpsilonNode(node, table) {
+    return isEpsilonNode(node, table) && node.variant === null;
+}
+
 /**
  * Applies CST-to-AST transform rules to a concrete syntax tree.
  */
@@ -7188,7 +7228,8 @@ class CstTransformer {
                 if (childNode === null) {
                     return null;
                 }
-                if (this.isEpsilonNode(childNode)) {
+                // Drop synthetic unlabeled epsilons; keep authored `#label` empty alts.
+                if (isSyntheticEpsilonNode(childNode, this.table)) {
                     continue;
                 }
                 const child = this.transformNode(childNode);
@@ -7220,7 +7261,7 @@ class CstTransformer {
         }
         let acc = this.buildAstNode(expression.typeName, expression.variant, [left, operator, right], node.location);
         let tail = this.findRepeatTail(node, slots);
-        while (tail !== null && !this.isEpsilonNode(tail)) {
+        while (tail !== null && !isSyntheticEpsilonNode(tail, this.table)) {
             const tailSlots = this.resolveReferences(tail, expression.references);
             if (tailSlots === null) {
                 return null;
@@ -7244,7 +7285,7 @@ class CstTransformer {
     applyFoldRight(node, expression) {
         const parts = [];
         let current = node;
-        while (current !== null && !this.isEpsilonNode(current)) {
+        while (current !== null && !isSyntheticEpsilonNode(current, this.table)) {
             const leftRef = expression.references[0];
             const operatorRef = expression.references[1];
             const rightRef = expression.references[2];
@@ -7286,14 +7327,14 @@ class CstTransformer {
     applyFlatten(node, expression) {
         const items = [];
         let current = node;
-        while (current !== null && !this.isEpsilonNode(current)) {
+        while (current !== null && !isSyntheticEpsilonNode(current, this.table)) {
             const head = this.transformFlattenHead(current, expression.head);
             if (head === null) {
                 return null;
             }
             items.push(head);
             const tail = this.resolveReferenceNode(current, expression.tail);
-            if (tail === null || this.isEpsilonNode(tail)) {
+            if (tail === null || isSyntheticEpsilonNode(tail, this.table)) {
                 break;
             }
             current = tail;
@@ -7333,10 +7374,19 @@ class CstTransformer {
     /**
      * Transforms a CST node without explicit transform rules.
      *
+     * @remarks
+     * Authored labeled epsilon alternatives (`#absent`) keep their identity.
+     * Synthetic unlabeled epsilons from `{…}` / `[…]` desugaring are dropped.
+     *
      * @param node - CST node to pass through or unwrap.
      */
     defaultTransform(node) {
-        if (this.isEpsilonNode(node)) {
+        // Authored `#label` empty alternatives are first-class nodes.
+        if (isAuthoredEpsilonNode(node, this.table)) {
+            return AstNode.rule(node.symbol, [], node.location, node.variant);
+        }
+        // Synthetic unlabeled epsilons are scaffolding, not AST content.
+        if (isSyntheticEpsilonNode(node, this.table)) {
             return null;
         }
         const children = this.transformChildren(node.children);
@@ -7458,21 +7508,6 @@ class CstTransformer {
         }
         return null;
     }
-    /**
-     * Returns whether a CST node represents an epsilon production.
-     *
-     * @param node - CST node to test.
-     */
-    isEpsilonNode(node) {
-        if (node.isTerminal) {
-            return false;
-        }
-        if (node.children.length > 0) {
-            return false;
-        }
-        const production = this.productionFor(node);
-        return production !== null && production.rhs.length === 0;
-    }
     /**
      * Returns parse table production metadata for a CST node.
      *
@@ -13826,7 +13861,7 @@ function validateGrammarTable(grammar) {
         for (const rule of grammar.transformSchema.rules) {
             validateTransformProductionExists(rule, bnfProductionNames, issues);
             for (const alternative of rule.alternatives) {
-                validateTransformExpression(grammar, alternative, issues);
+                validateTransformExpression(grammar, rule, alternative, issues);
                 collectPassCollapseWarnings(grammar, rule, alternative, bnf.productions, issues);
             }
         }
@@ -13930,12 +13965,13 @@ function syntheticRepeatPrefix(name) {
  * @param alternative - Transform alternative owning the expression.
  * @param issues - Issue list to append to.
  */
-function validateTransformExpression(grammar, alternative, issues) {
+function validateTransformExpression(grammar, rule, alternative, issues) {
     const expression = alternative.expression;
     const location = alternative.location ?? null;
     switch (expression.kind) {
         case 'build':
             validateAstTarget(grammar, expression.typeName, expression.variant, location, issues);
+            validateBuildArity(grammar, rule, alternative, expression, location, issues);
             break;
         case 'foldLeft':
         case 'foldRight':
@@ -13944,6 +13980,130 @@ function validateTransformExpression(grammar, alternative, issues) {
             break;
     }
 }
+/**
+ * Records an error when a build argument list conflicts with a zero-factor shape.
+ *
+ * @remarks
+ * Build argument counts are not required to match grammar or AST slot counts in
+ * general: keywords may be dropped, punctuation may be kept, and child
+ * productions may build a shared parent AST variant. The only coherent checks
+ * are zero-factor cases and empty builds targeting a non-empty AST variant.
+ *
+ * @param grammar - Parsed grammar model.
+ * @param rule - Transform rule owning the build expression.
+ * @param alternative - Transform alternative owning the build expression.
+ * @param expression - Build transform expression.
+ * @param location - Source span of the transform alternative.
+ * @param issues - Issue list to append to.
+ */
+function validateBuildArity(grammar, rule, alternative, expression, location, issues) {
+    const argumentCount = expression.arguments.length;
+    const production = grammar.production(rule.production);
+    // Reject build arguments on a labeled zero-factor grammar alternative.
+    if (production !== null) {
+        const alternativeExpression = findGrammarAlternativeExpression(production.expression, alternative.label);
+        if (alternativeExpression !== null
+            && isZeroFactorExpression(alternativeExpression)
+            && argumentCount > 0) {
+            issues.push({
+                severity: 'error',
+                message: `transform ${expression.typeName}.${expression.variant} has `
+                    + `${String(argumentCount)} argument(s) but ast variant declares 0`,
+                location,
+            });
+            return;
+        }
+    }
+    if (grammar.astSchema === null) {
+        return;
+    }
+    const astType = grammar.astSchema.type(expression.typeName);
+    if (astType === null) {
+        return;
+    }
+    const variantExpression = findAstVariantExpression(astType.expression, expression.variant);
+    if (variantExpression === null) {
+        return;
+    }
+    // Reject build arguments on a zero-factor AST variant.
+    if (isZeroFactorExpression(variantExpression)) {
+        if (argumentCount > 0) {
+            issues.push({
+                severity: 'error',
+                message: `transform ${expression.typeName}.${expression.variant} has `
+                    + `${String(argumentCount)} argument(s) but ast variant declares 0`,
+                location,
+            });
+        }
+        return;
+    }
+    // Reject empty builds that target a non-empty AST variant.
+    if (argumentCount === 0) {
+        issues.push({
+            severity: 'error',
+            message: `transform ${expression.typeName}.${expression.variant} has `
+                + `0 argument(s) but ast variant requires 1`,
+            location,
+        });
+    }
+}
+/**
+ * Returns whether an expression is a labeled zero-factor alternative.
+ *
+ * @param expression - Grammar or AST alternative expression.
+ */
+function isZeroFactorExpression(expression) {
+    return expression.kind === 'sequence' && expression.elements.length === 0;
+}
+/**
+ * Returns the expression for one labeled grammar alternative.
+ *
+ * @param expression - Production right-hand side expression.
+ * @param label - Transform alternative label.
+ */
+function findGrammarAlternativeExpression(expression, label) {
+    if (expression.kind === 'choice') {
+        for (const alternative of expression.alternatives) {
+            if (alternative.label === label) {
+                return alternative.expression;
+            }
+        }
+        if (label === 'main' && expression.alternatives.length === 1) {
+            return expression.alternatives[0]?.expression ?? null;
+        }
+        return null;
+    }
+    if (label === 'main') {
+        return expression;
+    }
+    return null;
+}
+/**
+ * Returns the expression for one labeled AST alternative.
+ *
+ * @param expression - AST type right-hand side.
+ * @param variant - Variant label to find.
+ */
+function findAstVariantExpression(expression, variant) {
+    if (expression.kind === 'choice') {
+        for (const alternative of expression.alternatives) {
+            if (alternative.label === variant) {
+                return alternative.expression;
+            }
+        }
+        return null;
+    }
+    if (expression.kind === 'sequence' || expression.kind === 'group') {
+        const inner = expression.kind === 'sequence'
+            ? expression.elements[0]
+            : expression.element;
+        if (inner === undefined) {
+            return null;
+        }
+        return findAstVariantExpression(inner, variant);
+    }
+    return null;
+}
 /**
  * Records an error when a transform references an undefined AST type or variant.
  *