occam-verify-cli 1.0.281 → 1.0.285

package/src/context/local.js

@@ -375,15 +375,15 @@ class LocalContext {
 
   tokensAsString(tokens) { return this.context.tokensAsString(tokens); }
 
-  trace(message, node) { this.context.trace(message, node); }
+  trace(message, node = null) { this.context.trace(message, node); }
 
-  debug(message, node) { this.context.debug(message, node); }
+  debug(message, node = null) { this.context.debug(message, node); }
 
-  info(message, node) { this.context.info(message, node); }
+  info(message, node = null) { this.context.info(message, node); }
 
-  warning(message, node) { this.context.warning(message, node); }
+  warning(message, node = null) { this.context.warning(message, node); }
 
-  error(message, node) { this.context.error(message, node); }
+  error(message, node = null) { this.context.error(message, node); }
 
   static fromContext(context) {
     const tokens = null,

package/src/context/release.js

@@ -414,15 +414,15 @@ export default class ReleaseContext {
 
   matchShortenedVersion(shortenedVersion) { return this.entries.matchShortenedVersion(shortenedVersion); }
 
-  trace(message, filePath = null) { this.log.trace(message, filePath); }
+  trace(message, filePath = null, lineIndex = null) { this.log.trace(message, filePath, lineIndex); }
 
-  debug(message, filePath = null) { this.log.debug(message, filePath); }
+  debug(message, filePath = null, lineIndex = null) { this.log.debug(message, filePath, lineIndex); }
 
-  info(message, filePath = null) { this.log.info(message, filePath); }
+  info(message, filePath = null, lineIndex = null) { this.log.info(message, filePath, lineIndex); }
 
-  warning(message, filePath = null) { this.log.warning(message, filePath); }
+  warning(message, filePath = null, lineIndex = null) { this.log.warning(message, filePath, lineIndex); }
 
-  error(message, filePath = null) { this.log.error(message, filePath); }
+  error(message, filePath = null, lineIndex = null) { this.log.error(message, filePath, lineIndex); }
 
   initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),

package/src/dom/axiom.js

@@ -16,10 +16,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     let verifies;
 
     const axiom = this, ///
+          node = this.getNode(),
           context = this.getContext(),
           axiomString = axiom.getString();
 
-    context.trace(`Verifying the '${axiomString}' axiom...`);
+    context.trace(`Verifying the '${axiomString}' axiom...`, node);
 
     const signatureVerifies = this.verifySignature();
 
@@ -32,7 +33,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
       context.addAxiom(axiom);
 
-      context.debug(`...verified the '${axiomString}' axiom.`);
+      context.debug(`...verified the '${axiomString}' axiom.`, node);
     }
 
     return verifies;
@@ -81,15 +82,16 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   unifyStep(step, substitutions, context) {
     let stepUnifies = false;
 
-    const stepString = step.getString(),
-          axiomString = this.string;  ///
+    const node = this.getNode(),
+          stepString = step.getString(),
+          axiomString = this.getString();
 
-    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
+    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`, node);
 
     const unconditional = this.isUnconditional();
 
     if (!unconditional) {
-      context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`);
+      context.trace(`Cannot unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
     } else {
       const statement = step.getStatement(),
             specificContext = context;  ///
@@ -105,7 +107,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     }
 
     if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
+      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`, node);
     }
 
     return stepUnifies;
@@ -114,11 +116,12 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   unifyLastStep(lastStep, substitutions, generalContext, specificContext) {
     let lastStepUnifies = false;
 
-    const context = specificContext,  ///
-          axiomString = this.string,  ///
+    const node = this.getNode(),
+          context = specificContext,  ///
+          axiomString = this.getString(),
           lastStepString = lastStep.getString();
 
-    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`)
+    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`, node)
 
     const statement = lastStep.getStatement(),
           statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, generalContext, specificContext);
@@ -128,7 +131,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     }
 
     if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`)
+      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`, node)
     }
 
     return lastStepUnifies;
