occam-verify-cli 0.0.677 → 0.0.679

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,7 @@ 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);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -62,7 +63,7 @@ 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),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;
@@ -91,7 +92,7 @@ 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);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -108,7 +109,7 @@ 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),
           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,7 @@ 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);
 
           if (nonTerminalNodeVerified) {
             return true;
@@ -59,7 +60,7 @@ 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),
           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/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,57 @@
+"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) {
+    let nonTerminalNodeVerified;
+
+    const ruleName = nonTerminalNode.getRuleName(); ///
+
+    switch (ruleName) {
+      case METAVARIABLE_RULE_NAME: {
+        const metavariableNode = nonTerminalNode, ///
+              metavariableVerified = verifyMetavariable(metavariableNode, metaproofContext),
+              metavariableNodeVerified = metavariableVerified;  ///
+
+        nonTerminalNodeVerified = metavariableNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, metaproofContext);
+
+        break;
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const metastatementNodeVerifier = new MetastatementNodeVerifier();
+
+export default metastatementNodeVerifier;
+
+function verifyMetavariable(metavariableNode, metaproofContext) {
+  let metavariableVerified;
+
+  const metavariableString = metaproofContext.nodeAsString(metavariableNode);
+
+  metaproofContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariablePresent = metaproofContext.isMetavariablePresentByMetavariableName(metavariableName);
+
+  metavariableVerified = metavariablePresent;
+
+  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;
+}

package/src/verifier/node/termAsConstructor.js

@@ -0,0 +1,124 @@
+"use strict";
+
+import verifyTerm from "../../verify/term";
+import NodeVerifier from "../../verifier/node";
+
+import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../../ruleNames";
+
+const typeNodeQuery = nodeQuery("/argument/type"),
+      termNodeQuery = nodeQuery("/argument/term");
+
+class TermAsConstructorNodeVerifier extends NodeVerifier {
+  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const ruleName = nonTerminalNode.getRuleName();
+
+    switch (ruleName) {
+      case TERM_RULE_NAME: {
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
+              termNodeVerified = standaloneTermVerified;  ///
+
+        nonTerminalNodeVerified = termNodeVerified; ///
+
+        break;
+      }
+
+      case ARGUMENT_RULE_NAME: {
+        const argumentNode = nonTerminalNode, ///
+              argumentVerified = verifyArgument(argumentNode, fileContext, verifyAhead),
+              argumentNodeVerified = argumentVerified;  ///
+
+        nonTerminalNodeVerified = argumentNodeVerified; ///
+
+        break;
+      }
+
+      default: {
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead);
+
+        break;
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
+
+export default termAsConstructorNodeVerifier;
+
+export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
+  let standaloneTermVerified;
+
+  const termString = fileContext.nodeAsString(termNode);
+
+  fileContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
+
+  const types = [],
+        context = fileContext,  ///
+        termVerified = verifyTerm(termNode, types, context, verifyAhead);
+
+  standaloneTermVerified = termVerified;  ///
+
+  if (standaloneTermVerified) {
+    fileContext.debug(`...verified the '${termString}' standalone term.`, termNode);
+  }
+
+  return standaloneTermVerified;
+}
+
+export function verifyType(typeNode, fileContext, verifyAhead) {
+  let typeVerified = false;
+
+  const typeString = fileContext.nodeAsString(typeNode);
+
+  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
+
+  const typeName = typeNameFromTypeNode(typeNode),
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
+
+  if (!typePresent) {
+    fileContext.info(`The type '${typeName}' is not present.`, typeNode);
+  } else {
+    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
+
+    const verifiedAhead = verifyAhead();
+
+    typeVerified = verifiedAhead; ///
+  }
+
+  return typeVerified;
+}
+
+function verifyArgument(argumentNode, fileContext, verifyAhead) {
+  let argumentVerified;
+
+  const argumentString = fileContext.nodeAsString(argumentNode);
+
+  fileContext.trace(`Verifying the '${argumentString}' argument...`, argumentNode);
+
+  const typeNode = typeNodeQuery(argumentNode),
+        termNode = termNodeQuery(argumentNode);
+
+  if (typeNode !== null) {
+    const typeVerified = verifyType(typeNode, fileContext, verifyAhead);
+
+    argumentVerified = typeVerified; ///
+  }
+
+  if (termNode !== null) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead);
+
+    argumentVerified = standaloneTermVerified;  ///
+  }
+
+  if (argumentVerified) {
+    fileContext.debug(`...verified the '${argumentString}' argument.`, argumentNode);
+  }
+
+  return argumentVerified;
+}

package/src/verifier/node.js

