occam-verify-cli 0.0.309 → 0.0.310

package/src/context/file.js

@@ -1,11 +1,16 @@
 "use strict";
 
+import { levels } from "necessary";
 import { rewriteNodes } from "occam-grammar-utilities";
 
 import { push } from "../utilities/array";
+import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "../utilities/tokens";
+
+const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
 
 export default class FileContext {
-  constructor(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {
+  constructor(filePath, tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext) {
+    this.filePath = filePath;
     this.tokens = tokens;
     this.node = node;
     this.rules = rules;
@@ -17,6 +22,10 @@ export default class FileContext {
     this.releaseContext = releaseContext;
   }
 
+  getFilePath() {
+    return this.filePath;
+  }
+
   getTokens() {
     return this.tokens;
   }
@@ -236,21 +245,28 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
-  trace(message) { this.releaseContext.trace(message); }
+  trace(message, node) { this.log(node, TRACE_LEVEL, message); }
 
-  debug(message) { this.releaseContext.debug(message); }
+  debug(message, node) { this.log(node, DEBUG_LEVEL, message); }
 
-  info(message) { this.releaseContext.info(message); }
+  info(message, node) { this.log(node, INFO_LEVEL, message); }
 
-  warning(message) { this.releaseContext.warning(message); }
+  warning(message, node) { this.log(node, WARNING_LEVEL, message); }
 
-  error(message) { this.releaseContext.error(message); }
+  error(message, node) { this.log(node, ERROR_LEVEL, message); }
 
-  fatal(message) { this.releaseContext.fatal(message); }
+  fatal(message, node) { this.log(node, FATAL_LEVEL, message); }
+
+  log(node, level, message) {
+    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, this.tokens),
+          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, this.tokens);
+
+    this.releaseContext.log(level, message, this.filePath, leastLineIndex, greatestLineIndex);
+  }
 
   static fromReleaseContextAndFilePath(releaseContext, filePath) {
-    const fileContent = releaseContext.getFileContent(filePath),
-          content = fileContent,  ///
+    const file = releaseContext.getFile(filePath),
+          content = file.getContent(),
           tokens = releaseContext.tokenise(content),
           node = releaseContext.parse(tokens);
 
@@ -262,7 +278,7 @@ export default class FileContext {
           variables = [],
           combinators = [],
           constructors = [],
-          fileContext = new FileContext(tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);
+          fileContext = new FileContext(filePath, tokens, node, rules, types, axioms, variables, combinators, constructors, releaseContext);
 
     return fileContext;
   }

package/src/context/metaproof.js

@@ -79,17 +79,17 @@ export default class MetaproofContext {
     this.metaAssertions.push(metaAssertion);
   }
 
-  trace(message) { this.context.trace(message); }
+  trace(message, node) { this.context.trace(message, node); }
 
-  debug(message) { this.context.debug(message); }
+  debug(message, node) { this.context.debug(message, node); }
 
-  info(message) { this.context.info(message); }
+  info(message, node) { this.context.info(message, node); }
 
-  warning(message) { this.context.warning(message); }
+  warning(message, node) { this.context.warning(message, node); }
 
-  error(message) { this.context.error(message); }
+  error(message, node) { this.context.error(message, node); }
 
-  fatal(message) { this.context.fatal(message); }
+  fatal(message, node) { this.context.fatal(message, node); }
 
   static fromContext(context) {
     const derived = false,

package/src/context/proof.js

@@ -80,17 +80,17 @@ export default class ProofContext {
     this.statementNodes.push(statementNode);
   }
 
-  trace(message) { this.context.trace(message); }
+  trace(message, node) { this.context.trace(message, node); }
 
-  debug(message) { this.context.debug(message); }
+  debug(message, node) { this.context.debug(message, node); }
 
-  info(message) { this.context.info(message); }
+  info(message, node) { this.context.info(message, node); }
 
-  warning(message) { this.context.warning(message); }
+  warning(message, node) { this.context.warning(message, node); }
 
-  error(message) { this.context.error(message); }
+  error(message, node) { this.context.error(message, node); }
 
-  fatal(message) { this.context.fatal(message); }
+  fatal(message, node) { this.context.fatal(message, node); }
 
   static fromContext(context) {
     const derived = false,

package/src/context/release.js

@@ -1,17 +1,22 @@
 "use strict";
 
-import { CustomGrammar, lexersUtilities, parsersUtilities, CombinedCustomGrammar } from "occam-custom-grammars";
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+
+import logMixins from "../mixins/log";
 
 import { push } from "../utilities/array";
+import { customGrammarFromRelease, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
-export default class ReleaseContext {
-  constructor(log, release, verified, fileContexts, florenceLexer, florenceParser, releaseContexts) {
+class ReleaseContext {
+  constructor(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
     this.log = log;
     this.release = release;
     this.verified = verified;
+    this.customGrammar = customGrammar;
+
     this.fileContexts = fileContexts;
     this.florenceLexer = florenceLexer;
     this.florenceParser = florenceParser;
@@ -30,6 +35,10 @@ export default class ReleaseContext {
     return this.verified;
   }
 
+  getCustomGrammar() {
+    return this.customGrammar;
+  }
+
   getFileContexts() {
     return this.fileContexts;
   }
@@ -46,28 +55,20 @@ export default class ReleaseContext {
     return this.releaseContexts;
   }
 
-  getReleaseName() {
-    const releaseName = this.release.getName();
+  getFile(filePath) { return this.release.getFile(filePath); }
 
-    return releaseName;
-  }
+  getName() { return this.release.getName(); }
 
   getVersion() { return this.release.getVersion(); }
 
   getFilePaths() { return this.release.getFilePaths(); }
 
-  getFileContent(filePath) {
-    const file = this.release.getFile(filePath),
-          fileContent = file.getContent();
-
-    return fileContent;
-  }
-
   getDependencies() { return this.release.getDependencies(); }
 
   getRules(releaseNames = []) {
-    const rules = [],
-          releaseName = this.getReleaseName(),
+    const name = this.getName(),
+          rules = [],
+          releaseName = name, ///
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
@@ -92,8 +93,9 @@ export default class ReleaseContext {
   }
 
   getTypes(releaseNames = []) {
-    const types = [],
-          releaseName = this.getReleaesName(),
+    const name = this.getName(),
+          types = [],
+          releaseName = name, ///
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
@@ -118,8 +120,9 @@ export default class ReleaseContext {
   }
 
   getAxioms(releaseNames = []) {
-    const axioms = [],
-          releaseName = this.getReleaseName(),
+    const name = this.getName(),
+          axioms = [],
+          releaseName = name, ///
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
@@ -144,8 +147,9 @@ export default class ReleaseContext {
   }
 
   getCombinators(releaseNames = []) {
-    const combinators = [],
-          releaseName = this.getReleaseName(),
+    const name = this.getName(),
+          combinators = [],
+          releaseName = name, ///
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
@@ -170,8 +174,9 @@ export default class ReleaseContext {
   }
 
   getConstructors(releaseNames = []) {
-    const releaseName = this.getReleaseName(),
+    const name = this.getName(),
           constructors = [],
+          releaseName = name, ///
           releaseNamesIncludesReleaseName = releaseNames.includes(releaseName);
 
     if (!releaseNamesIncludesReleaseName) {
@@ -195,20 +200,6 @@ export default class ReleaseContext {
     return constructors;
   }
 
-  getCustomGrammar() {
-    const releaseName = this.getReleaseName(),
-          name = releaseName, ///
-          termBNF = this.release.getTermBNF(),
-          statementBNF = this.release.getStatementBNF(),
-          metastatementBNF = this.release.getMetastatementBNF(),
-          typePattern = this.release.getTypePattern(),
-          symbolPattern = this.release.getSymbolPattern(),
-          operatorPattern = this.release.getOperatorPattern(),
-          customGrammar = CustomGrammar.fromNameTermBNFStatementBNFMetastatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
-
-    return customGrammar;
-  }
-
   addFileContext(fileContext) {
     this.fileContexts.push(fileContext);
   }
@@ -217,45 +208,33 @@ export default class ReleaseContext {
 
   parse(tokens) { return this.florenceParser.parse(tokens); }
 
-  trace(message) { this.log.trace(message); }
-
-  debug(message) { this.log.debug(message); }
-
-  info(message) { this.log.info(message); }
-
-  warning(message) { this.log.warning(message); }
-
-  error(message) { this.log.error(message); }
-
-  fatal(message) { this.log.fatal(message); }
-
   initialise(releaseContexts, dependencyReleaseContexts) {
-    this.releaseContexts = releaseContexts;
-
     const releaseContext = this;  ///
 
     releaseContexts = [ releaseContext, ...dependencyReleaseContexts ]; ///
 
-    const customGrammars = releaseContexts.map((releaseContext) => {
-            const customGrammar = releaseContext.getCustomGrammar();
-
-            return customGrammar;
-          }),
-          combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+    const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
 
     this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
     this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+
+    this.releaseContexts = releaseContexts;
   }
 
   static fromLogAndRelease(log, release, ...remainingArguments) {
     const verified = false,
+          customGrammar = customGrammarFromRelease(release),
           fileContexts = [],
           florenceLexer = null,
           florenceParser = null,
           releaseContexts = [],
-          releaseContext = new ReleaseContext(log, release, verified, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
+          releaseContext = new ReleaseContext(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
 
     return releaseContext;
   }
 }
+
+Object.assign(ReleaseContext.prototype, logMixins);
+
+export default ReleaseContext;

package/src/mixins/log.js

@@ -0,0 +1,28 @@
+"use strict";
+
+import { levels } from "necessary";
+
+const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
+
+function trace(message) { this.log(TRACE_LEVEL, message); }
+
+function debug(message) { this.log(DEBUG_LEVEL, message); }
+
+function info(message) { this.log(INFO_LEVEL, message); }
+
+function warning(message) { this.log(WARNING_LEVEL, message); }
+
+function error(message) { this.log(ERROR_LEVEL, message); }
+
+function fatal(message) { this.log(FATAL_LEVEL, message); }
+
+const logMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal
+};
+
+export default logMixins;

package/src/utilities/customGrammar.js

@@ -0,0 +1,27 @@
+"use strict";
+
+import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
+
+export function customGrammarFromRelease(release) {
+  const name = release.getName(),
+        termBNF = release.getTermBNF(),
+        statementBNF = release.getStatementBNF(),
+        metastatementBNF = release.getMetastatementBNF(),
+        typePattern = release.getTypePattern(),
+        symbolPattern = release.getSymbolPattern(),
+        operatorPattern = release.getOperatorPattern(),
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFMetastatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+
+  return customGrammar;
+}
+
+export function combinedCustomGrammarFromReleaseContexts(releaseContexts) {
+  const customGrammars = releaseContexts.map((releaseContext) => {
+          const customGrammar = releaseContext.getCustomGrammar();
+
+          return customGrammar;
+        }),
+        combinedCustomGrammar = CombinedCustomGrammar.fromCustomGrammars(customGrammars);
+
+  return combinedCustomGrammar;
+}

package/src/utilities/tokens.js

@@ -0,0 +1,67 @@
+"use strict";
+
+export function leastLineIndexFromNodeAndTokens(node, tokens) {
+  let leastLineIndex = undefined; ///
+
+  const firstSignificantToken = node.getFirstSignificantToken(),
+        firstSignificantTokenIndex = significantTokenIndexFromSignificantTokenAndTokens(firstSignificantToken, tokens); ///
+
+  let lineIndex = 0;
+
+  tokens.some((token, tokenIndex) => {  ///
+    if (tokenIndex === firstSignificantTokenIndex) {
+      leastLineIndex = lineIndex;  ///
+
+      return true;
+    }
+
+    const tokenEndOfLineToken = token.isEndOfLineToken();
+
+    if (tokenEndOfLineToken) {
+      lineIndex += 1;
+    }
+  });
+
+  return leastLineIndex;
+}
+
+export function greatestLineIndexFromNodeAndTokens(node, tokens) {
+  let greatestLineIndex = undefined;  ///
+
+  const lastSignificantToken = node.getLastSignificantToken(),
+        lastSignificantTokenIndex = significantTokenIndexFromSignificantTokenAndTokens(lastSignificantToken, tokens);
+
+  let lineIndex = 0;
+
+  tokens.some((token, tokenIndex) => {  ///
+    if (tokenIndex === lastSignificantTokenIndex) {
+      greatestLineIndex = lineIndex;  ///
+
+      return true;
+    }
+
+    const tokenEndOfLineToken = token.isEndOfLineToken();
+
+    if (tokenEndOfLineToken) {
+      lineIndex += 1;
+    }
+  });
+
+  return greatestLineIndex;
+}
+
+function significantTokenIndexFromSignificantTokenAndTokens(significantToken, tokens) {
+  let significantTokenIndex = -1;
+
+  tokens.some((token) => {
+    significantTokenIndex++;
+
+    const tokenEqualToSignificantToken = token.isEqualTo(significantToken);
+
+    if (tokenEqualToSignificantToken) {
+      return true;
+    }
+  });
+
+  return significantTokenIndex;
+}

package/src/verify/assertion/type.js

@@ -17,7 +17,7 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The ${typeName} type is not present.`);
+    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     const derived = context.isDerived();
 
@@ -37,7 +37,7 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
               value = firstValue;
 
         if (value !== undefined) {
-          context.error(`The value of the ${variableName} variable is not undefined.`);
+          context.error(`The value of the ${variableName} variable is not undefined.`, typeAssertionNode);
         } else {
           const type = context.findTypeByTypeName(typeName),
                 firstType = first(types),
@@ -45,7 +45,7 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
                 typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
 
           if (!typeSubTypeOfVariableType) {
-            context.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
+            context.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`, typeAssertionNode);
           } else {
             const name = variableName,  ///
                   variable = Variable.fromTypeAndName(type, name);

package/src/verify/axiom.js

@@ -17,7 +17,7 @@ export default function verifyAxiom(axiomNode, context) {
   const labelNodes = labelNodesQuery(axiomNode),
         labelsString = nodesAsString(labelNodes);
 
-  context.debug(`Verifying the '${labelsString}' axiom...`);
+  context.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const proofContext = ProofContext.fromContext(context);
 
@@ -61,7 +61,7 @@ export default function verifyAxiom(axiomNode, context) {
   }
 
   if (axiomVerified) {
-    context.info(`Verified the '${labelsString}' axiom.`);
+    context.info(`Verified the '${labelsString}' axiom.`, axiomNode);
   }
 
   return axiomVerified;

package/src/verify/label.js

@@ -10,7 +10,7 @@ export default function verifyLabel(labelNode, labels, context) {
         labelPresent = context.isLabelPresent(label);
 
   if (labelPresent) {
-    context.error(`The label ${label} is already present`);
+    context.error(`The label ${label} is already present`, labelNode);
   } else {
     labels.push(label);
 

package/src/verify/metastatement/qualified.js

@@ -26,7 +26,7 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
   if (qualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    context.debug(`Verified the '${metastatementString}' qualified metastatement.`);
+    context.debug(`Verified the '${metastatementString}' qualified metastatement.`, qualifiedMetastatementNode);
   }
 
   return qualifiedMetastatementVerified;

package/src/verify/metastatement/unqualified.js

@@ -28,7 +28,7 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
   if (unqualifiedMetastatementVerified) {
     const metastatementString = nodeAsString(metastatementNode);
 
-    context.debug(`Verified the '${metastatementString}' unqualified metastatement.`);
+    context.debug(`Verified the '${metastatementString}' unqualified metastatement.`, unqualifiedMetastatementNode);
   }
 
   return unqualifiedMetastatementVerified;

package/src/verify/release.js

@@ -42,7 +42,7 @@ export default function verifyRelease(releaseName, releaseContextMap, releaseCon
       if (releaseVerified) {
         releaseContexts.push(releaseContext);
 
-        releaseContext.info(`Verified the '${releaseName}' release.`);
+        releaseContext.info(`Verified the '${releaseName}' package.`);
       }
     }
   }

package/src/verify/rule.js

@@ -26,7 +26,7 @@ export default function verifyRule(ruleNode, context) {
 
   context = metaproofContext; ///
 
-  context.debug(`Verifying the '${labelsString}' rule...`);
+  context.debug(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, context);
@@ -69,7 +69,7 @@ export default function verifyRule(ruleNode, context) {
     }
 
     if (ruleVerified) {
-      context.info(`Verified the '${labelsString}' rule.`);
+      context.info(`Verified the '${labelsString}' rule.`, ruleNode);
     }
   }
 

package/src/verify/statement.js

@@ -14,7 +14,7 @@ export default function verifyStatement(statementNode, context) {
 
   const statementString = nodeAsString(statementNode);
 
-  context.debug(`Verifying the '${statementString}' statement...`);
+  context.debug(`Verifying the '${statementString}' statement...`, statementNode);
 
   const equalityNode = equalityNodeQuery(statementNode),
         typeAssertionNode = typeAssertionNodeQuery(statementNode);
@@ -34,7 +34,7 @@ export default function verifyStatement(statementNode, context) {
   }
 
   if (statementVerified) {
-    context.info(`Verified the '${statementString}' statement.`);
+    context.info(`Verified the '${statementString}' statement.`, statementNode);
   }
 
   return statementVerified;

package/src/verify/statementAsCombinator.js

@@ -11,7 +11,7 @@ export default function verifyStatementAsCombinator(statementNode, context) {
 
   const statementString = nodeAsString(statementNode);
 
-  context.debug(`Verifying the ${statementString} statement as a combinator...`);
+  context.debug(`Verifying the ${statementString} statement as a combinator...`, statementNode);
 
   const nonTerminalNode = statementNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -28,7 +28,7 @@ export default function verifyStatementAsCombinator(statementNode, context) {
 
     const statementString = nodeAsString(statementNode);
 
-    context.info(`Verified the '${statementString}' combinator.`);
+    context.info(`Verified the '${statementString}' combinator.`, statementNode);
   }
 
   return statementVerifiedAsCombinator;
@@ -117,7 +117,7 @@ function verifyTypeNode(typeNode, context) {
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The type '${typeName}' is missing.`);
+    context.error(`The type '${typeName}' is missing.`, typeNode);
   } else {
     typeNodeVerified = true;
   }

package/src/verify/term.js

@@ -153,7 +153,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a term, not a type`);
+    context.error(`The ${argumentString} argument should be a term, not a type`, argumentNode);
   } else {
     const types = [],
           values = [],

package/src/verify/termAsConstructor.js

@@ -15,7 +15,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
 
   const termString = nodeAsString(termNode);
 
-  context.debug(`Verifying the '${termString}' term as a constructor...`);
+  context.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
   const nonTerminalNode = termNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -36,7 +36,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
       } else {
         const termString = nodeAsString(termNode);
 
-        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+        context.error(`The '${termString}' constructor's '${typeName}' type is missing.`, termNode);
       }
     }
   }
@@ -48,7 +48,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, context) {
 
     const termString = nodeAsString(termNode);
 
-    context.info(`Verified the '${termString}' constructor.`);
+    context.info(`Verified the '${termString}' constructor.`, termNode);
   }
 
   return termVerifiedAsConstructor;
@@ -121,7 +121,7 @@ function verifyNonTerminalNode(nonTerminalNode, context) {
         if (type !== null) {
           const termString = nodeAsString(termNode);
 
-          context.error(`The type of the constructor's compound '${termString}' term node is not null.`);
+          context.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -151,13 +151,13 @@ function verifyArgumentNode(argumentNode, context) {
   if (typeNode === null) {
     const argumentString = nodeAsString(argumentNode);
 
-    context.error(`The ${argumentString} argument should be a type.`);
+    context.error(`The ${argumentString} argument should be a type.`, argumentNode);
   } else {
     const typeName = typeNameFromTypeNode(typeNode),
           typePresent = context.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
-      context.error(`The type '${typeName}' is missing.`);
+      context.error(`The type '${typeName}' is missing.`, typeNode);
     } else {
       typeNodeVerified = true;
     }

package/src/verify/termAsVariable.js

@@ -14,7 +14,7 @@ export default function verifyTermAsVariable(termNode, types, names, values, con
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
     if (!variablePresent) {
-      context.error(`The ${variableName} variable is not present.`)
+      context.error(`The ${variableName} variable is not present.`, variableNode)
     } else {
       const variable = context.findVariableByVariableName(variableName),
             type = variable.getType(),