occam-verify-cli 0.0.678 → 0.0.680

package/src/context/file.js

@@ -11,6 +11,7 @@ import Combinator from "../combinator";
 import Constructor from "../constructor";
 import Metavariable from "../metavariable";
 
+import { objectType } from "../type";
 import { push, filter } from "../utilities/array";
 import { statementMetaType } from "../metaType";
 import { nodeAsString, nodesAsString } from "../utilities/string";
@@ -254,8 +255,14 @@ export default class FileContext {
   }
 
   findTypeByTypeName(typeName) {
-    const types = this.getTypes(),
-          type = types.find((type) => {
+    let types = this.getTypes();
+
+    types = [ ///
+      ...types,
+      objectType
+    ];
+
+    const type = types.find((type) => {
             const matches = type.matchTypeName(typeName);
 
             if (matches) {

package/src/context/release.js

@@ -5,6 +5,7 @@ import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 import FileContext from "./file";
 
 import { push } from "../utilities/array";
+import { objectType } from "../type";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
@@ -274,8 +275,14 @@ export default class ReleaseContext {
   }
 
   findTypeByTypeName(typeName) {
-    const types = this.getTypes(),
-          type = types.find((type) => {
+    let types = this.getTypes();
+
+    types = [ ///
+      ...types,
+      objectType
+    ];
+
+    const type = types.find((type) => {
             const matches = type.matchTypeName(typeName);
 
             if (matches) {

package/src/equality.js

@@ -1,14 +1,10 @@
 "use strict";
 
-import Verifier from "./verifier";
-import verifyTerm from "./verify/term";
 import equalityStatementNode from "./node/statement/equality";
+import equalityNodesVerifier from "./verifier/nodes/equality";
 
 import { nodeQuery } from "./utilities/query";
-import { first, second } from "./utilities/array";
-import { TERM_RULE_NAME } from "./ruleNames";
 import { EQUALITY_DEPTH } from "./constants";
-import { verifyTermAsVariable } from "./verify/term";
 
 const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
@@ -35,7 +31,7 @@ export default class Equality {
                                     this.rightTermNode :
                                       this.leftTermNode,  ///
             rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
+            nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeVerified; ///
     }
@@ -45,7 +41,7 @@ export default class Equality {
                                     this.leftTermNode :
                                       this.rightTermNode,  ///
             rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
+            nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeVerified; ///
     }
@@ -78,10 +74,10 @@ export default class Equality {
     return matches;
   }
 
-  verify(equalities, context) {
+  verify(equalities, context, verifyAhead) {
     const leftNonTerminalNode = this.leftTermNode,  ///
           rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeVerified = equalityVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context),
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context, verifyAhead),
           verified = nonTerminalNodeVerified; ///
 
     return verified;
@@ -93,157 +89,35 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const depth = EQUALITY_DEPTH,
-            statementNodeMatchesEqualityStatementNode = statementNode.match(equalityStatementNode, depth);
-
-      if (statementNodeMatchesEqualityStatementNode) {
-        const leftTermNode = leftTermNodeQuery(statementNode),
-              rightTermNode = rightTermNodeQuery(statementNode);
-
-        equality = new Equality(leftTermNode, rightTermNode);
-      }
+      equality = Equality.fromStatementNode(statementNode);
     }
 
     return equality;
   }
 
   static fromStatementNode(statementNode) {
-    const leftTermNode = leftTermNodeQuery(statementNode),
-          rightTermNode = rightTermNodeQuery(statementNode),
-          equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
-
-    return equality;
-  }
-}
-
-class EqualityVerifier extends Verifier {
-  verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context) {
-    let nonTerminalNodeVerified = false;
-
-    const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
-          rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
-
-    if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
-      const ruleName = leftNonTerminalNodeRuleName, ///
-            ruleNameTermRuleName = (ruleName === TERM_RULE_NAME);
-
-      if (ruleNameTermRuleName) {
-        const leftTermNode = leftNonTerminalNode, ///
-              rightTermNode = rightNonTerminalNode, ///
-              termNodeVerified = this.verifyTermNode(leftTermNode, rightTermNode, equalities, context);
+    let equality = null;
 
-        nonTerminalNodeVerified = termNodeVerified;  ///
-      }
+    const depth = EQUALITY_DEPTH,
+          statementNodeMatchesEqualityStatementNode = statementNode.match(equalityStatementNode, depth);
 
-      if (!nonTerminalNodeVerified) {
-        const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
-              rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
-              leftNodes = leftNonTerminalNodeChildNodes, ///
-              rightNodes = rightNonTerminalNodeChildNodes, ///
-              nodesVerified = this.verifyNodes(leftNodes, rightNodes, equalities, context);
+    if (statementNodeMatchesEqualityStatementNode) {
+      const leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode);
 
-        nonTerminalNodeVerified = nodesVerified; ///
-      }
+      equality = new Equality(leftTermNode, rightTermNode);
     }
 
-    return nonTerminalNodeVerified;
+    return equality;
   }
 
-  verifyTermNode(leftTermNode, rightTermNode, equalities, context) {
-    let termNodeVerified = false;
-
-    const variables = [],
-          leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
-          rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
-
-    let equality = null;
-
-    if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
-      const firstVariable = first(variables),
-            secondVariable = second(variables),
-            leftVariable = firstVariable, ///
-            rightVariable = secondVariable, ///
-            leftVariableType = leftVariable.getType(),
-            rightVariableType = rightVariable.getType(),
-            leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
-
-      if (leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else if (leftTermVerifiedAsVariable) {
-      const types = [];
-
-      verifyTerm(rightTermNode, types, context);
-
-      const firstType = first(types),
-            firstVariable = first(variables),
-            leftVariable = firstVariable, ///
-            rightTermType = firstType,  ///
-            leftVariableType = leftVariable.getType(),
-            leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
-
-      if (leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else if (rightTermVerifiedAsVariable) {
-      const types = [];
-
-      verifyTerm(leftTermNode, types, context);
-
-      const firstType = first(types),
-            firstVariable = first(variables),
-            leftTermType = firstType,  ///
-            rightVariable = firstVariable, ///
-            rightVariableType = rightVariable.getType(),
-            rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
-
-      if (rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    } else {
-      const types = [];
-
-      verifyTerm(leftTermNode, types, context);
-
-      verifyTerm(rightTermNode, types, context);
-
-      const firstType = first(types),
-            secondType = second(types),
-            leftTermType = firstType, ///
-            rightTermType = secondType, ///
-            leftTermTypeEqualToOrSubTypeOfOfSuperTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOfOfSuperTypeOf(rightTermType);
-
-      if (leftTermTypeEqualToOrSubTypeOfOfSuperTypeOfRightTermType) {
-        equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode);
-      }
-    }
-
-    if (equality !== null) {
-      const equalityA = equality, ///
-            equalitiesB = equalities, ///
-            equalityMatches = equalitiesB.some((equalityB) => { ///
-              const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
-
-              if (equalityAMatchesEqualityB) {
-                return true;
-              }
-            });
-
-      termNodeVerified = equalityMatches;  ///
-    }
+  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
+    const equality = new Equality(leftTermNode, rightTermNode);
 
-    return termNodeVerified;
+    return equality;
   }
 }
 
-const equalityVerifier = new EqualityVerifier();
-
 function filterEqualities(equalities, equality) {
   const equalityA = equality; ///
 

package/src/premise.js

@@ -1,10 +1,11 @@
 "use strict";
 
+import premiseStatementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable/premise";
+import premiseMetastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable/premise";
+
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { premiseStatementForMetavariableVerifier } from "./verifier/statementForMetavariable/premise";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
-import { premiseMetastatementForMetavariableVerifier } from "./verifier/metastatementForMetavariable/premise";
 
 const ruleSubproofAssertionNodeQuery = nodeQuery("/metastatement/ruleSubproofAssertion!"),
       ruleSubproofPremiseMetastatementQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
@@ -45,7 +46,11 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
                 proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);
+                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -62,7 +67,11 @@ export default class Premise {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB),
+          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
@@ -91,7 +100,11 @@ export default class Premise {
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
                 metaproofContextB = metastatementMetaproofContext,  ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -108,7 +121,11 @@ export default class Premise {
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
           metaproofContextB = metastatementMetaproofContext,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB),
+          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           metastatementNodeMatches = nonTerminalNodeVerified; ///
 
     return metastatementNodeMatches;

package/src/supposition.js

@@ -1,9 +1,10 @@
 "use strict";
 
+import suppositionTermForVariableNodesVerifier from "./verifier/nodes/termForVariable/supposition";
+
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 import { statementNodeFromStatementString } from "./utilities/node";
-import { suppositionTermForVariableVerifier } from "./verifier/termForVariable/supposition";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
@@ -42,7 +43,11 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 proofContextA = proofContext, ///
                 proofContextB = statementProofContext,  ///
-                nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB);
+                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -59,7 +64,11 @@ export default class Supposition {
           nonTerminalNodeB = statementNode,  ///
           proofContextA = proofContext, ///
           proofContextB = statementProofContext,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB),
+          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;

package/src/type.js

@@ -187,18 +187,13 @@ function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
 
   if (superTypeJSON !== null) {
     const json = superTypeJSON, ///
-          { name } = json;
-
-    if (name === OBJECT_TYPE_NAME) {
-      superType = objectType; ///
-    } else {
-      const typeName = name,  ///
-            type = fileContext.findTypeByTypeName(typeName);
+          { name } = json,
+          typeName = name,  ///
+          type = fileContext.findTypeByTypeName(typeName);
 
       superType = (type !== null) ?
                     type :  ///
                       Type.fromJSONAndFileContext(json, fileContext);  ///
-    }
   }
 
   return superType;

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, filter } = arrayUtilities;
+export const { first, second, last, push, prune, filter, clear } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/utilities/string.js

@@ -3,39 +3,22 @@
 import { COMMA, EMPTY_STRING } from "../constants";
 
 export function nodeAsString(node, tokens) {
-  let string = null;
+  let string = EMPTY_STRING;
 
   if (node !== null) {
     const nodeTerminalNode = node.isTerminalNode();
 
     if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            content = terminalNode.getContent();
+      const terminalNode = node;  ///
 
-      string = content; ///
+      string = terminalNodeAsString(terminalNode);
     } else {
-      const nonTerminalNode = node, ///
-            firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
-            lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
-            firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
-            lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
-            start = firstSignificantTokenIndex, ///
-            end = lastSignificantTokenIndex + 1;
+      const nonTerminalNode = node; ///
 
-      tokens = tokens.slice(start, end);  ///
-
-      string = tokens.reduce((string, token) => {
-        const content = token.getContent();
-
-        string = `${string}${content}`;
-
-        return string;
-      }, EMPTY_STRING);
+      string = nonTerminalNodeAsString(nonTerminalNode, tokens);
     }
-  }
 
-  if (string !== null) {
-    string = string.replace(/[\r\n]/, EMPTY_STRING)
+    string = string.replace(/[\r\n]/, EMPTY_STRING);
   }
 
   return string;
@@ -54,3 +37,31 @@ export function nodesAsString(nodes, tokens) {
 
   return string;
 }
+
+export function terminalNodeAsString(terminalNode) {
+  const content = terminalNode.getContent(),
+        string = content; ///
+
+  return string;
+}
+
+export function nonTerminalNodeAsString(nonTerminalNode, tokens) {
+  const firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+        lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
+        firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+        lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+        start = firstSignificantTokenIndex, ///
+        end = lastSignificantTokenIndex + 1;
+
+  tokens = tokens.slice(start, end);  ///
+
+  const string = tokens.reduce((string, token) => {
+    const content = token.getContent();
+
+    string = `${string}${content}`;
+
+    return string;
+  }, EMPTY_STRING);
+
+  return string;
+}

package/src/verifier/node/metastatement.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import NodeVerifier from "../../verifier/node";
+
+import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
+import { metavariableNameFromMetavariableNode } from "../../utilities/query";
+
+class MetastatementNodeVerifier extends NodeVerifier {
+  verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const ruleName = nonTerminalNode.getRuleName(); ///
+
+    switch (ruleName) {
+      case METAVARIABLE_RULE_NAME: {
+        const metavariableNode = nonTerminalNode, ///
+              metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext, verifyAhead),
+              metavariableNodeVerified = metavariableVerified;  ///
+
+        nonTerminalNodeVerified = metavariableNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, metaproofContext, verifyAhead);
+
+        break;
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const metastatementNodeVerifier = new MetastatementNodeVerifier();
+
+export default metastatementNodeVerifier;
+
+function verifyMetavariable(metavariableNode, metaproofContext, verifyAhead) {
+  let metavariableVerified;
+
+  const metavariableString = metaproofContext.nodeAsString(metavariableNode);
+
+  metaproofContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+  if (metavariablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    metavariableVerified = verifiedAhead; ///
+  }
+
+  if (metavariableVerified) {
+    metaproofContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}

package/src/verifier/node/statementAsCombinator.js

@@ -0,0 +1,80 @@
+"use strict";
+
+import NodeVerifier from "../../verifier/node";
+import verifyStatement from "../../verify/statement";
+
+import { verifyStandaloneTerm, verifyType } from "./../../verifier/node/termAsConstructor";
+import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
+
+class StatementAsCombinatorNodeVerifier extends NodeVerifier {
+  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const ruleName = nonTerminalNode.getRuleName();
+
+    switch (ruleName) {
+      case TYPE_RULE_NAME: {
+        const typeNode = nonTerminalNode, ///
+              typeVerified = verifyType(typeNode, fileContext, verifyAhead),
+              typeNodeVerified = typeVerified;  ///
+
+        nonTerminalNodeVerified = typeNodeVerified; ///
+
+        break;
+      }
+
+      case TERM_RULE_NAME: {
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
+              termNodeVerified = standaloneTermVerified;  ///
+
+        nonTerminalNodeVerified = termNodeVerified; ///
+
+        break;
+      }
+
+      case STATEMENT_RULE_NAME: {
+        const statementNode = nonTerminalNode, ///
+              standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
+              statementNodeVerified = standaloneStatementVerified; ///
+
+        nonTerminalNodeVerified = statementNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead); ///
+
+        break;
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const statementAsCombinatorNodeVerifier = new StatementAsCombinatorNodeVerifier();
+
+export default statementAsCombinatorNodeVerifier;
+
+function verifyStandaloneStatement(statementNode, fileContext, verifyAhead) {
+  let standaloneStatementVerified;
+
+  const statementString = fileContext.nodeAsString(statementNode);
+
+  fileContext.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
+
+  const context = fileContext,  ///
+        derived = false,
+        assignments = [],
+        statementVerified = verifyStatement(statementNode, assignments, derived, context, verifyAhead);
+
+  standaloneStatementVerified = statementVerified;  ///
+
+  if (standaloneStatementVerified) {
+    fileContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
+  }
+
+  return standaloneStatementVerified;
+}