@@ -0,0 +1,85 @@
+"use strict";
+
+export default class NodeVerifier {
+  verifyNode(node, ...remainingArguments) {
+    let nodeVerified;
+
+    const nodeTerminalNode = node.isTerminalNode();
+
+    if (nodeTerminalNode) {
+      const terminalNode = node,  ///
+            terminalNodeVerified = this.verifyTerminalNode(terminalNode, ...remainingArguments);
+
+      nodeVerified = terminalNodeVerified;  ///
+    } else {
+      const nonTerminalNode = node,  ///
+            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, ...remainingArguments);
+
+      nodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return nodeVerified;
+  }
+
+  verifyChildNodes(childNodes, ...remainingArguments) {
+    let childNodesVerify;
+
+    const index = 0,
+          childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+
+    childNodesVerify = childNodesVerifyAhead; ///
+
+    return childNodesVerify;
+  }
+
+  verifyChildNodesAhead(index, childNodes, ...remainingArguments) {
+    let childNodesVerify;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          childNodesLength = childNodes.length;
+
+    if (index === childNodesLength) {
+      const verifiedAhead = verifyAhead();
+
+      childNodesVerify = verifiedAhead; ///
+    } else {
+      const childNode = childNodes[index],
+            node = childNode, ///
+            nodeVerified = this.verifyNode(node, ...remainingArguments, () => {
+              index++;
+
+              remainingArguments.push(verifyAhead);
+
+              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodes, ...remainingArguments);
+
+              return childNodesVerifyAhead;
+            });
+
+      childNodesVerify = nodeVerified;  ///
+    }
+
+    return childNodesVerify;
+  }
+
+  verifyTerminalNode(terminalNode, ...remainingArguments) {
+    let terminalNodeVerified;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          verifiedAhead = verifyAhead();  ///
+
+    terminalNodeVerified = verifiedAhead; ///
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
+    let nonTerminalNodeVerified;
+
+    const childNodes = nonTerminalNode.getChildNodes(), ///
+          childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
+
+    nonTerminalNodeVerified = childNodesVerify; ///
+
+    return nonTerminalNodeVerified;
+  }
+}

package/src/verifier/nodes/metastatementForMetavariable/conclusion.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import MetastatementForMetavariableNodesVerifier from "../../../verifier/nodes/metastatementForMetavariable";
+
+class ConclusionMetastatementForMetavariableNodesVerifier extends MetastatementForMetavariableNodesVerifier {
+  static createSubstitutions = false;
+}
+
+const conclusionMetastatementForMetavariableNodesVerifier = new ConclusionMetastatementForMetavariableNodesVerifier();
+
+export default conclusionMetastatementForMetavariableNodesVerifier;

package/src/verifier/nodes/metastatementForMetavariable/premise.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import MetastatementForMetavariableNodesVerifier from "../../../verifier/nodes/metastatementForMetavariable";
+
+class PremiseMetastatementForMetavariableNodesVerifier extends MetastatementForMetavariableNodesVerifier {
+  static createSubstitutions = true;
+}
+
+const premiseMetastatementForMetavariableNodesVerifier = new PremiseMetastatementForMetavariableNodesVerifier();
+
+export default premiseMetastatementForMetavariableNodesVerifier;

package/src/verifier/{metastatementForMetavariable.js → nodes/metastatementForMetavariable.js}

@@ -1,15 +1,15 @@
 "use strict";
 
-import Verifier from "../verifier";
-import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+import NodesVerifier from "../../verifier/nodes";
+import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
 
-import { nodeQuery } from "../utilities/query";
-import { METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { nodeQuery } from "../../utilities/query";
+import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
+import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-export default class MetastatementForMetavariableVerifier extends Verifier {
+export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB) {
     let nonTerminalNodeVerified = false;
 

package/src/verifier/nodes/statement.js

@@ -0,0 +1,98 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import { nodeQuery } from "../../utilities/query";
+import { verifyArgument } from "../../verifier/nodes/term";
+import { STATEMENT_META_TYPE } from "../../metaTypes";
+import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
+
+const metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
+      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
+
+class StatementNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNode = nonTerminalNodeA, ///
+          combinatorNonTerminalNode = nonTerminalNodeB; ///
+
+    const ruleName = nonTerminalNode.getRuleName(), ///
+          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === combinatorRuleName) {
+      switch (ruleName) {
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = combinatorNonTerminalNode, ///
+                argumentVerified = verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead);
+
+          nonTerminalNodeVerified = argumentVerified; ///
+
+          break;
+        }
+
+        case META_ARGUMENT_RULE_NAME: {
+          const metaArgumentNode = nonTerminalNode, ///
+                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
+                metaArgumentVerified = verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead),
+                metaArgumentNodeVerified = metaArgumentVerified;  ///
+
+          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const statementNodesVerifier = new StatementNodesVerifier();
+
+export default statementNodesVerifier;
+
+function verifyMetaargument(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+  let metaArgumentVerified = false;
+
+  const metaArgumentString = context.nodeAsString(metaArgumentNode);
+
+  context.trace(`Verifying the '${metaArgumentString}' metaargument...`, metaArgumentNode);
+
+  const statementNode = statementNodeQuery(metaArgumentNode),
+        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+
+  if (statementNode === null) {
+    context.info(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+  } else {
+    if (combinatorMetaTYpeNode === null) {
+      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+
+      context.info(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+    } else {
+      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
+            content = combinatorMetaTypeTerminalNode.getContent(),
+            contentStatementMetaType = (content === STATEMENT_META_TYPE);
+
+      if (!contentStatementMetaType) {
+        context.info(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+      } else {
+        metaArgumentVerified = true;
+      }
+    }
+  }
+
+  if (metaArgumentVerified) {
+    context.debug(`...verified the '${metaArgumentString}' metaargument.`, metaArgumentNode);
+  }
+
+  return metaArgumentVerified;
+}