occam-verify-cli 0.0.1002 → 0.0.1005

package/src/unify/qualifiedStatement.js

@@ -1,208 +0,0 @@
-"use strict";
-
-import metavariableUnifier from "../unifier/metavariable";
-import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
-
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
-
-const unifyQualifiedStatementFunctions = [
-  unifyQualifiedStatementAWithRule,
-  unifyQualifiedStatementAWithAxiom,
-  unifyQualifiedStatementAWithLemma,
-  unifyQualifiedStatementAWithTheorem,
-  unifyQualifiedStatementAWithConjecture,
-  unifyQualifiedStatementAWithReference
-];
-
-export default function unifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnified;
-
-  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
-
-  qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {
-    const qualifiedStatementUnified = unifyQualifiedStatementFunction(qualifiedStatementNode, substitutions, localContext);
-
-    return qualifiedStatementUnified;
-  });
-
-  if (qualifiedStatementUnified) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
-  }
-
-  return qualifiedStatementUnified;
-}
-
-function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithRule = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        rule = localContext.findRuleByMetavariableNode(metavariableNode);
-
-  if (rule !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
-
-    const statementUnified = rule.unifyStatement(statementNode, localContext);
-
-    qualifiedStatementUnifiedWithRule = statementUnified;  ///
-
-    if (qualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithRule;
-}
-
-function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithAxiom = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
-
-  if (axiom !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
-
-    const statementUnified = axiom.unifyStatement(statementNode, localContext);
-
-    qualifiedStatementUnifiedWithAxiom = statementUnified; ///
-
-    if (qualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithAxiom;
-}
-
-function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithLemma = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
-
-  if (lemma !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
-
-    const statementUnified = lemma.unifyStatement(statementNode, localContext);
-
-    qualifiedStatementUnifiedWithLemma = statementUnified; ///
-
-    if (qualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithLemma;
-}
-
-function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithTheorem = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
-
-  if (theorem !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
-
-    const statementUnified = theorem.unifyStatement(statementNode, localContext);
-
-    qualifiedStatementUnifiedWithTheorem = statementUnified; ///
-
-    if (qualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithTheorem;
-}
-
-function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithConjecture = false;
-
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
-
-  if (conjecture !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
-
-    const statementUnified = conjecture.unifyStatement(statementNode, localContext);
-
-    qualifiedStatementUnifiedWithConjecture = statementUnified; ///
-
-    if (qualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithConjecture;
-}
-
-function unifyQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedWithReference = false;
-
-  let metavariableNode = metavariableNodeQuery(qualifiedStatementNode);
-
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-  if (metavariable !== null) {
-    const statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementString = localContext.nodeAsString(statementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode);
-
-    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
-
-    const metavariableNodeA = metavariableNode; ///
-
-    metavariableNode = metavariable.getNode();
-
-    const metavariableNodeB = metavariableNode; ///
-
-    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-
-    if (unified) {
-      metavariableNode = metavariableNodeA; ///
-
-      const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
-            substitution = statementForMetavariableSubstitution, ///
-            localContextA = localContext, ///
-            localContextB = localContext; ///
-
-      substitutions.addSubstitution(substitution, localContextA, localContextB);
-
-      qualifiedStatementUnifiedWithReference = true;
-    }
-
-    if (qualifiedStatementUnifiedWithReference) {
-      localContext.debug(`...unified the '${statementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
-    }
-  }
-
-  return qualifiedStatementUnifiedWithReference;
-}

package/src/unify/statementWithBracketedCombinator.js

@@ -1,22 +0,0 @@
-"use strict";
-
-import bracketedCombinator from "../ocmbinator/bracketed";
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
-
-export default function unifyStatementWithBracketedCombinator(statementNode, assignments, stated, localContext) {
-  let statementUnifiedWithBracketedCombinator;
-
-  const statementString = localContext.nodeAsString(statementNode);
-
-  localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`, statementNode);
-
-  const bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode();
-
-  statementUnifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, bracketedCombinatorStatementNode, assignments, stated, localContext);
-
-  if (statementUnifiedWithBracketedCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`, statementNode);
-  }
-
-  return statementUnifiedWithBracketedCombinator;
-}

package/src/unify/statementWithCombinator.js

@@ -1,22 +0,0 @@
-"use strict";
-
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
-
-export default function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext) {
-  let statementUnifiedWithCombinator;
-
-  const statementString = localContext.nodeAsString(statementNode),
-        combinatorString = combinator.getString();
-
-  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
-
-  const combinatorStatementNode = combinator.getStatementNode();
-
-  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, stated, localContext);
-
-  if (statementUnifiedWithCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
-  }
-
-  return statementUnifiedWithCombinator;
-}

package/src/unify/statementWithCombinators.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import unifyStatementWithCombinator from "../unify/statementWithCombinator";
-
-export default function unifyStatementWithCombinators(statementNode, assignments, stated, localContext) {
-  let statementUnifiedWithCombinators;
-
-  const combinators = localContext.getCombinators();
-
-  assignments = null; ///
-
-  stated = true;  ///
-
-  statementUnifiedWithCombinators = combinators.some((combinator) => {
-    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext);
-
-    if (statementUnifiedWithCombinator) {
-      return true;
-    }
-  });
-
-  return statementUnifiedWithCombinators;
-}

package/src/unify/statementWithMetaType.js

@@ -1,14 +0,0 @@
-"use strict";
-
-import verifyStatementGivenMetaType from "../verify/statementGivenMetaType";
-
-export default function unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, stated, localContext) {
-  let statementUnifiedWithMetaType;
-
-  const metaType = localContext.findMetaTypeByMetaTypeNode(metaTypeNode),
-        statementVerifiedGivenMetaType = verifyStatementGivenMetaType(statementNode, metaType, assignments, stated, localContext);
-
-  statementUnifiedWithMetaType = statementVerifiedGivenMetaType;  ///
-
-  return statementUnifiedWithMetaType;
-}

package/src/verify/conclusion.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import Conclusion from "../conclusion";
-import verifyStatement from "../verify/statement";
-
-import { nodeQuery } from "../utilities/query";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/conclusion/unqualifiedStatement!");
-
-export default function verifyConclusion(conclusionNode, conclusions, localContext) {
-  let conclusionVerified = false;
-
-  const conclusionString = localContext.nodeAsString(conclusionNode);
-
-  localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const stated = true,
-          assignments = null,
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const conclusion = Conclusion.fromStatementNode(statementNode);
-
-      conclusions.push(conclusion);
-
-      conclusionVerified = true;
-    }
-  }
-
-  if (conclusionVerified) {
-    localContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
-  }
-
-  return conclusionVerified;
-}

package/src/verify/derivation.js

@@ -1,23 +0,0 @@
-"use strict";
-
-import verifyProofStep from "../verify/proofStep";
-
-import { nodesQuery } from "../utilities/query";
-
-const proofStepNodesQuery = nodesQuery("/derivation/proofStep|lastProofStep");
-
-export default function verifyDerivation(derivationNode, substitutions, localContext) {
-  let derivationVerified;
-
-  const proofStepNodes = proofStepNodesQuery(derivationNode);
-
-  derivationVerified = proofStepNodes.every((proofStepNode) => {
-    const proofStepVerified = verifyProofStep(proofStepNode, substitutions, localContext);
-
-    if (proofStepVerified) {
-      return true;
-    }
-  });
-
-  return derivationVerified;
-}

package/src/verify/label.js

@@ -1,34 +0,0 @@
-"use strict";
-
-import Label from "../label";
-
-import { nodeQuery } from "../utilities/query";
-
-const metavariableNodeQuery = nodeQuery("/label/metavariable!");
-
-export default function verifyLabel(labelNode, labels, fileContext) {
-  let labelVerified = false;
-
-  const labelString = fileContext.nodeAsString(labelNode);
-
-  fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
-
-  const metavariableNode = metavariableNodeQuery(labelNode),
-        labelPresent = fileContext.isLabelPresentByMetavariableNode(metavariableNode);
-
-  if (labelPresent) {
-    fileContext.debug(`The '${labelString}' label is already present.`, labelNode);
-  } else {
-    const label = Label.fromMetavariableNode(metavariableNode);
-
-    labels.push(label);
-
-    labelVerified = true;
-  }
-
-  if (labelVerified) {
-    fileContext.debug(`...verified the '${labelString}' label.`, labelNode);
-  }
-
-  return labelVerified;
-}

package/src/verify/labels.js

@@ -1,17 +0,0 @@
-"use strict";
-
-import verifyLabel from "../verify/label";
-
-export default function verifyLabels(labelNodes, labels, fileContext) {
-  let labelsVerified;
-
-  labelsVerified = labelNodes.every((labelNode) => {
-    const labelVerified = verifyLabel(labelNode, labels, fileContext);
-
-    if (labelVerified) {
-      return true;
-    }
-  });
-
-  return labelsVerified;
-}

package/src/verify/premise.js

@@ -1,49 +0,0 @@
-"use strict";
-
-import Premise from "../premise";
-import ProofStep from "../proofStep";
-import verifyStatement from "../verify/statement";
-
-import { nodeQuery } from "../utilities/query";
-import { assignAssignments } from "../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/premise/unqualifiedStatement!");
-
-export default function verifyPremise(premiseNode, premises, localContext) {
-  let premiseVerified;
-
-  const premiseString = localContext.nodeAsString(premiseNode);
-
-  localContext.trace(`Verifying the '${premiseString}' premise...`, premiseNode);
-
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(premiseNode);
-
-  if (unqualifiedStatementNode !== null) {
-    const stated = true,
-          assignments = [],
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-      if (assignmentsAssigned) {
-        const premise = Premise.fromStatementNode(statementNode),
-              proofStep = ProofStep.fromStatementNode(statementNode);
-
-        premises.push(premise);
-
-        localContext.addProofStep(proofStep);
-
-        premiseVerified = true;
-      }
-    }
-  }
-
-  if (premiseVerified) {
-    localContext.debug(`...verified the '${premiseString}' premise.`, premiseNode);
-  }
-
-  return premiseVerified;
-}

package/src/verify/premises.js

@@ -1,17 +0,0 @@
-"use strict";
-
-import verifyPremise from "../verify/premise";
-
-export default function verifyPremises(premiseNodes, premises, localContext) {
-  let premisesVerified;
-
-  premisesVerified = premiseNodes.every((premiseNode) => {
-    const premiseVerified = verifyPremise(premiseNode, premises, localContext);
-
-    if (premiseVerified) {
-      return true;
-    }
-  });
-
-  return premisesVerified;
-}

package/src/verify/proof.js

@@ -1,31 +0,0 @@
-"use strict";
-
-import LocalContext from "../context/local";
-import verifyDerivation from "../verify/derivation";
-
-import { nodeQuery } from "../utilities/query";
-
-const derivationNodeQuery = nodeQuery("/proof/derivation!");
-
-export default function verifyProof(proofNode, statementNode, substitutions, localContext) {
-  let proofVerified = false;
-
-  localContext = LocalContext.fromLocalContext(localContext); ///
-
-  const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, substitutions, localContext);
-
-  if (derivationVerified) {
-    const lastProofStep = localContext.getLastProofStep();
-
-    if (lastProofStep !== null) {
-      const lastProofStepStatementNode = lastProofStep.getStatementNode(),
-            lastStatementNode = lastProofStepStatementNode, ///
-            statementNodeMatchesLastStatementNode = statementNode.match(lastStatementNode);
-
-      proofVerified = statementNodeMatchesLastStatementNode;  ///
-    }
-  }
-
-  return proofVerified;
-}

package/src/verify/rule.js

@@ -1,71 +0,0 @@
-"use strict";
-
-import Rule from "../rule";
-import verifyProof from "../verify/proof";
-import LocalContext from "../context/local";
-import verifyLabels from "../verify/labels";
-import verifyPremises from "../verify/premises";
-import verifyConclusion from "../verify/conclusion";
-
-import { first } from "../utilities/array";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import Substitutions from "../substitutions";
-
-const proofNodeQuery = nodeQuery("/rule/proof!"),
-      labelNodesQuery = nodesQuery("/rule/label"),
-      premisesNodeQuery = nodesQuery("/rule/premise"),
-      conclusionNodeQuery = nodeQuery("/rule/conclusion!");
-
-export default function verifyRule(ruleNode, fileContext) {
-  let ruleVerified = false;
-
-  const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = fileContext.nodesAsString(labelNodes);
-
-  fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
-
-  const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
-
-  if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext),
-          premises = [],
-          premiseNodes = premisesNodeQuery(ruleNode),
-          premisesVerified = verifyPremises(premiseNodes, premises, localContext);
-
-    if (premisesVerified) {
-      const conclusions = [],
-            conclusionNode = conclusionNodeQuery(ruleNode),
-            conclusionVerified = verifyConclusion(conclusionNode, conclusions, localContext);
-
-      if (conclusionVerified) {
-        let proofVerified = true; ///
-
-        const firstConclusion = first(conclusions),
-              proofNode = proofNodeQuery(ruleNode),
-              conclusion = firstConclusion; ///
-
-        if (proofNode !== null) {
-          const substitutions = Substitutions.fromNothing(),
-                statementNode = conclusion.getStatementNode();
-
-          proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
-        }
-
-        if (proofVerified) {
-          const rule = Rule.fromLabelsPremisesConclusionAndFileContext(labels, premises, conclusion, fileContext);
-
-          fileContext.addRule(rule);
-
-          ruleVerified = true;
-        }
-      }
-    }
-  }
-
-  if (ruleVerified) {
-    fileContext.debug(`...verified the '${labelsString}' rule.`, ruleNode);
-  }
-
-  return ruleVerified;
-}

package/src/verify/statement/qualified.js

@@ -1,40 +0,0 @@
-"use strict";
-
-import verifyStatement from "../../verify/statement";
-import unifyQualifiedStatement from "../../unify/qualifiedStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { assignAssignments } from "../../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
-
-export default function verifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementVerified = false;
-
-  const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
-
-  localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
-
-  if (!qualifiedStatementVerified) {
-    const stated = true,
-          assignments = [],
-          statementNode = statementNodeQuery(qualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const qualifiedStatementUnified = unifyQualifiedStatement(qualifiedStatementNode, substitutions, localContext);
-
-      if (qualifiedStatementUnified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        qualifiedStatementVerified = assignmentsAssigned; ///
-      }
-    }
-  }
-
-  if (qualifiedStatementVerified) {
-    localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
-  }
-
-  return qualifiedStatementVerified;
-}

package/src/verify/statement/unqualified.js

@@ -1,49 +0,0 @@
-"use strict";
-
-import verifyStatement from "../../verify/statement";
-import unifyUnqualifiedStatement from "../../unify/unqualifiedStatement";
-
-import { nodeQuery } from "../../utilities/query";
-import { assignAssignments } from "../../utilities/assignments";
-
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
-
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, localContext) {
-  let unqualifiedStatementVerified = false;
-
-  const unqualifiedStatementString = localContext.nodeAsString(unqualifiedStatementNode);
-
-  localContext.trace(`Verifying the '${unqualifiedStatementString}' unqualified statement...`, unqualifiedStatementNode);
-
-  if (!unqualifiedStatementVerified) {
-    const stated = false,
-          assignments = [],
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-      unqualifiedStatementVerified = assignmentsAssigned;  ///
-    }
-  }
-
-  if (!unqualifiedStatementVerified) {
-    const stated = true,
-          assignments = null,
-          statementNode = statementNodeQuery(unqualifiedStatementNode),
-          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-    if (statementVerified) {
-      const unqualifiedStatementUnified = unifyUnqualifiedStatement(unqualifiedStatementNode, localContext);
-
-      unqualifiedStatementVerified = unqualifiedStatementUnified; ///
-    }
-  }
-
-  if (unqualifiedStatementVerified) {
-    localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`, unqualifiedStatementNode);
-  }
-
-  return unqualifiedStatementVerified;
-}