occam-verify-cli 0.0.1067 → 0.0.1069

package/src/unify/simpleSubstitutionStatementWithComplexSubstitutionStatement.js

@@ -1,27 +0,0 @@
-"use strict";
-
-import metaLevelUnifier from "../unifier/metaLevel";
-
-export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(simpleSubstitutionStatementNode, complexSubstitutionStatementNode, substitutions, localContextA, localContextB) {
-  let simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement;
-
-  const simpleSubstitutionStatementString = localContextB.nodeAsString(simpleSubstitutionStatementNode),
-        complexSubstitutionStatementString = localContextB.nodeAsString(complexSubstitutionStatementNode);
-
-  localContextB.trace(`Unifying the simple substitution's '${simpleSubstitutionStatementString}' statement with the complex substitution's '${complexSubstitutionStatementString}' statement...`, simpleSubstitutionStatementNode);
-
-  const nodeA = complexSubstitutionStatementNode,  ///
-        nodeB = simpleSubstitutionStatementNode;  ///
-
-  localContextA = localContextB;  ///
-
-  const unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-  simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement = unifiedAtMetaLevel;  ///
-
-  if (simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement) {
-    localContextB.trace(`...unified the simple substitution's '${simpleSubstitutionStatementString}' statement with the complex substitution's '${complexSubstitutionStatementString}' statement.`, simpleSubstitutionStatementNode);
-  }
-
-  return simpleSubstitutionStatementUnifiedWithComplexSubstitutionStatement;
-}

package/src/unify/statementWithSttaemetnGivenEquivalences.js

@@ -1,51 +0,0 @@
-"use strict";
-
-import Substitutions from "../substitutions";
-import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
-
-export default function unifyStatementWithStatementGivenEquivalences(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
-  let statementUnifiedWithStatementGivenEquivalences = false;
-
-  const statementStringA = localContextA.nodeAsString(statementNodeA),
-        statementStringB = localContextB.nodeAsString(statementNodeB);
-
-  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement given equivalences...`, statementNodeB);
-
-  if (!statementUnifiedWithStatementGivenEquivalences) {
-    const substitutions = Substitutions.fromNothing(),
-          nodeA = statementNodeA,  ///
-          nodeB = statementNodeB,  ///
-          unifiedAtIntrinsicLevel = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-    if (unifiedAtIntrinsicLevel) {
-      const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
-
-      statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///
-    }
-  }
-
-  if (!statementUnifiedWithStatementGivenEquivalences) {
-    const localContext = localContextA; ///
-
-    localContextA = localContextB;  ///
-
-    localContextB = localContext; ///
-
-    const substitutions = Substitutions.fromNothing(),
-          nodeA = statementNodeB,  ///
-          nodeB = statementNodeA,  ///
-          unifiedAtIntrinsicLevel = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-    if (unifiedAtIntrinsicLevel) {
-      const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
-
-      statementUnifiedWithStatementGivenEquivalences = substitutionsUnifiedWithEquivalences;  ///
-    }
-  }
-
-  if (statementUnifiedWithStatementGivenEquivalences) {
-    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement given equivalences.`, statementNodeB);
-  }
-
-  return statementUnifiedWithStatementGivenEquivalences;
-}

package/src/verify/declaration.js

