occam-verify-cli 0.0.922 → 0.0.924

package/src/verify/metaproofStep.js

@@ -1,137 +0,0 @@
-"use strict";
-
-import MetaproofStep from "../step/metaproof";
-import verifyMetaSubproof from "../verify/metaSubproof";
-import verifyMetaSubDerivation from "../verify/metaSubDerivation";
-import verifyQualifiedStatement from "../verify/statement/qualified";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
-import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
-
-import { nodeQuery } from "../utilities/query";
-import { assignAssignment } from "../utilities/assignments";
-
-const metaSubproofNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/metaSubproof!"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
-      qualifiedStatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/qualifiedStatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/unqualifiedStatement!"),
-      qualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/qualifiedMetastatement!"),
-      unqualifiedMetastatementNodeQuery = nodeQuery("/metaproofStep|lastMetaproofStep/unqualifiedMetastatement!");
-
-export default function verifyMetaproofStep(metaproofStepNode, substitutions, localContext) {
-  let metaproofStepVerified = false;
-
-  const metaSubproofNode = metaSubproofNodeQuery(metaproofStepNode),
-        qualifiedStatementNode = qualifiedStatementNodeQuery(metaproofStepNode),
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(metaproofStepNode),
-        qualifiedMetastatementNode = qualifiedMetastatementNodeQuery(metaproofStepNode),
-        unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(metaproofStepNode);
-
-  if (false) {
-    ///
-  } else if (metaSubproofNode !== null) {
-    let metaSubproofVerified;
-
-    metaSubproofVerified = verifyMetaSubproof(metaSubproofNode, substitutions, localContext);
-
-    if (metaSubproofVerified) {
-      const metaproofStep = MetaproofStep.fromMetaSubproofNode(metaSubproofNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  } else if (qualifiedStatementNode !== null) {
-    let qualifiedStatementVerified;
-
-    const assignments = [];  ///
-
-    qualifiedStatementVerified = verifyQualifiedStatement(qualifiedStatementNode, assignments, localContext);
-
-    if (qualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      qualifiedStatementVerified = assignmentAssigned; ///
-    }
-
-    if (qualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(qualifiedStatementNode),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  } else if (unqualifiedStatementNode !== null) {
-    let unqualifiedStatementVerified;
-
-    const derived = true,
-          assignments = [];
-
-    unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
-
-    if (unqualifiedStatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      unqualifiedStatementVerified = assignmentAssigned; ///
-    }
-
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            metaproofStep = MetaproofStep.fromStatementNode(statementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = unqualifiedStatementVerified; ///
-    }
-  } else if (qualifiedMetastatementNode !== null) {
-    let qualifiedMetastatementVerified;
-
-    const assignments = [];
-
-    qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext);
-
-    if (qualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      qualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (qualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = qualifiedMetastatementVerified; ///
-    }
-  } else if (unqualifiedMetastatementNode !== null) {
-    let unqualifiedMetastatementVerified;
-
-    const derived = true,
-          assignments = [];
-
-    unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext);
-
-    if (unqualifiedMetastatementVerified) {
-      const assignmentAssigned = assignAssignment(assignments, localContext);
-
-      unqualifiedMetastatementVerified = assignmentAssigned; ///
-    }
-
-    if (unqualifiedMetastatementVerified) {
-      const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-            metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
-
-      localContext.addMetaproofStep(metaproofStep);
-
-      metaproofStepVerified = true;
-    }
-  }
-
-  return metaproofStepVerified;
-}
-
-Object.assign(verifyMetaSubDerivation, {
-  verifyMetaproofStep
-});

package/src/verify/metastatement/qualified.js

@@ -1,130 +0,0 @@
-"use strict";
-
-import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
-
-import { nodeQuery } from "../../utilities/query";
-
-const metavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
-
-export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, substitutions, assignments, localContext) {
-  let qualifiedMetastatementVerified;
-
-  const qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
-
-  localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
-
-  const metavariableNode = metavariableNodeQuery(qualifiedMetastatementNode),
-        verifyQualifiedMetastatementFunctions = [
-          verifyQualifiedMetastatementAAgainstRule,
-          verifyQualifiedMetastatementAAgainstReference
-        ];
-
-  qualifiedMetastatementVerified = verifyQualifiedMetastatementFunctions.some((verifyQualifiedMetastatementFunction) => {  ///
-    const qualifiedMetastatementVerified = verifyQualifiedMetastatementFunction(qualifiedMetastatementNode, metavariableNode, substitutions, localContext);
-
-    if (qualifiedMetastatementVerified) {
-      return true;
-    }
-  });
-
-  if (qualifiedMetastatementVerified) {
-    const derived = false,
-          metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-          metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext, () => {
-            const verifiedAhead = true;
-
-            return verifiedAhead;
-          });
-
-    qualifiedMetastatementVerified = metastatementVerified; ///
-  }
-
-  if (qualifiedMetastatementVerified) {
-    localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
-  }
-
-  return qualifiedMetastatementVerified;
-}
-
-function verifyQualifiedMetastatementAAgainstRule(qualifiedMetastatementNode, metavariableNode, substitutions, localContext) {
-  let qualifiedMetastatementVerifiedAgainstRule = false;
-
-  const rule = localContext.findRuleByMetavariableNode(metavariableNode);
-
-  if (rule !== null) {
-    const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
-
-    localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule...`, qualifiedMetastatementNode);
-
-    const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, localContext);
-
-    qualifiedMetastatementVerifiedAgainstRule = ruleMatchesMetastatement;  ///
-
-    if (qualifiedMetastatementVerifiedAgainstRule) {
-      localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' rule.`, qualifiedMetastatementNode);
-    }
-  }
-
-  return qualifiedMetastatementVerifiedAgainstRule;
-}
-
-function verifyQualifiedMetastatementAAgainstReference(qualifiedMetastatementNode, metavariableNode, substitutions, localContext) {
-  let qualifiedMetastatementVerifiedAgainstReference = false;
-
-  if (substitutions !== null) {
-    const metavariableString = localContext.nodeAsString(metavariableNode),
-          metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode, localContext),
-          qualifiedMetastatementString = localContext.nodeAsString(qualifiedMetastatementNode);
-
-    localContext.trace(`Verifying the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference...`, qualifiedMetastatementNode);
-
-    if (metavariablePresent) {
-      const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
-            metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      qualifiedMetastatementVerifiedAgainstReference = metavariableVerifiedAgainstMetastatement; ///
-    }
-
-    if (qualifiedMetastatementVerifiedAgainstReference) {
-      localContext.debug(`...verified the '${qualifiedMetastatementString}' qualified metastatement against the '${metavariableString}' reference.`, qualifiedMetastatementNode);
-    }
-  }
-
-  return qualifiedMetastatementVerifiedAgainstReference;
-}
-
-function verifyMetastatement(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerified;
-
-  const metastatementString = localContext.nodeAsString(metastatementNode);
-
-  localContext.trace(`Verifying the '${metastatementString}' metastatement...`, metastatementNode);
-
-  const verifyMetaStatementFunctions = [
-    ///
-  ];
-
-  verifyMetaStatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, assignments, derived, localContext);
-
-    if (metastatementVerified) {
-      return true;
-    }
-  });
-
-  metastatementVerified = true; ///
-
-  if (metastatementVerified) {
-    localContext.debug(`...verified the '${metastatementString}' metastatement.`, metastatementNode);
-  }
-
-  return metastatementVerified;
-}
-

