occam-verify-cli 0.0.845 → 0.0.847

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.845",
+  "version": "0.0.847",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.742",
+    "occam-custom-grammars": "^5.0.744",
     "occam-entities": "^1.0.125",
     "occam-file-system": "^6.0.167",
     "occam-grammar-utilities": "^8.0.201",

package/src/assignment/equality.js

@@ -9,15 +9,15 @@ export default class EqualityAssignment {
     return this.equality;
   }
 
-  assign(context) {
-    const equalityAdded = context.addEquality(this.equality),
+  assign(localContext) {
+    const equalityAdded = localContext.addEquality(this.equality),
           equalityNode = this.equality.getNode(),
-          equalityString = context.nodeAsString(equalityNode),
+          equalityString = localContext.nodeAsString(equalityNode),
           equalityAssigned = equalityAdded; ///
 
     equalityAssigned ?
-      context.trace(`Assigned the '${equalityString}' equality.`, equalityNode) :
-        context.debug(`Unable to assign the '${equalityString}' equality.`, equalityNode);
+      localContext.trace(`Assigned the '${equalityString}' equality.`, equalityNode) :
+        localContext.debug(`Unable to assign the '${equalityString}' equality.`, equalityNode);
 
     return equalityAssigned;
   }

package/src/assignment/variable.js

@@ -9,17 +9,17 @@ export default class VariableAssignment {
     return this.variable;
   }
 
-  assign(context) {
-    const variableAdded = context.addVariable(this.variable),
+  assign(localContext) {
+    const variableAdded = localContext.addVariable(this.variable),
           variableNode = this.variable.getNode(),
           variableType = this.variable.getType(),
-          variableString = context.nodeAsString(variableNode),
+          variableString = localContext.nodeAsString(variableNode),
           variableTypeName = variableType.getName(),
           variableAssigned = variableAdded; ///
 
     variableAssigned ?
-      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeName}'.`, variableNode) :
-        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeName}'.`, variableNode);
+      localContext.trace(`Assigned the '${variableString}' variable with type '${variableTypeName}'.`, variableNode) :
+        localContext.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeName}'.`, variableNode);
 
     return variableAssigned;
   }

package/src/conclusion.js

@@ -15,12 +15,12 @@ export default class Conclusion {
     return this.metastatementNode;
   }
 
