occam-verify-cli 0.0.527 → 0.0.529

package/src/verify/derivation.js

@@ -17,8 +17,6 @@ const childNodesQuery = nodesQuery("/derivation|subDerivation/*"),
 export default function verifyDerivation(derivationNode, proofContext) {
   let derivationVerified;
 
-  proofContext.begin(derivationNode);
-
   const childNodes = childNodesQuery(derivationNode);
 
   derivationVerified = childNodes.every((childNode) => {
@@ -29,18 +27,12 @@ export default function verifyDerivation(derivationNode, proofContext) {
     }
   });
 
-  derivationVerified ?
-    proofContext.complete(derivationNode) :
-      proofContext.halt(derivationNode);
-
   return derivationVerified;
 }
 
 function verifySubDerivation(subDerivationNode, proofContext) {
   let subDerivationVerified;
 
-  proofContext.begin(subDerivationNode);
-
   const childNodes = childNodesQuery(subDerivationNode);
 
   subDerivationVerified = childNodes.every((childNode) => {
@@ -51,10 +43,6 @@ function verifySubDerivation(subDerivationNode, proofContext) {
     }
   });
 
-  subDerivationVerified ?
-    proofContext.complete(subDerivationNode) :
-      proofContext.halt(subDerivationNode);
-
   return subDerivationVerified;
 }
 

package/src/verify/label.js

@@ -7,8 +7,6 @@ import { labelNameFromLabelNode } from "../utilities/query";
 export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
-  fileContext.begin(labelNode);
-
   const labelName = labelNameFromLabelNode(labelNode),
         labelPresent = fileContext.isLabelPresentByLabelName(labelName);
 
@@ -24,9 +22,5 @@ export default function verifyLabel(labelNode, labels, fileContext) {
     labelVerified = true;
   }
 
-  labelVerified ?
-    fileContext.complete(labelNode) :
-      fileContext.halt(labelNode);
-
   return labelVerified;
 }

package/src/verify/lemma.js

@@ -19,15 +19,13 @@ const proofNodeQuery = nodeQuery("/lemma/proof!"),
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  fileContext.begin(lemmaNode);
-
   const labelNodes = labelNodesQuery(lemmaNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
-    fileContext.debug(`Verifying a lemma...`) :
-      fileContext.debug(`Verifying the '${labelsString}' lemma...`);
+    fileContext.debug(`Verifying a lemma...`, lemmaNode) :
+      fileContext.debug(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -67,13 +65,9 @@ export default function verifyLemma(lemmaNode, fileContext) {
 
   if (lemmaVerified) {
     (labelsString === EMPTY_STRING) ?
-      fileContext.info(`Verified the lemma.`) :
-        fileContext.info(`Verified the '${labelsString}' lemma.`);
+      fileContext.info(`Verified the lemma.`, lemmaNode) :
+        fileContext.info(`Verified the '${labelsString}' lemma.`, lemmaNode);
   }
 
-  lemmaVerified ?
-    fileContext.complete(lemmaNode) :
-      fileContext.complete(lemmaNode);
-
   return lemmaVerified;
 }

package/src/verify/metastatement/qualified.js

@@ -10,14 +10,12 @@ const referenceNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/ref
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let qualifiedMetastatementVerified = false;
 
-  metaproofContext.begin(qualifiedMetastatementNode);
-
   const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
     let ruleMatchesMetastatement = true;
 
@@ -39,9 +37,5 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
     }
   }
 
-  qualifiedMetastatementVerified ?
-    metaproofContext.complete(qualifiedMetastatementNode) :
-      metaproofContext.halt(qualifiedMetastatementNode);
-
   return qualifiedMetastatementVerified;
 }

package/src/verify/metastatement/unqualified.js

