occam-verify-cli 0.0.910 → 0.0.911

package/src/frame.js

@@ -37,7 +37,7 @@ export default class Frame {
   }
 
   matchSubstitution(substitution) {
-    const substitutionMatches = this.declarations.some((declaration) => {
+    const matchesSubstitution = this.declarations.some((declaration) => {
       const declarationMatchesSubstitution = declaration.matchSubstitution(substitution);
 
       if (declarationMatchesSubstitution) {
@@ -45,12 +45,12 @@ export default class Frame {
       }
     });
 
-    return substitutionMatches;
+    return matchesSubstitution;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          metaLemmaOrMetaTheoremMatches = substitutions.every((substitution) => {
+          matchesMetaLemmaOrMetaTheorem = substitutions.every((substitution) => {
             const frameMatchesSubstitution = this.matchSubstitution(substitution);
 
             if (frameMatchesSubstitution) {
@@ -58,7 +58,7 @@ export default class Frame {
             }
           });
 
-    return metaLemmaOrMetaTheoremMatches;
+    return matchesMetaLemmaOrMetaTheorem;
   }
 
   static fromDeclarations(declarations) {

package/src/frameAssertion.js

@@ -22,9 +22,9 @@ export default class FrameAssertion {
   getDeclarations() { return this.frame.getDeclarations(); }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }

package/src/metaConsequent.js

@@ -21,7 +21,7 @@ export default class MetaConsequent {
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -35,10 +35,10 @@ export default class MetaConsequent {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/metaLemmaMetatheorem.js

@@ -53,7 +53,7 @@ export default class MetaLemmaMetatheorem {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
+    const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
 
       if (labelMatchesMetavariableNode) {
@@ -61,7 +61,7 @@ export default class MetaLemmaMetatheorem {
       }
     });
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   toJSON(tokens) {
@@ -160,29 +160,29 @@ function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions,
 }
 
 function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext) {
-  let suppositionMatches = false;
+  let matchesMetaSupposition = false;
 
   const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
         metastatementNode = metaproofStep.getMetastatementNode();
 
   if (metaSubproofNode !== null) {
-    const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-    suppositionMatches - metaSubProofMatches; ///
+    matchesMetaSupposition - metaSuppositionMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-    suppositionMatches - metastatementMatches; ///
+    matchesMetaSupposition - metaSuppositionMatchesMetastatementNode; ///
   }
 
-  return suppositionMatches;
+  return matchesMetaSupposition;
 }
 
 function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
-        metaConsequentMatches = nonTerminalNodeMatches; ///
+  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+        metaConsequentMatches = metaConsequentMatchesMetastatementNode; ///
 
   return metaConsequentMatches;
 }

package/src/metaSupposition.js

@@ -28,7 +28,7 @@ export default class MetaSupposition {
   }
 
   matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
-    let metaSubproofNodeMatches = false;
+    let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -42,7 +42,7 @@ export default class MetaSupposition {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -61,11 +61,11 @@ export default class MetaSupposition {
       }
     }
 
-    return metaSubproofNodeMatches;
+    return matchesMetaSubproofNode;
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -79,10 +79,10 @@ export default class MetaSupposition {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/metaType.js

@@ -25,23 +25,23 @@ export default class MetaType {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchMetaTypeName(metaTypeName) {
-    const metaTypeNameMatches = (this.name === metaTypeName);
+    const matchesMetaTypeName = (this.name === metaTypeName);
 
-    return metaTypeNameMatches;
+    return matchesMetaTypeName;
   }
 
   matchMetaTypeNode(metaTypeNode) {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          metaTypeNameMatches = this.matchMetaTypeName(metaTypeName),
-          metaTypeNodeMatches = metaTypeNameMatches;  ///
+          matchesMetaTypeName = this.matchMetaTypeName(metaTypeName),
+          matchesMetaTypeNode = matchesMetaTypeName;  ///
 
-    return metaTypeNodeMatches;
+    return matchesMetaTypeNode;
   }
 
   asString(tokens) {

package/src/metavariable.js

@@ -37,13 +37,13 @@ export default class Metavariable {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchNode(node, localMetaContext) {
-    let nodeMatches = false;
+    let matchesNode = false;
 
     const metavariableNode = node,  ///
           typeNode = typeNodeQuery(metavariableNode);
@@ -57,16 +57,16 @@ export default class Metavariable {
         if (false) {
           ///
         } else if ((termNode === null) && (this.termType === null)) {
-          nodeMatches = true;
+          matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
           const termVerifiedAgainstTermType = verifyTermAgainstTermType(termNode, this.termType, localMetaContext);
 
-          nodeMatches = termVerifiedAgainstTermType;  ///
+          matchesNode = termVerifiedAgainstTermType;  ///
         }
       }
     }
 
-    return nodeMatches;
+    return matchesNode;
   }
 
   toJSON(tokens) {

package/src/mixins/nodesVerifier/intrinsiclevel.js

@@ -18,9 +18,9 @@ function verifyVariableNode(variableNodeA, termNodeB, substitutions, localContex
 
   if (substitution !== null) {
     const termNode = termNodeB, ///
-          termNodeMatches = substitution.matchTermNode(termNode);
+          substitutionMatchesTermNode = substitution.matchTermNode(termNode);
 
-    if (termNodeMatches) {
+    if (substitutionMatchesTermNode) {
       const verifiedAhead = verifyAhead();
 
       variableNodeVerified = verifiedAhead;  ///

package/src/mixins/nodesVerifier/metaLevel.js

@@ -15,9 +15,9 @@ function verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitut
 
   if (substitution !== null) {
     const metastatementNode = metastatementNodeB, ///
-          metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
+          substitutionMetastatementNode = substitution.matchMetastatementNode(metastatementNode);
 
-    metavariableNodeVerified = metastatementNodeMatches;  ///
+    metavariableNodeVerified = substitutionMetastatementNode;  ///
   } else {
     const metavariableNode = metavariableNodeA, ///
           metastatementNode = metastatementNodeB, ///

package/src/premise.js

@@ -34,7 +34,7 @@ export default class Premise {
   }
 
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
-    let statementNodeMatches = false;
+    let matchesStatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -48,14 +48,14 @@ export default class Premise {
               return verifiedAhead;
             });
 
-      statementNodeMatches = nonTerminalNodeVerified; ///
+      matchesStatementNode = nonTerminalNodeVerified; ///
     }
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
-    let subproofNodeMatches = false;
+    let matchesSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -69,7 +69,7 @@ export default class Premise {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        subproofNodeMatches = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+        matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
@@ -88,11 +88,11 @@ export default class Premise {
       }
     }
 
-    return subproofNodeMatches;
+    return matchesSubproofNode;
   }
 
   matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext) {
-    let ruleSubproofNodeMatches = false;
+    let matchesRuleSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -106,7 +106,7 @@ export default class Premise {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        ruleSubproofNodeMatches = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -125,11 +125,11 @@ export default class Premise {
       }
     }
 
-    return ruleSubproofNodeMatches;
+    return matchesRuleSubproofNode;
   }
 
   matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
-    let metaSubproofNodeMatches = false;
+    let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
@@ -143,7 +143,7 @@ export default class Premise {
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -162,11 +162,11 @@ export default class Premise {
       }
     }
 
-    return metaSubproofNodeMatches;
+    return matchesMetaSubproofNode;
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -180,10 +180,10 @@ export default class Premise {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/rule.js

@@ -31,7 +31,7 @@ export default class Rule {
   }
 
   matchStatement(statementNode, localContext) {
-    let statementNatches = false;
+    let matchesStatement = false;
 
     const proofSteps = localContext.getProofSteps(),
           substitutions = [],
@@ -40,14 +40,14 @@ export default class Rule {
     if (premisesMatch) {
       const conclusionMatches = matchConclusion(this.conclusion, statementNode, substitutions, this.fileContext, localContext);
 
-      statementNatches = conclusionMatches;  ///
+      matchesStatement = conclusionMatches;  ///
     }
 
-    return statementNatches;
+    return matchesStatement;
   }
 
   matchMetastatement(metastatementNode, localMetaContext) {
-    let metastatementNatches = false;
+    let matchesMetastatement = false;
 
     const metaproofSteps = localMetaContext.getMetaproofSteps(),
           substitutions = [],
@@ -56,14 +56,14 @@ export default class Rule {
     if (premisesMatch) {
       const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localMetaContext);
 
-      metastatementNatches = conclusionMatches;  ///
+      matchesMetastatement = conclusionMatches;  ///
     }
 
-    return metastatementNatches;
+    return matchesMetastatement;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
+    const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
 
       if (labelMatchesMetavariableNode) {
@@ -71,7 +71,7 @@ export default class Rule {
       }
     });
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   toJSON(tokens) {
@@ -150,15 +150,15 @@ function matchPremise(premise, proofStep, substitutions, fileContext, localConte
         statementNode = proofStep.getStatementNode();
 
   if (subproofNode !== null) {
-    const subproofNodeMatches = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
+    const premiseMatchesSubproofNode = premise.matchSubproofNode(subproofNode, substitutions, fileContext, localContext);
 
-    premiseMatches = subproofNodeMatches; ///
+    premiseMatches = premiseMatchesSubproofNode; ///
   }
 
   if (statementNode !== null) {
-    const statementNodeMatches = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
+    const premiseMatchesStatementNode = premise.matchStatementNode(statementNode, substitutions, fileContext, localContext);
 
-    premiseMatches = statementNodeMatches;  ///
+    premiseMatches = premiseMatchesStatementNode;  ///
   }
 
   return premiseMatches;
@@ -181,8 +181,8 @@ function matchPremises(premises, proofSteps, substitutions, fileContext, localCo
 }
 
 function matchConclusion(conclusion, statementNode, substitutions, fileContext, localContext) {
-  const statementNodeMatches = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
-        conclusionMatches = statementNodeMatches; ///
+  const conclusionMatchesStatementNode = conclusion.matchStatementNode(statementNode, substitutions, fileContext, localContext),
+        conclusionMatches = conclusionMatchesStatementNode; ///
 
   return conclusionMatches;
 }
@@ -195,21 +195,21 @@ function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, lo
         metastatementNode = metaproofStep.getMetastatementNode()
 
   if (ruleSubproofNode !== null) {
-    const ruleSubProofNodeMatches = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = ruleSubProofNodeMatches; ///
+    premiseMatches = premiseMatchesRuleSubproofNode; ///
   }
 
   if (metaSubproofNode !== null) {
-    const metaSubProofNodeMatches = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = metaSubProofNodeMatches; ///
+    premiseMatches = premiseMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const metastatementNodeMatches = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-    premiseMatches = metastatementNodeMatches;  ///
+    premiseMatches = premiseMatchesMetastatementNode;  ///
   }
 
   return premiseMatches;
@@ -232,8 +232,8 @@ function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext,
 }
 
 function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const metastatementNodeMatches = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
-        conclusionMatches = metastatementNodeMatches; ///
+  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+        conclusionMatches = conclusionMatchesMetastatementNode; ///
 
   return conclusionMatches;
 }

package/src/step/metaproof.js

@@ -24,14 +24,14 @@ export default class MetaproofStep {
     return this.metastatementNode;
   }
 
-  matchMetastatement(metastatementNode) {
-    let matches = false;
+  matchMetastatementNode(metastatementNode) {
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
-      matches = this.metastatementNode.match(metastatementNode);
+      matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
     }
 
-    return matches;
+    return matchesMetastatementNode;
   }
 
   static fromStatementNode(statementNode) {

package/src/step/proof.js

@@ -14,14 +14,14 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  matchStatement(statementNode) {
-    let matches = false;
+  matchStatementNode(statementNode) {
+    let matchesStatementNode = false;
 
     if (this.statementNode !== null) {
-      matches = this.statementNode.match(statementNode);
+      matchesStatementNode = this.statementNode.match(statementNode);
     }
 
-    return matches;
+    return matchesStatementNode;
   }
 
   static fromSubproofNode(subproofNode) {

package/src/substitution/metastatementForMetavariable.js

@@ -23,27 +23,27 @@ export default class MetastatementForMetavariableSubstitution extends Substituti
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetastatementNode(metastatementNode) {
-    let metastatementNodeMatches;
+    let matchesMetastatementNode;
 
-    metastatementNodeMatches = this.metastatementNode.match(metastatementNode)
+    matchesMetastatementNode = this.metastatementNode.match(metastatementNode)
 
-    if (!metastatementNodeMatches) {
+    if (!matchesMetastatementNode) {
       const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
       if (bracketedMetastatementChildNode !== null) {
         const metastatementNode = bracketedMetastatementChildNode; ///
 
-        metastatementNodeMatches = this.metastatementNode.match(metastatementNode);
+        matchesMetastatementNode = this.metastatementNode.match(metastatementNode);
       }
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/substitution/statementForMetavariable.js

@@ -50,9 +50,9 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
@@ -102,7 +102,9 @@ function matchStatementNode(statementNodeA, statementNodeB, substitution, substi
   let statementNodeMatches;
 
   if (substitution === null) {
-    statementNodeMatches = statementNodeB.match(statementNodeA);
+    const statementNodeAMatchesStatementNodeB = statementNodeB.match(statementNodeA);
+
+    statementNodeMatches = statementNodeAMatchesStatementNodeB; ///
   } else {
     const statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 

package/src/substitution/termForVariable.js

@@ -34,15 +34,15 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   matchTermNode(termNode) {
-    const termNodeMatches = this.termNode.match(termNode);
+    const matchesTermNode = this.termNode.match(termNode);
 
-    return termNodeMatches;
+    return matchesTermNode;
   }
 
   matchVariableNode(variableNode) {
-    const variableNodeMatches = this.variableNode.match(variableNode);
+    const matchesVariableNode = this.variableNode.match(variableNode);
 
-    return variableNodeMatches;
+    return matchesVariableNode;
   }
 
   static fromSubstitutionNode(substitutionNode) {
@@ -91,9 +91,9 @@ function substituteTermNode(termNode, substitutions) {
 
   if (termVariableNode !== null) {
     substitutions.some((substitution) => {
-      const variableNodeMatches = substitution.matchVariableNode(termVariableNode);
+      const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
-      if (variableNodeMatches) {
+      if (substitutionMatchesVariableNode) {
         termNode = substitution.getTermNode();  ///
 
         return true;
@@ -106,9 +106,9 @@ function substituteTermNode(termNode, substitutions) {
 
 function substituteVariableNode(variableNode, substitutions) {
   substitutions.some((substitution) => {
-    const variableNodeMatches = substitution.matchVariableNode(variableNode);
+    const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
-    if (variableNodeMatches) {
+    if (substitutionMatchesVariableNode) {
       const termNode = substitution.getTermNode(),
             termVariableNode = variableNodeQuery(termNode);