@@ -137,15 +140,16 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
-    const axiomString = this.string,  ///
+    const node = this.getNode(),
+          axiomString = this.getString(),
           subproofString = subproof.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`, node);
 
     const unconditional = this.isUnconditional();
 
     if (unconditional) {
-      context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
+      context.trace(`Cannot unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
     } else {
       const lastStep = subproof.getLastStep(),
             specificContext = context;  ///
@@ -166,7 +170,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     }
 
     if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
+      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`, node);
     }
 
     return subproofUnifies;
@@ -237,10 +241,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   unifyAxiomLemmaTheoremOrConjecture(axiomLemmaTheoremOrConjecture, substitutions, context) {
     let axiomLemmaTheoremOrConjectureUnifies = false;
 
-    const axiomString = this.getString(),
+    const node = this.getNode(),
+          axiomString = this.getString(),
           axiomLemmaTheoremOrConjectureString = axiomLemmaTheoremOrConjecture.getString();
 
-    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`);
+    context.trace(`Unifying the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom...`, node);
 
     const hypothesesCorrelate = axiomLemmaTheoremOrConjecture.correlateHypotheses(context);
 
@@ -262,7 +267,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     }
 
     if (axiomLemmaTheoremOrConjectureUnifies) {
-      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`);
+      context.debug(`...unified the '${axiomLemmaTheoremOrConjectureString}' axiom, lemma, theorem or conjecture with the '${axiomString}' axiom.`, node);
     }
 
     return axiomLemmaTheoremOrConjectureUnifies;

package/src/dom/conclusion.js

@@ -6,11 +6,16 @@ import { domAssigned } from "../dom";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default domAssigned(class Conclusion {
-  constructor(string, statement) {
+  constructor(node, string, statement) {
+    this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -24,7 +29,7 @@ export  default domAssigned(class Conclusion {
 
     const conclusionString = this.string;  ///
 
-    context.trace(`Verifying the '${conclusionString}' conclusion...`);
+    context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);
 
     if (this.statement !== null) {
       const stated = true,
@@ -34,11 +39,11 @@ export  default domAssigned(class Conclusion {
       verifies = statementVerifies; ///
 
     } else {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${conclusionString}' conclusion.`);
+      context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);
     }
 
     return verifies;
@@ -51,12 +56,12 @@ export  default domAssigned(class Conclusion {
           statementString = statement.getString(),
           conclusionString = conclusion.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`, this.node);
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`, this.node);
     }
 
     return statementUnifies;