@@ -9,14 +9,12 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, assertions, derived, metaproofContext) {
   let unqualifiedMetastatementVerified = false;
 
-  metaproofContext.begin(unqualifiedMetastatementNode);
-
   const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
 
   if (metastatementNode !== null) {
     const metastatementString = metaproofContext.nodeAsString(metastatementNode);
 
-    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`);
+    metaproofContext.debug(`Verifying the '${metastatementString}' unqualified metastatement...`, unqualifiedMetastatementNode);
 
     let metastatementMatches = true;
 
@@ -31,9 +29,5 @@ export default function verifyUnqualifiedMetastatement(unqualifiedMetastatementN
     }
   }
 
-  unqualifiedMetastatementVerified ?
-    metaproofContext.complete(unqualifiedMetastatementNode) :
-      metaproofContext.halt(unqualifiedMetastatementNode);
-
   return unqualifiedMetastatementVerified;
 }

package/src/verify/metastatement.js

@@ -3,13 +3,7 @@
 export default function verifyMetastatement(metastatementNode, assertions, derived, metaproofContext) {
   let metastatementVerified = true; ///
 
-  metaproofContext.begin(metastatementNode);
-
   ///
 
-  metastatementVerified ?
-    metaproofContext.complete(metastatementNode) :
-      metaproofContext.halt(metastatementNode);
-
   return metastatementVerified;
 }

package/src/verify/premise.js

@@ -12,11 +12,9 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyPremise(premiseNode, premises, metaproofContext) {
   let premiseVerified;
 
-  metaproofContext.begin(premiseNode);
-
   const premiseString = metaproofContext.nodeAsString(premiseNode);
 
-  metaproofContext.debug(`Verifying the '${premiseString}' premise...`);
+  metaproofContext.debug(`Verifying the '${premiseString}' premise...`, premiseNode);
 
   const derived = false,
         assertions = [],
@@ -35,9 +33,5 @@ export default function verifyPremise(premiseNode, premises, metaproofContext) {
     premiseVerified = true;
   }
 
-  premiseVerified ?
-    metaproofContext.complete(premiseNode) :
-      metaproofContext.halt(premiseNode);
-
   return premiseVerified;
 }

package/src/verify/proof.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import matcher from "../matcher";
 import verifyDerivation from "../verify/derivation";
 
-import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
@@ -10,8 +10,6 @@ const derivationNodeQuery = nodeQuery("/proof/derivation!");
 export default function verifyProof(proofNode, conclusion, proofContext) {
   let proofVerified = false;
 
-  proofContext.begin(proofNode);
-
   const derivationNode = derivationNodeQuery(proofNode),
         derivationVerified = verifyDerivation(derivationNode, proofContext);
 
@@ -27,9 +25,5 @@ export default function verifyProof(proofNode, conclusion, proofContext) {
     proofVerified = nodeMatches;  ///
   }
 
-  proofVerified ?
-    proofContext.complete(proofNode) :
-      proofContext.complete(proofNode);
-
   return proofVerified;
 }

package/src/verify/rule.js

@@ -18,13 +18,11 @@ const labelNodesQuery = nodesQuery("/rule/label"),
 export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
-  fileContext.begin(ruleNode);
-
   const labelNodes = labelNodesQuery(ruleNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         metaProofContext = MetaproofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' rule...`);
+  fileContext.debug(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -68,12 +66,8 @@ export default function verifyRule(ruleNode, fileContext) {
   }
 
   if (ruleVerified) {
-    fileContext.info(`Verified the '${labelsString}' rule.`);
+    fileContext.info(`Verified the '${labelsString}' rule.`, ruleNode);
   }
 
-  ruleVerified ?
-    fileContext.complete(ruleNode) :
-      fileContext.complete(ruleNode);
-
   return ruleVerified;
 }

package/src/verify/ruleDerivation.js

@@ -17,8 +17,6 @@ const childNodesQuery = nodesQuery("/ruleDerivation|ruleSubDerivation/*"),
 export default function verifyRuleDerivation(ruleDerivationNode, metaproofContext) {
   let ruleDerivationVerified;
 
-  metaproofContext.begin(ruleDerivationNode);
-
   const childNodes = childNodesQuery(ruleDerivationNode);
 
   ruleDerivationVerified = childNodes.every((childNode) => {
@@ -29,18 +27,12 @@ export default function verifyRuleDerivation(ruleDerivationNode, metaproofContex
     }
   });
 
-  ruleDerivationVerified ?
-    metaproofContext.complete(ruleDerivationNode) :
-      metaproofContext.halt(ruleDerivationNode);
-
   return ruleDerivationVerified;
 }
 
 function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
   let ruleSubDerivationVerified;
 
-  metaproofContext.begin(ruleSubDerivationNode);
-
   const childNodes = childNodesQuery(ruleSubDerivationNode);
 
   ruleSubDerivationVerified = childNodes.every((childNode) => {
@@ -51,10 +43,6 @@ function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
     }
   });
 
