occam-verify-cli 1.0.521 → 1.0.524

package/src/element/declaration/typePrefix.js

@@ -18,29 +18,28 @@ export default define(class TypePrefixDeclaration extends Declaration {
   verifyTypePrefix() {
     let typePrefixVerifies = false;
 
-    const node = this.getNode(),
-          context = this.getContext(),
+    const context = this.getContext(),
           typePrefixString = this.typePrefix.getString();
 
-    context.trace(`Verifying the '${typePrefixString}' type prefix...`, node);
+    context.trace(`Verifying the '${typePrefixString}' type prefix...`);
 
     const typePrefix = context.getTypePrefix();
 
     if (typePrefix !== null) {
-      context.trace(`The package already has a '${typePrefixString}' type prefix.`, node);
+      context.trace(`The package already has a '${typePrefixString}' type prefix.`);
     } else {
 
       const typePrefixName = this.typePrefix.getName(),
             typePrefixPresent = context.isTypePrefixPresentByTypePrefixName(typePrefixName);
 
       if (typePrefixPresent) {
-        context.trace(`The '${typePrefixString}' type prefix is already present.`, node);
+        context.trace(`The '${typePrefixString}' type prefix is already present.`);
       } else {
         const nominalTypeName = typePrefixName,  ///
               typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
 
         if (typePresent) {
-          context.trace(`The '${typePrefixString}' type is already present.`, node);
+          context.trace(`The '${typePrefixString}' type is already present.`);
         } else {
           typePrefixVerifies = true;
         }
@@ -48,7 +47,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
     }
 
     if (typePrefixVerifies) {
-      context.debug(`...verified the '${typePrefixString}' type prefix.`, node);
+      context.debug(`...verified the '${typePrefixString}' type prefix.`);
     }
 
     return typePrefixVerifies;
@@ -57,11 +56,10 @@ export default define(class TypePrefixDeclaration extends Declaration {
   async verify() {
     let verifies = false;
 
-    const node = this.getNode(),
-          context = this.getContext(),
+    const context = this.getContext(),
           typePrefixDeclarationString = this.getString();  ///
 
-    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`, node);
+    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
 
     const includeRelease = true,
           includeDependencies = false,
@@ -69,7 +67,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
           typesLength = types.length;
 
     if (typesLength > 0) {
-      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
+      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`);
     } else {
       const typePrefixVerifies = this.verifyTypePrefix();
 
@@ -81,7 +79,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
     }
 
     if (verifies) {
-      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`, node);
+      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`);
     }
 
     return verifies;

package/src/element/declaration/variable.js

@@ -18,23 +18,22 @@ export default define(class VariableDeclaration extends Declaration {
   verifyVariable() {
     let  variableVerifies = false;
 
-    const node = this.getNode(),
-          context = this.getContext(),
+    const context = this.getContext(),
           variableString = this.variable.getString();
 
-    context.trace(`Verifying the '${variableString}' variable...`, node);
+    context.trace(`Verifying the '${variableString}' variable...`);
 
     const variableIdentifier = this.variable.getIdentifier(),
           variablePresent = context.isVariablePresentByVariableIdentifier(variableIdentifier);
 
     if (variablePresent) {
-      context.debug(`The '${variableName}' variable is already present.`, node);
+      context.debug(`The '${variableName}' variable is already present.`);
     } else {
       variableVerifies = true;
     }
 
     if ( variableVerifies) {
-      context.debug(`...verified the '${variableString}' variable.`, node);
+      context.debug(`...verified the '${variableString}' variable.`);
     }
 
     return variableVerifies;
@@ -43,8 +42,7 @@ export default define(class VariableDeclaration extends Declaration {
   verifyVariableType() {
     let variableTypeVerifies = false;
 
-    const node = this.getNode(),
-          context = this.getContext();
+    const context = this.getContext();
 
     let type;
 
@@ -52,7 +50,7 @@ export default define(class VariableDeclaration extends Declaration {
 
     const typeString = type.getString();
 
-    context.trace(`Verifying the '${typeString}' type...`, node);
+    context.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes),
@@ -63,14 +61,14 @@ export default define(class VariableDeclaration extends Declaration {
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      context.debug(`The '${typeString}' type is not present.`, node);
+      context.debug(`The '${typeString}' type is not present.`);
     } else {
       const typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
         provisional ?
-          context.debug(`The '${typeString}' type is present but not provisional.`, node) :
-            context.debug(`The '${typeString}' type is present but provisional.`, node);
+          context.debug(`The '${typeString}' type is present but not provisional.`) :
+            context.debug(`The '${typeString}' type is present but provisional.`);
       } else {
         this.variable.setType(type);
 
@@ -79,7 +77,7 @@ export default define(class VariableDeclaration extends Declaration {
     }
 
     if (variableTypeVerifies) {
-      context.debug(`...verified the '${typeString}' type.`, node);
+      context.debug(`...verified the '${typeString}' type.`);
     }
 
     return variableTypeVerifies;

package/src/element/deduction.js

@@ -20,10 +20,9 @@ export default define(class Deduction extends Element {
   verify(context) {
     let verifies = false;
 
-    const node = this.getNode(),
-          deductionString = this.getString();  ///
+    const deductionString = this.getString();  ///
 
-    context.trace(`Verifying the '${deductionString}' deduction...`, node);
+    context.trace(`Verifying the '${deductionString}' deduction...`);
 
     if (this.statement !== null) {
       attempt((context) => {
@@ -38,11 +37,11 @@ export default define(class Deduction extends Element {
         }
       }, context);
     } else {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, node);
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${deductionString}' deduction.`, node);
+      context.debug(`...verified the '${deductionString}' deduction.`);
     }
 
     return verifies;

package/src/element/hypothesis.js

@@ -57,11 +57,10 @@ export default define(class Hypothesis extends Element {
   compareProofAssertion(proofAssertion, context) {
     let comparesToProofAssertion = false;
 
-    const node = this.getNode(),
-          hypothesisString = this.getString(), ///
+    const hypothesisString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
 
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`, node);
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`);
 
     const proofAssertionStatement = proofAssertion.getStatement(),
           statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
@@ -71,7 +70,7 @@ export default define(class Hypothesis extends Element {
     }
 
     if (comparesToProofAssertion) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`, node);
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`);
     }
 
     return comparesToProofAssertion;

package/src/element/proofAssertion/premise.js

@@ -37,7 +37,7 @@ export default define(class Premise extends ProofAssertion {
     const node = this.getNode(),
           premiseString = this.getString(); ///
 
-    context.trace(`Verifying the '${premiseString}' premise...`, node);
+    context.trace(`Verifying the '${premiseString}' premise...`);
 
     const statement = this.getStatement(),
           procedureCall = this.getProcedureCall();
@@ -74,11 +74,11 @@ export default define(class Premise extends ProofAssertion {
         }
       }, context);
     } else {
-      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`, node);
+      context.debug(`Unable to verify the '${premiseString}' premise because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${premiseString}' premise.`, node);
+      context.debug(`...verified the '${premiseString}' premise.`);
     }
 
     return verifies;
@@ -202,11 +202,10 @@ export default define(class Premise extends ProofAssertion {
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
-    const node = this.getNode(),
-          premiseString = this.getString(),
+    const premiseString = this.getString(),
           subproofString = subproof.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`, node);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`);
 
     const specificContext = context;  ///
 
@@ -236,7 +235,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`, node);
+      context.debug(`...unified the '${subproofString}' subproof with the '${premiseString}' premise.`);
     }
 
     return subproofUnifies;

package/src/element/proofAssertion/step.js

@@ -59,10 +59,9 @@ export default define(class Step extends ProofAssertion {
   verify(assignments, context) {
     let verifies = false;
 
-    const node = this.getNode(),
-          stepString = this.getString(); ///
+    const stepString = this.getString(); ///
 
-    context.trace(`Verifying the '${stepString}' step...`, node);
+    context.trace(`Verifying the '${stepString}' step...`);
 
     const statement = this.getStatement();
 
@@ -103,11 +102,11 @@ export default define(class Step extends ProofAssertion {
         return verifies;
       }, context);
     } else {
-      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`, node);
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${stepString}' step.`, node);
+      context.debug(`...verified the '${stepString}' step.`);
     }
 
     return verifies;

package/src/element/proofAssertion/supposition.js

@@ -34,10 +34,9 @@ export default define(class Supposition extends ProofAssertion {
   verify(context) {
     let verifies = false;
 
-    const node = this.getNode(),
-          suppositionString = this.getString(); ///
+    const suppositionString = this.getString(); ///
 
-    context.trace(`Verifying the '${suppositionString}' supposition...`, node);
+    context.trace(`Verifying the '${suppositionString}' supposition...`);
 
     const statement = this.getStatement(),
           procedureCall = this.getProcedureCall();
@@ -74,11 +73,11 @@ export default define(class Supposition extends ProofAssertion {
         }
       }, context);
     } else {
-      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`, node);
+      context.debug(`Unable to verify the '${suppositionString}' supposition because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${suppositionString}' supposition.`, node);
+      context.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
     return verifies;
@@ -202,11 +201,10 @@ export default define(class Supposition extends ProofAssertion {
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
-    const node = this.getNode(),
-          subproofString = subproof.getString(),
+    const subproofString = subproof.getString(),
           suppositionString = this.getString(); ///
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`, node);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
 
     const specificContext = context;  ///
 
@@ -236,7 +234,7 @@ export default define(class Supposition extends ProofAssertion {
     }
 
     if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`, node);
+      context.debug(`...unified the '${subproofString}' subproof with the '${suppositionString}' supposition.`);
     }
 
     return subproofUnifies;
@@ -245,13 +243,12 @@ export default define(class Supposition extends ProofAssertion {
   unifySupposition(supposition, substitutions, generalContext, specificContext) {
     let suppositionUnifies;
 
-    const node = this.getNode(),
-          context = specificContext,  ///
+    const context = specificContext,  ///
           specificSupposition = supposition,  ///
           generalSuppositionString = this.getString(), ///
           specificSuppositionString = specificSupposition.getString();
 
-    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`, node);
+    context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
 
     const statement = specificSupposition.getStatement(),
           statementUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
@@ -259,7 +256,7 @@ export default define(class Supposition extends ProofAssertion {
     suppositionUnifies = statementUnifies;  ///
 
     if (suppositionUnifies) {
-      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`, node);
+      context.debug(`...unified the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition.`);
     }
 
     return suppositionUnifies;

package/src/element/rule.js

@@ -185,11 +185,10 @@ export default define(class Rule extends Element {
   async verify() {
     let verifies = false;
 
-    const node = this.getNode(),
-          context = this.getContext(),
+    const context = this.getContext(),
           ruleString = this.getString(); ///
 
-    context.trace(`Verifying the '${ruleString}' rule...`, node);
+    context.trace(`Verifying the '${ruleString}' rule...`);
 
     scope((context) => {
       const labelsVerify = this.verifyLabels();
@@ -216,7 +215,7 @@ export default define(class Rule extends Element {
 
       context.addRule(rule);
 
-      context.debug(`...verified the '${ruleString}' rule.`, node);
+      context.debug(`...verified the '${ruleString}' rule.`);
     }
 
     return verifies;

package/src/element/topLevelAssertion/axiom.js

@@ -57,16 +57,15 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context = step.getContext();
 
-    const node = this.getNode(),
-          stepString = step.getString(),
+    const stepString = step.getString(),
           axiomString = this.getString();
 
-    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`, node);
+    context.trace(`Unifying the '${stepString}' step with the '${axiomString}' axiom...`);
 
     const unconditional = this.isUnconditional();
 
     if (!unconditional) {
-      context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`, node);
+      context.trace(`Unable to unify the '${stepString}' step with the '${axiomString}' axiom because the axiom is not unconditional.`);
     } else {
       const statement = step.getStatement(),
             statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, substitutions, context);
@@ -77,7 +76,7 @@ export default define(class Axiom extends TopLevelAssertion {
     }
 
     if (stepUnifies) {
-      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`, node);
+      context.debug(`...unified the '${stepString}' step with the '${axiomString}' axiom.`);
     }
 
     return stepUnifies;
@@ -86,16 +85,15 @@ export default define(class Axiom extends TopLevelAssertion {
   unifySubproof(subproof, substitutions, context) {
     let subproofUnifies = false;
 
-    const node = this.getNode(),
-          axiomString = this.getString(),
+    const axiomString = this.getString(),
           subproofString = subproof.getString();
 
-    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`, node);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
 
     const unconditional = this.isUnconditional();
 
     if (unconditional) {
-      context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`, node);
+      context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
     } else {
       const lastProofAssertion = subproof.getLastProofAssertion(),
             lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, substitutions, context);
@@ -111,7 +109,7 @@ export default define(class Axiom extends TopLevelAssertion {
     }
 
     if (subproofUnifies) {
-      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`, node);
+      context.debug(`...unified the '${subproofString}' subproof with the '${axiomString}' axiom.`);
     }
 
     return subproofUnifies;

package/src/element/topLevelAssertion/conjecture.js

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

package/src/element/topLevelAssertion/lemma.js

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

package/src/element/topLevelAssertion/theorem.js

@@ -8,11 +8,10 @@ export default define(class Theorem extends TopLevelAssertion {
   async verify() {
     let verifies;
 
-    const node = this.getNode(),
-          context = this.getContext(),
+    const context = this.getContext(),
           theoremString = this.getString();  ///
 
-    context.trace(`Verifying the '${theoremString}' theorem...`, node);
+    context.trace(`Verifying the '${theoremString}' theorem...`);
 
     verifies = super.verify();
 
@@ -21,7 +20,7 @@ export default define(class Theorem extends TopLevelAssertion {
 
       context.addTheorem(theorem);
 
-      context.debug(`...verified the '${theoremString}' theorem.`, node);
+      context.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verifies;

package/src/element/topLevelMetaAssertion/metaLemma.js

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

package/src/element/topLevelMetaAssertion/metatheorem.js

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

package/src/utilities/customGrammar.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
+import { CustomGrammar, CombinedCustomGrammar } from "occam-nominal";
 
 export function customGrammarFromNameAndEntries(name, entries) {
   const termBNF = entries.getTermBNF(),

package/src/utilities/nominal.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+import { lexersUtilities, parsersUtilities } from "occam-nominal";
 
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";