package/src/verify/metastatement/unqualified.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import verifyMetastatement from "../../verify/metastatement";
-
-import { nodeQuery } from "../../utilities/query";
-
-const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
-
-export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assignments, derived, localContext) {
-  let unqualifiedMetastatementVerified = false;
-
-  const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
-        unqualifiedMetastatementString = localContext.nodeAsString(unqualifiedMetastatementNode);
-
-  localContext.trace(`Verifying the '${unqualifiedMetastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
-
-  if (derived) {
-    const matchesMetastatementNode = localContext.matchMetastatementNode(metastatementNode);
-
-    unqualifiedMetastatementVerified = matchesMetastatementNode;  ///
-  }
-
-  if (!unqualifiedMetastatementVerified) {
-    const metastatementVerified = verifyMetastatement(metastatementNode, assignments, derived, localContext);
-
-    unqualifiedMetastatementVerified = metastatementVerified; ///
-  }
-
-  if (unqualifiedMetastatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedMetastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
-  }
-
-  return unqualifiedMetastatementVerified;
-}

package/src/verify/metastatementAsContainedAssertion.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-
-import { CONTAINED } from "../constants";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { isMetastatementNegated } from "../utilities/verify";
-
-const termNodeQuery = nodeQuery("/metastatement/term!"),
-      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator"),
-      metastatementTermNodesQuery = nodesQuery("/metastatement/metastatement//term");
-
-export default function verifyMetastatementAsContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsContainedAssertion;
-
-  const metastatementContainedAssertion = isMetastatementContainedAssertion(metastatementNode);
-
-  if (metastatementContainedAssertion) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const metastatementFunctions = [
-      verifyMetastatementAsDerivedContainedAssertion,
-      verifyMetastatementAsStatedContainedAssertion
-    ];
-
-    metastatementVerifiedAsContainedAssertion = metastatementFunctions.some((metastatementFunction) => {
-      const metastatementVerifiedAsContainedAssertion = metastatementFunction(metastatementNode, assignments, derived, localContext);
-
-      if (metastatementVerifiedAsContainedAssertion) {
-        return true;
-      }
-    });
-
-    if (metastatementVerifiedAsContainedAssertion) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsContainedAssertion;
-}
-
-function verifyMetastatementAsDerivedContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsDefinedContainedAssertion = false;
-
-  if (derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const metastatementNegated = isMetastatementNegated(metastatementNode),
-          negated = metastatementNegated,
-          termNode = termNodeQuery(metastatementNode),
-          metastatementTermNodes = metastatementTermNodesQuery(metastatementNode),
-          termNodeMatchesMetaArgumentTermNode = metastatementTermNodes.some((metastatementTermNode) => {
-            const termNodeMatchesMetaArgumentTermNode = termNode.match(metastatementTermNode);
-
-            if (termNodeMatchesMetaArgumentTermNode) {
-              return true;
-            }
-          });
-
-    if (!negated) {
-      if (termNodeMatchesMetaArgumentTermNode) {
-        metastatementVerifiedAsDefinedContainedAssertion = true;
-      }
-    }
-
-    if (negated) {
-      if (!termNodeMatchesMetaArgumentTermNode) {
-        metastatementVerifiedAsDefinedContainedAssertion = true;
-      }
-    }
-
-    if (metastatementVerifiedAsDefinedContainedAssertion) {
-      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsDefinedContainedAssertion;
-}
-
-function verifyMetastatementAsStatedContainedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsStatedContainedAssertion = false;
-
-  if (!derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a contained assertion...`, metastatementNode);
-
-    const intrinsicLevel = localContext.isIntrinsicLevel();
-
-    if (intrinsicLevel) {
-      localContext.debug(`The stated '${metastatementString}' metastatement as a contained assertion cannot be verified at intrinsic level.`, metastatementNode);
-    } else {
-      const nonTerminalNode = metastatementNode, ///
-            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      metastatementVerifiedAsStatedContainedAssertion = nonTerminalNodeVerified; ///
-    }
-
-    if (metastatementVerifiedAsStatedContainedAssertion) {
-      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a contained assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsStatedContainedAssertion;
-}
-
-export function isMetastatementContainedAssertion(metastatementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
-        metastatementContainedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentContained = (content === CONTAINED);
-
-          if (contentContained) {
-            return true;
-          }
-        });
-
-  return metastatementContainedAssertion;
-}

