occam-verify-cli 0.0.533 → 0.0.535

package/src/equality.js

@@ -1,15 +1,6 @@
 "use strict";
 
-import Variable from "./variable";
-import verifyTerm from "./verify/term";
-
-import { nodeQuery } from "./utilities/query";
-import { first, second } from "./utilities/array";
 import { TERM_RULE_NAME } from "./ruleNames";
-import { verifyTermAsVariable } from "./verify/term";
-
-const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
-      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
 
 export default class Equality {
   constructor(leftTermNode, rightTermNode) {
@@ -25,7 +16,7 @@ export default class Equality {
     return this.rightTermNode;
   }
 
-  matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context) {
+  matchTermNodes(leftTermNode, rightTermNode, reversed, context) {
     let leftTermNodeAndRightTermNodeMatch = true;
 
     if (leftTermNodeAndRightTermNodeMatch) {
@@ -33,7 +24,7 @@ export default class Equality {
                                     this.rightTermNode :
                                       this.leftTermNode,  ///
             rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
     }
@@ -43,7 +34,7 @@ export default class Equality {
                                     this.leftTermNode :
                                       this.rightTermNode,  ///
             rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
     }
@@ -51,24 +42,22 @@ export default class Equality {
     return leftTermNodeAndRightTermNodeMatch;
   }
 
-  match(equality, equalities, context) {
+  match(equality, context) {
     let matches = false;
 
     const leftTermNode = equality.getLeftTermNode(),
           rightTermNode = equality.getRightTermNode();
 
-    equalities = filterEqualities(equalities, equality);  ///
-
     if (!matches) {
       const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, context);
 
       matches = leftTermNodeAndRightTermNodeMatch;  ///
     }
 
     if (!matches) {
       const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, context);
 
       matches = leftTermNodeAndRightTermNodeMatch;  ///
     }
@@ -76,25 +65,23 @@ export default class Equality {
     return matches;
   }
 
-  equate(equalities, context) {
+  equate(context) {
     const leftNonTerminalNode = this.leftTermNode,  ///
           rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context),
+          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context),
           equates = nonTerminalNodeEquates; ///
 
     return equates;
   }
 
-  static fromStatementNode(statementNode, context) {
-    const leftTermNode = leftTermNodeQuery(statementNode),
-          rightTermNode = rightTermNodeQuery(statementNode),
-          equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
+  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
+    const equality = new Equality(leftTermNode, rightTermNode);
 
     return equality;
   }
 }
 
-function equateNode(nodeA, nodeB, equalities, context) {
+function equateNode(nodeA, nodeB, context) {
   let nodeEquates = false;
 
   const nodeATerminalNode = nodeA.isTerminalNode(),
@@ -104,13 +91,13 @@ function equateNode(nodeA, nodeB, equalities, context) {
     if (nodeATerminalNode) {
       const terminalNodeA = nodeA,  ///
             terminalNodeB = nodeB,  ///
-            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities, context);
+            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, context);
 
       nodeEquates = terminalNodeEquates;  ///
     } else {
       const nonTerminalNodeA = nodeA,  ///
             nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities, context);
+            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context);
 
       nodeEquates = nonTerminalNodeEquates; ///
     }
@@ -119,7 +106,7 @@ function equateNode(nodeA, nodeB, equalities, context) {
   return nodeEquates;
 }
 
-function equateNodes(leftNodes, rightNodes, equalities, context) {
+function equateNodes(leftNodes, rightNodes, context) {
   let nodesEquate = false;
 
   const leftNodesLength = leftNodes.length,
@@ -128,7 +115,7 @@ function equateNodes(leftNodes, rightNodes, equalities, context) {
   if (leftNodesLength === rightNodesLength) {
     nodesEquate = leftNodes.every((LeftNode, index) => {
       const rightNode = rightNodes[index],
-            nodeEquates = equateNode(LeftNode, rightNode, equalities, context);
+            nodeEquates = equateNode(LeftNode, rightNode, context);
 
       if (nodeEquates) {
         return true;
@@ -139,14 +126,14 @@ function equateNodes(leftNodes, rightNodes, equalities, context) {
   return nodesEquate;
 }
 
-function equateTerminalNode(terminalNodeA, terminalNodeB, equalities, context) {
+function equateTerminalNode(terminalNodeA, terminalNodeB, context) {
   const matches = terminalNodeA.match(terminalNodeB),
         terminalNodeEquates = matches;  ///
 
   return terminalNodeEquates;
 }
 
-function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context) {
+function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, context) {
   let nonTerminalNodeEquates = false;
 
   const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
@@ -159,7 +146,7 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
     if (ruleNameTermRuleName) {
       const leftTermNode = leftNonTerminalNode, ///
             rightTermNode = rightNonTerminalNode, ///
-            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities, context);
+            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, context);
 
       nonTerminalNodeEquates = termNodeEquates;  ///
     }
@@ -169,7 +156,7 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
             rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
             leftNodes = leftNonTerminalNodeChildNodes, ///
             rightNodes = rightNonTerminalNodeChildNodes, ///
-            nodesEquate = equateNodes(leftNodes, rightNodes, equalities, context);
+            nodesEquate = equateNodes(leftNodes, rightNodes, context);
 
       nonTerminalNodeEquates = nodesEquate; ///
     }
@@ -178,7 +165,7 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
   return nonTerminalNodeEquates;
 }
 
-function equateTermNode(leftTermNode, rightTermNode, equalities, context) {
+function equateTermNode(leftTermNode, rightTermNode, context) {
   let termNodeEquates = false;
 
   const equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
@@ -199,75 +186,3 @@ function equateTermNode(leftTermNode, rightTermNode, equalities, context) {
 
   return termNodeEquates;
 }
-
-function filterEqualities(equalities, equality) {
-  const equalityA = equality; ///
-
-  equalities = equalities.filter((equality) => {
-    const equalityB = equality; ///
-
-    if (equalityA !== equalityB) {
-      return true;
-    }
-  });
-
-  return equalities;
-}
-
-function equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context) {
-  let equality = null;
-
-  const types = [],
-        leftTermVerified = verifyTerm(leftTermNode, types, context),
-        rightTermVerified = verifyTerm(rightTermNode, types, context);
-
-  if (leftTermVerified && rightTermVerified) {
-    const firstType = first(types),
-          secondType = second(types),
-          leftTermType = firstType, ///
-          rightTermType = secondType, ///
-          leftTermTypeEqualToRightTermType = leftTermType.isEqualTo(rightTermType);
-
-    if (leftTermTypeEqualToRightTermType) {
-      equality = new Equality(leftTermNode, rightTermNode);
-    } else {
-      const leftTermTypeSubTypeOfRightTermType = leftTermType.isSubTypeOf(rightTermType);
-
-      if (false) {
-          ///
-      } else if (leftTermTypeSubTypeOfRightTermType) {
-        const variables = [],
-              rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
-
-        if (rightTermVerifiedAsVariable) {
-          let rightVariable;
-
-          const firstVariable = first(variables);
-
-          rightVariable = firstVariable;  ///
-
-          const rightVariableName = rightVariable.getName(),
-                rightName = rightVariableName,  ///
-                rightType = leftTermType; ///
-
-          rightVariable = Variable.fromTypeAndName(rightType, rightName);
-
-          context.addVariable(rightVariable);
-
-          equality = new Equality(leftTermNode, rightTermNode);
-        }
-      }
-    }
-
-    if (equality === null) {
-      const leftTermString = context.nodeAsString(leftTermNode),
-            rightTermString = context.nodeAsString(rightTermNode),
-            leftTermTypeName = leftTermType.getName(),
-            rightTermTypeName = rightTermType.getName();
-
-      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type and neither can be inferred.'`, leftTermNode);
-    }
-  }
-
-  return equality;
-}

package/src/log.js

@@ -103,7 +103,7 @@ export default class Log {
   }
 }
 
-function formatMessage(level, message, node, tokens, filePath) {
+function formatMessage(level, message, node = null, tokens = null, filePath = null) {
   const upperCaseLevel = level.toUpperCase();
 
   if (node === null) {

package/src/premise.js

@@ -43,9 +43,9 @@ export default class Premise {
           const subproofStatementNode = subproofStatementNodes[index],
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
-                nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+                nonTerminalNodeVerifies = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
 
-          if (nonTerminalNodeMatches) {
+          if (nonTerminalNodeVerifies) {
             return true;
           }
         });
@@ -58,8 +58,8 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = premiseStatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          statementNodeMatches = nonTerminalNodeMatches; ///
+          nonTerminalNodeVerifies = premiseStatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeVerifies; ///
 
     return statementNodeMatches;
   }
@@ -82,15 +82,15 @@ export default class Premise {
 
       if (ruleSubproofMetastatementNodesLength === ruleSubproofAssertionMetastatementNodesLength) {
         ruleSubproofNodeMatches = ruleSubproofAssertionMetastatementNodes.every((ruleSubproofAssertionMetastatementNode, index) => {
-                                    const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
-                                          nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
-                                          nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                                          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-
-                                    if (nonTerminalNodeMatches) {
-                                      return true;
-                                    }
-                                  });
+          const ruleSubproofMetastatementNode = ruleSubproofMetastatementNodes[index],
+                nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
+                nonTerminalNodeVerifies = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+
+          if (nonTerminalNodeVerifies) {
+            return true;
+          }
+        });
       }
     }
 
@@ -100,8 +100,8 @@ export default class Premise {
   matchMetastatementNode(metastatementNode, substitutions) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          nonTerminalNodeMatches = premiseMetastatementForMetavariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          metastatementNodeMatches = nonTerminalNodeMatches; ///
+          nonTerminalNodeVerifies = premiseMetastatementForMetavariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          metastatementNodeMatches = nonTerminalNodeVerifies; ///
 
     return metastatementNodeMatches;
   }

package/src/supposition.js

@@ -37,15 +37,15 @@ export default class Supposition {
 
       if (subproofStatementNodesLength === subproofAssertionStatementNodesLength) {
         subproofNodeMatches = subproofAssertionStatementNodes.every((subproofAssertionStatementNode, index) => {
-                                const subproofStatementNode = subproofStatementNodes[index],
-                                      nonTerminalNodeA = subproofAssertionStatementNode,  ///
-                                      nonTerminalNodeB = subproofStatementNode, ///
-                                      nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
-
-                                if (nonTerminalNodeMatches) {
-                                  return true;
-                                }
-                              });
+          const subproofStatementNode = subproofStatementNodes[index],
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                nonTerminalNodeB = subproofStatementNode, ///
+                nonTerminalNodeVerifies = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+
+          if (nonTerminalNodeVerifies) {
+            return true;
+          }
+        });
       }
     }
 
@@ -55,8 +55,8 @@ export default class Supposition {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeMatches = suppositionTermForVariableVerifier.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
-          statementNodeMatches = nonTerminalNodeMatches; ///
+          nonTerminalNodeVerifies = suppositionTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeVerifies; ///
 
     return statementNodeMatches;
   }

package/src/verifier/metastatementForMetavariable.js

@@ -10,8 +10,8 @@ import { metavariableNameFromMetavariableNode } from "../utilities/query";
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
 export default class MetastatementForMetavariableVerifier extends Verifier {
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
-    let nonTerminalNodeMatches = false;
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeVerifies = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -23,37 +23,37 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeMatches = this.matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+              metastatementNodeVerifies = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
 
-        if (metastatementNodeMatches) {
-          nonTerminalNodeMatches = true;  ///
+        if (metastatementNodeVerifies) {
+          nonTerminalNodeVerifies = true;  ///
         } else {
-          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+          nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
         }
       } else {
-        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        nonTerminalNodeVerifies = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
     }
 
-    return nonTerminalNodeMatches;
+    return nonTerminalNodeVerifies;
   }
 
-  matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
-    let metastatementNodeMatches = false;
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
+    let metastatementNodeVerifies = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+      const metaVariableNodeVerifies = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
 
-      metastatementNodeMatches = metaVariableNodeMatches; ///
+      metastatementNodeVerifies = metaVariableNodeVerifies; ///
     }
 
-    return metastatementNodeMatches;
+    return metastatementNodeVerifies;
   }
 
-  matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
-    let metavariableNodeMatches;
+  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
+    let metavariableNodeVerifies;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
           substitution = substitutions.find((substitution) => {
@@ -66,9 +66,9 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
 
     if (substitution !== null) {
       const metastatementNode = metastatementNodeB, ///
-            substitutionNodesMatch = substitution.matchMetastatementNode(metastatementNode);
+            metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
 
-      metavariableNodeMatches = substitutionNodesMatch;  ///
+      metavariableNodeVerifies = metastatementNodeMatches;  ///
     } else {
       const { createSubstitutions } = this.constructor;
 
@@ -81,9 +81,9 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
         substitutions.push(substitution);
       }
 
-      metavariableNodeMatches = true;
+      metavariableNodeVerifies = true;
     }
 
-    return metavariableNodeMatches;
+    return metavariableNodeVerifies;
   }
 }