@@ -1,113 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import Reference from "../reference";
-import Declaration from "../declaration"
-import verifyMetavariableGivenMetaType from "../verify/metavariableGivenMetaType";
-
-import { nodeQuery } from "../utilities/query";
-import { referenceMetaType } from "../metaType";
-
-const statementNodeQuery = nodeQuery("/declaration/statement"),
-      metavariableNodeQuery = nodeQuery("/declaration/reference/metavariable"); ///
-
-const verifyDeclarationFunctions = [
-  verifyDerivedDeclaration,
-  verifyStatedDeclaration
-];
-
-export default function verifyDeclaration(declarationNode, declarations, stated, localContext) {
-  let declarationVerified;
-
-  const declarationString = localContext.nodeAsString(declarationNode);
-
-  localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
-
-  declarationVerified = verifyDeclarationFunctions.some((verifyDeclarationFunction) => {
-    const declarationVerified = verifyDeclarationFunction(declarationNode, declarations, stated, localContext);
-
-    if (declarationVerified) {
-      return true;
-    }
-  });
-
-  if (declarationVerified) {
-    localContext.debug(`...verified the '${declarationString}' declaration.`, declarationNode);
-  }
-
-  return declarationVerified;
-}
-
-function verifyDerivedDeclaration(declarationNode, declarations, stated, localContext) {
-  let derivedDeclarationVerified;
-
-  if (!stated) {
-    const declarationString = localContext.nodeAsString(declarationNode);
-
-    localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
-
-    const metaType = referenceMetaType, ///
-          metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-    if (metavariableVerifiedGivenMetaType) {
-      const { verifyStatement } = shim,
-            stated = true,
-            assignments = null,
-            statementNode = statementNodeQuery(declarationNode),
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-      if (statementVerified) {
-        const reference = Reference.fromMetavariableNode(metavariableNode),
-              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
-
-        declarations.push(declaration);
-
-        derivedDeclarationVerified = true;
-      }
-    }
-
-    if (derivedDeclarationVerified) {
-      localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
-    }
-  }
-
-  return derivedDeclarationVerified;
-}
-
-function verifyStatedDeclaration(declarationNode, declarations, stated, localContext) {
-  let statedDeclarationVerified = false;
-
-  if (stated) {
-    const declarationString = localContext.nodeAsString(declarationNode);
-
-    localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
-
-    const metaType = referenceMetaType, ///
-          metavariableNode = metavariableNodeQuery(declarationNode),
-          metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-    if (metavariableVerifiedGivenMetaType) {
-      const { verifyStatement } = shim,
-            stated = true,
-            assignments = null,
-            statementNode = statementNodeQuery(declarationNode),
-            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
-
-      if (statementVerified) {
-        const reference = Reference.fromMetavariableNode(metavariableNode),
-              declaration = Declaration.fromReferenceAndStatementNode(reference, statementNode);
-
-        declarations.push(declaration);
-
-        statedDeclarationVerified = true;
-      }
-    }
-
-    if (statedDeclarationVerified) {
-      localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
-    }
-  }
-
-  return statedDeclarationVerified;
-}

package/src/verify/frame.js

