occam-verify-cli 1.0.185 → 1.0.198

package/src/node/combinator.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class CombinatorNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(CombinatorNode, ruleName, childNodes, opacity, precedence); }
+export default class CombinatorNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(CombinatorNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/conclusion.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ConclusionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConclusionNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class ConclusionNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConclusionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/conjecture.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import TopLevelAssertionNode from "../node/topLevelAssertion";
 
-export default class ConjectureNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConjectureNode, ruleName, childNodes, opacity, precedence); }
+export default class ConjectureNode extends TopLevelAssertionNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return TopLevelAssertionNode.fromRuleNameChildNodesOpacityAndPrecedence(ConjectureNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/constructor.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class ConstructorNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorNode, ruleName, childNodes, opacity, precedence); }
+export default class ConstructorNode extends NonTerminalNode {
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/combinator.js

@@ -1,17 +1,16 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class ContainedDeclarationNode extends Node {
-  getStatementNode() {
-    const statementNode = this.fromSecondChildNode((secondChildNode) => {
-      const statementNode = secondChildNode;  ///
+import { STATEMENT_RULE_NAME } from "../../ruleNames";
 
-      return statementNode;
-    });
+export default class ContainedDeclarationNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ContainedDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ContainedDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/complexType.js

@@ -1,77 +1,74 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONAL } from "../../constants";
-import { isNodeTypeNode, isNodePropertyDeclarationNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, TYPES_RULE_NAME, PROPERTY_DECLARATION_RULE_NAME } from "../../ruleNames";
 
-export default class ComplexTypeDeclarationNode extends Node {
-  getTypeName() {
-    let typeName;
+export default class ComplexTypeDeclarationNode extends NonTerminalNode {
+  isProvisional() {
+    let provisional = false;
 
     this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode,
+              content = terminalNode.getContent(),
+              contentProvisional = (content === PROVISIONAL);
 
-        typeName = typeNode.getTypeName();
+        if (contentProvisional) {
+          provisional = true;
 
-        return true;
+          return true;
+        }
       }
     });
 
-    return typeName;
+    return provisional;
   }
 
-  isProvisional() {
-    const provisional = this.fromFirstChildNode((firstChildNode) => {
-      const terminalNode = firstChildNode,  ///
-            content = terminalNode.getContent(),
-            contentProvisional = (content === PROVISIONAL),
-            provisional = contentProvisional; ///
+  getTypeName() {
+    const typeNode = this.getTypeNode(),
+          typeName = typeNode.getTypeName();
 
-      return provisional;
-    });
+    return typeName;
+  }
 
-    return provisional;
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
   }
 
-  getSuperTypeNodes() {
-    const typeNodes = this.reduceChildNode((typeNodes, childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+  getTypesNode() {
+    const ruleName = TYPES_RULE_NAME,
+          typesNode = this.getNodeByRuleName(ruleName);
 
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
+    return typesNode;
+  }
 
-        typeNodes.push(typeNode);
-      }
+  getSuperTypeNodes() {
+    let superTypeNodes = [];
 
-      return typeNodes;
-    }, []);
+    const typesNode = this.getTypesNode();
 
-    typeNodes.pop();
+    if (typesNode !== null) {
+      const typeNodes = typesNode.getTypeNodes();
 
-    const superTypeNodes = typeNodes; ///
+      superTypeNodes = typeNodes; ///
+    }
 
     return superTypeNodes;
   }
 
   getPropertyDeclarationNodes() {
-    const propertyDeclarationNodes = this.reduceChildNode((propertyDeclarationNodes, childNode) => {
-      const childNodePropertyDeclarationNode = isNodePropertyDeclarationNode(childNode);
-
-      if (childNodePropertyDeclarationNode) {
-        const propertyDeclarationNode = childNode;  ///
-
-        propertyDeclarationNodes.push(propertyDeclarationNode);
-      }
-
-      return propertyDeclarationNodes;
-    }, []);
+    const ruleName = PROPERTY_DECLARATION_RULE_NAME,
+          propertyDeclarationNodes = this.getNodesByRuleName(ruleName);
 
     return propertyDeclarationNodes;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ComplexTypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ComplexTypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/constructor.js

@@ -1,51 +1,46 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONALLY } from "../../constants";
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
-export default class ConstructorDeclarationNode extends Node {
-  getTermNode() {
-    const termNode = this.fromSecondChildNode((secondChildNode) => {
-      const termNode = secondChildNode; ///
-
-      return termNode;
-    });
-
-    return termNode;
-  }
-
-  getTypeNode() {
-    const typeNode = this.fromFourthChildNode((fourthChildNode) => {
-      const typeNode = fourthChildNode; ///
-
-      return typeNode;
-    }) || null;
-
-    return typeNode;
-  }
-
+export default class ConstructorDeclarationNode extends NonTerminalNode {
   isProvisional() {
-    const provisional = this.fromSecondLastChildNode((secondLastChildNode) => {
-      let provisional = false;
+    let provisional = false;
 
-      const secondLastChildNodeTerminalNode = secondLastChildNode.isTerminalNode();
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (secondLastChildNodeTerminalNode) {
-        const terminalNode = secondLastChildNode, ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode,
               content = terminalNode.getContent(),
               contentProvisionally = (content === PROVISIONALLY);
 
         if (contentProvisionally) {
           provisional = true;
+
+          return true;
         }
       }
-
-      return provisional;
     });
 
     return provisional;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
+
+    return typeNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/metavariable.js

@@ -1,7 +1,30 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-export default class MetavariableDeclarationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
+import { META_TYPE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
+
+export default class MetavariableDeclarationNode extends NonTerminalNode {
+  getTypeNode() {
+    const metavariableNode = this.getMetavariableNode(),
+          typeNode = metavariableNode.getTypeNode();
+
+    return typeNode;
+  }
+
+  getMetaTypeNode() {
+    const ruleName = META_TYPE_RULE_NAME,
+          metaTypeNode = this.getNodeByRuleName(ruleName);
+
+    return metaTypeNode
+  }
+
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetavariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/property.js

@@ -1,36 +1,30 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
-import { isNodePropertyNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, PROPERTY_RULE_NAME } from "../../ruleNames";
 
-export default class PropertyDeclarationNode extends Node {
-  getTypeNode() {
-    const typeNode = this.fromSecondLastChildNode((secondLastChildNode) => {
-      const typeNode = secondLastChildNode;; ///
-
-      return typeNode;
-    });
+export default class PropertyDeclarationNode extends NonTerminalNode {
+  getPropertyName() {
+    const propertyNode = this.getPropertyNode(),
+          propertyName = propertyNode.getPropertyName();
 
-    return typeNode;
+    return propertyName;
   }
 
-  getPropertyNames() {
-    const propertyNames = this.reduceChildNode((propertyNames, childNode) => {
-      const childNodePropertyNode = isNodePropertyNode(childNode);
-
-      if (childNodePropertyNode) {
-        const propertyNode = childNode, ///
-              propertyName = propertyNode.getPropertyName();
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-        propertyNames.push(propertyName);
-      }
+    return typeNode;
+  }
 
-      return propertyNames;
-    }, []);
+  getPropertyNode() {
+    const ruleName = PROPERTY_RULE_NAME,
+          propertyNode = this.getNodeByRuleName(ruleName);
 
-    return propertyNames;
+    return propertyNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(PropertyDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/type.js

@@ -1,62 +1,73 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONAL } from "../../constants";
-import { isNodeTypeNode } from "../../utilities/node";
+import { TYPE_RULE_NAME, TYPES_RULE_NAME } from "../../ruleNames";
 
-export default class TypeDeclarationNode extends Node {
-  getTypeName() {
-    let typeName;
+export default class TypeDeclarationNode extends NonTerminalNode {
+  isProvisional() {
+    let provisional = false;
 
     this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode,
+              content = terminalNode.getContent(),
+              contentProvisional = (content === PROVISIONAL);
 
-        typeName = typeNode.getTypeName();
+        if (contentProvisional) {
+          provisional = true;
 
-        return true;
+          return true;
+        }
       }
     });
 
-    return typeName;
+    return provisional;
   }
 
-  isProvisional() {
-    const provisional = this.fromFirstChildNode((firstChildNode) => {
-      const terminalNode = firstChildNode,  ///
-            content = terminalNode.getContent(),
-            contentProvisional = (content === PROVISIONAL),
-            provisional = contentProvisional; ///
+  getTypeName() {
+    let typeName = null;
 
-      return provisional;
-    });
+    const typeNode = this.getTypeNode();
 
-    return provisional;
+    if (typeNode !== null) {
+      typeName = typeNode.getTypeName();
+    }
+
+    return typeName;
   }
 
-  getSuperTypeNodes() {
-    const typeNodes = this.reduceChildNode((typeNodes, childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-      if (childNodeTypeNode) {
-        const typeNode = childNode;  ///
+    return typeNode;
+  }
 
-        typeNodes.push(typeNode);
-      }
+  getTypesNode() {
+    const ruleName = TYPES_RULE_NAME,
+          typesNode = this.getNodeByRuleName(ruleName);
+
+    return typesNode;
+  }
+
+  getSuperTypeNodes() {
+    let superTypeNodes = [];
 
-      return typeNodes;
-    }, []);
+    const typesNode = this.getTypesNode();
 
-    typeNodes.pop();
+    if (typesNode !== null) {
+      const typeNodes = typesNode.getTypeNodes();
 
-    const superTypeNodes = typeNodes; ///
+      superTypeNodes = typeNodes; ///
+    }
 
     return superTypeNodes;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(TypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypeDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }
 

package/src/node/declaration/variable.js

@@ -1,61 +1,43 @@
 "use strict";
 
-import Node from "../../node";
+import NonTerminalNode from "../../node/nonTerminal";
 
 import { PROVISIONALLY } from "../../constants";
-import { isNodeTypeNode, isNodeVariableNode } from "../../utilities/node";
-
-export default class VariableDeclarationNode extends Node {
-  getTypeNode() {
-    let typeNode;
-
-    this.someChildNode((childNode) => {
-      const childNodeTypeNode = isNodeTypeNode(childNode);
-
-      if (childNodeTypeNode) {
-        typeNode = childNode; ///
-
-        return true;
-      }
-    });
-
-    return typeNode;
-  }
+import { TYPE_RULE_NAME, VARIABLE_RULE_NAME } from "../../ruleNames";
 
+export default class VariableDeclarationNode extends NonTerminalNode {
   isProvisional() {
-    const provisional = this.fromSecondLastChildNode((secondLastChildNode) => {
-      let provisional = false;
+    let provisional = false;
 
-      const secondLastChildNodeTerminalNode = secondLastChildNode.isTerminalNode();
+    this.someChildNode((childNode) => {
+      const childNodeTerminalNode = childNode.isTerminalNode();
 
-      if (secondLastChildNodeTerminalNode) {
-        const terminalNode = secondLastChildNode, ///
+      if (childNodeTerminalNode) {
+        const terminalNode = childNode, ///
               content = terminalNode.getContent(),
               contentProvisionally = (content === PROVISIONALLY);
 
         if (contentProvisionally) {
           provisional = true;
+
+          return true;
         }
       }
-
-      return provisional;
     });
 
     return provisional;
   }
 
-  getVariableNode() {
-    let variableNode;
-
-    this.someChildNode((childNode) => {
-      const childNodeVariableNode = isNodeVariableNode(childNode);
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNode = this.getNodeByRuleName(ruleName);
 
-      if (childNodeVariableNode) {
-        variableNode = childNode; ///
+    return typeNode;
+  }
 
-        return true;
-      }
-    });
+  getVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNode = this.getNodeByRuleName(ruleName);
 
     return variableNode;
   }
@@ -67,5 +49,5 @@ export default class VariableDeclarationNode extends Node {
     return variableName;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(VariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(VariableDeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration.js

@@ -1,7 +1,23 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class DeclarationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DeclarationNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
+
+export default class DeclarationNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  getMetavariableNode() {
+    const ruleName = METAVARIABLE_RULE_NAME,
+          metavariableNode = this.getNodeByRuleName(ruleName);
+
+    return metavariableNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DeclarationNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/deduction.js

@@ -1,7 +1,16 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class DeductionNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DeductionNode, ruleName, childNodes, opacity, precedence); }
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class DeductionNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DeductionNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/derivation.js

@@ -1,7 +1,19 @@
 "use strict";
 
-import Node from "../node";
+import NonTerminalNode from "../node/nonTerminal";
 
-export default class DerivationNode extends Node {
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return Node.fromRuleNameChildNodesOpacityAndPrecedence(DerivationNode, ruleName, childNodes, opacity, precedence); }
+import { STEP_RULE_NAME, SUBPROOF_RULE_NAME } from "../ruleNames";
+
+export default class DerivationNode extends NonTerminalNode {
+  getStepOrSubproofNodes() {
+    const ruleNames = [
+            STEP_RULE_NAME,
+            SUBPROOF_RULE_NAME,
+          ],
+          stepOrSubproofNodes = this.getNodesByRuleName(...ruleNames);
+
+    return stepOrSubproofNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(DerivationNode, ruleName, childNodes, opacity, precedence); }
 }