occam-verify-cli 1.0.281 → 1.0.285

package/src/dom/declaration/metavariable.js

@@ -5,8 +5,9 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class MetavariableDeclaration {
-  constructor(context, string, metavariable) {
+  constructor(context, node, string, metavariable) {
     this.context = context;
+    this.node = node;
     this.string = string;
     this.metavariable = metavariable;
   }
@@ -15,6 +16,10 @@ export default domAssigned(class MetavariableDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -28,7 +33,7 @@ export default domAssigned(class MetavariableDeclaration {
 
     const metavariableDeclarationString = this.string; ///
 
-    this.context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
+    this.context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`, this.node);
 
     const metavariableVerifies = this.verifyMetavariable(this.metavariable);
 
@@ -39,7 +44,7 @@ export default domAssigned(class MetavariableDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
+      this.context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`, this.node);
     }
 
     return verifies;
@@ -54,18 +59,18 @@ export default domAssigned(class MetavariableDeclaration {
       const typeName = type.getName(),
             typeString = type.getString();
 
-      this.context.trace(`Verifying the '${typeString}' type...`);
+      this.context.trace(`Verifying the '${typeString}' type...`, this.node);
 
       const typePresent = this.context.isTypePresentByTypeName(typeName);
 
       if (!typePresent) {
-        this.context.debug(`The '${typeString}' type is not present.`);
+        this.context.debug(`The '${typeString}' type is not present.`, this.node);
       } else {
         typeVerifies = true;
       }
 
       if (typeVerifies) {
-        this.context.debug(`...verified the '${typeString}' type.`);
+        this.context.debug(`...verified the '${typeString}' type.`, this.node);
       }
     }
 
@@ -77,19 +82,19 @@ export default domAssigned(class MetavariableDeclaration {
 
     const metavariableString = metavariable.getString();
 
-    this.context.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
+    this.context.trace(`Verifying the '${metavariableString}' metavariable when declared...`, this.node);
 
     const metavariableNode = metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
 
     if (termNode !== null) {
-      this.context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
+      this.context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`, this.node);
     } else {
       const metavariableName = metavariable.getName(),
             metavariablePresent = this.context.isMetavariablePresentByMetavariableName(metavariableName);
 
       if (metavariablePresent) {
-        this.context.debug(`The '${metavariableName}' metavariable is already present.`);
+        this.context.debug(`The '${metavariableName}' metavariable is already present.`, this.node);
       } else {
         const type = metavariable.getType(),
               typeVerifies = this.verifyType(type);
@@ -99,7 +104,7 @@ export default domAssigned(class MetavariableDeclaration {
     }
 
     if (metavariableVerifies) {
-      this.context.debug(`...verified the '${metavariableString}' metavariable when declared.`);
+      this.context.debug(`...verified the '${metavariableString}' metavariable when declared.`, this.node);
     }
 
     return metavariableVerifies;
@@ -109,10 +114,11 @@ export default domAssigned(class MetavariableDeclaration {
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const { Metavariable } = dom,
+          node = metavariableDeclarationNode, ///
           metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           string = stringFromMetavariableAndMetaType(metavariable, metaType),
-          metavariableDeclaration = new MetavariableDeclaration(context, string, metavariable);
+          metavariableDeclaration = new MetavariableDeclaration(context, node, string, metavariable);
 
     return metavariableDeclaration;
   }

package/src/dom/declaration/simpleType.js

@@ -7,8 +7,9 @@ import { domAssigned } from "../../dom";
 import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class SimpleTypeDeclaration {
-  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 SimpleTypeDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -30,7 +35,7 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     const typeDeclarationString = this.getString(); ///
 
-    this.context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+    this.context.trace(`Verifying the '${typeDeclarationString}' type declaration...`), this.node;
 
     const typeVerifies = this.verifyType();
 
@@ -45,7 +50,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+      this.context.debug(`...verified the '${typeDeclarationString}' type declaration.`, this.node);
     }
 
     return verifies;
@@ -56,19 +61,19 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     const typeString = this.type.getString();
 
-    this.context.trace(`Verifying the '${typeString}' type...`);
+    this.context.trace(`Verifying the '${typeString}' type...`), this.node;
 
     const typeName = this.type.getName(),
           typePresent = this.context.isTypePresentByTypeName(typeName);
 
     if (typePresent) {
-      this.context.debug(`The type '${typeString}' is already present.`);
+      this.context.debug(`The type '${typeString}' is already present.`, this.node);
     } else {
       typeVerifies = true;
     }
 
     if (typeVerifies) {
-      this.context.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`, this.node);
     }
 
     return typeVerifies;
@@ -79,7 +84,7 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     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);
@@ -89,7 +94,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     }
 
     if (superTypeVerifies) {
-      this.context.debug(`...verified the '${superTypeString}' super-type.`);
+      this.context.debug(`...verified the '${superTypeString}' super-type.`, this.node);
     }
 
     return superTypeVerifies;
@@ -98,7 +103,7 @@ export default domAssigned(class SimpleTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerify = false;
 
-    this.context.trace(`Verifying the super-types...`);
+    this.context.trace(`Verifying the super-types...`), this.node;
 
     let superTypes;
 
@@ -119,7 +124,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     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();
@@ -129,7 +134,7 @@ export default domAssigned(class SimpleTypeDeclaration {
             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 {
         superTypesVerify = superTypes.every((superType) => {
           const superTypeVerifies = this.verifySuperType(superType);
@@ -158,7 +163,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.context.debug(`...verified the super-types.`);
+      this.context.debug(`...verified the super-types.`, this.node);
     }
 
     return superTypesVerify;
@@ -168,11 +173,12 @@ export default domAssigned(class SimpleTypeDeclaration {
 
   static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
     const { Type } = dom,
+          node = simpleTypeDeclarationNode, ///
           type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, type);
+          simpleTypeDeclaration = new SimpleTypeDeclaration(context, node, string, type);
 
     return simpleTypeDeclaration;
   }

package/src/dom/declaration/variable.js

@@ -5,8 +5,9 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class VariableDeclaration {
-  constructor(context, string, variable) {
+  constructor(context, node, string, variable) {
     this.context = context;
+    this.node = node;
     this.string = string;
     this.variable = variable;
   }
@@ -15,6 +16,10 @@ export default domAssigned(class VariableDeclaration {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -28,7 +33,7 @@ export default domAssigned(class VariableDeclaration {
 
     const variableDeclarationString = this.getString();
 
-    this.context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
+    this.context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`, this.node);
 
     const variableTypeVerifies = this.verifyVariableType();
 
@@ -43,7 +48,7 @@ export default domAssigned(class VariableDeclaration {
     }
 
     if (verifies) {
-      this.context.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+      this.context.debug(`...verified the '${variableDeclarationString}' variable declaration.`, this.node);
     }
 
     return verifies;
@@ -54,19 +59,19 @@ export default domAssigned(class VariableDeclaration {
 
     const variableString = this.variable.getString();
 
-    this.context.trace(`Verifying the '${variableString}' variable...`);
+    this.context.trace(`Verifying the '${variableString}' variable...`, this.node);
 
     const variableIdentifier = this.variable.getIdentifier(),
           variablePresent = this.context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
     if (variablePresent) {
-      this.context.debug(`The '${variableName}' variable is already present.`);
+      this.context.debug(`The '${variableName}' variable is already present.`, this.node);
     } else {
       variableVerifies = true;
     }
 
     if ( variableVerifies) {
-      this.context.debug(`...verified the '${variableString}' variable.`);
+      this.context.debug(`...verified the '${variableString}' variable.`, this.node);
     }
 
     return  variableVerifies;
@@ -82,7 +87,7 @@ export default domAssigned(class VariableDeclaration {
     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);
@@ -92,14 +97,14 @@ export default domAssigned(class VariableDeclaration {
     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.variable.setType(type);
 
@@ -108,7 +113,7 @@ export default domAssigned(class VariableDeclaration {
     }
 
     if (variableTypeVerifies) {
-      this.context.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`, this.node);
     }
 
     return variableTypeVerifies;
@@ -121,7 +126,7 @@ export default domAssigned(class VariableDeclaration {
           node = variableDeclarationNode, ///
           string = context.nodeAsString(node),
           variable = Variable.fromVariableDeclarationNode(variableDeclarationNode, context),
-          variableDeclaration = new VariableDeclaration(context, string, variable);
+          variableDeclaration = new VariableDeclaration(context, node, string, variable);
 
     return variableDeclaration;
   }

package/src/dom/deduction.js

@@ -6,11 +6,16 @@ import { domAssigned } from "../dom";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export default domAssigned(class Deduction {
-  constructor(string, statement) {
+  constructor(node, string, statement) {
+    this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getNode(node) {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -24,7 +29,7 @@ export default domAssigned(class Deduction {
 
     const deductionString = this.string;  ///
 
-    context.trace(`Verifying the '${deductionString}' deduction...`);
+    context.trace(`Verifying the '${deductionString}' deduction...`, this.node);
 
     if (this.statement !== null) {
       const stated = true,
@@ -33,11 +38,11 @@ export default domAssigned(class Deduction {
 
       verifies = statementVerifies; ///
     } else {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${deductionString}' deduction.`);
+      context.debug(`...verified the '${deductionString}' deduction.`, this.node);
     }
 
     return verifies;
@@ -50,12 +55,12 @@ export default domAssigned(class Deduction {
           statementString = statement.getString(),
           deductionString = deduction.getString();
 
-    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${deductionString}' deduction...`, this.node);
 
     statementUnifies = this.statement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnifies) {
-      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${deductionString}' deduction.`, this.node);
     }
 
     return statementUnifies;
@@ -69,7 +74,7 @@ export default domAssigned(class Deduction {
           generalDeductionString = this.string, ///
           specificDeductionString = specificDeduction.getString();
 
-    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`);
+    context.trace(`Unifying the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction...`, this.node);
 
     const statement = specificDeduction.getStatement(),
           statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
@@ -77,7 +82,7 @@ export default domAssigned(class Deduction {
     deductionUnifies = statementUnifies;  ///
 
     if (deductionUnifies) {
-      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`);
+      context.debug(`...unified the '${specificDeductionString}' deduction with the '${generalDeductionString}' deduction.`, this.node);
     }
 
     return deductionUnifies;
@@ -97,8 +102,9 @@ export default domAssigned(class Deduction {
 
   static fromJSON(json, context) {
     const statement = statementFromJSON(json, context),
+          node = null,
           string = statement.getString(),
-          deduction = new Deduction(string, statement);
+          deduction = new Deduction(node, string, statement);
 
     return deduction;
   }
@@ -108,7 +114,7 @@ export default domAssigned(class Deduction {
           node = deductionNode,  ///
           string = context.nodeAsString(node),
           statement = Statement.fromDeductionNode(deductionNode, context),
-          deduction = new Deduction(string, statement);
+          deduction = new Deduction(node, string, statement);
 
     return deduction;
   }

package/src/dom/error.js

@@ -3,8 +3,9 @@
 import { domAssigned } from "../dom";
 
 export default domAssigned(class Error {
-  constructor(context, string) {
+  constructor(context, node, string) {
     this.context = context;
+    this.node = node;
     this.string = string;
   }
 
@@ -12,6 +13,10 @@ export default domAssigned(class Error {
     return this.context;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -21,7 +26,7 @@ export default domAssigned(class Error {
 
     const errorString = this.string;  ///
 
-    this.context.warning(`The '${errorString}' error cannot be verified.`);
+    this.context.warning(`The '${errorString}' error cannot be verified.`, this.node);
 
     return verifies;
   }
@@ -31,7 +36,7 @@ export default domAssigned(class Error {
   static fromErrorNode(errorNode, context) {
     const node = errorNode, ///
           string = context.nodeAsString(node),
-          error = new Error(context, string);
+          error = new Error(context, node, string);
 
     return error;
   }

package/src/dom/hypothesis.js

@@ -8,11 +8,16 @@ import { subproofAssertionFromStatement } from "../utilities/context";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export default domAssigned(class Hypothesis {
-  constructor(string, statement) {
+  constructor(node, string, statement) {
+    this.node = node;
     this.string = string;
     this.statement = statement;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getString() {
     return this.string;
   }
@@ -26,7 +31,7 @@ export default domAssigned(class Hypothesis {
 
     const hypothesisString = this.string; ///
 
-    context.trace(`Verifying the '${hypothesisString}' hypothesis...`);
+    context.trace(`Verifying the '${hypothesisString}' hypothesis...`, this.node);
 
     if (false) {
       ///
@@ -49,11 +54,11 @@ export default domAssigned(class Hypothesis {
         }
       }
     } else {
-      context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`);
+      context.debug(`Unable to verify the '${hypothesisString}' hypothesis because it is nonsense.`, this.node);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${hypothesisString}' hypothesis.`);
+      context.debug(`...verified the '${hypothesisString}' hypothesis.`, this.node);
     }
 
     return verifies;
@@ -65,7 +70,7 @@ export default domAssigned(class Hypothesis {
     const stepString = step.getString(),
           hypothesisString = this.string; ///
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${stepString}' step...`, this.node);
 
     const stepStatement = step.getStatement(),
           statementEqualToStepStatement = this.statement.isEqualTo(stepStatement);
@@ -75,7 +80,7 @@ export default domAssigned(class Hypothesis {
     }
 
     if (equalToStep) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`);
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${stepString}' step.`, this.node);
     }
 
     return equalToStep;
@@ -102,7 +107,8 @@ export default domAssigned(class Hypothesis {
       string = statement.getString();
     }
 
-    const hypothesis = new Hypothesis(string, statement);
+    const node = null,
+          hypothesis = new Hypothesis(node, string, statement);
 
     return hypothesis;
   }
@@ -112,7 +118,7 @@ export default domAssigned(class Hypothesis {
           node = hypothesisNode, ///
           string = context.nodeAsString(node),
           statement = Statement.fromHypothesisNode(hypothesisNode, context),
-          hypothesis = new Hypothesis(string, statement);
+          hypothesis = new Hypothesis(node, string, statement);
 
     return hypothesis
   }

package/src/dom/lemma.js

@@ -9,12 +9,13 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
     let verifies;
 
     const lemma = this, ///
+          node = this.getNode(),
           context = this.getContext(),
           lemmaString = lemma.getString();
 
     (lemmaString === null) ?
-      context.trace(`Verifying a lemma...`) :
-        context.trace(`Verifying the '${lemmaString}' lemma...`);
+      context.trace(`Verifying a lemma...`, node) :
+        context.trace(`Verifying the '${lemmaString}' lemma...`, node);
 
     verifies = super.verify();
 
@@ -24,8 +25,8 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
       context.addLemma(lemma);
 
       (lemmaString === null) ?
-        context.debug(`...verified a lemma.`) :
-          context.debug(`...verified the '${lemmaString}' lemma.`);
+        context.debug(`...verified a lemma.`, node) :
+          context.debug(`...verified the '${lemmaString}' lemma.`, node);
     }
 
     return verifies;

package/src/dom/metaLemma.js

@@ -8,11 +8,12 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const context = this.getContext(),
+    const node = this.getNode(),
+          context = this.getContext(),
           metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
+    context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`, node);
 
     verifies = super.verify();
 
@@ -21,7 +22,7 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
       context.addMetatheorem(metaTheorem);
 
-      context.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
+      context.debug(`...verified the '${metaLemmaString}' meta-lemma.`, node);
     }
 
     return verifies;

package/src/dom/metatheorem.js

@@ -8,11 +8,12 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const context = this.getContext(),
+    const node = this.getNode(),
+          context = this.getContext(),
           metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    context.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
+    context.trace(`Verifying the '${metaLemmaString}' metatheorem...`, node);
 
     verifies = super.verify();
 
@@ -21,7 +22,7 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
       context.addMetatheorem(metaTheorem);
 
-      context.debug(`...verified the '${metaLemmaString}' metatheorem.`);
+      context.debug(`...verified the '${metaLemmaString}' metatheorem.`, node);
     }
 
     return verifies;