@@ -1,157 +0,0 @@
-"use strict";
-
-import Frame from "../frame";
-import verifyDeclaration from "../verify/declaration";
-import verifyMetavariableGivenMetaType from "./metavariableGivenMetaType";
-
-import { frameMetaType } from "../metaType";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-const metavariableNodeQuery = nodeQuery("/frame/metavariable"),
-      declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodesQuery = nodesQuery("/frame/metavariable");
-
-const verifyFrameFunctions = [
-  verifyDerivedFrame,
-  verifyStatedFrame
-];
-
-export default function verifyFrame(frameNode, frames, stated, localContext) {
-  let frameVerified;
-
-  const frameString = localContext.nodeAsString(frameNode);
-
-  localContext.trace(`Verifying the '${frameString}' frame...`);
-
-  frameVerified = verifyFrameFunctions.some((verifyFrameFunction) => {
-    const frameVerified = verifyFrameFunction(frameNode, frames, stated, localContext);
-
-    if (frameVerified) {
-      return true;
-    }
-  });
-
-  if (frameVerified) {
-    localContext.debug(`...verified the '${frameString}' frame.`);
-  }
-
-  return frameVerified;
-}
-
-function verifyDerivedFrame(frameNode, frames, stated, localContext) {
-  let derivedFrameVerified;
-
-  if (!stated) {
-    const frameString = localContext.nodeAsString(frameNode);
-
-    localContext.trace(`Verifying the '${frameString}' derived frame...`);
-
-    const declarations = [],
-          declarationNodes = declarationNodesQuery(frameNode),
-          declarationsVerified = declarationNodes.every((declarationNode) => {
-            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-            if (declarationVerified) {
-              return true;
-            }
-          });
-
-    if (declarationsVerified) {
-      const metavariableNodes = metavariableNodesQuery(frameNode),
-            metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-              const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
-
-              if (metavariableVerified) {
-                return true;
-              }
-            });
-
-      if (metavariablesVerified) {
-        const frame = Frame.fromDeclarations(declarations);
-
-        frames.push(frame);
-
-        derivedFrameVerified = true; ///
-      }
-    }
-
-    if (derivedFrameVerified) {
-      localContext.debug(`...verified the '${frameString}' derived frame.`);
-    }
-  }
-
-  return derivedFrameVerified;
-}
-
-function verifyStatedFrame(frameNode, frames, stated, localContext) {
-  let statedFrameVerified;
-
-  if (stated) {
-    const frameString = localContext.nodeAsString(frameNode);
-
-    localContext.trace(`Verifying the '${frameString}' stated frame...`);
-
-    const declarationNodes = declarationNodesQuery(frameNode),
-          declarationNodesLength = declarationNodes.length;
-
-    if (declarationNodesLength === 0) {
-      const metavariableNode = metavariableNodeQuery(frameNode);
-
-      if (metavariableNode !== null) {
-        const metaType = frameMetaType, ///
-              metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-        if (metavariableVerifiedGivenMetaType) {
-          const frame = Frame.fromMetavariableNode(metavariableNode);
-
-          frames.push(frame);
-
-          statedFrameVerified = true;
-        }
-      } else {
-        localContext.trace(`The '${frameString}' stated frame cannot have more than one metavariable.`);
-      }
-    } else {
-      localContext.trace(`The '${frameString}' stated frame cannot have declarations.`);
-    }
-
-    if (statedFrameVerified) {
-      localContext.debug(`...verified the '${frameString}' stated frame.`);
-    }
-  }
-
-  return statedFrameVerified;
-}
-
-function verifyMetavariable(metavariableNode, declarations, localContext) {
-  let metavariableVerified = false;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable...`);
-
-  const metaType = frameMetaType, ///
-        metavariableVerifiedGivenMetaType = verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext);
-
-  if (metavariableVerifiedGivenMetaType) {
-    const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          judgement = localContext.findJudgementByMetavariableName(metavariableName);
-
-    if (judgement !== null) {
-      const declaration = judgement.getDeclaration();
-
-      declarations.push(declaration);
-
-      metavariableVerified = true;
-    } else {
-      localContext.trace(`There is no judgement for the '${metavariableString}' metavariable.`);
-    }
-  }
-
-  if (metavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable.`);
-  }
-
-  return metavariableVerified;
-}

package/src/verify/judgement.js

