occam-verify-cli 1.0.192 → 1.0.199

package/src/node/substitution/term.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import NonTerminalNode from "../../node/nonTerminal";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+export default class TermSubstitutionNode extends NonTerminalNode {
+  getLastTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          lastTermNode = this.getLastNodeByRuleName(ruleName);
+
+    return lastTermNode;
+  }
+
+  getFirstTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          firstTermNode = this.getFirstNodeByRuleName(ruleName);
+
+    return firstTermNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TermSubstitutionNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/supposition.js

@@ -1,30 +1,20 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeStatementNode, isNodeProcedureCallNode } from "../utilities/node";
+import { STATEMENT_RULE_NAME, PROCEDURE_CALL_RULE_NAME } from "../ruleNames";
 
 export default class SuppositionNode extends NonTerminalNode {
   getStatementNode() {
-    const statementNode = this.findChildNode((childNode) => {
-      const childNodeStatementNode = isNodeStatementNode(childNode);
-
-      if (childNodeStatementNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
 
     return statementNode;
   }
 
   getProcedureCallNode() {
-    const procedureCallNode = this.findChildNode((childNode) => {
-      const childNodeProcedureCallNode = isNodeProcedureCallNode(childNode);
-
-      if (childNodeProcedureCallNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROCEDURE_CALL_RULE_NAME,
+          procedureCallNode = this.getNodeByRuleName(ruleName);
 
     return procedureCallNode;
   }

package/src/node/term.js

@@ -1,21 +1,13 @@
 "use strict";
 
-import { arrayUtilities } from "necessary";
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
-import { isNodeTermNode, isNodeVariableNode } from "../utilities/node";
-
-const { first } = arrayUtilities;
+import { ARGUMENT_RULE_NAME, VARIABLE_RULE_NAME } from "../ruleNames";
 
 export default class TermNode extends NonTerminalNode {
   getVariableNodes() {
-    const variableNodes = this.filterDescendantNode((descendantNode) => {
-      const descendantNodeVariableNode = isNodeVariableNode(descendantNode);
-
-      if (descendantNodeVariableNode) {
-        return true;
-      }
-    });
+    const ruleName = VARIABLE_RULE_NAME,
+          variableNodes = this.getNodesByRuleName(ruleName);
 
     return variableNodes;
   }
@@ -23,41 +15,25 @@ export default class TermNode extends NonTerminalNode {
   getSingularTermNode() {
     let singularTermNode = null;
 
-    const termNodes = this.filterChildNode((childNode) => {
-            const childNodeTermNode = isNodeTermNode(childNode);
-
-            if (!childNodeTermNode) {
-              return true;
-            }
-          }),
-          termNodesLength = termNodes.length;
+    const singularArgumentNode = this.getSingularArgumentNode();
 
-    if (termNodesLength === 1) {
-      const firstTermNode = first(termNodes);
-
-      singularTermNode = firstTermNode; ///
+    if (singularArgumentNode !== null) {
+      singularTermNode = singularArgumentNode.getSingularTermNode();
     }
 
     return singularTermNode;
   }
 
-  getSingularVariableNode() {
-    let singularVariableNode = null;
-
-    const variableNodes = this.filterChildNode((childNode) => {
-            const childNodeVariableNode = isNodeVariableNode(childNode);
-
-            if (!childNodeVariableNode) {
-              return true;
-            }
-          }),
-          variableNodesLength = variableNodes.length;
+  getSingularArgumentNode() {
+    const ruleName = ARGUMENT_RULE_NAME,
+          singularArgumentNode = this.getSingularTNodeByRuleName(ruleName);
 
-    if (variableNodesLength === 1) {
-      const firstVariableNode = first(variableNodes);
+    return singularArgumentNode;
+  }
 
-      singularVariableNode = firstVariableNode; ///
-    }
+  getSingularVariableNode() {
+    const ruleName = VARIABLE_RULE_NAME,
+          singularVariableNode = this.getSingularTNodeByRuleName(ruleName);
 
     return singularVariableNode;
   }

package/src/node/topLevelAssertion.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 import { SATISFIABLE } from "../constants";
-import { isNodeProofNode,
-         isNodeDeductionNode,
-         isNodeSuppositionNode,
-         isNodeParenthesisedLabelsNode } from "../utilities/node";
+import { PROOF_RULE_NAME,
+         DEDUCTION_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
+         PARENTHESISED_LABELS_RULE_NAME } from "../ruleNames";
 
 export default class TopLevelAssertionNode extends NonTerminalNode {
   isSatisfiable() {
@@ -42,49 +42,29 @@ export default class TopLevelAssertionNode extends NonTerminalNode {
   }
 
   getProofNode() {
-    const proofNode = this.findChildNode((childNode) => {
-      const childNOdeProofNode = isNodeProofNode(childNode);
-
-      if (childNOdeProofNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
 
     return proofNode;
   }
 
   getDeductionNode() {
-    const deductionNode = this.findChildNode((childNode) => {
-      const childNOdeDeductionNode = isNodeDeductionNode(childNode);
-
-      if (childNOdeDeductionNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = DEDUCTION_RULE_NAME,
+          deductionNode = this.getNodeByRuleName(ruleName);
 
     return deductionNode;
   }
 
   getSuppositionNodes() {
-    const suppositionNodes = this.filterChildNode((childNode) => {
-      const childNodeSuppositionNode = isNodeSuppositionNode(childNode);
-
-      if (childNodeSuppositionNode) {
-        return true;
-      }
-    });
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
 
     return suppositionNodes;
   }
 
   getParenthesisedLabelsNode() {
-    const parenthesisedLabelsNode = this.findChildNode((childNode) => {
-      const childNodeParenthesisedLabelNode = isNodeParenthesisedLabelsNode(childNode);
-
-      if (childNodeParenthesisedLabelNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PARENTHESISED_LABELS_RULE_NAME,
+          parenthesisedLabelsNode = this.getNodeByRuleName(ruleName);
 
     return parenthesisedLabelsNode;
   }

package/src/node/topLevelMetaAssertion.js

@@ -1,62 +1,43 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
-import { isNodeProofNode, isNodePremiseNode, isNodeConclusionNode, isNodeParenthesisedLabelsNode } from "../utilities/node";
+import NonTerminalNode from "../node/nonTerminal";
+
+import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME, PARENTHESISED_LABEL_RULE_NAME } from "../ruleNames";
 
 export default class TopLevelMetaAssertionNode extends NonTerminalNode {
-  getLabelNodes() {
-    const parenthesisedLabelsNode = this.getParenthesisedLabelsNode(),
-          labelNodes = parenthesisedLabelsNode.getLabelNodes();
+  getLabelNode() {
+    const parenthesisedLabelNode = this.getParenthesisedLabelNode(),
+          labelNodes = parenthesisedLabelNode.getLabelNode();
 
     return labelNodes;
   }
 
   getProofNode() {
-    const proofNode = this.findChildNode((childNode) => {
-      const childNOdeProofNode = isNodeProofNode(childNode);
-
-      if (childNOdeProofNode) {
-        return true;
-      }
-    }) || null;
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
 
     return proofNode;
   }
 
-  getPremiseNodes() {
-    const premiseNodes = this.filterChildNode((childNode) => {
-      const childNOdePremiseNode = isNodePremiseNode(childNode);
-
-      if (childNOdePremiseNode) {
-        return true;
-      }
-    }) || null;
+  getDeductionNode() {
+    const ruleName = DEDUCTION_RULE_NAME,
+          deductionNode = this.getNodeByRuleName(ruleName);
 
-    return premiseNodes;
+    return deductionNode;
   }
 
-  getConclusionNode() {
-    const conclusionNode = this.findChildNode((childNode) => {
-      const childNOdeConclusionNode = isNodeConclusionNode(childNode);
+  getSuppositionNodes() {
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
 
-      if (childNOdeConclusionNode) {
-        return true;
-      }
-    }) || null;
-
-    return conclusionNode;
+    return suppositionNodes;
   }
 
-  getParenthesisedLabelsNode() {
-    const parenthesisedLabelsNode = this.findChildNode((childNode) => {
-      const childNodeParenthesisedLabelNode = isNodeParenthesisedLabelsNode(childNode);
-
-      if (childNodeParenthesisedLabelNode) {
-        return true;
-      }
-    }) || null;
+  getParenthesisedLabelNode() {
+    const ruleName = PARENTHESISED_LABEL_RULE_NAME,
+          parenthesisedLabelNode = this.getNodeByRuleName(ruleName);
 
-    return parenthesisedLabelsNode;
+    return parenthesisedLabelNode;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }

package/src/node/type.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 export default class TypeNode extends NonTerminalNode {
   getTypeName() {

package/src/node/types.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import NonTerminalNode from "../node/nonTerminal";
+
+import { TYPE_RULE_NAME } from "../ruleNames";
+
+export default class TypesNode extends NonTerminalNode {
+  getTypeNodes() {
+    const ruleName = TYPE_RULE_NAME,
+          typeNodes = this.getNodesByRuleName(ruleName);
+
+    return typeNodes;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(TypesNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/variable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { NonTerminalNode } from "occam-parsers";
+import NonTerminalNode from "../node/nonTerminal";
 
 export default class VariableNode extends NonTerminalNode {
   getVariableName() {

package/src/nonTerminalNodeMap.js

@@ -1,51 +1,59 @@
 "use strict";
 
-import TermNode from "./node/term"
-import TypeNode from "./node/type"
-import RuleNode from "./node/rule"
-import StepNode from "./node/step"
-import ErrorNode from "./node/error"
-import FrameNode from "./node/frame"
-import AxiomNode from "./node/axiom"
-import LemmaNode from "./node/lemma"
-import ProofNode from "./node/proof"
-import LabelNode from "./node/label"
-import LabelsNode from "./node/labels"
-import PremiseNode from "./node/premise"
-import TheoremNode from "./node/theorem"
-import SubproofNode from "./node/subproof"
-import PropertyNode from "./node/property"
-import MetaTypeNode from "./node/metaType"
-import EqualityNode from "./node/equality"
-import VariableNode from "./node/variable"
-import StatementNode from "./node/statement"
-import ReferenceNode from "./node/reference"
-import DeductionNode from "./node/deduction"
-import JudgementNode from "./node/judgement"
-import MetaLemmaNode from "./node/metaLemma"
-import ParameterNode from "./node/parameter"
-import DerivationNode from "./node/derivation"
-import CombinatorNode from "./node/combinator"
-import ConclusionNode from "./node/conclusion"
-import ConjectureNode from "./node/conjecture"
-import SuppositionNode from "./node/supposition"
-import ConstructorNode from "./node/constructor"
-import DeclarationNode from "./node/declaration"
-import MetatheoremNode from "./node/metatheorem"
-import MetavariableNode from "./node/metavariable"
-import ProcedureCallNode from "./node/procedureCall"
-import SubDerivationNode from "./node/subDerivation"
+import TermNode from "./node/term";
+import RuleNode from "./node/rule";
+import StepNode from "./node/step";
+import TypeNode from "./node/type";
+import TypesNode from "./node/types";
+import ErrorNode from "./node/error";
+import FrameNode from "./node/frame";
+import AxiomNode from "./node/axiom";
+import LemmaNode from "./node/lemma";
+import ProofNode from "./node/proof";
+import LabelNode from "./node/label";
+import LabelsNode from "./node/labels";
+import PremiseNode from "./node/premise";
+import TheoremNode from "./node/theorem";
+import ArgumentNode from "./node/argument";
+import SubproofNode from "./node/subproof";
+import PropertyNode from "./node/property";
+import MetaTypeNode from "./node/metaType";
+import EqualityNode from "./node/equality";
+import VariableNode from "./node/variable";
+import StatementNode from "./node/statement";
+import ReferenceNode from "./node/reference";
+import DeductionNode from "./node/deduction";
+import JudgementNode from "./node/judgement";
+import MetaLemmaNode from "./node/metaLemma";
+import ParameterNode from "./node/parameter";
+import DerivationNode from "./node/derivation";
+import CombinatorNode from "./node/combinator";
+import ConclusionNode from "./node/conclusion";
+import ConjectureNode from "./node/conjecture";
+import SuppositionNode from "./node/supposition";
+import ConstructorNode from "./node/constructor";
+import DeclarationNode from "./node/declaration";
+import MetatheoremNode from "./node/metatheorem";
+import MetaArgumentNode from "./node/metaArgument";
+import MetavariableNode from "./node/metavariable";
+import ProcedureCallNode from "./node/procedureCall";
+import SubDerivationNode from "./node/subDerivation";
 import TypeAssertionNode from "./node/assertion/type";
 import typeDeclarationNode from "./node/declaration/type";
 import PropertyRelationNode from "./node/propertyRelation"
 import DefinedAssertionNode from "./node/assertion/defined";
+import TermSubstitutionNode from "./node/substitution/term";
 import PropertyAssertionNode from "./node/assertion/property";
 import SubproofAssertionNode from "./node/assertion/subproof";
+import FrameSubstitutionNode from "./node/substitution/frame";
+import ParenthesisedLabelNode from "./node/parenthesisedLabel";
 import ContainedAssertionNode from "./node/assertion/contained";
 import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import variableDeclarationNode from "./node/declaration/variable";
+import StatementSubstitutionNode from "./node/substitution/statement";
+import ReferenceSubstitutionNode from "./node/substitution/reference";
 import combinatorDeclarationNode from "./node/declaration/combinator";
 import complexTypeDeclarationNode from "./node/declaration/complexType";
 import constructorDeclarationNode from "./node/declaration/constructor";
@@ -55,6 +63,7 @@ import { RULE_RULE_NAME,
          STEP_RULE_NAME,
          TERM_RULE_NAME,
          TYPE_RULE_NAME,
+         TYPES_RULE_NAME,
          PROOF_RULE_NAME,
          ERROR_RULE_NAME,
          FRAME_RULE_NAME,
@@ -64,6 +73,7 @@ import { RULE_RULE_NAME,
          LABELS_RULE_NAME,
          THEOREM_RULE_NAME,
          PREMISE_RULE_NAME,
+         ARGUMENT_RULE_NAME,
          SUBPROOF_RULE_NAME,
          PROPERTY_RULE_NAME,
          EQUALITY_RULE_NAME,
@@ -84,19 +94,25 @@ import { RULE_RULE_NAME,
          SUPPOSITION_RULE_NAME,
          METATHEOREM_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         META_ARGUMENT_RULE_NAME,
          SUB_DERIVATION_RULE_NAME,
          TYPE_ASSERTION_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
          TYPE_DECLARATION_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
          PROPERTY_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
+         PARENTHESISED_LABEL_RULE_NAME,
          PARENTHESISED_LABELS_RULE_NAME,
          PROPERTY_DECLARATION_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME,
          COMBINATOR_DECLARATION_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          COMPLEX_TYPE_DECLARATION_RULE_NAME,
@@ -107,6 +123,7 @@ const nonTerminalNodeMap = {
   [STEP_RULE_NAME]: StepNode,
   [TERM_RULE_NAME]: TermNode,
   [TYPE_RULE_NAME]: TypeNode,
+  [TYPES_RULE_NAME]: TypesNode,
   [ERROR_RULE_NAME]: ErrorNode,
   [FRAME_RULE_NAME]: FrameNode,
   [LEMMA_RULE_NAME]: LemmaNode,
@@ -116,6 +133,7 @@ const nonTerminalNodeMap = {
   [LABELS_RULE_NAME]: LabelsNode,
   [THEOREM_RULE_NAME]: TheoremNode,
   [PREMISE_RULE_NAME]: PremiseNode,
+  [ARGUMENT_RULE_NAME]: ArgumentNode,
   [PROPERTY_RULE_NAME]: PropertyNode,
   [SUBPROOF_RULE_NAME]: SubproofNode,
   [EQUALITY_RULE_NAME]: EqualityNode,
@@ -126,29 +144,35 @@ const nonTerminalNodeMap = {
   [DEDUCTION_RULE_NAME]: DeductionNode,
   [PARAMETER_RULE_NAME]: ParameterNode,
   [STATEMENT_RULE_NAME]: StatementNode,
+  [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [COMBINATOR_RULE_NAME]: CombinatorNode,
   [CONCLUSION_RULE_NAME]: ConclusionNode,
   [CONJECTURE_RULE_NAME]: ConjectureNode,
   [DERIVATION_RULE_NAME]: DerivationNode,
-  [META_LEMMA_RULE_NAME]: MetaLemmaNode,
   [SUPPOSITION_RULE_NAME]: SuppositionNode,
   [CONSTRUCTOR_RULE_NAME]: ConstructorNode,
   [DECLARATION_RULE_NAME]: DeclarationNode,
   [METATHEOREM_RULE_NAME]: MetatheoremNode,
   [METAVARIABLE_RULE_NAME]: MetavariableNode,
+  [META_ARGUMENT_RULE_NAME]: MetaArgumentNode,
   [TYPE_ASSERTION_RULE_NAME]: TypeAssertionNode,
   [PROCEDURE_CALL_RULE_NAME]: ProcedureCallNode,
   [SUB_DERIVATION_RULE_NAME]: SubDerivationNode,
   [TYPE_DECLARATION_RULE_NAME]: typeDeclarationNode,
   [PROPERTY_RELATION_RULE_NAME]: PropertyRelationNode,
   [DEFINED_ASSERTION_RULE_NAME]: DefinedAssertionNode,
+  [TERM_SUBSTITUTION_RULE_NAME]: TermSubstitutionNode,
   [SUBPROOF_ASSERTION_RULE_NAME]: SubproofAssertionNode,
   [PROPERTY_ASSERTION_RULE_NAME]: PropertyAssertionNode,
+  [FRAME_SUBSTITUTION_RULE_NAME]: FrameSubstitutionNode,
+  [PARENTHESISED_LABEL_RULE_NAME]: ParenthesisedLabelNode,
   [SATISFIES_ASSERTION_RULE_NAME]: SatisfiesAssertionNode,
   [CONTAINED_ASSERTION_RULE_NAME]: ContainedAssertionNode,
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: variableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
+  [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
+  [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: combinatorDeclarationNode,
   [CONSTRUCTOR_DECLARATION_RULE_NAME]: constructorDeclarationNode,
   [COMPLEX_TYPE_DECLARATION_RULE_NAME]: complexTypeDeclarationNode,

package/src/ruleNames.js

@@ -4,6 +4,7 @@ export const RULE_RULE_NAME = "rule";
 export const STEP_RULE_NAME = "step";
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
+export const TYPES_RULE_NAME = "types";
 export const LEMMA_RULE_NAME = "lemma";
 export const AXIOM_RULE_NAME = "axiom";
 export const ERROR_RULE_NAME = "error";
@@ -13,6 +14,7 @@ export const LABEL_RULE_NAME = "label";
 export const LABELS_RULE_NAME = "labels";
 export const THEOREM_RULE_NAME = "theorem";
 export const PREMISE_RULE_NAME = "premise";
+export const ARGUMENT_RULE_NAME = "argument";
 export const PROPERTY_RULE_NAME = "property";
 export const EQUALITY_RULE_NAME = "equality";
 export const VARIABLE_RULE_NAME = "variable";
@@ -33,19 +35,25 @@ export const CONSTRUCTOR_RULE_NAME = "constructor";
 export const DECLARATION_RULE_NAME = "declaration";
 export const METATHEOREM_RULE_NAME = "metatheorem";
 export const METAVARIABLE_RULE_NAME = "metavariable";
+export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const PROCEDURE_CALL_RULE_NAME = "procedureCall";
 export const SUB_DERIVATION_RULE_NAME = "subDerivation";
 export const TYPE_ASSERTION_RULE_NAME = "typeAssertion";
 export const TYPE_DECLARATION_RULE_NAME = "typeDeclaration";
 export const PROPERTY_RELATION_RULE_NAME = "propertyRelation";
 export const DEFINED_ASSERTION_RULE_NAME = "definedAssertion";
+export const TERM_SUBSTITUTION_RULE_NAME = "termSubstitution";
 export const PROPERTY_ASSERTION_RULE_NAME = "propertyAssertion";
 export const SUBPROOF_ASSERTION_RULE_NAME = "subproofAssertion";
+export const FRAME_SUBSTITUTION_RULE_NAME = "frameSubstitution";
 export const CONTAINED_ASSERTION_RULE_NAME = "containedAssertion";
 export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
+export const PARENTHESISED_LABEL_RULE_NAME = "parenthesisedLabel";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
+export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const COMPLEX_TYPE_DECLARATION_RULE_NAME = "complexTypeDeclaration";

package/src/substitution/frame.js

@@ -4,12 +4,6 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import FrameSubstitutionPartialContext from "../context/partial/substitution/frame";
 
-import { nodeQuery } from "../utilities/query";
-
-const frameNodeQuery = nodeQuery("/frameSubstitution/frame[0]"),
-      metavariableNodeQuery = nodeQuery("/frameSubstitution/frame[1]/metavariable!"),
-      frameSubstitutionNodeQuery = nodeQuery("/statement/frameSubstitution");
-
 export default class FrameSubstitution extends Substitution {
   constructor(string, node, tokens, frame, metavariable) {
     super(string, node, tokens);
@@ -42,14 +36,17 @@ export default class FrameSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let frameSubstitution = null;
 
-    const frameSubstitutionNode = frameSubstitutionNodeQuery(statementNode);
+    const frameSubstitutionNode = statementNode.getFrameSubstitutionNode();
 
     if (frameSubstitutionNode !== null) {
-      const frameNode = frameNodeQuery(frameSubstitutionNode),
-            metavariableNode = metavariableNodeQuery(frameSubstitutionNode);
+      const lastFrameNode = frameSubstitutionNode.getLastFrameNode(),
+            firstFrameNode = frameSubstitutionNode.getFirstFrameNode(),
+            singularMetavariableNode = lastFrameNode.getSingularMetavariableNode();
 
-      if ((frameNode !== null) && (metavariableNode !== null)) {
+      if (singularMetavariableNode !== null) {
         const { Frame, Metavariable } = dom,
+              frameNode = firstFrameNode, ///
+              metavariableNode = singularMetavariableNode,  ///
               frame = Frame.fromFrameNode(frameNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               node = frameSubstitutionNode,  ///

package/src/substitution/reference.js

@@ -4,12 +4,6 @@ import dom from "../dom";
 import Substitution from "../substitution";
 import ReferenceSubstitutionPartialContext from "../context/partial/substitution/reference";
 
-import { nodeQuery } from "../utilities/query";
-
-const referenceNodeQuery = nodeQuery("/referenceSubstitution/reference[0]"),
-      metavariableNodeQuery = nodeQuery("/referenceSubstitution/reference[1]/metavariable!"),
-      referenceSubstitutionNodeQuery = nodeQuery("/statement/referenceSubstitution");
-
 export default class ReferenceSubstitution extends Substitution {
   constructor(string, node, tokens, reference, metavariable) {
     super(string, node, tokens);
@@ -33,14 +27,17 @@ export default class ReferenceSubstitution extends Substitution {
   static fromStatementNode(statementNode, context) {
     let referenceSubstitution = null;
 
-    const referenceSubstitutionNode = referenceSubstitutionNodeQuery(statementNode);
+    const referenceSubstitutionNode = statementNode.getReferenceSubstitutionNode();
 
     if (referenceSubstitutionNode !== null) {
-      const referenceNode = referenceNodeQuery(referenceSubstitutionNode),
-            metavariableNode = metavariableNodeQuery(referenceSubstitutionNode);
+      const lastReferenceNode = referenceSubstitutionNode.getLastReferenceNode(),
+            firstReferenceNode = referenceSubstitutionNode.getFirstReferenceNode(),
+            singularMetavariableNode = lastReferenceNode.getSingularMetavariableNode();
 
-      if ((referenceNode !== null) && (metavariableNode !== null)) {
+      if (singularMetavariableNode !== null) {
         const { Reference, Metavariable } = dom,
+              referenceNode = firstReferenceNode, ///
+              metavariableNode = singularMetavariableNode,  ///
               reference = Reference.fromReferenceNode(referenceNode, context),
               metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
               node = referenceSubstitutionNode,  ///