package/src/verifier/statement.js

@@ -0,0 +1,135 @@
+"use strict";
+
+import Verifier from "../verifier";
+import verifyTerm from "../verify/term";
+
+import { first } from "../utilities/array";
+import { objectType } from "../type";
+import { OBJECT_TYPE_NAME } from "../typeNames";
+import { STATEMENT_META_TYPE } from "../metaTypes";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
+
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
+      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
+
+class StatementVerifier extends Verifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, context) {
+    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, ///
+                combinatorArgumentNode = combinatorNonTerminalNode, ///
+                argumentNodeVerified = this.verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, context);
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
+        case META_ARGUMENT_RULE_NAME: {
+          const metaArgumentNode = nonTerminalNode, ///
+                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
+                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context);
+
+          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          const childNodes = nonTerminalNode.getChildNodes(),
+                combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
+                nodesA = childNodes, ///
+                nodesB = combinatorChildNodes, ///
+                nodesVerified = this.verifyNodes(nodesA, nodesB, substitutions, context);
+
+          nonTerminalNodeVerified = nodesVerified; ///
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyArgumentNode(argumentNode, combinatorArgumentNode, substitutions, context) {
+    let argumentNodeVerified = false;
+
+    const termNode = termNodeQuery(argumentNode);
+
+    if (termNode === null) {
+      const argumentString = context.nodeAsString(argumentNode);
+
+      context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
+    } else {
+      const types = [],
+            termVerified = verifyTerm(termNode, types, context);
+
+      if (termVerified) {
+        const firstType = first(types),
+              termType = firstType, ///
+              typeNode = typeNodeQuery(combinatorArgumentNode),
+              typeName = typeNameFromTypeNode(typeNode),
+              type = (typeName === OBJECT_TYPE_NAME) ?
+                        objectType :  ///
+                          context.findTypeByTypeName(typeName),
+              statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+
+        if (statementTypeEqualToOrSubTypeOfType) {
+          argumentNodeVerified = true;
+        }
+      }
+    }
+
+    return argumentNodeVerified;
+  }
+
+  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, substitutions, context) {
+    let metaArgumentNodeVerified = false;
+
+    const statementNode = statementNodeQuery(metaArgumentNode),
+          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+
+    if (statementNode === null) {
+      const metaArgumentString = context.nodeAsString(metaArgumentNode);
+
+      context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+    } else {
+      if (combinatorMetaTYpeNode === null) {
+        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+
+        context.error(`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.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+        } else {
+          metaArgumentNodeVerified = true;
+        }
+      }
+    }
+
+    return metaArgumentNodeVerified;
+  }
+}
+
+const statementVerifier = new StatementVerifier();
+
+export default statementVerifier;
+