occam-verify-cli 0.0.844 → 0.0.846

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -12,7 +12,7 @@ const metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNode = nonTerminalNodeA, ///
@@ -25,7 +25,7 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
         case META_ARGUMENT_RULE_NAME: {
           const metaArgumentNode = nonTerminalNode, ///
                 combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead);
+                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -35,7 +35,7 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
         case ARGUMENT_RULE_NAME: {
           const argumentNode = nonTerminalNode, ///
                 constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termAgainstConstructorNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+                argumentNodeVerified = termAgainstConstructorNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -43,7 +43,7 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
         }
 
         default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
           break;
         }
@@ -53,28 +53,28 @@ class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context, verifyAhead) {
+  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead) {
     let metaArgumentNodeVerified = false;
 
-    const metaArgumentString = context.nodeAsString(metaArgumentNode);
+    const metaArgumentString = localContext.nodeAsString(metaArgumentNode);
 
     const statementNode = statementNodeQuery(metaArgumentNode),
           combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
     if (statementNode === null) {
-      context.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
+      localContext.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
     } else {
       if (combinatorMetaTYpeNode === null) {
-        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
+        const combinatorMetaargumentString = localContext.nodeAsString(combinatorMetaargumentNode);
 
-        context.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+        localContext.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);
+          localContext.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE}' but got '${content}' instead.`, metaArgumentNode);
         } else {
           const verifiedAhead = verifyAhead();
 

package/src/verifier/nodes/substitution.js

@@ -0,0 +1,125 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import TermForVariableSubstitution from "../../substitution/termForVariable";
+
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME } from "../../ruleNames";
+
+const variableNodeQuery = nodeQuery("/term/variable");
+
+class SubstitutionNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
+
+      switch (ruleName) {
+        case TERM_RULE_NAME: {
+          const termNodeA = nonTerminalNodeA, ///
+                termNodeB = nonTerminalNodeB, ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = termNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let termNodeVerified;
+
+    const variableNodeA = variableNodeQuery(termNodeA);
+
+    if (variableNodeA !== null) {
+      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = variableNodeVerified; ///
+    } else {
+      const nonTerminalNodeA = termNodeA, ///
+            nonTerminalNodeB = termNodeB, ///
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+      termNodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return termNodeVerified;
+  }
+
+  verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let variableNodeVerified = false;
+
+    if (variableNodeVerified === false) {
+      const variableNodeB = variableNodeQuery(termNodeB);
+
+      if (variableNodeB !== null) {
+        const variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);
+
+        if (variableNodeAMatchedVariableNodeB) {
+          const verifiedAhead = verifyAhead();
+
+          variableNodeVerified = verifiedAhead; ///
+        }
+      }
+    }
+
+    if (variableNodeVerified === false) {
+      const variableNode = variableNodeA,
+            substitution = substitutions.find((substitution) => {
+              const matches = substitution.matchVariableNode(variableNode);
+
+              if (matches) {
+                return true;
+              }
+            }) || null;
+
+      if (substitution !== null) {
+        const termNode = termNodeB, ///
+              termNodeMatches = substitution.matchTermNode(termNode);
+
+        if (termNodeMatches) {
+          const verifiedAhead = verifyAhead();
+
+          variableNodeVerified = verifiedAhead;  ///
+        }
+      } else {
+        let verifiedAhead;
+
+        const termNode = termNodeB, ///
+              termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
+              substitution = termForVariableSubstitution; ///
+
+        substitutions.push(substitution);
+
+        verifiedAhead = verifyAhead();
+
+        if (!verifiedAhead) {
+          substitutions.pop();
+        }
+
+        variableNodeVerified = verifiedAhead; ///
+      }
+    }
+
+    return variableNodeVerified;
+  }
+}
+
+const substitutionNodesVerifier = new SubstitutionNodesVerifier();
+
+export default substitutionNodesVerifier;