package/src/verify/metastatementAsDefinedAssertion.js

@@ -1,156 +0,0 @@
-"use strict";
-
-import verifyTerm from "./term";
-import metaLevelNodeVerifier from "../verifier/node/metaLevel";
-
-import { first } from "../utilities/array";
-import { DEFINED } from "../constants";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { isMetastatementNegated } from "../utilities/verify";
-
-const termNodeQuery = nodeQuery("/metastatement/term!"),
-      variableNodeQuery = nodeQuery("/metastatement/term/variable!"),
-      operatorTerminalNodesQuery = nodesQuery("/metastatement/@operator");
-
-export default function verifyMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
-  let metastatementVerifiedAsDefinedAssertion = false;
-
-  const metastatementDefinedAssertion = isMetastatementDefinedAssertion(metastatementNode);
-
-  if (metastatementDefinedAssertion) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
-
-    const definedAssertionFunctions = [
-      verifyDerivedMetastatementAsDefinedAssertion,
-      verifyStatedMetastatementAsDefinedAssertion
-    ];
-
-    metastatementVerifiedAsDefinedAssertion = definedAssertionFunctions.some((definedAssertionFunction) => {
-      const metastatementVerifiedAsDefinedAssertion = definedAssertionFunction(metastatementNode, assignments, derived, localContext);
-
-      if (metastatementVerifiedAsDefinedAssertion) {
-        return true;
-      }
-    });
-
-    if (metastatementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
-    }
-  }
-
-  return metastatementVerifiedAsDefinedAssertion;
-}
-
-function verifyDerivedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
-  let derivedMetastatementVerifiedAsDefeindAssertion = false;
-
-  if (derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the derived '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
-
-    const metastatementNegated = isMetastatementNegated(metastatementNode),
-          variableNode = variableNodeQuery(metastatementNode),
-          termNode = termNodeQuery(metastatementNode);
-
-    if (false) {
-      ///
-    } else if (variableNode !== null) {
-      const variable = localContext.findVariableByVariableNode(variableNode);
-
-      if (variable !== null) {
-        const variableDefined = localContext.isVariableDefined(variable);
-
-        if (!metastatementNegated) {
-          if (variableDefined) {
-            derivedMetastatementVerifiedAsDefeindAssertion = true;
-          }
-        }
-
-        if (metastatementNegated) {
-          if (!variableDefined) {
-            derivedMetastatementVerifiedAsDefeindAssertion = true;
-          }
-        }
-      }
-    } else if (termNode !== null) {
-      const terms = [],
-            termVerified = verifyTerm(termNode, terms, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      if (termVerified) {
-        const firstTerm = first(terms),
-              term = firstTerm, ///
-              termGrounded = localContext.isTermGrounded(term);
-
-        if (!metastatementNegated) {
-          if (termGrounded) {
-            derivedMetastatementVerifiedAsDefeindAssertion = true;
-          }
-        }
-
-        if (metastatementNegated) {
-          if (!termGrounded) {
-            derivedMetastatementVerifiedAsDefeindAssertion = true;
-          }
-        }
-      }
-    }
-
-    if (derivedMetastatementVerifiedAsDefeindAssertion) {
-      localContext.debug(`...verified the derived '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
-    }
-  }
-
-  return derivedMetastatementVerifiedAsDefeindAssertion;
-}
-
-function verifyStatedMetastatementAsDefinedAssertion(metastatementNode, assignments, derived, localContext) {
-  let statedMetastatementVerifiedAsDefinedAssertion = false;
-
-  if (!derived) {
-    const metastatementString = localContext.nodeAsString(metastatementNode);
-
-    localContext.trace(`Verifying the stated '${metastatementString}' metastatement as a defined assertion...`, metastatementNode);
-
-    const intrinsicLevel = localContext.isIntrinsicLevel();
-
-    if (intrinsicLevel) {
-      localContext.debug(`The stated '${metastatementString}' metastatement as a defined assertion cannot be verified at intrinsic level.`, metastatementNode);
-    } else {
-      const nonTerminalNode = metastatementNode, ///
-            nonTerminalNodeVerified = metaLevelNodeVerifier.verifyNonTerminalNode(nonTerminalNode, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      statedMetastatementVerifiedAsDefinedAssertion = nonTerminalNodeVerified; ///
-    }
-
-    if (statedMetastatementVerifiedAsDefinedAssertion) {
-      localContext.debug(`...verified the stated '${metastatementString}' metastatement as a defined assertion.`, metastatementNode);
-    }
-  }
-
-  return statedMetastatementVerifiedAsDefinedAssertion;
-}
-
-export function isMetastatementDefinedAssertion(metastatementNode) {
-  const operatorTerminalNodes = operatorTerminalNodesQuery(metastatementNode),
-        metastatementDefinedAssertion = operatorTerminalNodes.some((operatorTerminalNode) => {
-          const content = operatorTerminalNode.getContent(),
-                contentDefined = (content === DEFINED);
-
-          if (contentDefined) {
-            return true;
-          }
-        });
-
-  return metastatementDefinedAssertion;
-}

package/src/verify/metavariableAgainstMetastatement.js

@@ -1,42 +0,0 @@
-"use strict";
-
-import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
-
-export default function verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, verifyAhead) {
-  let metavariableVerifiedAgainstMetastatement = false;
-
-  const substitution = substitutions.find((substitution) => {
-    const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNode);
-
-    if (substitutionMatchesMetavariableNodeA) {
-      return true;
-    }
-  }) || null;
-
-  if (substitution !== null) {
-    const metastatementNodeMatches = substitution.matchMetastatementNode(metastatementNode);
-
-    if (metastatementNodeMatches) {
-      const verifiedAhead = verifyAhead();
-
-      metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
-    }
-  } else {
-    let verifiedAhead;
-
-    const metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-          substitution = metastatementForMetavariableSubstitution;  ///
-
-    substitutions.push(substitution);
-
-    verifiedAhead = verifyAhead();
-
-    if (!verifiedAhead) {
-      substitutions.pop();
-    }
-
-    metavariableVerifiedAgainstMetastatement = verifiedAhead; ///
-  }
-
-  return metavariableVerifiedAgainstMetastatement;
-}