occam-verify-cli 0.0.678 → 0.0.680

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.debug(`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/equality.js

@@ -0,0 +1,68 @@
+"use strict";
+
+import Equality from "../../equality";
+import verifyTerms from "../../verify/terms";
+import NodesVerifier from "../../verifier/nodes";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
+          rightNonTerminalNodeRuleName = rightNonTerminalNode.getRuleName();
+
+    if (leftNonTerminalNodeRuleName === rightNonTerminalNodeRuleName) {
+      const leftNonTerminalNodeRuleNameTermRuleName = (leftNonTerminalNodeRuleName === TERM_RULE_NAME),
+            rightNonTerminalNodeRuleNameTermRuleName = (rightNonTerminalNodeRuleName === TERM_RULE_NAME);
+
+      if (leftNonTerminalNodeRuleNameTermRuleName && rightNonTerminalNodeRuleNameTermRuleName) {
+        const leftTermNode = leftNonTerminalNode, ///
+              rightTermNode = rightNonTerminalNode, ///
+              termNodeVerified = this.verifyTermNode(leftTermNode, rightTermNode, equalities, context, verifyAhead);
+
+        nonTerminalNodeVerified = termNodeVerified;  ///
+      }
+
+      if (!nonTerminalNodeVerified) {
+        const leftNonTerminalNodeChildNodes = leftNonTerminalNode.getChildNodes(),
+              rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
+              leftChildNodes = leftNonTerminalNodeChildNodes, ///
+              rightChildNodes = rightNonTerminalNodeChildNodes, ///
+              childNodesVerified = this.verifyChildNodes(leftChildNodes, rightChildNodes, equalities, context, verifyAhead);
+
+        nonTerminalNodeVerified = childNodesVerified; ///
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyTermNode(leftTermNode, rightTermNode, equalities, context, verifyAhead) {
+    let termNodeVerified = false;
+
+    const termsVerified = verifyTerms(leftTermNode, rightTermNode, context, verifyAhead);
+
+    if (termsVerified) {
+      const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
+            equalityA = equality, ///
+            equalitiesB = equalities, ///
+            equalityMatches = equalitiesB.some((equalityB) => { ///
+              const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
+
+              if (equalityAMatchesEqualityB) {
+                return true;
+              }
+            });
+
+      termNodeVerified = equalityMatches;  ///
+    }
+
+    return termNodeVerified;
+  }
+}
+
+const equalityNodesVerifier = new EqualityNodesVerifier();
+
+export default equalityNodesVerifier;

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,16 +1,16 @@
 "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 {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB) {
+export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -23,28 +23,28 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
       if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
         const metastatementNodeA = nonTerminalNodeA,  ///
               metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
+              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
 
         if (metastatementNodeVerified) {
           nonTerminalNodeVerified = true;  ///
         } else {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
         }
       } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let metastatementNodeVerified = false;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
     }
@@ -52,7 +52,7 @@ export default class MetastatementForMetavariableVerifier extends Verifier {
     return metastatementNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB) {
+  verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, metaproofContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),

package/src/verifier/nodes/statement.js

@@ -0,0 +1,100 @@
+"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.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+  } else {
+    if (combinatorMetaTYpeNode === null) {
+      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+
+      context.debug(`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.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
+      } else {
+        const verifiedAhead = verifyAhead();
+
+        metaArgumentVerified = verifiedAhead; ///
+      }
+    }
+  }
+
+  if (metaArgumentVerified) {
+    context.debug(`...verified the '${metaArgumentString}' metaargument.`, metaArgumentNode);
+  }
+
+  return metaArgumentVerified;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+
+import StatementForMetavariableNodesVerifier from "../../../verifier/nodes/statementForMetavariable";
+
+class ConclusionStatementForMetavariableNodesVerifier extends StatementForMetavariableNodesVerifier {
+  static createSubstitutions = false;
+}
+
+const conclusionStatementForMetavariableNodesVerifier = new ConclusionStatementForMetavariableNodesVerifier();
+
+export default conclusionStatementForMetavariableNodesVerifier;

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