package/src/verifier/nodes/termAgainstConstructor.js

@@ -10,7 +10,7 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!");
 
 class TermAgainstConstructorNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNode = nonTerminalNodeA, ///
@@ -23,7 +23,7 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
         case ARGUMENT_RULE_NAME: {
           const argumentNode = nonTerminalNode, ///
                 constructorArgumentNode = constructorNonTerminalNode, ///
-                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
 
           nonTerminalNodeVerified = argumentNodeVerified; ///
 
@@ -31,7 +31,7 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
         }
 
         default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, localContext, verifyAhead);
 
           break;
         }
@@ -41,15 +41,15 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead) {
+  verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead) {
     let argumentNodeVerified = false;
 
-    const argumentString = context.nodeAsString(argumentNode);
+    const argumentString = localContext.nodeAsString(argumentNode);
 
     const typeNode = typeNodeQuery(argumentNode);
 
     if (typeNode !== null) {
-      context.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
+      localContext.debug(`The '${argumentString}' argument should be a term, not a type.`, argumentNode);
     } else {
       const termNode = termNodeQuery(argumentNode);
 
@@ -59,7 +59,7 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
         if (constructorTermNode !== null) {
           const node = termNode,  ///
                 constructorNode = constructorTermNode,  ///
-                nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
+                nodeVerified = this.verifyNode(node, constructorNode, localContext, verifyAhead);
 
           argumentNodeVerified = nodeVerified;  ///
         }
@@ -71,14 +71,14 @@ class TermAgainstConstructorNodesVerifier extends NodesVerifier {
         if (constructorTypeNode !== null) {
           const { verifyTerm } = termAgainstConstructorNodesVerifier,
                 terms = [],
-                termVerified = verifyTerm(termNode, terms, context, () => {
+                termVerified = verifyTerm(termNode, terms, localContext, () => {
                   let verifiedAhead = false;
 
                   const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
                         firstTerm = first(terms),
                         term = firstTerm, ///
                         termType = term.getType(),
-                        constructorType = context.findTypeByTypeName(constructorTypeName),
+                        constructorType = localContext.findTypeByTypeName(constructorTypeName),
                         termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
 
                   if (termTypeEqualToOrSubTypeOfType) {

package/src/verify/containment.js

@@ -4,33 +4,59 @@ import { second } from "../utilities/array";
 import { CONTAINED } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const variableNodesQuery = nodesQuery("/metaArgument//variable"),
-      containmentVariableNodeQuery = nodeQuery("/argument/term/variable!");
+const termNodeQuery = nodeQuery("/argument/term!"),
+      variableNodeQuery = nodeQuery("/argument/term/variable!"),
+      metaArgumentTermNodesQuery = nodesQuery("/metaArgument//term"),
+      metaArgumentVariableNodesQuery = nodesQuery("/metaArgument//variable");
 
-export default function verifyContainment(argumentNode, containmentNode, metaArgumentNode, context) {
+export default function verifyContainment(argumentNode, containmentNode, metaArgumentNode, localContext) {
   let containmentVerified = false;
 
-  const containmentVariableNode = containmentVariableNodeQuery(argumentNode);
+  const contained = containedFromContainmentNode(containmentNode),
+        termNode = termNodeQuery(argumentNode),
+        variableNode = variableNodeQuery(argumentNode);
 
-  if (containmentVariableNode !== null) {
-    const contained = containedFromContainmentNode(containmentNode),
-          variableNodes = variableNodesQuery(metaArgumentNode),
-          containmentVariableNodeMatchesStatementVariableNode = variableNodes.some((statementVariableNode) => {
-            const containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
+  if (false) {
+    ///
+  } else if (variableNode !== null) {
+    const metaArgumentVariableNodes = metaArgumentVariableNodesQuery(metaArgumentNode),
+          variableNodeMatchesMetaArgumentVariableNode = metaArgumentVariableNodes.some((metaArgumentVariableNode) => {
+            const variableNodeMatchesMetaArgumentVariableNode = variableNode.match(metaArgumentVariableNode);
 
-            if (containmentVariableNodeMatchesStatementVariableNode) {
+            if (variableNodeMatchesMetaArgumentVariableNode) {
               return true;
             }
           });
 
     if (contained) {
-      if (containmentVariableNodeMatchesStatementVariableNode) {
+      if (variableNodeMatchesMetaArgumentVariableNode) {
         containmentVerified = true;
       }
     }
 
     if (!contained) {
-      if (!containmentVariableNodeMatchesStatementVariableNode) {
+      if (!variableNodeMatchesMetaArgumentVariableNode) {
+        containmentVerified = true;
+      }
+    }
+  } else if (termNode !== null) {
+    const metaArgumentTermNodes = metaArgumentTermNodesQuery(metaArgumentNode),
+          termNodeMatchesMetaArgumentTermNode = metaArgumentTermNodes.some((metaArgumentTermNode) => {
+            const termNodeMatchesMetaArgumentTermNode = termNode.match(metaArgumentTermNode);
+
+            if (termNodeMatchesMetaArgumentTermNode) {
+              return true;
+            }
+          });
+
+    if (contained) {
+      if (termNodeMatchesMetaArgumentTermNode) {
+        containmentVerified = true;
+      }
+    }
+
+    if (!contained) {
+      if (!termNodeMatchesMetaArgumentTermNode) {
         containmentVerified = true;
       }
     }

package/src/verify/defining.js

@@ -9,7 +9,7 @@ import { first, second } from "../utilities/array";
 const termNodeQuery = nodeQuery("/argument/term!"),
       variableNodeQuery = nodeQuery("/argument/term/variable!");
 
-export default function verifyDefining(argumentNode, definingNode, context) {
+export default function verifyDefining(argumentNode, definingNode, localContext) {
   let definingVerified = false;
 
   const defined = definedFromDefiningNode(definingNode),
@@ -19,10 +19,10 @@ export default function verifyDefining(argumentNode, definingNode, context) {
   if (false) {
     ///
   } else if (variableNode !== null) {
-    const variable = context.findVariableByVariableNode(variableNode);
+    const variable = localContext.findVariableByVariableNode(variableNode);
 
     if (variable !== null) {
-      const variableDefined = context.isVariableDefined(variable);
+      const variableDefined = localContext.isVariableDefined(variable);
 
       if (defined) {
         if (variableDefined) {
@@ -38,12 +38,12 @@ export default function verifyDefining(argumentNode, definingNode, context) {
     }
   } else if (termNode !== null) {
     const terms = [],
-          termVerified = verifyTerm(termNode, terms, context, () => {
+          termVerified = verifyTerm(termNode, terms, localContext, () => {
             let verifiedAhead;
 
             const firstTerm = first(terms),
                   term = firstTerm, ///
-                  termGrounded = context.isTermGrounded(term);
+                  termGrounded = localContext.isTermGrounded(term);
 
             if (defined) {
               if (termGrounded) {

package/src/verify/equality.js

@@ -10,12 +10,12 @@ import { first, second } from "../utilities/array";
 const leftTermNodeQuery = nodeQuery("/equality/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/equality/argument[1]/term!");
 
-export default function verifyEquality(equalityNode, assignments, derived, context, verifyAhead) {
+export default function verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
   let equalityVerified;
 
-  const equalityString = context.nodeAsString(equalityNode);
+  const equalityString = localContext.nodeAsString(equalityNode);
 
-  context.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
+  localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
 
   const verifyEqualityFunctions = [
     verifyDerivedEquality,
@@ -23,7 +23,7 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
   ];
 
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
-    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, context, verifyAhead);
+    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext, verifyAhead);
 
     if (equalityVerified) {
       return true;
@@ -31,19 +31,19 @@ export default function verifyEquality(equalityNode, assignments, derived, conte
   });
 
   if (equalityVerified) {
-    context.debug(`...verified the '${equalityString}' equality.`, equalityNode);
+    localContext.debug(`...verified the '${equalityString}' equality.`, equalityNode);
   }
 
   return equalityVerified;
 }
 
-function verifyDerivedEquality(equalityNode, assignments, derived, context, verifyAhead) {
+function verifyDerivedEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
   let derivedEqualityVerified = false;
 
   if (derived) {
-    const equalityString = context.nodeAsString(equalityNode);
+    const equalityString = localContext.nodeAsString(equalityNode);
 
-    context.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -52,7 +52,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
             leftTermNode,
             rightTermNode
           ],
-          termsVerified = verifyTerms(termNodes, terms, context, () => {
+          termsVerified = verifyTerms(termNodes, terms, localContext, () => {
             let verifiedAhead = false;
 
             const firstTerm = first(terms),
@@ -62,7 +62,7 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
                   equality = Equality.fromLeftTermRightTermAndEqualityNode(leftTerm, rightTerm, equalityNode);
 
             if (equality !== null) {
-              const equalityEqual = equality.isEqual(context);
+              const equalityEqual = equality.isEqual(localContext);
 
               if (equalityEqual) {
                 const equalityAssignment = EqualityAssignment.fromEquality(equality),
@@ -84,20 +84,20 @@ function verifyDerivedEquality(equalityNode, assignments, derived, context, veri
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      context.trace(`...verified the '${equalityString}' derived equality.`, equalityNode);
+      localContext.trace(`...verified the '${equalityString}' derived equality.`, equalityNode);
     }
   }
 
   return derivedEqualityVerified;
 }
 
-function verifyGivenEquality(equalityNode, assignments, derived, context, verifyAhead) {
+function verifyGivenEquality(equalityNode, assignments, derived, localContext, verifyAhead) {
   let givenEqualityVerified = false;
 
   if (!derived) {
-    const equalityString = context.nodeAsString(equalityNode);
+    const equalityString = localContext.nodeAsString(equalityNode);
 
-    context.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' given equality...`, equalityNode);
 
     const terms = [],
           leftTermNode = leftTermNodeQuery(equalityNode),
@@ -106,7 +106,7 @@ function verifyGivenEquality(equalityNode, assignments, derived, context, verify
             leftTermNode,
             rightTermNode
           ],
-          termsVerified = verifyTerms(termNodes, terms, context, () => {
+          termsVerified = verifyTerms(termNodes, terms, localContext, () => {
             let verifiedAhead = false;
 
             const firstTerm = first(terms),
@@ -134,7 +134,7 @@ function verifyGivenEquality(equalityNode, assignments, derived, context, verify
     givenEqualityVerified = termsVerified; ///
 
     if (givenEqualityVerified) {
-      context.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
+      localContext.trace(`...verified the '${equalityString}' given equality.`, equalityNode);
     }
   }
 

package/src/verify/givenType.js

@@ -2,15 +2,15 @@
 
 import { typeNameFromTypeNode } from "../utilities/query";
 
-export default function verifyGivenType(typeNode, types, context, verifyAhead) {
+export default function verifyGivenType(typeNode, types, localContext, verifyAhead) {
   let givenTypeVerified = false;
 
-  const typeString = context.nodeAsString(typeNode);
+  const typeString = localContext.nodeAsString(typeNode);
 
-  context.trace(`Verifying the given '${typeString}' type...`, typeNode);
+  localContext.trace(`Verifying the given '${typeString}' type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
-        type = context.findTypeByTypeName(typeName);
+        type = localContext.findTypeByTypeName(typeName);
 
   if (type !== null) {
     let verifiedAhead;
@@ -27,7 +27,7 @@ export default function verifyGivenType(typeNode, types, context, verifyAhead) {
   }
 
   if (givenTypeVerified) {
-    context.debug(`...verified the given '${typeString}' type.`, typeNode);
+    localContext.debug(`...verified the given '${typeString}' type.`, typeNode);
   }
 
   return givenTypeVerified;

package/src/verify/givenVariable.js

@@ -1,13 +1,13 @@
 "use strict";
 
-export default function verifyGivenVariable(variableNode, variables, context, verifyAhead) {
+export default function verifyGivenVariable(variableNode, variables, localContext, verifyAhead) {
   let givenVariableVerified = false;
 
-  const variableString = context.nodeAsString(variableNode);
+  const variableString = localContext.nodeAsString(variableNode);
 
-  context.trace(`Verifying the '${variableString}' given variable...`, variableNode);
+  localContext.trace(`Verifying the '${variableString}' given variable...`, variableNode);
 
-  const variable = context.findVariableByVariableNode(variableNode);
+  const variable = localContext.findVariableByVariableNode(variableNode);
 
   if (variable !== null) {
     let verifiedAhead;
@@ -24,7 +24,7 @@ export default function verifyGivenVariable(variableNode, variables, context, ve
   }
 
   if (givenVariableVerified) {
-    context.debug(`...verified the '${variableString}' given variable.`, variableNode);
+    localContext.debug(`...verified the '${variableString}' given variable.`, variableNode);
   }
 
   return givenVariableVerified;

package/src/verify/metavariable.js

@@ -35,14 +35,14 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
   return metavariableVerified;
 }
 
-export function verifyStandaloneMetavariable(metavariableNode, contexct, verifyAhead) {
+export function verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead) {
   let standaloneMetavariableVerified = false;
 
-  const metavariableString = contexct.nodeAsString(metavariableNode);
+  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
 
-  contexct.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
+  localMetaContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
 
-  const metavariablePresent = contexct.isMetavariablePresentByMetavariableNode(metavariableNode);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();
@@ -51,7 +51,7 @@ export function verifyStandaloneMetavariable(metavariableNode, contexct, verifyA
   }
 
   if (standaloneMetavariableVerified) {
-    contexct.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
+    localMetaContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
   }
 
   return standaloneMetavariableVerified;

package/src/verify/statement/qualified.js

@@ -41,14 +41,13 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
     if (qualifiedStatementVerified) {
       derived = false;  ///
 
-      const context = localContext, ///
-            verifyQualifiedStatementFunctions = [
+      const verifyQualifiedStatementFunctions = [
               verifyQualifiedStatementAsEquality,
               verifyQualifiedStatementAsTypeAssertion
             ];
 
       qualifiedStatementVerified = verifyQualifiedStatementFunctions.every((verifyQualifiedStatementFunction) => { ///
-        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, context, () => {
+        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, localContext, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;
@@ -188,44 +187,44 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, refe
   return qualifiedStatementVerifiedAgainstConjecture;
 }
 
-function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsEquality = true; ///
 
   const equalityNode = equalityNodeQuery(qualifiedStatementNode);
 
   if (equalityNode !== null) {
-    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead);
 
     statementVerifiedAsEquality = equalityVerified; ///
 
     if (statementVerifiedAsEquality) {
-      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
     }
   }
 
   return statementVerifiedAsEquality;
 }
 
-function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsTypeAssertion = true;  ///
 
   const typeAssertionNode = typeAssertionNodeQuery(qualifiedStatementNode);
 
   if (typeAssertionNode !== null) {
-    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
     if (statementVerifiedAsTypeAssertion) {
-      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
     }
   }
 

package/src/verify/statement/unqualified.js

@@ -23,8 +23,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
 
     if (!unqualifiedStatementVerified) {
-      const context = localContext, ///
-            statementVerified = verifyStatement(statementNode, assignments, derived, context, () => {
+      const statementVerified = verifyStatement(statementNode, assignments, derived, localContext, () => {
               const verifiedAhead = true;
 
               return verifiedAhead;