occam-verify-cli 0.0.1016 → 0.0.1020

package/lib/verify/variable.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyVariable;
-    }
-});
-function verifyVariable(variableNode, localContext) {
-    var variableVerified = false;
-    var variableString = localContext.nodeAsString(variableNode);
-    localContext.trace("Verifying the '".concat(variableString, "' variable..."), variableNode);
-    var variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
-    if (variablePresent) {
-        variableVerified = true;
-    }
-    if (variableVerified) {
-        localContext.debug("...verified the '".concat(variableString, "' variable."), variableNode);
-    }
-    return variableVerified;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy92ZXJpZnkvdmFyaWFibGUuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHZlcmlmeVZhcmlhYmxlKHZhcmlhYmxlTm9kZSwgbG9jYWxDb250ZXh0KSB7XG4gIGxldCB2YXJpYWJsZVZlcmlmaWVkID0gZmFsc2U7XG5cbiAgY29uc3QgdmFyaWFibGVTdHJpbmcgPSBsb2NhbENvbnRleHQubm9kZUFzU3RyaW5nKHZhcmlhYmxlTm9kZSk7XG5cbiAgbG9jYWxDb250ZXh0LnRyYWNlKGBWZXJpZnlpbmcgdGhlICcke3ZhcmlhYmxlU3RyaW5nfScgdmFyaWFibGUuLi5gLCB2YXJpYWJsZU5vZGUpO1xuXG4gIGNvbnN0IHZhcmlhYmxlUHJlc2VudCA9IGxvY2FsQ29udGV4dC5pc1ZhcmlhYmxlUHJlc2VudEJ5VmFyaWFibGVOb2RlKHZhcmlhYmxlTm9kZSk7XG5cbiAgaWYgKHZhcmlhYmxlUHJlc2VudCkge1xuICAgIHZhcmlhYmxlVmVyaWZpZWQgPSB0cnVlO1xuICB9XG5cbiAgaWYgKHZhcmlhYmxlVmVyaWZpZWQpIHtcbiAgICBsb2NhbENvbnRleHQuZGVidWcoYC4uLnZlcmlmaWVkIHRoZSAnJHt2YXJpYWJsZVN0cmluZ30nIHZhcmlhYmxlLmAsIHZhcmlhYmxlTm9kZSk7XG4gIH1cblxuICByZXR1cm4gdmFyaWFibGVWZXJpZmllZDtcbn1cbiJdLCJuYW1lcyI6WyJ2ZXJpZnlWYXJpYWJsZSIsInZhcmlhYmxlTm9kZSIsImxvY2FsQ29udGV4dCIsInZhcmlhYmxlVmVyaWZpZWQiLCJ2YXJpYWJsZVN0cmluZyIsIm5vZGVBc1N0cmluZyIsInRyYWNlIiwidmFyaWFibGVQcmVzZW50IiwiaXNWYXJpYWJsZVByZXNlbnRCeVZhcmlhYmxlTm9kZSIsImRlYnVnIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFFQTs7O2VBQXdCQTs7O0FBQVQsU0FBU0EsZUFBZUMsWUFBWSxFQUFFQyxZQUFZO0lBQy9ELElBQUlDLG1CQUFtQjtJQUV2QixJQUFNQyxpQkFBaUJGLGFBQWFHLFlBQVksQ0FBQ0o7SUFFakRDLGFBQWFJLEtBQUssQ0FBQyxBQUFDLGtCQUFnQyxPQUFmRixnQkFBZSxrQkFBZ0JIO0lBRXBFLElBQU1NLGtCQUFrQkwsYUFBYU0sK0JBQStCLENBQUNQO0lBRXJFLElBQUlNLGlCQUFpQjtRQUNuQkosbUJBQW1CO0lBQ3JCO0lBRUEsSUFBSUEsa0JBQWtCO1FBQ3BCRCxhQUFhTyxLQUFLLENBQUMsQUFBQyxvQkFBa0MsT0FBZkwsZ0JBQWUsZ0JBQWNIO0lBQ3RFO0lBRUEsT0FBT0U7QUFDVCJ9

package/src/tokens/constructorTerm/bracketed.js

@@ -1,10 +0,0 @@
-"use strict";
-
-import { OBJECT_TYPE_NAME } from "../../typeNames";
-import { termTokensFromTermString } from "../../utilities/tokens";
-
-const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME})`;
-
-const bracketedConstructorDeclarationTokens = termTokensFromTermString(bracketedConstructorTermString)
-
-export default bracketedConstructorDeclarationTokens;

package/src/unify/termWithBracketedConstructor.js

@@ -1,39 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import bracketedConstructor from "../constructor/bracketed";
-import unifyTermWithConstructor from "../unify/termWithConstructor";
-
-import { nodeQuery } from "../utilities/query";
-
-const termNodeQuery = nodeQuery("/term/argument/term");
-
-export default function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedWithBracketedConstructor;
-
-  const termString = localContext.nodeAsString(termNode),
-        bracketedTerms = [];
-
-  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);
-
-  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
-    let verifiedAhead;
-
-    const bracketedTermNode = termNode; ///
-
-    termNode = termNodeQuery(bracketedTermNode); ///
-
-    const { verifyTerm } = shim,
-          termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
-
-    verifiedAhead = termVVerified;  ///
-
-    return verifiedAhead;
-  });
-
-  if (termUnifiedWithBracketedConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);
-  }
-
-  return termUnifiedWithBracketedConstructor;
-}

package/src/unify/termWithConstructor.js

@@ -1,39 +0,0 @@
-"use strict";
-
-import Term from "../term";
-import termWithConstructorUnifier from "../unifier/termWithConstructor";
-
-export default function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedWithConstructor = false;
-
-  const termString = localContext.nodeAsString(termNode),
-        constructorString = constructor.getString(),
-        constructorTermNode = constructor.getTermNode();
-
-  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
-
-  const termNodeA = termNode,  ///
-        constructorTermNodeB = constructorTermNode,  ///
-        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
-
-  if (unified) {
-    let verifiedAhead;
-
-    const type = constructor.getType(),
-          term = Term.fromTermNodeAndType(termNode, type);
-
-    terms.push(term);
-
-    verifiedAhead = verifyAhead();
-
-    terms.pop();
-
-    termUnifiedWithConstructor = verifiedAhead;  ///
-  }
-
-  if (termUnifiedWithConstructor) {
-    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
-  }
-
-  return termUnifiedWithConstructor;
-}

package/src/unify/termWithConstructors.js

@@ -1,27 +0,0 @@
-"use strict";
-
-import unifyTermWithConstructor from "../unify/termWithConstructor";
-
-import { nodeQuery } from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
-
-export default function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedWithConstructors = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode === null) {
-    const constructors = localContext.getConstructors();
-
-    termUnifiedWithConstructors = constructors.some((constructor) => {
-      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
-
-      if (termUnifiedWithConstructor) {
-        return true;
-      }
-    });
-  }
-
-  return termUnifiedWithConstructors;
-}

package/src/unify/termWithTerm.js

@@ -1,24 +0,0 @@
-"use strict";
-
-import { findEquivalenceByTermNodes } from "../utilities/equivalences";
-
-export default function unifyTermWithTerm(leftTermNode, rightTermNode, localContext) {
-  let termUnifiedWithTerm;
-
-  const leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode);
-
-  if (leftTermNodeMatchesRightTermNode) {
-    termUnifiedWithTerm = true;
-  } else {
-    const equivalences = localContext.getEquivalences(),
-          termNodes = [
-            leftTermNode,
-            rightTermNode
-          ],
-          equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
-
-    termUnifiedWithTerm = (equivalence !== null);
-  }
-
-  return termUnifiedWithTerm;
-}

package/src/unify/termWithType.js

@@ -1,14 +0,0 @@
-"use strict";
-
-import verifyTermGivenType from "../verify/termGivenType";
-
-export default function unifyTermWithType(termNode, typeNode, localContext) {
-  let termUnifiedWithType;
-
-  const type = localContext.findTypeByTypeNode(typeNode),
-        termVerifiedGivenType = verifyTermGivenType(termNode, type, localContext);
-
-  termUnifiedWithType = termVerifiedGivenType;  ///
-
-  return termUnifiedWithType;
-}

package/src/verify/axiom.js

@@ -1,56 +0,0 @@
-"use strict";
-
-import Axiom from "../axiom";
-import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
-import verifyConsequent from "../verify/consequent";
-// import verifySuppositions from "../verify/suppositions";
-
-import { first } from "../utilities/array";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const labelNodesQuery = nodesQuery("/axiom/label"),
-      consequentNodeQuery = nodeQuery("/axiom/consequent!"),
-      suppositionsNodeQuery = nodesQuery("/axiom/supposition");
-
-export default function verifyAxiom(axiomNode, fileContext) {
-  let axiomVerified = false;
-
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = fileContext.nodesAsString(labelNodes);
-
-  fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
-
-  const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
-
-  if (labelsVerified) {
-    const localContext = LocalContext.fromFileContext(fileContext),
-          suppositions = [],
-          suppositionNodes = suppositionsNodeQuery(axiomNode),
-          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
-
-    if (suppositionsVerified) {
-      const consequents = [],
-            consequentNode = consequentNodeQuery(axiomNode),
-            consequentVerified = verifyConsequent(consequentNode, consequents, localContext);
-
-      if (consequentVerified) {
-        const firstConsequent = first(consequents),
-              substitutions = Substitutions.fromNothing(),
-              consequent = firstConsequent, ///
-              axiom = Axiom.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
-
-        fileContext.addAxiom(axiom);
-
-        axiomVerified = true;
-      }
-    }
-  }
-
-  if (axiomVerified) {
-    fileContext.debug(`...verified the '${labelsString}' axiom.`, axiomNode);
-  }
-
-  return axiomVerified;
-}

package/src/verify/consequent.js

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

package/src/verify/declaration/variable.js

@@ -1,85 +0,0 @@
-"use strict";
-
-import Variable from "../../variable";
-import VariableAssignment from "../../assignment/variable";
-
-import { nodeQuery } from "../../utilities/query";
-import { objectType } from "../../type";
-import { EMPTY_STRING } from "../../constants";
-
-const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
-      variableNodeQuery = nodeQuery("/variableDeclaration/variable");
-
-export default function verifyVariableDeclaration(variableDeclarationNode, fileContext) {
-  let variableDeclarationVerified;
-
-  const typeNode = typeNodeQuery(variableDeclarationNode),
-        variableNode = variableNodeQuery(variableDeclarationNode),
-        typeString = (typeNode === null) ?
-                       EMPTY_STRING :
-                         fileContext.nodeAsString(typeNode),
-        variableString = fileContext.nodeAsString(variableNode);
-
-  (typeString === EMPTY_STRING) ?
-    fileContext.trace(`Verifying the '${variableString}' variable declaration...`, variableDeclarationNode) :
-      fileContext.trace(`Verifying the '${variableString}:${typeString}' variable declaration...`, variableDeclarationNode);
-
-  const variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
-
-  variableDeclarationVerified = variableVVerified;  ///
-
-  if (variableDeclarationVerified) {
-    (typeString === EMPTY_STRING) ?
-      fileContext.debug(`...verified the '${variableString}' variable declaration.`, variableDeclarationNode) :
-        fileContext.debug(`...verified the '${variableString}:${typeString}' variable declaration.`, variableDeclarationNode);
-  }
-
-  return variableDeclarationVerified;
-}
-
-function verifyVariable(variableNode, typeNode, fileContext) {
-  let variableVerified = false;
-
-  const variableString = fileContext.nodeAsString(variableNode);
-
-  fileContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
-
-  const variablePresent = fileContext.isVariablePresentByVariableNode(variableNode);
-
-  if (variablePresent) {
-    fileContext.debug(`The variable '${variableString}' is already present.`, variableNode);
-  } else {
-    let variable;
-
-    if (typeNode === null) {
-      const type = objectType;
-
-      variable = Variable.fromVariableNodeAndType(variableNode, type);
-    } else {
-      const type = fileContext.findTypeByTypeNode(typeNode);
-
-      if (type === null) {
-        const typeString = fileContext.nodeAsString(typeNode);
-
-        fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`, variableNode);
-      } else {
-        variable = Variable.fromVariableNodeAndType(variableNode, type);
-      }
-    }
-
-    if (variable !== null) {
-      const variableAssignment = VariableAssignment.fromVariable(variable),
-            variableAssigned = variableAssignment.assign(fileContext);
-
-      if (variableAssigned) {
-        variableVerified = true;
-      }
-    }
-  }
-
-  if (variableVerified) {
-    fileContext.debug(`...verified the '${variableString}' variable.`, variableNode);
-  }
-
-  return variableVerified;
-}