@@ -1,127 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import Judgement from "../judgement";
-import verifyFrame from "../verify/frame";
-import verifyDeclaration from "./declaration";
-import JudgementAssignment from "../assignment/judgement";
-
-import { nodeQuery } from "../utilities/query";
-
-const { first } = arrayUtilities;
-
-const frameNodeQuery = nodeQuery("/judgement/frame"),
-      declarationNodeQuery = nodeQuery("/judgement/declaration");
-
-const verifyJudgementFunctions = [
-  verifyDerivedJudgement,
-  verifyStatedJudgement
-];
-
-export default function verifyJudgement(judgementNode, assignments, stated, localContext) {
-  let judgementVerified;
-
-  const judgementString = localContext.nodeAsString(judgementNode);
-
-  localContext.trace(`Verifying the '${judgementString}' judgement...`, judgementNode);
-
-  judgementVerified = verifyJudgementFunctions.some((verifyJudgementFunction) => {
-    const judgementVerified = verifyJudgementFunction(judgementNode, assignments, stated, localContext);
-
-    if (judgementVerified) {
-      return true;
-    }
-  });
-
-  if (judgementVerified) {
-    localContext.debug(`...verified the '${judgementString}' judgement.`, judgementNode);
-  }
-
-  return judgementVerified;
-}
-
-function verifyDerivedJudgement(judgementNode, assignments, stated, localContext) {
-  let derivedJudgementVerified = false;
-
-  if (!stated) {
-    const judgementString = localContext.nodeAsString(judgementNode);
-
-    localContext.trace(`Verifying the '${judgementString}' derived judgement...`, judgementNode);
-
-    const declarations = [],
-          declarationNode = declarationNodeQuery(judgementNode),
-          declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-    if (declarationVerified) {
-      const firstDeclaration = first(declarations),
-            declaration = firstDeclaration, ///
-            metavariableNode = declaration.getMetavariableNode(),
-            metatheorem = localContext.findMetatheoremByMetavariableNode(metavariableNode),
-            metaLemma = localContext.findMetaLemmaByMetavariableNode(metavariableNode),
-            metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
-
-      if (metaLemmaMetatheorem !== null) {
-        const frames = [],
-              frameNode = frameNodeQuery(judgementNode),
-              frameVerified = verifyFrame(frameNode, frames, stated, localContext);
-
-        if (frameVerified) {
-          const firstFrame = first(frames),
-                frame = firstFrame, ///
-                metaLemmaMetatheoremUnified = frame.unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem);
-
-          derivedJudgementVerified = metaLemmaMetatheoremUnified; ///
-        }
-      }
-    }
-
-    if (derivedJudgementVerified) {
-      localContext.debug(`...verified the '${judgementString}' derived judgement.`, judgementNode);
-    }
-  }
-
-  return derivedJudgementVerified;
-}
-
-function verifyStatedJudgement(judgementNode, assignments, stated, localContext) {
-  let statedJudgementVerified = false;
-
-  if (stated) {
-    const judgementString = localContext.nodeAsString(judgementNode);
-
-    localContext.trace(`Verifying the '${judgementString}' stated judgement...`, judgementNode);
-
-    const frames = [],
-          frameNode = frameNodeQuery(judgementNode),
-          frameVerified = verifyFrame(frameNode, frames, stated, localContext);
-
-    if (frameVerified) {
-      const declarations = [],
-            declarationNode = declarationNodeQuery(judgementNode),
-            declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
-
-      if (declarationVerified) {
-        if (assignments !== null) {
-          const firstDeclaration = first(declarations),
-                firstFrame = first(frames),
-                frame = firstFrame,
-                declaration = firstDeclaration, ///
-                judgement = Judgement.fromJudgementNodeFrameAndDeclaration(judgementNode, frame, declaration),
-                judgementAssignment = JudgementAssignment.fromJudgement(judgement),
-                assignment = judgementAssignment;
-
-          assignments.push(assignment);
-        }
-
-        statedJudgementVerified = true;
-      }
-    }
-
-    if (statedJudgementVerified) {
-      localContext.debug(`...verified the '${judgementString}' stated judgement.`, judgementNode);
-    }
-  }
-
-  return statedJudgementVerified;
-}

package/src/verify/metaLemma.js

@@ -1,72 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-import MetaLemma from "../metaLemma";
-// import verifyProof from "../verify/proof";
-import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
-// import verifyConsequent from "../verify/consequent";
-// import verifySuppositions from "../verify/suppositions";
-
-import { EMPTY_STRING } from "../constants";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const { first } = arrayUtilities;
-
-const proofNodeQuery = nodeQuery("/metaLemma/proof!"),
-      labelNodesQuery = nodesQuery("/metaLemma/label"),
-      consequentNodeQuery = nodeQuery("/metaLemma/consequent!"),
-      suppositionsNodeQuery = nodesQuery("/metaLemma/supposition");
-
-export default function verifyMetaLemma(metaLemmaNode, fileContext) {
-  let metaLemmaVerified = false;
-
-  const labelNodes = labelNodesQuery(metaLemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes);
-
-  (labelsString === EMPTY_STRING) ?
-    fileContext.trace(`Verifying a meta-lLemma...`, metaLemmaNode) :
-      fileContext.trace(`Verifying the '${labelsString}' meta-lLemma...`, metaLemmaNode);
-
-  const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
-
-  if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext),
-          suppositions = [],
-          suppositionNodes = suppositionsNodeQuery(metaLemmaNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-    if (suppositionsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(metaLemmaNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
-
-      if (consequentVerified) {
-        const proofNode = proofNodeQuery(metaLemmaNode),
-              firstConsequent = first(consequents),
-              consequent = firstConsequent, ///
-              statementNode = consequent.getStatementNode(),
-              substitutions = Substitutions.fromNothing(),
-              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
-
-        if (proofVerified) {
-          const metaLemma = MetaLemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
-
-          fileContext.addMetaLemma(metaLemma);
-
-          metaLemmaVerified = true;
-        }
-      }
-    }
-  }
-
-  if (metaLemmaVerified) {
-    (labelsString === EMPTY_STRING) ?
-      fileContext.debug(`...verified the meta-lemma.`, metaLemmaNode) :
-        fileContext.debug(`...verified the '${labelsString}' meta-lemma.`, metaLemmaNode);
-  }
-
-  return metaLemmaVerified;
-}