-  ruleSubDerivationVerified ?
-    metaproofContext.complete(ruleSubDerivationNode) :
-      metaproofContext.halt(ruleSubDerivationNode);
-
   return ruleSubDerivationVerified;
 }
 

package/src/verify/ruleProof.js

@@ -1,8 +1,8 @@
 "use strict";
 
+import matcher from "../matcher";
 import verifyRuleDerivation from "../verify/ruleDerivation";
 
-import { matcher } from "../matcher";
 import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
@@ -10,8 +10,6 @@ const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 export default function verifyRuleProof(ruleProofNode, conclusion, metaproofContext) {
   let ruleProofVerified = false;
 
-  metaproofContext.begin(ruleProofNode);
-
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
         ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, metaproofContext);
 
@@ -27,9 +25,5 @@ export default function verifyRuleProof(ruleProofNode, conclusion, metaproofCont
     ruleProofVerified = nodeMatches;  ///
   }
 
-  ruleProofVerified ?
-    metaproofContext.complete(ruleProofNode) :
-      metaproofContext.complete(ruleProofNode);
-
   return ruleProofVerified;
 }

package/src/verify/statement/qualified.js

@@ -10,14 +10,12 @@ const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/referen
 export default function verifyQualifiedStatement(qualifiedStatementNode, assertions, derived, proofContext) {
   let qualifiedStatementVerified = false;
 
-  proofContext.begin(qualifiedStatementNode);
-
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
     const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the '${statementString}' qualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode);
 
@@ -81,9 +79,5 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, asserti
     }
   }
 
-  qualifiedStatementVerified ?
-    proofContext.complete(qualifiedStatementNode) :
-      proofContext.halt(qualifiedStatementNode);
-
   return qualifiedStatementVerified;
 }

package/src/verify/statement/unqualified.js