@@ -76,8 +81,9 @@ export  default domAssigned(class Conclusion {
 
   static fromJSON(json, context) {
     const statement = statementFromJSON(json, context),
+          node = null,
           string = statement.getString(),
-          conclusion = new Conclusion(string, statement);
+          conclusion = new Conclusion(node, string, statement);
 
     return conclusion;
   }
@@ -87,7 +93,7 @@ export  default domAssigned(class Conclusion {
           node = conclusionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromConclusionNode(conclusionNode, context),
-          conclusion = new Conclusion(string, statement);
+          conclusion = new Conclusion(node, string, statement);
 
     return conclusion;
   }

package/src/dom/conjecture.js

@@ -8,11 +8,12 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
   verify() {
     let verifies;
 
-    const context = this.getContext(),
+    const node = this.getNode(),
+          context = this.getContext(),
           conjecture = this,  ///
           conjectureString = conjecture.getString();
 
-    context.trace(`Verifying the '${conjectureString}' conjecture...`);
+    context.trace(`Verifying the '${conjectureString}' conjecture...`, node);
 
     verifies = super.verify();
 
@@ -21,7 +22,7 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
 
       context.addConjecture(conjecture);
 
-      context.debug(`...verified the '${conjectureString}' conjecture.`);
+      context.debug(`...verified the '${conjectureString}' conjecture.`, node);
     }
 
     return verifies;

package/src/dom/constructor/bracketed.js

@@ -12,7 +12,7 @@ export default domAssigned(class BracketedConstructor extends Constructor {
 
     const termString = term.getString();
 
-    context.trace(`Unifying the '${termString}' term with the bracketed constructor...`, term);
+    context.trace(`Unifying the '${termString}' term with the bracketed constructor...`);
 
     termUnifies = super.unifyTerm(term, context, () => {
       let verifiesAhead = false;
@@ -46,7 +46,7 @@ export default domAssigned(class BracketedConstructor extends Constructor {
     });
 
     if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the bracketed constructor.`, term);
+      context.debug(`...unified the '${termString}' term with the bracketed constructor.`);
     }
 
     return termUnifies;

package/src/dom/constructor.js

@@ -34,7 +34,7 @@ export default domAssigned(class Constructor {
           termString = term.getString(),
           constructorString = constructor.getString();
 
-    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, term);
+    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 
     const termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
 
@@ -51,7 +51,7 @@ export default domAssigned(class Constructor {
     }
 
     if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, term);
+      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);
     }
 
     return termUnifies;

package/src/dom/declaration/combinator.js

@@ -7,8 +7,9 @@ import { domAssigned } from "../../dom";
 import combinatorVerifier from "../../verifier/combinator";
 
 export default domAssigned(class CombinatorDeclaration {
-  constructor(context, string, combinator) {
+  constructor(context, node, string, combinator) {
     this.context = context;
+    this.node = node;
     this.string = string;
     this.combinator = combinator;
   }
@@ -17,6 +18,10 @@ export default domAssigned(class CombinatorDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -30,7 +35,7 @@ export default domAssigned(class CombinatorDeclaration {
 
     const combinatorDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
+    this.context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`, this.node);
 
     const combinatorVerifies = this.verifyCombinator();
 
@@ -41,7 +46,7 @@ export default domAssigned(class CombinatorDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`);
+      this.context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration.`, this.node);
     }
 
     return verifies;
@@ -52,7 +57,7 @@ export default domAssigned(class CombinatorDeclaration {
 
     const combinatorString = this.combinator.getString();
 
-    this.context.trace(`Verifying the '${combinatorString}' combinator...`);
+    this.context.trace(`Verifying the '${combinatorString}' combinator...`, this.node);
 
     const statement = this.combinator.getStatement(),
           statementNode = statement.getNode();
@@ -60,7 +65,7 @@ export default domAssigned(class CombinatorDeclaration {
     statementVerifies = combinatorVerifier.verifyStatement(statementNode, this.context);
 
     if (statementVerifies) {
-      this.context.debug(`...verified the '${combinatorString}' combinator.`);
+      this.context.debug(`...verified the '${combinatorString}' combinator.`, this.node);
     }
 
     return statementVerifies;
@@ -73,7 +78,7 @@ export default domAssigned(class CombinatorDeclaration {
           node = combinatorDeclarationNode, ///
           string = context.nodeAsString(node),
           combinator = Combinator.fromCombinatorDeclarationNode(combinatorDeclarationNode, context),
-          combinatorDeclaration = new CombinatorDeclaration(context, string, combinator);
+          combinatorDeclaration = new CombinatorDeclaration(context, node, string, combinator);
 
     return combinatorDeclaration;
   }

package/src/dom/declaration/complexType.js

@@ -7,8 +7,9 @@ import { domAssigned } from "../../dom";
 import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
-  constructor(context, string, type) {
+  constructor(context, node, string, type) {
     this.context = context;
+    this.node = node;
     this.string = string;
     this.type = type;
   }
@@ -17,6 +18,10 @@ export default domAssigned(class ComplexTypeDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -46,7 +51,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const complexTypeDeclarationString = this.getString();
 
-    this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
+    this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`, this.node);
 
     const typeVerifies = this.verifyType();
 
@@ -65,7 +70,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
+      this.context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`, this.node);
     }
 
     return verifies;
@@ -76,7 +81,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const complexTypeString = this.type.getString();
 
-    this.context.trace(`Verifying the '${complexTypeString}' complex type...`);
+    this.context.trace(`Verifying the '${complexTypeString}' complex type...`, this.node);
 
     const typeName = this.type.getName(),
           releaseTypes = this.getReleaseTypes(),
@@ -89,13 +94,13 @@ export default domAssigned(class ComplexTypeDeclaration {
           });
 
     if (typePresent) {
-      this.context.debug(`The type '${complexTypeString}' is already present in the package.`);
+      this.context.debug(`The type '${complexTypeString}' is already present in the package.`, this.node);
     } else {
       typeVerifies = true;
     }
 
     if (typeVerifies) {
-      this.context.debug(`...verified the '${complexTypeString}' complex type.`);
+      this.context.debug(`...verified the '${complexTypeString}' complex type.`, this.node);
     }
 
     return typeVerifies;
@@ -106,7 +111,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const superTypeString = superType.getString();
 
-    this.context.trace(`Verifying the '${superTypeString}' super-type...`);
+    this.context.trace(`Verifying the '${superTypeString}' super-type...`, this.node);
 
     const superTypeName = superType.getName(),
           superTypePresent = this.context.isTypePresentByTypeName(superTypeName);
@@ -116,7 +121,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     }
 
     if (superTypeVerifies) {
-      this.context.debug(`...verified the '${superTypeString}' super-type.`);
+      this.context.debug(`...verified the '${superTypeString}' super-type.`, this.node);
     }
 
     return superTypeVerifies;
@@ -125,7 +130,7 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerify = false;
 
-    this.context.trace(`Verifying the super-types...`);
+    this.context.trace(`Verifying the super-types...`, this.node);
 
     let superTypes;
 
@@ -150,7 +155,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     if (typeBasic) {
       superTypesVerify = true;
 
-      this.context.trace(`The '${typeString}' type is basic.`)
+      this.context.trace(`The '${typeString}' type is basic., this.node`)
     } else {
       const superTypeNames = superTypes.map((superType) => {
               const superTypeName = superType.getName();
@@ -160,7 +165,7 @@ export default domAssigned(class ComplexTypeDeclaration {
             superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
 
       if (superTypeNamesIncludesTypeName) {
-        this.context.trace(`The '${typeName}' type cannot be a super-type `);
+        this.context.trace(`The '${typeName}' type cannot be a super-type `, this.node);
       } else {
         if (superTypesLength === 0) {
           const type = this.context.findTypeByTypeName(typeName),
@@ -197,7 +202,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.context.debug(`...verified the super-types.`);
+      this.context.debug(`...verified the super-types.`, this.node);
     }
 
     return superTypesVerify;
@@ -208,7 +213,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const propertyString = property.getString();
 
-    this.context.trace(`Verifying the '${propertyString}' property...`);
+    this.context.trace(`Verifying the '${propertyString}' property...`, this.node);
 
     const propertyIdentifier = property.getIdentifier(),
           count = properties.reduce((count, property) => {
@@ -222,7 +227,7 @@ export default domAssigned(class ComplexTypeDeclaration {
           }, 0);
 
     if (count > 1) {
-      this.context.debug(`The '${propertyString}' property appears more than once.`);
+      this.context.debug(`The '${propertyString}' property appears more than once.`, this.node);
     } else {
       const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
         const propertyIdentifierMatches = superTypeProperty.matchPropertyIdentifier(propertyIdentifier);
@@ -235,7 +240,7 @@ export default domAssigned(class ComplexTypeDeclaration {
       if (superTypeProperty !== null) {
         const superTypePropertyString = superTypeProperty.getString();
 
-        this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`);
+        this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`, this.node);
       } else {
         let propertyType;
 
@@ -265,7 +270,7 @@ export default domAssigned(class ComplexTypeDeclaration {
         property.setType(this.type);
       }
 
-      this.context.debug(`verifies the '${propertyString}' property.`);
+      this.context.debug(`verifies the '${propertyString}' property.`, this.node);
     }
 
     return propertyVerifies;
@@ -306,7 +311,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     } else  {
       const propertyTypeString = propertyType.getString(); ///
 
-      this.context.trace(`Verifying the '${propertyTypeString}' property type...`);
+      this.context.trace(`Verifying the '${propertyTypeString}' property type...`, this.node);
 
       const propertyTypeName = propertyType.getName(),
             propertyTypePresent = this.context.isTypePresentByTypeName(propertyTypeName);
@@ -314,13 +319,13 @@ export default domAssigned(class ComplexTypeDeclaration {
       if (!propertyTypePresent) {
         const propertyTypeString = propertyType.getString();
 
-        this.context.debug(`The '${propertyTypeString}' property type is not present.`);
+        this.context.debug(`The '${propertyTypeString}' property type is not present.`, this.node);
       } else {
         propertyTypeVerifies = true;
       }
 
       if (propertyTypeVerifies) {
-        this.context.debug(`...verified the '${propertyTypeString}' property type.`);
+        this.context.debug(`...verified the '${propertyTypeString}' property type.`, this.node);
       }
     }
 
@@ -331,11 +336,12 @@ export default domAssigned(class ComplexTypeDeclaration {
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
     const { Type } = dom,
+          node = complexTypeDeclarationNode,  ///
           type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          complexTypeDeclaration = new ComplexTypeDeclaration(context, string, type);
+          complexTypeDeclaration = new ComplexTypeDeclaration(context, node, string, type);
 
     return complexTypeDeclaration;
   }

package/src/dom/declaration/constructor.js

@@ -7,8 +7,9 @@ import constructorVerifier from "../../verifier/constructor";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class ConstructorDeclaration {
-  constructor(context, string, constructor) {
+  constructor(context, node, string, constructor) {
     this.context = context;
+    this.node = node;
     this.string = string;
     this.constructor = constructor;
   }
@@ -17,6 +18,10 @@ export default domAssigned(class ConstructorDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -30,7 +35,7 @@ export default domAssigned(class ConstructorDeclaration {
 
     const constructorDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+    this.context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`, this.node);
 
     const constructorTypeVerifies = this.verifyConstructorType();
 
@@ -45,7 +50,7 @@ export default domAssigned(class ConstructorDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+      this.context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`, this.node);
     }
 
     return verifies;
@@ -56,7 +61,7 @@ export default domAssigned(class ConstructorDeclaration {
 
     const constructorString = this.constructor.getString();
 
-    this.context.trace(`Verifying the '${constructorString}' constructor...`);
+    this.context.trace(`Verifying the '${constructorString}' constructor...`, this.node);
 
     const term = this.constructor.getTerm(),
           termNode = term.getNode();
@@ -64,7 +69,7 @@ export default domAssigned(class ConstructorDeclaration {
     constructorVerifies = constructorVerifier.verifyTerm(termNode, this.context);
 
     if (constructorVerifies) {
-      this.context.debug(`...verified the '${constructorString}' constructor.`);
+      this.context.debug(`...verified the '${constructorString}' constructor.`, this.node);
     }
 
     return constructorVerifies;
@@ -80,7 +85,7 @@ export default domAssigned(class ConstructorDeclaration {
     const typeName = type.getName(),
           typeString = type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' type...`);
+    this.context.trace(`Verifying the '${typeString}' type...`, this.node);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
@@ -90,14 +95,14 @@ export default domAssigned(class ConstructorDeclaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.context.debug(`The '${typeString}' type is not present.`);
+      this.context.debug(`The '${typeString}' type is not present.`, this.node);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.context.debug(`The '${typeString}' type is present but not provisional.`) :
-            this.context.debug(`The '${typeString}' type is present but provisional.`);
+          this.context.debug(`The '${typeString}' type is present but not provisional.`, this.node) :
+            this.context.debug(`The '${typeString}' type is present but provisional.`, this.node);
       } else {
         this.constructor.setType(type);
 
@@ -106,7 +111,7 @@ export default domAssigned(class ConstructorDeclaration {
     }
 
     if (constructorTypeVerifies) {
-      this.context.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`, this.node);
     }
 
     return constructorTypeVerifies;
@@ -119,7 +124,7 @@ export default domAssigned(class ConstructorDeclaration {
           node = constructorDeclarationNode,  ///
           string = context.nodeAsString(node),
           constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, context),
-          constructorDeclaration = new ConstructorDeclaration(context, string, constructor);
+          constructorDeclaration = new ConstructorDeclaration(context, node, string, constructor);
 
     return constructorDeclaration;
   }