package/src/verify/metatheorem.js

@@ -1,67 +0,0 @@
-"use strict";
-
-import { arrayUtilities } from "necessary";
-
-// import verifyProof from "../verify/proof";
-import Metatheorem from "../metatheorem";
-import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
-// import verifyConsequent from "../verify/consequent";
-// import verifySuppositions from "../verify/suppositions";
-
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const { first } = arrayUtilities;
-
-const labelNodesQuery = nodesQuery("/metatheorem/label"),
-      proofNodeQuery = nodeQuery("/metatheorem/proof!"),
-      consequentNodeQuery = nodeQuery("/metatheorem/consequent!"),
-      suppositionsNodeQuery = nodesQuery("/metatheorem/supposition");
-
-export default function verifyMetatheorem(metatheoremNode, fileContext) {
-  let metatheoremVerified = false;
-
-  const labelNodes = labelNodesQuery(metatheoremNode),
-        labelsString = fileContext.nodesAsString(labelNodes);
-
-  fileContext.trace(`Verifying the '${labelsString}' metatheorem...`, metatheoremNode);
-
-  const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
-
-  if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext),
-          suppositions = [],
-          suppositionNodes = suppositionsNodeQuery(metatheoremNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-    if (suppositionsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(metatheoremNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
-
-      if (consequentVerified) {
-        const proofNode = proofNodeQuery(metatheoremNode),
-              firstConsequent = first(consequents),
-              consequent = firstConsequent, ///
-              substitutions = Substitutions.fromNothing(),
-              statementNode = consequent.getStatementNode(),
-              proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
-
-        if (proofVerified) {
-          const metatheorem = Metatheorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
-
-          fileContext.addMetatheorem(metatheorem);
-
-          metatheoremVerified = true;
-        }
-      }
-    }
-  }
-
-  if (metatheoremVerified) {
-    fileContext.debug(`...verified the '${labelsString}' metatheorem.`, metatheoremNode);
-  }
-
-  return metatheoremVerified;
-}

package/src/verify/metavariableGivenMetaType.js

@@ -1,45 +0,0 @@
-"use strict";
-
-import metavariableUnifier from "../unifier/metavariable";
-
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-
-export default function verifyMetavariableGivenMetaType(metavariableNode, metaType, localContext) {
-  let metavariableVerifiedGivenMetaType = false;
-
-  const metaTypeName = metaType.getName(),
-        metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type...`, metavariableNode);
-
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
-
-  if (metavariable !== null) {
-    const metavariableMetaType = metavariable.getMetaType();
-
-    if (metavariableMetaType === metaType) {
-      const metavariableNodeA = metavariableNode; ///
-
-      metavariableNode = metavariable.getNode();
-
-      const metavariableNodeB = metavariableNode; ///
-
-      const metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
-
-      metavariableVerifiedGivenMetaType = metavariableUnified;  ///
-    } else {
-      const metavariableMetaTypeName = metavariableMetaType.getName();
-
-      localContext.debug(`The '${metavariableString}' metavariable's meta-type is '${metavariableMetaTypeName}' when it should be '${metaTypeName}'.`, metavariableNode);
-    }
-  } else {
-    localContext.debug(`The '${metavariableString}' metavariable is not present'.`, metavariableNode);
-  }
-
-  if (metavariableVerifiedGivenMetaType) {
-    localContext.debug(`...verified the '${metavariableString}' metavariable given the '${metaTypeName}' meta-type.`, metavariableNode);
-  }
-
-  return metavariableVerifiedGivenMetaType;
-}