@@ -9,14 +9,12 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assertions, derived, proofContext) {
   let unqualifiedStatementVerified = false;
 
-  proofContext.begin(unqualifiedStatementNode);
-
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
     const statementString = proofContext.nodeAsString(statementNode);
 
-    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`);
+    proofContext.debug(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
 
     let statementMatches = true;
 
@@ -32,9 +30,5 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
   }
 
-  unqualifiedStatementVerified ?
-    proofContext.complete(unqualifiedStatementNode) :
-      proofContext.halt(unqualifiedStatementNode);
-
   return unqualifiedStatementVerified;
 }

package/src/verify/statement.js

@@ -14,15 +14,14 @@ import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
 
 const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!"),
-      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!/@meta-type"),
+      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export default function verifyStatement(statementNode, assertions, derived, context) {
   let statementVerified = false;
 
-  context.begin(statementNode);
-
   if (!statementVerified) {
     const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
 
@@ -41,10 +40,6 @@ export default function verifyStatement(statementNode, assertions, derived, cont
     statementVerified = statementVerifiedAsEquality;  //
   }
 
-  statementVerified ?
-    context.complete(statementNode) :
-      context.halt(statementNode);
-
   return statementVerified;
 }
 
@@ -69,12 +64,12 @@ function verifyStatementAgainstCombinators(statementNode, context) {
   ];
 
   const combinator = combinators.find((combinator) => {
-          const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
-          if (statementVerifiedAgainstCombinator) {
-            return true;
-          }
-        }) || null;
+    if (statementVerifiedAgainstCombinator) {
+      return true;
+    }
+  }) || null;
 
   if (combinator !== null) {
     statementVerifiedAgainstCombinators = true;
@@ -229,7 +224,7 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = context.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 = [],
           termVerified = verifyTerm(termNode, types, context);
@@ -256,32 +251,27 @@ function verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
 function verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
   let metaArgumentNodeVerified = false;
 
-  const statementNode = statementNodeQuery(metaArgumentNode);
+  const statementNode = statementNodeQuery(metaArgumentNode),
+        combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
   if (statementNode === null) {
     const metaArgumentString = context.nodeAsString(metaArgumentNode);
 
-    context.error(`The '${metaArgumentString}' meta-argument should be a statement, not a meta-type.`);
+    context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
   } else {
-    const derived = false,
-          assertions = [],
-          statementVerified = verifyStatement(statementNode, assertions, derived, context);
-
-    if (statementVerified) {
-      const combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
-
-      if (combinatorMetaTYpeNode !== null) {
-        const terminalNode = combinatorMetaTYpeNode,  ///
-              terminalNodeContent = terminalNode.getContent(),
-              terminalNodeContentStatementMetaType = (terminalNodeContent === STATEMENT_META_TYPE);
+    if (combinatorMetaTYpeNode === null) {
+      const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
 
-        metaArgumentNodeVerified = terminalNodeContentStatementMetaType;  ///
-      }
-
-      if (!metaArgumentNodeVerified) {
-        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-
-        context.error(`The '${combinatorMetaargumentString}' combinator meta-argument should be the 'Statement' meta-type.`);
+      context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
+    } else {
+      const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
+            content = combinatorMetaTypeTerminalNode.getContent(),
+            contentStatementMetaType = (content === STATEMENT_META_TYPE);
+
+      if (!contentStatementMetaType) {
+        context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
+      } else {
+        metaArgumentNodeVerified = true;
       }
     }
   }

package/src/verify/statementAsCombinator.js

@@ -10,11 +10,9 @@ import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleName
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
-  fileContext.begin(statementNode);
-
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.debug(`Verifying the '${statementString}' combinator....`);
+  fileContext.debug(`Verifying the '${statementString}' combinator....`, statementNode);
 
   const nonTerminalNode = statementNode,  ///
         childNodes = nonTerminalNode.getChildNodes(),
@@ -29,13 +27,9 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
   }
 
   if (statementVerifiedAsCombinator) {
-    fileContext.info(`Verified the '${statementString}' combinator.`);
+    fileContext.info(`Verified the '${statementString}' combinator.`, statementNode);
   }
 
-  statementVerifiedAsCombinator ?
-    fileContext.complete(statementNode) :
-      fileContext.halt(statementNode);
-
   return statementVerifiedAsCombinator;
 }
 
@@ -131,7 +125,7 @@ function verifyTypeNode(typeNode, fileContext) {
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    fileContext.error(`The type '${typeName}' is missing.`);
+    fileContext.error(`The type '${typeName}' not present.`, typeNode);
   } else {
     typeNodeVerified = true;
   }

package/src/verify/supposition.js

@@ -12,11 +12,9 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
 export default function verifySupposition(suppositionNode, suppositions, proofContext) {
   let suppositionVerified;
 
-  proofContext.begin(suppositionNode);
-
   const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the '${suppositionString}' supposition...`);
+  proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
         assertions = [],
@@ -39,9 +37,5 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
     suppositionVerified = true;
   }
 
-  suppositionVerified ?
-    proofContext.complete(suppositionNode) :
-      proofContext.halt(suppositionNode);
-
   return suppositionVerified;
 }

package/src/verify/term.js