@@ -0,0 +1,11 @@
+"use strict";
+
+import StatementForMetavariableNodesVerifier from "../../../verifier/nodes/statementForMetavariable";
+
+class PremiseStatementForMetavariableNodesVerifier extends StatementForMetavariableNodesVerifier {
+  static createSubstitutions = true;
+}
+
+const premiseStatementForMetavariableNodesVerifier = new PremiseStatementForMetavariableNodesVerifier();
+
+export default premiseStatementForMetavariableNodesVerifier;

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

@@ -1,16 +1,16 @@
 "use strict";
 
-import Verifier from "../verifier";
-import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+import NodesVerifier from "../../verifier/nodes";
+import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/query";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
+import { nodeQuery } from "../../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../../utilities/query";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-export default class StatementForMetavariableVerifier extends Verifier {
+export default class StatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
@@ -40,11 +40,11 @@ export default class StatementForMetavariableVerifier extends Verifier {
         } else {
           const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-                nodesA = nonTerminalNodeAChildNodes, ///
-                nodesB = nonTerminalNodeBChildNodes, ///
-                nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions, fileContextA, proofContextB);
+                childNodesA = nonTerminalNodeAChildNodes, ///
+                childNodesB = nonTerminalNodeBChildNodes, ///
+                childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, proofContextB);
 
-          nonTerminalNodeVerified = nodesMatch;  ///
+          nonTerminalNodeVerified = childNodesVerified;  ///
         }
       } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
         nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);

package/src/verifier/nodes/term.js

@@ -0,0 +1,106 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import { first } from "../../utilities/array";
+import { ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!");
+
+class TermNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const ruleName = nonTerminalNode.getRuleName(), ///
+          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === constructorRuleName) {
+      switch (ruleName) {
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = constructorNonTerminalNode, ///
+                argumentVerified = verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead),
+                argumentNodeVerified = argumentVerified;  ///
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const termNodesVerifier = new TermNodesVerifier();
+
+export default termNodesVerifier;
+
+export function verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead) {
+  let argumentVerified = false;
+
+  const argumentString = context.nodeAsString(argumentNode);
+
+  context.trace(`Verifying the '${argumentString}' argument...`, argumentNode);
+
+  const typeNode = typeNodeQuery(argumentNode);
+
+  if (typeNode !== null) {
+    context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
+  } else {
+    const termNode = termNodeQuery(argumentNode);
+
+    if (!argumentVerified) {
+      const constructorTermNode = termNodeQuery(constructorArgumentNode);
+
+      if (constructorTermNode !== null) {
+        const node = termNode,  ///
+              constructorNode = constructorTermNode,  ///
+              nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
+
+        argumentVerified = nodeVerified;  ///
+      }
+    }
+
+    if (!argumentVerified) {
+      const constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+
+      if (constructorTypeNode !== null) {
+        const { verifyTerm } = termNodesVerifier,
+              types = [],
+              termVerified = verifyTerm(termNode, types, context, () => {
+                let verifiedAhead = false;
+
+                const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
+                      firstType = first(types),
+                      termType = firstType, ///
+                      constructorType = context.findTypeByTypeName(constructorTypeName),
+                      termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+
+                if (termTypeEqualToOrSubTypeOfType) {
+                  verifiedAhead = verifyAhead();
+                }
+
+                return verifiedAhead;
+              });
+
+        argumentVerified = termVerified;  ///
+      }
+    }
+  }
+
+  if (argumentVerified) {
+    context.debug(`...verified the '${argumentString}' argument.`, argumentNode);
+  }
+
+  return argumentVerified;
+}

package/src/verifier/nodes/termForVariable/consequent.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TermForVariableNodesVerifier from "../../../verifier/nodes/termForVariable";
+
+class ConsequentTermForVariableNodesVerifier extends TermForVariableNodesVerifier {
+  static createSubstitutions = false;
+}
+
+const consequentTermForVariableNodesVerifier = new ConsequentTermForVariableNodesVerifier();
+
+export default consequentTermForVariableNodesVerifier;

package/src/verifier/nodes/termForVariable/supposition.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TermForVariableNodesVerifier from "../../../verifier/nodes/termForVariable";
+
+class SuppositionTermForVariableNodesVerifier extends TermForVariableNodesVerifier {
+  static createSubstitutions = true;
+}
+
+const suppositionTermForVariableNodesVerifier = new SuppositionTermForVariableNodesVerifier();
+
+export default suppositionTermForVariableNodesVerifier;