occam-verify-cli 0.0.525 → 0.0.526

package/src/context/file.js

@@ -3,6 +3,7 @@
 import { rewriteNodes } from "occam-grammar-utilities";
 
 import { push } from "../utilities/array";
+import { nodeAsString, nodesAsString } from "../utilities/string";
 import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
 
 export default class FileContext {
@@ -343,6 +344,18 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
+
+    return string;
+  }
+
+  nodesAsString(node) {
+    const string = nodesAsString(node, this.tokens);
+
+    return string;
+  }
+
   trace(message) { this.releaseContext.trace(message); }
 
   debug(message) { this.releaseContext.debug(message); }
@@ -380,43 +393,43 @@ export default class FileContext {
     const json = [];
 
     this.types.forEach((type) => {
-      const typeJSON = type.toJSON();
+      const typeJSON = type.toJSON(this.tokens);
 
       json.push(typeJSON);
     });
 
     this.rules.forEach((rule) => {
-      const ruleJSON = rule.toJSON();
+      const ruleJSON = rule.toJSON(this.tokens);
 
       json.push(ruleJSON);
     });
 
     this.axioms.forEach((axiom) => {
-      const axiomJSON = axiom.toJSON();
+      const axiomJSON = axiom.toJSON(this.tokens);
 
       json.push(axiomJSON);
     });
 
     this.lemmas.forEach((lemma) => {
-      const lemmaJSON = lemma.toJSON();
+      const lemmaJSON = lemma.toJSON(this.tokens);
 
       json.push(lemmaJSON);
     });
 
     this.theorems.forEach((theorem) => {
-      const theoremJSON = theorem.toJSON();
+      const theoremJSON = theorem.toJSON(this.tokens);
 
       json.push(theoremJSON);
     });
 
     this.combinators.forEach((combinator) => {
-      const combinatorJSON = combinator.toJSON();
+      const combinatorJSON = combinator.toJSON(this.tokens);
 
       json.push(combinatorJSON);
     });
 
     this.constructors.forEach((constructor) => {
-      const constructorJSON = constructor.toJSON();
+      const constructorJSON = constructor.toJSON(this.tokens);
 
       json.push(constructorJSON)
     });

package/src/context/metaproof.js

@@ -61,6 +61,10 @@ class MetaproofContext {
     return metastatementMatches;
   }
 
+  nodeAsString(node) { return this.context.nodeAsString(node); }
+
+  nodesAsString(node) { return this.context.nodesAsString(node); }
+
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           metaproofSteps = [],

package/src/context/proof.js

@@ -121,6 +121,10 @@ class ProofContext {
 
   isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
+  nodeAsString(node) { return this.context.nodeAsString(node); }
+
+  nodesAsString(node) { return this.context.nodesAsString(node); }
+
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],

package/src/label.js

@@ -21,14 +21,14 @@ export default class Label {
     return matchesName;
   }
 
-  asString() {
-    const string = nodeAsString(this.node);
+  asString(tokens) {
+    const string = nodeAsString(this.node, tokens);
 
     return string;
   }
 
-  toJSON() {
-    const string = nodeAsString(this.node),
+  toJSON(tokens) {
+    const string = nodeAsString(this.node, tokens),
           json = string;  ///
 
     return json;

package/src/premise.js

@@ -106,8 +106,8 @@ export default class Premise {
     return metastatementNodeMatches;
   }
 
-  toJSON() {
-    const metastatementString = nodeAsString(this.metastatementNode),
+  toJSON(tokens) {
+    const metastatementString = nodeAsString(this.metastatementNode, tokens),
           metastatement = metastatementString, ///
           json = {
             metastatement

package/src/rule.js

@@ -108,18 +108,18 @@ export default class Rule {
     return metastatementNatches;
   }
 
-  toJSON() {
+  toJSON(tokens) {
     const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
+            const labelJSON = label.toJSON(tokens);
 
             return labelJSON;
           }),
           premisesJSON = this.premises.map((premise) => {
-            const premiseJSON = premise.toJSON();
+            const premiseJSON = premise.toJSON(tokens);
 
             return premiseJSON;
           }),
-          conclusionJSON = this.conclusion.toJSON(),
+          conclusionJSON = this.conclusion.toJSON(tokens),
           kind = RULE_KIND,
           labels = labelsJSON,  ///
           premises = premisesJSON,  ///

package/src/supposition.js

@@ -61,8 +61,8 @@ export default class Supposition {
     return statementNodeMatches;
   }
 
-  toJSON() {
-    const statementString = nodeAsString(this.statementNode),
+  toJSON(tokens) {
+    const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString, ///
           json = {
             statement

package/src/type.js

@@ -96,7 +96,7 @@ export default class Type {
     return matchesTypeName;
   }
 
-  asString(noSuperType) {
+  asString(tokens, noSuperType) {
     let string;
 
     if (noSuperType) {
@@ -110,8 +110,8 @@ export default class Type {
     return string;
   }
 
-  toJSON() {
-    const superTypeJSON = this.superType.toJSON(),
+  toJSON(tokens) {
+    const superTypeJSON = this.superType.toJSON(tokens),
           kind = TYPE_KIND,
           name = this.name,
           superType = superTypeJSON,  ///
@@ -157,7 +157,7 @@ export default class Type {
 }
 
 class ObjectType extends Type {
-  toJSON() {
+  toJSON(tokens) {
     const kind = TYPE_KIND,
           name = this.name,
           superType = null,  ///

package/src/utilities/string.js

@@ -1,17 +1,14 @@
 "use strict";
 
-import { COMMA } from "../constants";
 import { nodeQuery } from "../utilities/query";
-import { LABEL_RULE_NAME,
-         UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONSTRUCTOR_DECLARATIONRULE_NAME,
-         UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { COMMA, EMPTY_STRING } from "../constants";
+import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function nodeAsString(node) {
+export function nodeAsString(node, tokens) {
   let string = null;
 
   if (node !== null) {
@@ -24,24 +21,35 @@ export function nodeAsString(node) {
       string = content; ///
     } else {
       const nonTerminalNode = node, ///
-            childNodes = nonTerminalNode.getChildNodes();
+            firstSignificantToken = nonTerminalNode.getFirstSignificantToken(),
+            lastSignificantToken = nonTerminalNode.getLastSignificantToken(),
+            firstSignificantTokenIndex = tokens.indexOf(firstSignificantToken),
+            lastSignificantTokenIndex = tokens.indexOf(lastSignificantToken),
+            start = firstSignificantTokenIndex, ///
+            end = lastSignificantTokenIndex + 1;
 
-      childNodes.forEach((childNode) => {
-        const nodeString = nodeAsString(childNode);
+      tokens = tokens.slice(start, end);  ///
 
-        string = (string === null) ?
-                   nodeString : ///
-                    `${string}${nodeString}`;
-      });
+      string = tokens.reduce((string, token) => {
+        const content = token.getContent();
+
+        string = `${string}${content}`;
+
+        return string;
+      }, EMPTY_STRING);
     }
   }
 
+  if (string !== null) {
+    string = string.replace(/[\r\n]/, EMPTY_STRING)
+  }
+
   return string;
 }
 
-export function nodesAsString(nodes) {
+export function nodesAsString(nodes, tokens) {
   const string = nodes.reduce((string, node) => {
-    const nodeString = nodeAsString(node);
+    const nodeString = nodeAsString(node, tokens);
 
     if (string === null) {
       string = nodeString;  ///

package/src/variable.js

@@ -45,7 +45,7 @@ export default class Variable {
     return equalTo;
   }
 
-  asString() {
+  asString(tokens) {
     let string;
 
     if (this.type === null) {

package/src/verify/assertion/type.js

@@ -15,7 +15,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, proof
 
   proofContext.begin(typeAssertionNode);
 
-  const typeAssertionString = nodeAsString(typeAssertionNode);
+  const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
 
   proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
 
@@ -110,7 +110,7 @@ function verifyTermTypeAssertion(typeAssertionNode, assertions, proofContext) {
             assertedType = proofContext.findTypeByTypeName(assertedTypeName),
             firstType = first(types),
             termType = firstType,
-            termString = nodeAsString(termNode),
+            termString = proofContext.nodeAsString(termNode),
             assertedTypeEqualToTermType = (termType === null) ?
                                              true : ///
                                                assertedType.isEqualTo(termType);

package/src/verify/axiom.js

@@ -20,7 +20,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   fileContext.begin(axiomNode);
 
   const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' axiom...`);

package/src/verify/conclusion.js

@@ -4,7 +4,6 @@ import Conclusion from "../conclusion";
 import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
@@ -14,7 +13,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
 
   metaproofContext.begin(conclusionNode);
 
-  const conclusionString = nodeAsString(conclusionNode);
+  const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
   metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`);
 

package/src/verify/consequence.js

@@ -4,7 +4,6 @@ import Consequence from "../consequence";
 import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/consequence/unqualifiedStatement!");
@@ -14,9 +13,9 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
 
   proofContext.begin(consequenceNode);
 
-  const consequenceString = nodeAsString(consequenceNode);
+  const consequenceString = proofContext.nodeAsString(consequenceNode);
 
-  proofContext.debug(`Verifying the ${consequenceString} consequence...`);
+  proofContext.debug(`Verifying the '${consequenceString}' consequence...`);
 
   const derived = false,
         assertions = [],

package/src/verify/label.js

@@ -2,7 +2,6 @@
 
 import Label from "../label";
 
-import { nodeAsString } from "../utilities/string";
 import { labelNameFromLabelNode } from "../utilities/query";
 
 export default function verifyLabel(labelNode, labels, fileContext) {
@@ -14,7 +13,7 @@ export default function verifyLabel(labelNode, labels, fileContext) {
         labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
   if (labelPresent) {
-    const labelString = nodeAsString(labelNode);
+    const labelString = fileContext.nodeAsString(labelNode);
 
     fileContext.error(`The '${labelString}' label is already present.`, labelNode);
   } else {

package/src/verify/lemma.js

@@ -23,7 +23,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
   fileContext.begin(lemmaNode);
 
   const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?

package/src/verify/metastatement/qualified.js

@@ -16,9 +16,9 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} qualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`);
 
     let ruleMatchesMetastatement = true;
 

package/src/verify/metastatement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
-    const metastatementString = nodeAsString(metastatementNode);
+    const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the ${metastatementString} unqualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`);
 
     let metastatementMatches = true;
 

package/src/verify/premise.js

@@ -5,7 +5,6 @@ import MetaproofStep from "../step/metaproof";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/premise/unqualifiedMetastatement!");
@@ -15,9 +14,9 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
 
   metaproofContext.begin(premiseNode);
 
-  const premiseString = nodeAsString(premiseNode);
+  const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the ${premiseString} premise...`);
+  metaproofContext.debug(`Verifying the '${premiseString}' premise...`);
 
   const derived = false,
         assertions = [],

package/src/verify/rule.js

@@ -22,7 +22,7 @@ export default function verifyRule(ruleNode, fileContext) {
   fileContext.begin(ruleNode);
 
   const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' rule...`);

package/src/verify/statement/qualified.js

@@ -16,9 +16,9 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} qualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
 
     let ruleMatchesStatement = true;
 

package/src/verify/statement/unqualified.js

@@ -15,9 +15,9 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = nodeAsString(statementNode);
+    const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the ${statementString} unqualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`);
 
     let statementMatches = true;
 

package/src/verify/statement.js

@@ -8,7 +8,6 @@ import verifyTypeAssertion from "../verify/assertion/type";
 
 import { first } from "../utilities/array";
 import { objectType } from "../type";
-import { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { STATEMENT_META_TYPE } from "../metaTypes";
 import { MAXIMUM_INDEXES_LENGTH } from "../constants";
@@ -230,7 +229,7 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   const termNode = termNodeQuery(argumentNode);
 
   if (termNode === null) {
-    const argumentString = nodeAsString(argumentNode);
+    const argumentString = context.nodeAsString(argumentNode);
 
     context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {
@@ -262,7 +261,7 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
   const statementNode = statementNodeQuery(metaArgumentNode);
 
   if (statementNode === null) {
-    const metaArgumentString = nodeAsString(metaArgumentNode);
+    const metaArgumentString = context.nodeAsString(metaArgumentNode);
 
     context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
   } else {
@@ -282,7 +281,7 @@ function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, co
       }
 
       if (!metaArgumentNodeVerified) {
-        const combinatorMetaargumentString = nodeAsString(combinatorMetaargumentNode);
+        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
         context.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
       }

package/src/verify/statementAsCombinator.js

@@ -4,7 +4,6 @@ import Combinator from "../combinator";
 import verifyTerm from "../verify/term";
 import verifyStatement from "../verify/statement";
 
-import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode } from "../utilities/query";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
@@ -13,7 +12,7 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
 
   fileContext.begin(statementNode);
 
-  const statementString = nodeAsString(statementNode);
+  const statementString = fileContext.nodeAsString(statementNode);
 
   fileContext.debug(`Verifying the '${statementString}' combinator....`);
 

package/src/verify/supposition.js

@@ -5,7 +5,6 @@ import Supposition from "../supposition";
 import verifyUnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
-import { nodeAsString } from "../utilities/string";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
@@ -15,9 +14,9 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
   proofContext.begin(suppositionNode);
 
-  const suppositionString = nodeAsString(suppositionNode);
+  const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the ${suppositionString} supposition...`);
+  proofContext.debug(`Verifying the '${suppositionString}' supposition...`);
 
   const derived = false,
         assertions = [],

package/src/verify/term.js

@@ -2,7 +2,6 @@
 
 import { first } from "../utilities/array";
 import { objectType } from "../type";
-import { nodeAsString } from "../utilities/string";
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { ARGUMENT_RULE_NAME } from "../ruleNames";
 import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
@@ -16,7 +15,7 @@ export default function verifyTerm(termNode, types, context) {
 
   context.begin(termNode);
 
-  const termString = nodeAsString(termNode);
+  const termString = context.nodeAsString(termNode);
 
   context.debug(`Verifying the '${termString}' term...`);
 
@@ -218,7 +217,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   const termNode = termNodeQuery(argumentNode);
 
   if (termNode === null) {
-    const argumentString = nodeAsString(argumentNode);
+    const argumentString = context.nodeAsString(argumentNode);
 
     context.error(`The ${argumentString} argument should be a term, not a type`);
   } else {

package/src/verify/termAsConstructor.js

@@ -4,7 +4,6 @@ import verifyTerm from "../verify/term";
 import Constructor from "../constructor";
 
 import { first } from "../utilities/array";
-import { nodeAsString } from "../utilities/string";
 import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
 import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../ruleNames";
 
@@ -18,7 +17,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
   let type = null;
 
   const nonTerminalNode = termNode,  ///
-        termString = nodeAsString(termNode);
+        termString = fileContext.nodeAsString(termNode);
 
   fileContext.debug(`Verifying the '${termString}' constructor...`);
 
@@ -123,7 +122,7 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
               type = firstType; ///
 
         if (type !== null) {
-          const termString = nodeAsString(termNode);
+          const termString = fileContext.nodeAsString(termNode);
 
           fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);
         } else {
@@ -153,7 +152,7 @@ function verifyArgumentNode(argumentNode, fileContext) {
   const typeNode = typeNodeQuery(argumentNode);
 
   if (typeNode === null) {
-    const argumentString = nodeAsString(argumentNode);
+    const argumentString = fileContext.nodeAsString(argumentNode);
 
     fileContext.error(`The ${argumentString} argument should be a type.`);
   } else {

package/src/verify/theorem.js

@@ -22,7 +22,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
   fileContext.begin(theoremNode);
 
   const labelNodes = labelNodesQuery(theoremNode),
-        labelsString = nodesAsString(labelNodes),
+        labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   fileContext.debug(`Verifying the '${labelsString}' theorem...`);

package/src/verify/type.js

@@ -2,7 +2,6 @@
 
 import Type from "../type";
 
-import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode } from "../utilities/query";
 
 export default function verifyType(typeNode, superTypeNode, fileContext) {
@@ -10,7 +9,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
 
   fileContext.begin(typeNode);
 
-  const typeString = nodeAsString(typeNode);
+  const typeString = fileContext.nodeAsString(typeNode);
 
   fileContext.debug(`Verifying the '${typeString}' type...`);
 

package/src/verify/variable.js

@@ -3,7 +3,6 @@
 import Variable from "../variable";
 
 import { objectType } from "../type";
-import { nodeAsString } from "../utilities/string";
 import { typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
 
 export default function verifyVariable(variableNode, typeNode, fileContext) {
@@ -11,7 +10,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
 
   fileContext.begin(variableNode);
 
-  const variableString = nodeAsString(variableNode);
+  const variableString = fileContext.nodeAsString(variableNode);
 
   fileContext.debug(`Verifying the '${variableString}' variable...`);