package/src/verify/equality.js

@@ -1,118 +0,0 @@
-"use strict";
-
-import Equality from "../equality";
-import verifyTerms from "../verify/terms";
-import EqualityAssignment from "../assignment/equality";
-
-import { nodesQuery } from "../utilities/query";
-
-const termNodesQuery = nodesQuery("/equality/term");
-
-const verifyEqualityFunctions = [
-  verifyDerivedEquality,
-  verifyStatedEquality
-];
-
-export default function verifyEquality(equalityNode, assignments, stated, localContext) {
-  let equalityVerified;
-
-  const equalityString = localContext.nodeAsString(equalityNode);
-
-  localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
-
-  equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
-    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, stated, localContext);
-
-    if (equalityVerified) {
-      return true;
-    }
-  });
-
-  if (equalityVerified) {
-    localContext.debug(`...verified the '${equalityString}' equality.`, equalityNode);
-  }
-
-  return equalityVerified;
-}
-
-function verifyDerivedEquality(equalityNode, assignments, stated, localContext) {
-  let derivedEqualityVerified = false;
-
-  if (!stated) {
-    const equalityString = localContext.nodeAsString(equalityNode);
-
-    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
-
-    const terms = [],
-          termNodes = termNodesQuery(equalityNode),
-          termsVerified = verifyTerms(termNodes, terms, localContext, () => {
-            let verifiedAhead = false;
-
-            const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
-
-            if (equality !== null) {
-              const equalityEqual = equality.isEqual(localContext);
-
-              if (equalityEqual) {
-                if (assignments !== null) {
-                  const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                        assignment = equalityAssignment; ///
-
-                  assignments.push(assignment);
-                }
-
-                verifiedAhead = true;
-              }
-            }
-
-            return verifiedAhead;
-          });
-
-    derivedEqualityVerified = termsVerified; ///
-
-    if (derivedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
-    }
-  }
-
-  return derivedEqualityVerified;
-}
-
-function verifyStatedEquality(equalityNode, assignments, stated, localContext) {
-  let statedEqualityVerified = false;
-
-  if (stated) {
-    const equalityString = localContext.nodeAsString(equalityNode);
-
-    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
-
-    const terms = [],
-          termNodes = termNodesQuery(equalityNode),
-          termsVerified = verifyTerms(termNodes, terms, localContext, () => {
-            let verifiedAhead = false;
-
-            const equality = Equality.fromTermsAndEqualityNode(terms, equalityNode);
-
-            if (equality !== null) {
-              if (assignments !== null) {
-                const equalityAssignment = EqualityAssignment.fromEquality(equality),
-                      assignment = equalityAssignment; ///
-
-                assignments.push(assignment);
-              }
-
-              verifiedAhead = true;
-            }
-
-            return verifiedAhead;
-          });
-
-    statedEqualityVerified = termsVerified; ///
-
-    if (statedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
-    }
-  }
-
-  return statedEqualityVerified;
-}