@@ -13,11 +13,9 @@ const termNodeQuery = nodeQuery("/argument/term!"),
 export default function verifyTerm(termNode, types, context) {
   let termVerified = false;
 
-  context.begin(termNode);
-
   const termString = context.nodeAsString(termNode);
 
-  context.debug(`Verifying the '${termString}' term...`);
+  context.trace(`Verifying the '${termString}' term...`, termNode);
 
   if (!termVerified) {
     const variables = [],
@@ -43,21 +41,15 @@ export default function verifyTerm(termNode, types, context) {
   }
 
   if (termVerified) {
-    context.info(`Verified the '${termString}' term.`);
+    context.debug(`Verified the '${termString}' term.`, termNode);
   }
 
-  termVerified ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerified;
 }
 
 export function verifyTermAsVariable(termNode, variables, context) {
   let termVerifiedAsVariable = false;
 
-  context.begin(termNode);
-
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
@@ -73,18 +65,12 @@ export function verifyTermAsVariable(termNode, variables, context) {
     }
   }
 
-  termVerifiedAsVariable ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerifiedAsVariable;
 }
 
 export function verifyTermAgainstConstructors(termNode, types, context) {
   let termVerifiedAgainstConstructors = false;
 
-  context.begin(termNode);
-
   const constructors = context.getConstructors(),
         constructor = constructors.find((constructor) => {
           const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
@@ -102,10 +88,6 @@ export function verifyTermAgainstConstructors(termNode, types, context) {
     termVerifiedAgainstConstructors = true;
   }
 
-  termVerifiedAgainstConstructors ?
-    context.complete(termNode) :
-      context.halt(termNode);
-
   return termVerifiedAgainstConstructors;
 }
 
@@ -219,7 +201,7 @@ function verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
   if (termNode === null) {
     const argumentString = context.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 = [],
           termVerified = verifyTerm(termNode, types, context);

package/src/verify/termAsConstructor.js

@@ -12,15 +12,11 @@ const typeNodeQuery = nodeQuery("/argument/type");
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
-  fileContext.begin(termNode);
-
   let type = null;
 
   const nonTerminalNode = termNode,  ///
         termString = fileContext.nodeAsString(termNode);
 
-  fileContext.debug(`Verifying the '${termString}' constructor...`);
-
   const childNodes = nonTerminalNode.getChildNodes(),
         childNodesVerified = verifyChildNodes(childNodes, fileContext);
 
@@ -35,7 +31,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.error(`The '${termString}' constructor's '${typeName}' type is missing.`);
+        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
       }
     }
   }
@@ -47,13 +43,9 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
   }
 
   if (termVerifiedAsConstructor) {
-    fileContext.info(`Verified the '${termString}' constructor.`);
+    fileContext.info(`Verified the '${termString}' constructor.`, termNode);
   }
 
-  termVerifiedAsConstructor ?
-    fileContext.complete(termNode) :
-      fileContext.halt(termNode);
-
   return termVerifiedAsConstructor;
 }
 
@@ -124,7 +116,7 @@ function verifyNonTerminalNode(nonTerminalNode, fileContext) {
         if (type !== null) {
           const termString = fileContext.nodeAsString(termNode);
 
-          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`);
+          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
         } else {
           nonTerminalNodeVerified = true; ///
         }
@@ -154,13 +146,13 @@ function verifyArgumentNode(argumentNode, fileContext) {
   if (typeNode === null) {
     const argumentString = fileContext.nodeAsString(argumentNode);
 
-    fileContext.error(`The ${argumentString} argument should be a type.`);
+    fileContext.error(`The ${argumentString} argument should be a type.`, argumentNode);
   } else {
     const typeName = typeNameFromTypeNode(typeNode),
           typePresent = fileContext.isTypePresentByTypeName(typeName);
 
     if (!typePresent) {
-      fileContext.error(`The type '${typeName}' is missing.`);
+      fileContext.error(`The type '${typeName}' is not present.`, argumentNode);
     } else {
       typeNodeVerified = true;
     }