occam-verify-cli 0.0.845 → 0.0.847

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;

package/src/verify/statement.js

@@ -17,12 +17,12 @@ const equalityNodeQuery = nodeQuery("/statement/equality!"),
       metaArgumentNodeQuery = nodeQuery("/statement/metaArgument!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-function verifyStatement(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatement(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerified;
 
-  const statementString = context.nodeAsString(statementNode);
+  const statementString = localContext.nodeAsString(statementNode);
 
-  context.trace(`Verifying the '${statementString}' statement...`, statementNode);
+  localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
   const verifyStatementFunctions = [
     verifyStatementAsEquality,
@@ -33,7 +33,7 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
   ];
 
   statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
-    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
 
     if (statementVerified) {
       return true;
@@ -41,27 +41,27 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
   });
 
   if (statementVerified) {
-    context.debug(`...verified the '${statementString}' statement.`, statementNode);
+    localContext.debug(`...verified the '${statementString}' statement.`, statementNode);
   }
 
   return statementVerified;
 }
 
-export function verifyStandaloneStatement(statementNode, context, verifyAhead) {
+export function verifyStandaloneStatement(statementNode, localContext, verifyAhead) {
   let standaloneStatementVerified;
 
-  const statementString = context.nodeAsString(statementNode);
+  const statementString = localContext.nodeAsString(statementNode);
 
-  context.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
+  localContext.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
 
   const derived = false,
         assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived, context, verifyAhead);
+        statementVerified = verifyStatement(statementNode, assignments, derived, localContext, verifyAhead);
 
   standaloneStatementVerified = statementVerified;  ///
 
   if (standaloneStatementVerified) {
-    context.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
+    localContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
   }
 
   return standaloneStatementVerified;
@@ -73,86 +73,86 @@ Object.assign(statementAgainstCombinatorNodesVerifier, {
 
 export default verifyStatement;
 
-function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatementAsEquality(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsEquality = false;
 
   const equalityNode = equalityNodeQuery(statementNode);
 
   if (equalityNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, localContext, verifyAhead);
 
     statementVerifiedAsEquality = equalityVerified; ///
 
     if (statementVerifiedAsEquality) {
-      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
     }
   }
 
   return statementVerifiedAsEquality;
 }
 
-function verifyStatementAboutDefining(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatementAboutDefining(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAboutDefining = false;
 
   const definingNode = definingNodeQuery(statementNode);
 
   if (definingNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    context.trace(`Verifying the '${statementString}' statement about defining...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement about defining...`, statementNode);
 
     const argumentNode = argumentNodeQuery(statementNode),
-          definingVerified = verifyDefining(argumentNode, definingNode, context);
+          definingVerified = verifyDefining(argumentNode, definingNode, localContext);
 
     statementVerifiedAboutDefining = definingVerified; ///
 
     if (statementVerifiedAboutDefining) {
-      context.debug(`...verified the '${statementString}' statement about defining.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement about defining.`, statementNode);
     }
   }
 
   return statementVerifiedAboutDefining;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    context.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
 
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext, verifyAhead);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
 
     if (statementVerifiedAsTypeAssertion) {
-      context.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
     }
   }
 
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAboutContainment(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatementAboutContainment(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAboutContainment = false;
 
   const containmentNode = containmentNodeQuery(statementNode);
 
   if (containmentNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    context.trace(`Verifying the '${statementString}' statement about containment...`, statementNode);
+    localContext.trace(`Verifying the '${statementString}' statement about containment...`, statementNode);
 
     const argumentNode = argumentNodeQuery(statementNode),
           metaArgumentNode = metaArgumentNodeQuery(statementNode),
-          containmentVerified = verifyContainment(argumentNode, containmentNode, metaArgumentNode, context);
+          containmentVerified = verifyContainment(argumentNode, containmentNode, metaArgumentNode, localContext);
 
     if (containmentVerified) {
       statementNode = statementNodeQuery(metaArgumentNode); ///
@@ -165,7 +165,7 @@ function verifyStatementAboutContainment(statementNode, assignments, derived, co
       const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
         const derived = false,
               assignments = [],
-              statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
+              statementVerified = verifyStatementFunction(statementNode, assignments, derived, localContext, verifyAhead);
 
         if (statementVerified) {
           return true;
@@ -176,36 +176,36 @@ function verifyStatementAboutContainment(statementNode, assignments, derived, co
     }
 
     if (statementVerifiedAboutContainment) {
-      context.debug(`...verified the '${statementString}' statement about containment.`, statementNode);
+      localContext.debug(`...verified the '${statementString}' statement about containment.`, statementNode);
     }
   }
 
   return statementVerifiedAboutContainment;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
+function verifyStatementAgainstCombinator(statementNode, combinator, localContext, verifyAhead) {
   let statementVerifiedAgainstCombinator;
 
-  const statementString = context.nodeAsString(statementNode),
+  const statementString = localContext.nodeAsString(statementNode),
         combinatorString = combinator.getString();
 
-  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+  localContext.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
 
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode, ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementAgainstCombinatorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+        nonTerminalNodeVerified = statementAgainstCombinatorNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
   statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
 
   if (statementVerifiedAgainstCombinator) {
-    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+    localContext.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
   }
 
   return statementVerifiedAgainstCombinator;
 }
 
-function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
+function verifyStatementAgainstCombinators(statementNode, assignments, derived, localContext, verifyAhead) {
   let statementVerifiedAgainstCombinators = false;
 
   const equalityNode = equalityNodeQuery(statementNode),
@@ -214,7 +214,7 @@ function verifyStatementAgainstCombinators(statementNode, assignments, derived,
         typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if ((equalityNode === null) && (definingNode === null) && (containmentNode === null) && (typeAssertionNode === null)) {
-    let combinators = context.getCombinators();
+    let combinators = localContext.getCombinators();
 
     combinators = [ ///
       bracketedCombinator,
@@ -222,7 +222,7 @@ function verifyStatementAgainstCombinators(statementNode, assignments, derived,
     ];
 
     statementVerifiedAgainstCombinators = combinators.some((combinator) => {
-      const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
+      const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, localContext, verifyAhead);
 
       if (statementVerifiedAgainstCombinator) {
         return true;

package/src/verify/statementAsCombinator.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Combinator from "../combinator";
+import LocalContext from "../context/local";
 import statementAsCombinatorNodeVerifier from "../verifier/node/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {

package/src/verify/term.js

@@ -11,12 +11,12 @@ import { nodeQuery } from "../utilities/query";
 const termNodeQuery = nodeQuery("/term/argument/term"),
       variableNodeQuery = nodeQuery("/term/variable!");
 
-function verifyTerm(termNode, terms, context, verifyAhead) {
+function verifyTerm(termNode, terms, localContext, verifyAhead) {
   let termVerified;
 
-  const termString = context.nodeAsString(termNode);
+  const termString = localContext.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term...`, termNode);
+  localContext.trace(`Verifying the '${termString}' term...`, termNode);
 
   const verifyTermFunctions = [
     verifyTermAsVariable,
@@ -25,7 +25,7 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   ];
 
   termVerified = verifyTermFunctions.some((verifyTermFunction) => {
-    const termVerified = verifyTermFunction(termNode, terms, context, verifyAhead);
+    const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);
 
     if (termVerified) {
       return true;
@@ -33,26 +33,26 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   });
 
   if (termVerified) {
-    context.debug(`...verified the '${termString}' term.`, termNode);
+    localContext.debug(`...verified the '${termString}' term.`, termNode);
   }
 
   return termVerified;
 }
 
-export function verifyStandaloneTerm(termNode, context, verifyAhead) {
+export function verifyStandaloneTerm(termNode, localContext, verifyAhead) {
   let standaloneTermVerified;
 
-  const termString = context.nodeAsString(termNode);
+  const termString = localContext.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' standalone term...`, termNode);
+  localContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
 
   const terms = [],
-        termVerified = verifyTerm(termNode, terms, context, verifyAhead);
+        termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
 
   standaloneTermVerified = termVerified;  ///
 
   if (standaloneTermVerified) {
-    context.debug(`...verified the '${termString}' standalone term.`, termNode);
+    localContext.debug(`...verified the '${termString}' standalone term.`, termNode);
   }
 
   return standaloneTermVerified;
@@ -64,18 +64,18 @@ Object.assign(termAgainstConstructorNodesVerifier, {
 
 export default verifyTerm;
 
-function verifyTermAsVariable(termNode, terms, context, verifyAhead) {
+function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
-    const termString = context.nodeAsString(termNode);
+    const termString = localContext.nodeAsString(termNode);
 
-    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
     const variables = [],
-          givenVariableVerified = verifyGivenVariable(variableNode, variables, context, () => {
+          givenVariableVerified = verifyGivenVariable(variableNode, variables, localContext, () => {
             let verifiedAhead;
 
             const firstVariable = first(variables),
@@ -97,25 +97,25 @@ function verifyTermAsVariable(termNode, terms, context, verifyAhead) {
     termVerifiedAsVariable = givenVariableVerified;  ///
 
     if (termVerifiedAsVariable) {
-      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
+      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);
     }
   }
 
   return termVerifiedAsVariable;
 }
 
-function verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead) {
+function verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
   let termVerifiedAgainstConstructor;
 
-  const termString = context.nodeAsString(termNode),
+  const termString = localContext.nodeAsString(termNode),
         constructorString = constructor.getString();
 
-  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
+  localContext.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
   const constructorTermNode = constructor.getTermNode(),
         nonTerminalNNdeA = termNode,  ///
         nonTerminalNodeB = constructorTermNode,  ///
-        nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
+        nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
           let verifiedAhead;
 
           const type = constructor.getType(),
@@ -135,22 +135,22 @@ function verifyTermAgainstConstructor(termNode, terms, constructor, context, ver
   termVerifiedAgainstConstructor = nodeVerified;  ///
 
   if (termVerifiedAgainstConstructor) {
-    context.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+    localContext.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
   }
 
   return termVerifiedAgainstConstructor;
 }
 
-function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
+function verifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
   let termVerifiedAgainstConstructors = false;
 
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode === null) {
-    const constructors = context.getConstructors();
+    const constructors = localContext.getConstructors();
 
     termVerifiedAgainstConstructors = constructors.some((constructor) => {
-      const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+      const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);
 
       if (termVerifiedAgainstConstructor) {
         return true;
@@ -161,18 +161,18 @@ function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
   return termVerifiedAgainstConstructors;
 }
 
-function verifyTermAgainstBracketedConstructor(termNode, terms, context, verifyAhead) {
+function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {
   let termVerifiedAgainstBracketedConstructor;
 
-  const termString = context.nodeAsString(termNode),
+  const termString = localContext.nodeAsString(termNode),
         bracketedConstructorString = bracketedConstructor.getString();
 
-  context.trace(`Verifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
+  localContext.trace(`Verifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
 
   const bracketedConstructorTermNode = bracketedConstructor.getTermNode(),
         nonTerminalNNdeA = termNode,  ///
         nonTerminalNodeB = bracketedConstructorTermNode,  ///
-        nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
+        nodeVerified = termAgainstConstructorNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
           let verifiedAhead;
 
           const bracketedTermNode = termNode; ///
@@ -184,7 +184,7 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, context, verifyA
           } else {
             let type;
 
-            verifyTerm(termNode, terms, context, () => {
+            verifyTerm(termNode, terms, localContext, () => {
               let verifiedAhead;
 
               const firstTerm = first(terms),
@@ -218,7 +218,7 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, context, verifyA
   termVerifiedAgainstBracketedConstructor = nodeVerified;  ///
 
   if (termVerifiedAgainstBracketedConstructor) {
-    context.debug(`...verified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
+    localContext.debug(`...verified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
   }
 
   return termVerifiedAgainstBracketedConstructor;

package/src/verify/termAndGivenType.js

@@ -3,18 +3,18 @@
 import verifyTerm from "../verify/term";
 import verifyGivenType from "../verify/givenType";
 
-export default function verifyTermAndGivenType(termNode, typeNode, terms, types, context, verifyAhead) {
+export default function verifyTermAndGivenType(termNode, typeNode, terms, types, localContext, verifyAhead) {
   let termAndGivenTypeVerified;
 
-  const termString = context.nodeAsString(termNode),
-        typeString = context.nodeAsString(typeNode);
+  const termString = localContext.nodeAsString(termNode),
+        typeString = localContext.nodeAsString(typeNode);
 
-  context.trace(`Verifying the '${termString}' term and the given '${typeString}' type...`, termNode);
+  localContext.trace(`Verifying the '${termString}' term and the given '${typeString}' type...`, termNode);
 
-  const termVerified = verifyTerm(termNode, terms, context, () => {
+  const termVerified = verifyTerm(termNode, terms, localContext, () => {
           let verifiedAhead;
 
-          const givenTypeVerified = verifyGivenType(typeNode, types, context, () => {
+          const givenTypeVerified = verifyGivenType(typeNode, types, localContext, () => {
             let verifiedAhead;
 
             verifiedAhead = verifyAhead();
@@ -30,7 +30,7 @@ export default function verifyTermAndGivenType(termNode, typeNode, terms, types,
   termAndGivenTypeVerified = termVerified; ///
 
   if (termAndGivenTypeVerified) {
-    context.debug(`...verified the '${termString}' term and the given '${typeString}' type.`, termNode);
+    localContext.debug(`...verified the '${termString}' term and the given '${typeString}' type.`, termNode);
   }
 
   return termAndGivenTypeVerified

package/src/verify/termAsConstructor.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import Constructor from "../constructor";
+import LocalContext from "../context/local";
 import termAsConstructorNodeVerifier from "../verifier/node/termAsConstructor";
 
 import { typeNameFromTypeNode } from "../utilities/query";
@@ -14,7 +15,8 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
   const nonTerminalNode = termNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+        localContext = LocalContext.fromFileContext(fileContext),
+        childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, localContext, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;

package/src/verify/terms.js

@@ -4,20 +4,20 @@ import verifyTerm from "../verify/term";
 
 import { first, second } from "../utilities/array";
 
-export default function verifyTerms(termNodes, terms, context, verifyAhead) {
+export default function verifyTerms(termNodes, terms, localContext, verifyAhead) {
   let termsVerified;
 
   const firstTermNode = first(termNodes),
         secondTermNode = second(termNodes),
-        firstTermString = context.nodeAsString(firstTermNode),
-        secondTermString = context.nodeAsString(secondTermNode);
+        firstTermString = localContext.nodeAsString(firstTermNode),
+        secondTermString = localContext.nodeAsString(secondTermNode);
 
-  context.trace(`Verifying the '${firstTermString}' and '${secondTermString}' terms...`, firstTermNode);
+  localContext.trace(`Verifying the '${firstTermString}' and '${secondTermString}' terms...`, firstTermNode);
 
-  const firstTermVerified = verifyTerm(firstTermNode, terms, context, () => {
+  const firstTermVerified = verifyTerm(firstTermNode, terms, localContext, () => {
           let verifiedAhead;
 
-          const secondTermVerified = verifyTerm(secondTermNode, terms, context, () => {
+          const secondTermVerified = verifyTerm(secondTermNode, terms, localContext, () => {
             let verifiedAhead;
 
             verifiedAhead = verifyAhead();
@@ -33,7 +33,7 @@ export default function verifyTerms(termNodes, terms, context, verifyAhead) {
   termsVerified = firstTermVerified; ///
 
   if (termsVerified) {
-    context.debug(`...verified the '${firstTermString}' and '${secondTermString}' terms.`, firstTermNode);
+    localContext.debug(`...verified the '${firstTermString}' and '${secondTermString}' terms.`, firstTermNode);
   }
 
   return termsVerified

package/src/verify/type.js

@@ -47,18 +47,18 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
   return typeVerified;
 }
 
-export function verifyStandaloneType(typeNode, context, verifyAhead) {
+export function verifyStandaloneType(typeNode, fileContext, verifyAhead) {
   let standaloneTypeVerified = false;
 
-  const typeString = context.nodeAsString(typeNode);
+  const typeString = fileContext.nodeAsString(typeNode);
 
-  context.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
+  fileContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
 
   const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
+        typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.debug(`The type '${typeName}' is not present.`, typeNode);
+    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
   } else {
     const verifiedAhead = verifyAhead();
 
@@ -66,7 +66,7 @@ export function verifyStandaloneType(typeNode, context, verifyAhead) {
   }
 
   if (standaloneTypeVerified) {
-    context.debug(`...verified the '${typeString}' standalone type.`, typeNode);
+    fileContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);
   }
 
   return standaloneTypeVerified;