package/src/verify/proofStep.js

@@ -1,21 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import ProofStep from "../proofStep";
-import verifySubproof from "../verify/subproof";
-import verifyQualifiedStatement from "../verify/statement/qualified";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
-
-import { nodeQuery } from "../utilities/query";
-
-const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement|unqualifiedStatement/statement!"),
-      qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement!"),
-      unqualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/unqualifiedStatement!");
-
-export default function verifyProofStep(proofStepNode, substitutions, localContext) {
-}
-
-Object.assign(shim, {
-  verifyProofStep
-});

package/src/verify/term.js

@@ -1,123 +0,0 @@
-"use strict";
-
-import shim from "../shim";
-import Term from "../term";
-import unifyTermWithConstructors from "../unify/termWithConstructors";
-import unifyTermWithBracketedConstructor from "../unify/termWithBracketedConstructor";
-
-import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
-
-const unifyTermFunctions = [
-        unifyTermWithBracketedConstructor,
-        unifyTermWithConstructors,
-      ],
-      verifyTermFunctions = [
-        verifyTermAsVariable
-      ];
-
-function verifyTerm(termNode, terms, localContext, verifyAhead) {
-  let termVerified = false;
-
-  const termString = localContext.nodeAsString(termNode);
-
-  localContext.trace(`Verifying the '${termString}' term...`, termNode);
-
-  if (!termVerified) {
-    const termUnified = unifyTermFunctions.some((unifyTermFunction) => {
-      const termUnified = unifyTermFunction(termNode, terms, localContext, verifyAhead);
-
-      if (termUnified) {
-        return true;
-      }
-    });
-
-    termVerified = termUnified; ///
-  }
-
-  if (!termVerified) {
-    termVerified = verifyTermFunctions.some((verifyTermFunction) => {
-      const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);
-
-      if (termVerified) {
-        return true;
-      }
-    });
-  }
-
-  if (termVerified) {
-    localContext.debug(`...verified the '${termString}' term.`, termNode);
-  }
-
-  return termVerified;
-}
-
-Object.assign(shim, {
-  verifyTerm
-});
-
-export default verifyTerm;
-
-function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
-  let termVerifiedAsVariable = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const termString = localContext.nodeAsString(termNode);
-
-    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);
-
-    const variables = [],
-          variableVerified = verifyVariable(variableNode, variables, localContext);
-
-    if (variableVerified) {
-      let verifiedAhead;
-
-      const firstVariable = first(variables),
-            variable = firstVariable, ///
-            type = variable.getType(),
-            term = Term.fromTermNodeAndType(termNode, type);
-
-      terms.push(term);
-
-      verifiedAhead = verifyAhead();
-
-      terms.pop();
-
-      termVerifiedAsVariable = verifiedAhead; ///
-    }
-
-    if (termVerifiedAsVariable) {
-      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);
-    }
-  }
-
-  return termVerifiedAsVariable;
-}
-
-function verifyVariable(variableNode, variables, localContext) {
-  let variableVerified = false;
-
-  const variableString = localContext.nodeAsString(variableNode);
-
-  localContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
-
-  const variable = localContext.findVariableByVariableNode(variableNode);
-
-  if (variable === null) {
-    localContext.trace(`The '${variableString}' variable is not present.`, variableNode);
-  } else {
-    variables.push(variable);
-
-    variableVerified = true;
-  }
-
-  if (variableVerified) {
-    localContext.debug(`...verified the '${variableString}' variable.`, variableNode);
-  }
-
-  return variableVerified;
-}