occam-verify-cli 0.0.526 → 0.0.529

package/src/utilities/metaproof.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import matcher from "../matcher";
+import bracketedMetastatementNode from "../node/metastatement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_METASTATEMENT_DEPTH } from "../constants";
+
+const bracketedMetastatementChildNodeQuery = nodeQuery('/metastatement/metastatement!');
+
+export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
+  let metastatementMatchesModuloBrackets = false;
+
+  if (!metastatementMatchesModuloBrackets) {
+    const nodeA = metastatementNodeA,  ///
+          nodeB = metastatementNodeB,  ///
+          nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    metastatementMatchesModuloBrackets = nodeMatches;  ///
+  }
+
+  if (!metastatementMatchesModuloBrackets) {
+    const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
+
+    if (bracketedMetastatementChildNodeA !== null) {
+      const nodeA = bracketedMetastatementChildNodeA,  ///
+            nodeB = metastatementNodeB, ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      metastatementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  if (!metastatementMatchesModuloBrackets) {
+    const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
+
+    if (bracketedMetastatementChildNodeB !== null) {
+      const nodeA = metastatementNodeA, ///
+            nodeB = bracketedMetastatementChildNodeB,  ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      metastatementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  return metastatementMatchesModuloBrackets;
+}
+
+export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {
+  let bracketedMetastatementChildNode = null;
+
+  const nodeA = metastatementNode,  ///
+        nodeB = bracketedMetastatementNode,  ///
+        depth = BRACKETED_METASTATEMENT_DEPTH,
+        nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+  if (nonTerminalNodeMatches) {
+    bracketedMetastatementChildNode = bracketedMetastatementChildNodeQuery(metastatementNode);
+  }
+
+  return bracketedMetastatementChildNode;
+}

package/src/utilities/node.js

@@ -0,0 +1,73 @@
+"use strict";
+
+import { rewriteNodes } from "occam-grammar-utilities";
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+
+import { nodeQuery } from "../utilities/query";
+import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME } from "../ruleNames";
+
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
+
+const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+
+const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
+      florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+      florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+
+const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
+      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
+
+export function termNodeFromTermString(termString, lexer, parser) {
+  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
+        content = `Constructor ${termString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        constructorDeclarationNode = node, ///
+        termNode = termNodeQuery(constructorDeclarationNode);
+
+  return termNode;
+}
+
+export function labelNodeFromLabelString(labelString, lexer, parser) {
+  const content = labelString, ///
+        ruleName = LABEL_RULE_NAME,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        labelNode = node; ///
+
+  return labelNode;
+}
+
+export function statementNodeFromStatementString(statementString, lexer, parser) {
+  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        content = `${statementString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        unqualifiedStatementNode = node,  ///
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
+  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
+        content = `${metastatementString}
+`,
+        node = nodeFromContentAndRuleName(content, ruleName, lexer, parser),
+        unqualifiedMetastatementNode = node,  ///
+        metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
+
+  return metastatementNode;
+}
+
+function nodeFromContentAndRuleName(content, ruleName, lexer = florenceLexer, parser = florenceParser) {
+  const ruleMap = parser.getRuleMap(),
+        rule = ruleMap[ruleName],
+        tokens = lexer.tokenise(content),
+        node = parser.parse(tokens, rule);
+
+  rewriteNodes(node);
+
+  return node;
+}

package/src/utilities/proof.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import matcher from "../matcher";
+import bracketedStatementNode from "../node/statement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_STATEMENT_DEPTH } from "../constants";
+
+const bracketedStatementChildNodeQuery = nodeQuery('/statement/metaArgument!/statement!');
+
+export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
+  let statementMatchesModuloBrackets = false;
+
+  if (!statementMatchesModuloBrackets) {
+    const nodeA = statementNodeA,  ///
+          nodeB = statementNodeB,  ///
+          nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    statementMatchesModuloBrackets = nonTerminalNodeMatches;  ///
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeA = bracketedStatementChildNodeFromStatementNode(statementNodeA);
+
+    if (bracketedStatementChildNodeA !== null) {
+      const nodeA = bracketedStatementChildNodeA,  ///
+            nodeB = statementNodeB, ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      statementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeB = bracketedStatementChildNodeFromStatementNode(statementNodeB);
+
+    if (bracketedStatementChildNodeB !== null) {
+      const nodeA = statementNodeA, ///
+            nodeB = bracketedStatementChildNodeB,  ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      statementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  return statementMatchesModuloBrackets;
+}
+
+export function bracketedStatementChildNodeFromStatementNode(statementNode) {
+  let bracketedStatementChildNode = null;
+
+  const nodeA = statementNode,  ///
+        nodeB = bracketedStatementNode,  ///
+        depth = BRACKETED_STATEMENT_DEPTH,
+        nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+  if (nonTerminalNodeMatches) {
+    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+  }
+
+  return bracketedStatementChildNode;
+}

package/src/utilities/releaseContext.js

@@ -35,7 +35,7 @@ export function createReleaseContext(dependency, dependentNames, context, callba
 
     error = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext);
 
-    if (error !== null)  {
+    if (error) {
       callback(error);
 
       return;
@@ -47,19 +47,25 @@ export function createReleaseContext(dependency, dependentNames, context, callba
   }, context);
 }
 
-export function initialiseReleaseContext(dependency, dependentName, verified, context) {
+export function initialiseReleaseContext(dependency, dependentName, verified, context, callback) {
+  let error = null;
+
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
         releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext === null) {
+    callback(error);
+
     return;
   }
 
   const initialised = releaseContext.isInitialised();
 
   if (initialised) {
+    callback(error);
+
     return;
   }
 
@@ -67,27 +73,39 @@ export function initialiseReleaseContext(dependency, dependentName, verified, co
 
   if (verified) {
     if (!releaseContextVerified) {
-      const { log } = context;
+      error = `Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`;
 
-      log.error(`Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`);
+      callback(error);
 
       return;
     }
   }
 
-  verified = releaseContextVerified;  ///
-
   dependentName = releaseName;  ///
 
+  verified = releaseContextVerified;  ///
+
   const dependencies = releaseContext.getDependencies();
 
-  dependencies.forEachDependency((dependency) => {
-    initialiseReleaseContext(dependency, dependentName, verified, context);
-  });
+  dependencies.asynchronousForEachDependency((dependency, next, done) => {
+    initialiseReleaseContext(dependency, dependentName, verified, context, (error) => {
+      if (error) {
+        callback(error);
 
-  const dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependency, context);
+        return;
+      }
 
-  releaseContext.initialise(dependencyReleaseContexts);
+      next();
+    });
+  }, done);
+
+  function done() {
+    const dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependency, context);
+
+    releaseContext.initialise(dependencyReleaseContexts);
+
+    callback(error);
+  }
 }
 
 export default {
@@ -153,7 +171,7 @@ function createDependencyReleaseContexts(dependency, dependentNames, context, ca
   dependencies.asynchronousForEachDependency((dependency, next, done) => {
     const error = checkCyclicDependencyExists(dependency, dependentNames);
 
-    if (error !== null) {
+    if (error) {
       callback(error);
 
       return;

package/src/utilities/string.js

@@ -1,12 +1,6 @@
 "use strict";
 
-import { nodeQuery } from "../utilities/query";
 import { COMMA, EMPTY_STRING } from "../constants";
-import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
-
-const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export function nodeAsString(node, tokens) {
   let string = null;
@@ -51,56 +45,13 @@ export function nodesAsString(nodes, tokens) {
   const string = nodes.reduce((string, node) => {
     const nodeString = nodeAsString(node, tokens);
 
-    if (string === null) {
-      string = nodeString;  ///
-    } else {
-      string = `${string}${COMMA}${nodeString}`;
-    }
+    string = (string === EMPTY_STRING) ?
+               nodeString :
+                `${string}${COMMA}${nodeString}`;
 
     return string;
-  }, null);
+  }, EMPTY_STRING);
 
   return string;
 }
 
-export function termNodeFromTermString(termString, releaseContext) {
-  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
-        content = `Constructor ${termString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        constructorDeclarationNode = node, ///
-        termNode = termNodeQuery(constructorDeclarationNode);
-
-  return termNode;
-}
-
-export function labelNodeFromLabelString(labelString, releaseContext) {
-  const content = labelString, ///
-        ruleName = LABEL_RULE_NAME,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        labelNode = node; ///
-
-  return labelNode;
-}
-
-export function statementNodeFromStatementString(statementString, releaseContext) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        content = `${statementString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        unqualifiedStatementNode = node,  ///
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-  return statementNode;
-}
-
-export function metastatementNodeFromMetastatementString(metastatementString, releaseContext) {
-  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
-        content = `${metastatementString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        unqualifiedMetastatementNode = node,  ///
-        metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-  return metastatementNode;
-}

package/src/variable.js

@@ -1,10 +1,9 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name, termNode) {
+  constructor(type, name) {
     this.type = type;
     this.name = name;
-    this.termNode = termNode;
   }
 
   getType() {
@@ -15,53 +14,21 @@ export default class Variable {
     return this.name;
   }
 
-  getTermNode() {
-    return this.termNode;
-  }
-
-  setTermNode(termNode) {
-    this.termNode = termNode;
-  }
-
   matchName(name) {
     const matchesName = (this.name === name);
 
     return matchesName;
   }
 
-  isEqualTo(variable) {
-    let equalTo = false;
-
-    if (variable === this) {
-      equalTo = true;
-    } else {
-      const termNode = variable.getTermNode();
-
-      if (termNode === this.termNode) {
-        equalTo = true;
-      }
-    }
-
-    return equalTo;
-  }
-
   asString(tokens) {
-    let string;
-
-    if (this.type === null) {
-      string = this.name;
-    } else {
-      const typeName = this.type.getName();
-
-      string = `${this.name}:${typeName}`;
-    }
+    const typeName = this.type.getName(),
+          string = `${this.name}:${typeName}`;
 
     return string;
   }
 
   static fromTypeAndName(type, name) {
-    const termNode = null,
-          variable = new Variable(type, name, termNode);
+    const variable = new Variable(type, name);
 
     return variable;
   }

package/src/verifier/metastatementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableVerifier from "../../verifier/metastatementForMetavariable";
+
+class ConclusionMetastatementForMetavariableVerifier extends MetastatementForMetavariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const conclusionMetastatementForMetavariableVerifier = new ConclusionMetastatementForMetavariableVerifier();

package/src/verifier/metastatementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableVerifier from "../../verifier/metastatementForMetavariable";
+
+class PremiseMetastatementForMetavariableVerifier extends MetastatementForMetavariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const premiseMetastatementForMetavariableVerifier = new PremiseMetastatementForMetavariableVerifier();

package/src/verifier/metastatementForMetavariable.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import Verifier from "../verifier";
+import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+
+import { nodeQuery } from "../utilities/query";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+
+const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
+
+export default class MetastatementForMetavariableVerifier extends Verifier {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      const nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+            nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === METASTATEMENT_RULE_NAME);
+
+      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+        const metastatementNodeA = nonTerminalNodeA,  ///
+              metastatementNodeB = nonTerminalNodeB,  ///
+              metastatementNodeMatches = this.matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+
+        if (metastatementNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        }
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
+    let metastatementNodeMatches = false;
+
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+
+      metastatementNodeMatches = metaVariableNodeMatches; ///
+    }
+
+    return metastatementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const metastatementNode = metastatementNodeB, ///
+            substitutionNodesMatch = substitution.matchMetastatementNode(metastatementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              metastatementNode = metastatementNodeB, ///
+              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode),
+              substitution = metastatementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/verifier/statementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableVerifier from "../../verifier/statementForMetavariable";
+
+class ConclusionStatementForMetavariableVerifier extends StatementForMetavariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const conclusionStatementForMetavariableVerifier = new ConclusionStatementForMetavariableVerifier();

package/src/verifier/statementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableVerifier from "../../verifier/statementForMetavariable";
+
+class PremiseStatementForMetavariableVerifier extends StatementForMetavariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const premiseStatementForMetavariableVerifier = new PremiseStatementForMetavariableVerifier();

package/src/verifier/statementForMetavariable.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import Verifier from "../verifier";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
+
+const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
+      metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
+
+export default class StatementForMetavariableVerifier extends Verifier {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);
+
+    if (nonTerminalNodeBRuleNameMetaArgumentRuleName) {
+      const metaArgumentNodeB = nonTerminalNodeB, ///
+            metaArgumentChildNodeB = metaArgumentChildNodeNodeQuery(metaArgumentNodeB);
+
+      nonTerminalNodeB = metaArgumentChildNodeB;  ///
+
+      nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    } else {
+      const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+            nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+            nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+            nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
+        const metastatementNodeA = nonTerminalNodeA,  ///
+              statementNodeB = nonTerminalNodeB,  ///
+              statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+
+        if (statementNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+                nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+                nodesA = nonTerminalNodeAChildNodes, ///
+                nodesB = nonTerminalNodeBChildNodes, ///
+                nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+
+          nonTerminalNodeMatches = nodesMatch;  ///
+        }
+      } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
+    let statementNodeMatches = false;
+
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const metavariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
+
+      statementNodeMatches = metavariableNodeMatches; ///
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const statementNode = statementNodeB, ///
+            substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              statementNode = statementNodeB, ///
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
+              substitution = statementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/verifier/termForVariable/consequence.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableVerifier from "../../verifier/termForVariable";
+
+class ConsequenceTermForVariableVerifier extends TermForVariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const consequenceTermForVariableVerifier = new ConsequenceTermForVariableVerifier();