-  matchStatementNode(statementNode, substitutions, fileContext, statementLocalContext) {
+  matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          fileContextA = fileContext, ///
+          localContextA = localContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifyAhead = true;
 
             return verifyAhead;
@@ -30,12 +30,12 @@ export default class Conclusion {
     return statementNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
+  matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
-          fileContextA = fileContext, ///
+          localContextA = localContext, ///
           localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/context/local.js

@@ -253,6 +253,8 @@ class LocalContext {
     return variable;
   }
 
+  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
+
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
@@ -296,6 +298,16 @@ class LocalContext {
     return localContext;
   }
 
+  static fromLocalMetaContext(localMetaContext) {
+    const context = localMetaContext,  ///
+          variables = [],
+          proofSteps = [],
+          equivalences = [],
+          localContext = new LocalContext(context, variables, proofSteps, equivalences);
+
+    return localContext;
+  }
+
   static fromJSONAndFileContext(json, fileContext) {
     let { variables } = json;
 

package/src/equality.js

@@ -28,16 +28,18 @@ export default class Equality {
     return reflexive;
   }
 
-  isEqual(context) {
+  isEqual(localContext) {
     const leftTerm = this.getLeftTerm(),
           rightTerm = this.getRightTerm(),
           leftTermNode = leftTerm.getNode(),
           rightTermNode = rightTerm.getNode(),
           nonTerminalNodeA = leftTermNode,  ///
           nonTerminalNodeB = rightTermNode, ///
-          equivalences = context.getEquivalences(),
-          localContext = this,  ///
-          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, () => {
+          equivalences = localContext.getEquivalences();
+
+    localContext = this;  ///
+
+    const nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/equivalence.js

@@ -21,9 +21,9 @@ export default class Equivalence {
     this.terms.push(term);
   }
 
-  getType(context) {
+  getType(localContext) {
     const type = this.terms.reduce((type, term) => {
-      const termType = termTypeFromTerm(term, context);
+      const termType = termTypeFromTerm(term, localContext);
 
       if (type === null) {
         type = termType;  ///
@@ -41,10 +41,10 @@ export default class Equivalence {
     return type;
   }
 
-  matchType(type, context) {
+  matchType(type, localContext) {
     const typeA = type; ///
 
-    type = this.getType(context);
+    type = this.getType(localContext);
 
     const typeB = type; ///
 
@@ -107,9 +107,9 @@ export default class Equivalence {
     return termNodesMatch;
   }
 
-  getGroundedTerms(definedVariables, groundedTerms, context) {
+  getGroundedTerms(definedVariables, groundedTerms, localContext) {
     this.terms.forEach((term) => {
-      const termGrounded = term.isGrounded(definedVariables, context);
+      const termGrounded = term.isGrounded(definedVariables, localContext);
 
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
@@ -129,25 +129,25 @@ export default class Equivalence {
     });
   }
 
-  isInitiallyGrounded(context) {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
+  isInitiallyGrounded(localContext) {
+    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(localContext),
           initiallyGroundedTermsLength = initiallyGroundedTerms.length,
           initiallyGrounded = (initiallyGroundedTermsLength > 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables, context) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
+  isImplicitlyGrounded(definedVariables, localContext) {
+    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, localContext),
           implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
           implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
 
     return implicitlyGrounded;
   }
 
-  getInitiallyGroundedTerms(context) {
+  getInitiallyGroundedTerms(localContext) {
     const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded(context);
+      const termInitiallyGrounded = term.isInitiallyGrounded(localContext);
 
       if (termInitiallyGrounded) {
         const initiallyGroundedTerm = term; ///
@@ -161,9 +161,9 @@ export default class Equivalence {
     return initiallyGroundedTerms;
   }
 
-  getImplicitlyGroundedTerms(definedVariables, context) {
+  getImplicitlyGroundedTerms(definedVariables, localContext) {
     const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
+      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, localContext);
 
       if (termImplicitlyGrounded) {
         const implicitlyGroundedTerm = term; ///
@@ -200,14 +200,14 @@ export default class Equivalence {
   }
 }
 
-function termTypeFromTerm(term, context) {
+function termTypeFromTerm(term, localContext) {
   let termType;
 
   const termNode = term.getNode(),
         variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
-    const variable = context.findVariableByVariableNode(variableNode),
+    const variable = localContext.findVariableByVariableNode(variableNode),
           variableType = variable.getType();
 
     termType = variableType;  ///

package/src/mixins/nodesVerifier/intrinsiclevel.js

@@ -32,9 +32,9 @@ function verifyVariableNode(variableNodeA, termNodeB, substitutions, localContex
 
     if (variable !== null) {
       const terms = [],
-            context = localContextB, ///
             termNode = termNodeB, ///
-            termVerified = verifyTerm(termNode, terms, context, () => {
+            localContext = localContextB, ///
+            termVerified = verifyTerm(termNode, terms, localContext, () => {
               let verifiedAhead = false;
 
               const firstTerm = first(terms),

package/src/mixins/nodesVerifier/metaLevel.js

@@ -2,7 +2,7 @@
 
 import MetastatementForMetavariableSubstitution from "../../substitution/metastatementForMetavariable";
 
-function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
   let metavariableNodeVerified;
 
   const substitution = substitutions.find((substitution) => {

package/src/premise.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalContext from "./context/local";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import metaLevelToIntrinsicLevelNodesVerifier from "./verifier/nodes/metaLevelToIntrinsicLevel";
 
@@ -45,8 +46,9 @@ export default class Premise {
           const nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+                nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -66,8 +68,9 @@ export default class Premise {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -98,8 +101,9 @@ export default class Premise {
           const nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),
                 localMetaContextB = metastatementLocalMetaContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -119,8 +123,9 @@ export default class Premise {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
+          localContextA = LocalContext.fromFileContext(fileContextA),
           localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/term.js

@@ -26,12 +26,12 @@ export default class Term {
     return matches;
   }
 
-  getVariables(context) {
+  getVariables(localContext) {
     const variables = [],
           variableNodes = variableNodesQuery(this.node);
 
     variableNodes.forEach((variableNode) => {
-      const variable = context.findVariableByVariableNode(variableNode),
+      const variable = localContext.findVariableByVariableNode(variableNode),
             variablesIncludesVariable = variables.includes(variable);
 
       if (!variablesIncludesVariable) {
@@ -42,8 +42,8 @@ export default class Term {
     return variables;
   }
 
-  isGrounded(definedVariables, context) {
-    const variables = this.getVariables(context);
+  isGrounded(definedVariables, localContext) {
+    const variables = this.getVariables(localContext);
 
     filter(variables, (variable) => {
       const definedVariablesIncludesVariable = definedVariables.includes(variable);
@@ -60,16 +60,16 @@ export default class Term {
     return grounded;
   }
 
-  isInitiallyGrounded(context) {
-    const variables = this.getVariables(context),
+  isInitiallyGrounded(localContext) {
+    const variables = this.getVariables(localContext),
           variablesLength = variables.length,
           initiallyGrounded = (variablesLength === 0);
 
     return initiallyGrounded;
   }
 
-  isImplicitlyGrounded(definedVariables, context) {
-    const grounded = this.isGrounded(definedVariables, context),
+  isImplicitlyGrounded(definedVariables, localContext) {
+    const grounded = this.isGrounded(definedVariables, localContext),
           implicitlyGrounded = grounded;  ///
 
     return implicitlyGrounded;

package/src/utilities/equivalences.js

@@ -83,7 +83,7 @@ export function findEquivalenceByTerm(equivalences, term) {
   return equivalence;
 }
 
-export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context) {
+export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, localContext) {
   let groundedEquivalences,
       remainingEquivalences,
       initiallyGroundedEquivalences,
@@ -93,7 +93,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
   initiallyGroundedEquivalences = [];
 
-  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context);
+  separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext);
 
   const initiallyGroundedEquivalencesLength = initiallyGroundedEquivalences.length;
 
@@ -109,9 +109,9 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
       while (definedVariablesLength > previousDefinedVariablesLength) {
         previousDefinedVariablesLength = definedVariablesLength;  ///
 
-        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context);
+        groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext);
 
-        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context);
+        definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext);
 
         definedVariablesLength = definedVariables.length;
       }
@@ -122,7 +122,7 @@ export function groundedTermsAndDefinedVariablesFromFromEquivalences(equivalence
 
       implicitlyGroundedEquivalences = [];
 
-      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context);
+      separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext);
 
       push(groundedEquivalences, implicitlyGroundedEquivalences);
 
@@ -153,12 +153,12 @@ function findEquivalenceByTermNodes(equivalences, termNodes) {
   return equivalence;
 }
 
-function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, context) {
+function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, localContext) {
   const terms = groundedTerms,  ///
         variables = definedVariables; ///
 
   terms.forEach((term) => {
-    const termVariables = term.getVariables(context);
+    const termVariables = term.getVariables(localContext);
 
     termVariables.forEach((termVariable) => {
       const variablesIncludesTermVariable = variables.includes(termVariable);
@@ -172,9 +172,9 @@ function definedVariablesFromGroundedTerms(groundedTerms, definedVariables, cont
   });
 }
 
-function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, context) {
+function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences, localContext) {
   separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
-    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(context);
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded(localContext);
 
     if (!equivalenceInitiallyGrounded) {
       return true;
@@ -182,9 +182,9 @@ function separateInitiallyGroundedEquivalences(equivalences, remainingEquivalenc
   });
 }
 
-function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, context) {
+function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, definedVariables, localContext) {
   separate(equivalences, remainingEquivalences, implicitlyGroundedEquivalences, (equivalence) => {
-    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, context);
+    const equivalenceImplicitlyGrounded = equivalence.isImplicitlyGrounded(definedVariables, localContext);
 
     if (!equivalenceImplicitlyGrounded) {
       return true;
@@ -192,8 +192,8 @@ function separateImplicitlyGroundedEquivalences(equivalences, remainingEquivalen
   });
 }
 
-function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, context) {
+function groundedTermsFromGroundedEquivalencesAndDefinedVariables(groundedEquivalences, definedVariables, groundedTerms, localContext) {
   groundedEquivalences.forEach((groundedEquivalence) => {
-    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, context);
+    groundedEquivalence.getGroundedTerms(definedVariables, groundedTerms, localContext);
   });
 }

package/src/verifier/node/metastatement.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import LocalContext from "../../context/local";
 import NodeVerifier from "../../verifier/node";
 
 import { verifyStandaloneTerm } from "../../verify/term";
@@ -15,9 +16,8 @@ class MetastatementNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case METAVARIABLE_RULE_NAME: {
-        const context = localMetaContext, ///
-              metavariableNode = nonTerminalNode, ///
-              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, context, verifyAhead),
+        const metavariableNode = nonTerminalNode, ///
+              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
               metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
         nonTerminalNodeVerified = metavariableNodeVerified; ///
@@ -26,9 +26,8 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       case VARIABLE_RULE_NAME: {
-        const context = localMetaContext, ///
-              variableNode = nonTerminalNode, ///
-              standaloneVariableVerified = verifyStandaloneVariable(variableNode, context, verifyAhead),
+        const variableNode = nonTerminalNode, ///
+              standaloneVariableVerified = verifyStandaloneVariable(variableNode, localMetaContext, verifyAhead),
               variableNodeVerified = standaloneVariableVerified;  ///
 
         nonTerminalNodeVerified = variableNodeVerified; ///
@@ -37,9 +36,9 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
-        const context = localMetaContext, ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///

package/src/verifier/node/statementAsCombinator.js

@@ -8,16 +8,15 @@ import { verifyStandaloneStatement } from "../../verify/statement";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
       case STATEMENT_RULE_NAME: {
-        const context = fileContext,  ///
-              statementNode = nonTerminalNode, ///
-              standaloneStatementVerified = verifyStandaloneStatement(statementNode, context, verifyAhead),
+        const statementNode = nonTerminalNode, ///
+              standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
               statementNodeVerified = standaloneStatementVerified; ///
 
         nonTerminalNodeVerified = statementNodeVerified; ///
@@ -26,9 +25,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
-        const context = fileContext,  ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -37,9 +35,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TYPE_RULE_NAME: {
-        const context = fileContext,  ///
-              typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
+        const typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
               typeNodeVerified = standaloneTypeVerified;  ///
 
         nonTerminalNodeVerified = typeNodeVerified; ///
@@ -48,7 +45,7 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead); ///
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead); ///
 
         break;
       }

package/src/verifier/node/termAsConstructor.js

@@ -7,16 +7,15 @@ import { verifyStandaloneTerm } from "../../verify/term";
 import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
-  verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
       case TERM_RULE_NAME: {
-        const context = fileContext,  ///
-              termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+        const termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -25,9 +24,8 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
 
       case TYPE_RULE_NAME: {
-        const context = fileContext,  ///
-              typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
+        const typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
               typeNodeVerified = standaloneTypeVerified;  ///
 
         nonTerminalNodeVerified = typeNodeVerified; ///
@@ -36,7 +34,7 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
       }
 
       default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead);
+        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
         break;
       }

package/src/verifier/nodes/metaLevel.js

@@ -9,7 +9,7 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
@@ -22,7 +22,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
         case METASTATEMENT_RULE_NAME: {
           const metastatementNodeA = nonTerminalNodeA,  ///
                 metastatementNodeB = nonTerminalNodeB,  ///
-                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
           nonTerminalNodeVerified = metastatementNodeVerified;  ///
 
@@ -30,7 +30,7 @@ class MetaLevelNodesVerifier extends NodesVerifier {
         }
 
         default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
           break;
         }
@@ -40,19 +40,19 @@ class MetaLevelNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
+  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
     let metastatementNodeVerified;
 
     const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
       metastatementNodeVerified = metaVariableNodeVerified; ///
     } else {
       const nonTerminalNodeA = metastatementNodeA,  ///
             nonTerminalNodeB = metastatementNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
       metastatementNodeVerified = nonTerminalNodeVerified;  ///
     }