occam-verify-cli 0.0.845 → 0.0.847

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import LocalContext from "../../context/local";
 import NodesVerifier from "../../verifier/nodes";
 import TermForVariableSubstitution from "../../substitution/termForVariable";
 import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
@@ -16,7 +15,7 @@ const variableNodeQuery = nodeQuery("/*/variable!"),
       substitutionNodeQuery = nodeQuery("/metastatement/substitution!");
 
 class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName();
@@ -24,7 +23,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     switch (nonTerminalNodeARuleName) {
       case METASTATEMENT_RULE_NAME: {
         const metastatementNodeA = nonTerminalNodeA, ///
-              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              metaArgumentNodeVerified = this.verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         nonTerminalNodeVerified = metaArgumentNodeVerified; ///
 
@@ -33,7 +32,6 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
       case TERM_RULE_NAME: {
         const termNodeA = nonTerminalNodeA, ///
-              localContextA = LocalContext.fromFileContext(fileContextA),
               termNodeVerified = this.verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -42,14 +40,14 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
       }
     }
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetastatementNode(metastatementNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metastatementNodeVerified;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -57,7 +55,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     switch (nonTerminalNodeBRuleName) {
       case META_ARGUMENT_RULE_NAME: {
         const metaArgumentNodeB = nonTerminalNodeB, ///
-              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              metaArgumentNodeVerified = this.verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         metastatementNodeVerified = metaArgumentNodeVerified; ///
 
@@ -66,7 +64,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
       case STATEMENT_RULE_NAME: {
         const statementNodeB = nonTerminalNodeB,  ///
-              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+              statementNodeVerified = this.verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
         metastatementNodeVerified = statementNodeVerified;  ///
 
@@ -77,7 +75,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metastatementNodeVerified;
   }
 
-  verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetaArgumentNode(metastatementNodeA, metaArgumentNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metaArgumentNodeVerified = false;
 
     const statementNodeB = statementNodeQuery(metaArgumentNodeB),
@@ -85,7 +83,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
     if ((metavariableNodeA !== null) && (statementNodeB !== null)) {
       const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
-            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
       metaArgumentNodeVerified = metavariableNodeVerified;  ///
     }
@@ -93,14 +91,14 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metaArgumentNodeVerified;
   }
 
-  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let statementNodeVerified;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
       const substitutionNodeA = substitutionNodeQuery(metastatementNodeA),
-            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+            metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
       statementNodeVerified = metavariableNodeVerified;  ///
     } else {
@@ -110,7 +108,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             childNodesA = nonTerminalNodeAChildNodes, ///
             childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
+            childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, verifyAhead);
 
       statementNodeVerified = childNodesVerified;  ///
     }
@@ -118,7 +116,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return statementNodeVerified;
   }
 
-  verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyMetavariableNode(metavariableNodeA, substitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let metavariableNodeVerified;
 
     const substitution = substitutions.find((substitution) => {
@@ -130,8 +128,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     }) || null;
 
     if (substitution !== null) {
-      const statementNode = substitution.getStatementNode(),
-            localContextA = LocalContext.fromFileContext(fileContextA);
+      const statementNode = substitution.getStatementNode();
 
       if (substitutionNodeA !== null) {
         const substitutionNode = substitutionNodeA, ///
@@ -161,7 +158,7 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
     return metavariableNodeVerified;
   }
 
-  verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
+  verifyTermNode(termNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let termNodeVerified = false;
 
     const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
@@ -172,14 +169,13 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
 
         if (variableNodeA !== null) {
           const termNodeB = nonTerminalNodeB, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
                 variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           termNodeVerified = variableNodeVerified; ///
         } else {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
-                nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+                nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
           termNodeVerified = nonTerminalNodeVerified; ///
         }

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

@@ -64,26 +64,29 @@ class SubstitutionNodesVerifier extends NodesVerifier {
   verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let variableNodeVerified = false;
 
-    const variableNodeB = variableNodeQuery(termNodeB);
+    if (variableNodeVerified === false) {
+      const variableNodeB = variableNodeQuery(termNodeB);
 
-    if (variableNodeB !== null) {
-      const variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);
+      if (variableNodeB !== null) {
+        const variableNodeAMatchedVariableNodeB = variableNodeA.match(variableNodeB);
 
-      if (variableNodeAMatchedVariableNodeB) {
-        const verifiedAhead = verifyAhead();
+        if (variableNodeAMatchedVariableNodeB) {
+          const verifiedAhead = verifyAhead();
 
-        variableNodeVerified = verifiedAhead;
+          variableNodeVerified = verifiedAhead; ///
+        }
       }
-    } else {
-      const variableNode = variableNodeA; ///
+    }
 
-      const substitution = substitutions.find((substitution) => {
-        const matches = substitution.matchVariableNode(variableNode);
+    if (variableNodeVerified === false) {
+      const variableNode = variableNodeA,
+            substitution = substitutions.find((substitution) => {
+              const matches = substitution.matchVariableNode(variableNode);
 
-        if (matches) {
-          return true;
-        }
-      }) || null;
+              if (matches) {
+                return true;
+              }
+            }) || null;
 
       if (substitution !== null) {
         const termNode = termNodeB, ///
@@ -109,7 +112,7 @@ class SubstitutionNodesVerifier extends NodesVerifier {
           substitutions.pop();
         }
 
-        variableNodeVerified = verifiedAhead;
+        variableNodeVerified = verifiedAhead; ///
       }
     }
 

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

@@ -9,7 +9,7 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       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 contained = containedFromContainmentNode(containmentNode),

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;