occam-verify-cli 1.0.826 → 1.0.828

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.826",
+  "version": "1.0.828",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/element/declaration/combinator.js

@@ -22,18 +22,16 @@ export default define(class CombinatorDeclaration extends Declaration {
     return combinatorDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const combinatorDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorValidates = this.validateCombinator();
+    const combinatorValidates = this.validateCombinator(context);
 
     if (combinatorValidates) {
       context.addCombinator(this.combinator);
@@ -48,11 +46,10 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
-  validateCombinator() {
+  validateCombinator(context) {
     let combinatorValidates;
 
-    const context = this.getContext(),
-          combinatorString = this.combinator.getString(),
+    const combinatorString = this.combinator.getString(),
           combinatorDeclarationString = this.getString();  ///
 
     context.trace(`Validating the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);

package/src/element/declaration/complexType.js

@@ -27,11 +27,9 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return complexTypeDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const complexTypeDeclarationString = this.getString(); ///
@@ -43,13 +41,13 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
       context.trace(`The '${typeString}' type is prefixed.`);
     } else {
-      const typeVerifies = this.verifyType();
+      const typeVerifies = this.verifyType(context);
 
       if (typeVerifies) {
-        const superTypesVerify = this.verifySuperTypes();
+        const superTypesVerify = this.verifySuperTypes(context);
 
         if (superTypesVerify) {
-          const propertiesVerify = this.verifyProperties();
+          const propertiesVerify = this.verifyProperties(context);
 
           if (propertiesVerify) {
             const typePrefix = context.getTypePrefix();
@@ -76,11 +74,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyType() {
+  verifyType(context) {
     let typeVerifies = false;
 
-    const context = this.getContext(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' complex type...`);
 
@@ -108,11 +105,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifySuperType(superType) {
+  verifySuperType(context, superType) {
     let superTypeVerifies = false;
 
-    const context = this.getContext(),
-          superTypeString = superType.getString();
+    const superTypeString = superType.getString();
 
     context.trace(`Verifying the '${superTypeString}' super-type...`);
 
@@ -145,11 +141,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return superTypeVerifies;
   }
 
-  verifySuperTypes() {
+  verifySuperTypes(context) {
     let superTypesVerify;
 
-    const context = this.getContext(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' complex type's super-types...`);
 
@@ -163,7 +158,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
       const superTypes = this.type.getSuperTypes();
 
       superTypesVerify = superTypes.every((superType) => {
-        const superTypeVerifies = this.verifySuperType(superType);
+        const superTypeVerifies = this.verifySuperType(context, superType);
 
         if (superTypeVerifies) {
           return true;
@@ -178,18 +173,17 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return superTypesVerify;
   }
 
-  verifyProperty(property, properties) {
+  verifyProperty(context, property, properties) {
     let propertyVerifies = false;
 
-    const context = this.getContext(),
-          propertyString = property.getString();
+    const propertyString = property.getString();
 
     context.trace(`Verifying the '${propertyString}' property...`);
 
-    const propertyNameVerifies = this.verifyPropertyName(property, properties);
+    const propertyNameVerifies = this.verifyPropertyName(context, property, properties);
 
     if (propertyNameVerifies) {
-      const propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(property, properties);
+      const propertyNominalTypeNameVerifies = this.verifyPropertyNominalTypeName(context, property, properties);
 
       if (propertyNominalTypeNameVerifies) {
         propertyVerifies = true;
@@ -203,11 +197,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return propertyVerifies;
   }
 
-  verifyProperties() {
+  verifyProperties(context) {
     let propertiesVerify;
 
-    const context = this.getContext(),
-          typeString = this.type.getString();
+    const typeString = this.type.getString();
 
     context.trace(`Verifying the '${typeString}' complex type's properties...`);
 
@@ -215,7 +208,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
           properties = this.type.getProperties(includeSuperTypes);
 
     propertiesVerify = properties.every((property) => {
-      const propertyVerifies = this.verifyProperty(property, properties);
+      const propertyVerifies = this.verifyProperty(context, property, properties);
 
       if (propertyVerifies) {
         return true;
@@ -229,11 +222,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return propertiesVerify;
   }
 
-  verifyPropertyName(property, properties) {
+  verifyPropertyName(context, property, properties) {
     let propertyNameVerifies = false;
 
-    const context = this.getContext(),
-          propertyString = property.getString();
+    const propertyString = property.getString();
 
     context.trace(`Verifying the '${propertyString}' property's name...`);
 
@@ -283,11 +275,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return propertyNameVerifies;
   }
 
-  verifyPropertyNominalTypeName(property) {
+  verifyPropertyNominalTypeName(context, property) {
     let propertyNominalTypeNameVerifies = false;
 
-    const context = this.getContext(),
-          propertyString = property.getString(),
+    const propertyString = property.getString(),
           nominalTypeName = property.getNominalTypeName();
 
     context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`);

package/src/element/declaration/constructor.js

@@ -32,21 +32,19 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const constructorDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    const typeVerified = this.verifyType();
+    const typeVerified = this.verifyType(context);
 
     if (typeVerified) {
-      const constructorValidates = this.validateConstructor();
+      const constructorValidates = this.validateConstructor(context);
 
       if (constructorValidates) {
         this.constructor.setType(this.type);
@@ -64,11 +62,10 @@ export default define(class ConstructorDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyType() {
+  verifyType(context) {
     let typeVerifies = false;
 
-    const context = this.getContext(),
-          typeString = this.type.getString(),
+    const typeString = this.type.getString(),
           constructorDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${typeString}' type...`);
@@ -100,11 +97,10 @@ export default define(class ConstructorDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  validateConstructor() {
+  validateConstructor(context) {
     let constructorValidates;
 
-    const context = this.getContext(),
-          includeType = false,
+    const includeType = false,
           constructorString = this.constructor.getString(includeType),
           constructorDeclarationString = this.getString();  ///
 

package/src/element/declaration/metavariable.js

@@ -20,21 +20,19 @@ export default define(class MetavariableDeclaration extends Declaration {
     return this.metavariable;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const metavariableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
-    const metavariableVerifies = this.verifyMetavariable();
+    const metavariableVerifies = this.verifyMetavariable(context);
 
     if (metavariableVerifies) {
-      const metaTypeVerifies = this.verifyMetaType();
+      const metaTypeVerifies = this.verifyMetaType(context);
 
       if (metaTypeVerifies) {
         const declaredMetavariable = this.metavariable; ///
@@ -52,11 +50,10 @@ export default define(class MetavariableDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyMetaType() {
+  verifyMetaType(context) {
     let metaTypeVerifies = true;
 
-    const context = this.getContext(),
-          metaTypeString = this.metaType.getString(),
+    const metaTypeString = this.metaType.getString(),
           metaTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${metaTypeDeclarationString}' metavariable declaration's '${metaTypeString}' metaType...`);
@@ -70,11 +67,10 @@ export default define(class MetavariableDeclaration extends Declaration {
     return metaTypeVerifies;
   }
 
-  verifyMetavariable() {
+  verifyMetavariable(context) {
     let metavariableVerifies = false;
 
-    const context = this.getContext(),
-          metavariableString = this.metavariable.getString(),
+    const metavariableString = this.metavariable.getString(),
           metavariableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration's '${metavariableString}' metavariable...`);

package/src/element/declaration/simpleType.js

@@ -34,27 +34,25 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return simpleTypeDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const simpleTypeDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
 
-    const typeVerifies = this.verifyType();
+    const typeVerifies = this.verifyType(context);
 
     if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes();
+      const superTypesVerify = this.verifySuperTypes(context);
 
       if (superTypesVerify) {
-        const typePrefixVerifies = this.verifyTypePrefix();
+        const typePrefixVerifies = this.verifyTypePrefix(context);
 
         if (typePrefixVerifies) {
-          const propertiesVerifies = this.verifyProperties();
+          const propertiesVerifies = this.verifyProperties(context);
 
           if (propertiesVerifies) {
             context.addType(this.type);
@@ -72,11 +70,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyType() {
+  verifyType(context) {
     let typeVerifies = false;
 
-    const context = this.getContext(),
-          typeString = this.type.getString(),
+    const typeString = this.type.getString(),
           simpleTypeDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type...`);
@@ -107,11 +104,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifySuperType(superType, superTypes) {
+  verifySuperType(context, superType, superTypes) {
     let superTypeVerifies = false;
 
-    const context = this.getContext(),
-          superTypeString = superType.getString(),
+    const superTypeString = superType.getString(),
           simpleTypeDeclarationString = this.getString(); ///;
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${superTypeString}' super-type...`);
@@ -141,11 +137,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return superTypeVerifies;
   }
 
-  verifySuperTypes() {
+  verifySuperTypes(context) {
     let superTypesVerify;
 
-    const context = this.getContext(),
-          superTypes = [],
+    const superTypes = [],
           superTypesString = superTypesStringFromSuperTypes(this.superTypes),
           simpleTypeDeclarationString = this.getString(); ///;
 
@@ -154,7 +149,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
         context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's super-types...`);
 
     superTypesVerify = this.superTypes.every((superType) => {
-      const superTypeVerifies = this.verifySuperType(superType, superTypes);
+      const superTypeVerifies = this.verifySuperType(context, superType, superTypes);
 
       if (superTypeVerifies) {
         return true;
@@ -181,12 +176,11 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return superTypesVerify;
   }
 
-  verifyTypePrefix() {
+  verifyTypePrefix(context) {
     let typePrefixVerifies = false;
 
-    const context = this.getContext(),
-      typeString = this.type.getString(),
-      simpleTypeDeclarationString = this.getString(); ///;
+    const typeString = this.type.getString(),
+          simpleTypeDeclarationString = this.getString(); ///;
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix...`);
 
@@ -205,11 +199,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typePrefixVerifies;
   }
 
-  verifyProperties() {
+  verifyProperties(context) {
     let propertiesVerify = true;  ///
 
-    const context = this.getContext(),
-          typeString = this.type.getString(),
+    const typeString = this.type.getString(),
           simpleTypeDeclarationString = this.getString(); ///;
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties...`);

package/src/element/declaration/typePrefix.js

@@ -22,11 +22,9 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return typePrefixDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const typePrefixDeclarationString = this.getString();  ///
@@ -37,7 +35,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
           typesLength = types.length;
 
     if (typesLength === 0) {
-      const typePrefixVerifies = this.verifyTypePrefix();
+      const typePrefixVerifies = this.verifyTypePrefix(context);
 
       if (typePrefixVerifies) {
         context.addTypePrefix(this.typePrefix);
@@ -55,11 +53,10 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyTypePrefix() {
+  verifyTypePrefix(context) {
     let typePrefixVerifies = false;
 
-    const context = this.getContext(),
-          typePrefixString = this.typePrefix.getString();
+    const typePrefixString = this.typePrefix.getString();
 
     context.trace(`Verifying the '${typePrefixString}' type prefix...`);
 

package/src/element/declaration/variable.js

@@ -32,21 +32,19 @@ export default define(class VariableDeclaration extends Declaration {
     return variableDeclarationNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const variableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
 
-    const typeVerifies = this.verifyType();
+    const typeVerifies = this.verifyType(context);
 
     if (typeVerifies) {
-      const variableVerifies = this.verifyVariable();
+      const variableVerifies = this.verifyVariable(context);
 
       if (variableVerifies) {
         const declaredVariable = this.variable;
@@ -64,11 +62,10 @@ export default define(class VariableDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyType() {
+  verifyType(context) {
     let typeVerifies = false;
 
-    const context = this.getContext(),
-          typeString = this.type.getString(),
+    const typeString = this.type.getString(),
           variableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${typeString}' type...`);
@@ -100,11 +97,10 @@ export default define(class VariableDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifyVariable() {
+  verifyVariable(context) {
     let  variableVerifies = false;
 
-    const context = this.getContext(),
-          variableString = this.variable.getString(),
+    const variableString = this.variable.getString(),
           variableDeclarationString = this.getString(); ///
 
     context.trace(`Verifying the '${variableDeclarationString}' variable declaration's '${variableString}' variable...`);

package/src/element/error.js

@@ -12,11 +12,10 @@ export default define(class Error extends Element {
     return errorNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext(),
-          errorString = this.getString();  ///
+    const errorString = this.getString();  ///
 
     context.warning(`The '${errorString}' error cannot be verified.`);
 

package/src/element/proofAssertion/premise.js

@@ -8,8 +8,8 @@ import { procedureCallFromPremiseNode } from "../../utilities/element";
 import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Premise extends ProofAssertion {
-  constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node, statement);
+  constructor(context, string, node, lineIndex, statement, procedureCall) {
+    super(context, string, node, lineIndex, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -305,13 +305,13 @@ export default define(class Premise extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               premiseNode = instantiatePremise(string, context),
               node = premiseNode,  ///
               statement = statementFromPremiseNode(premiseNode, context),
               procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 
-        premise = new Premise(context, string, node, statement, procedureCall);
+        premise = new Premise(context, string, node, lineIndex, statement, procedureCall);
       }, context);
     }, json, context);
 

package/src/element/proofAssertion/step.js

@@ -14,8 +14,8 @@ const { asyncSome } = asynchronousUtilities,
       { backwardsSome } = arrayUtilities;
 
 export default define(class Step extends ProofAssertion {
-  constructor(context, string, node, statement, reference, satisfiesAssertion) {
-    super(context, string, node, statement);
+  constructor(context, string, node, lineIndex, statement, reference, satisfiesAssertion) {
+    super(context, string, node, lineIndex, statement);
 
     this.reference = reference;
     this.satisfiesAssertion = satisfiesAssertion;

package/src/element/proofAssertion/supposition.js

@@ -8,8 +8,8 @@ import { procedureCallFromSuppositionNode } from "../../utilities/element";
 import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Supposition extends ProofAssertion {
-  constructor(context, string, node, statement, procedureCall) {
-    super(context, string, node, statement);
+  constructor(context, string, node, lineIndex, statement, procedureCall) {
+    super(context, string, node, lineIndex, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -327,13 +327,13 @@ export default define(class Supposition extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               suppositionNode = instantiateSupposition(string, context),
               node = suppositionNode,  ///
               statement = statementFromSuppositionNode(suppositionNode, context),
               procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 
-        supposition = new Supposition(context, string, node, statement, procedureCall);
+        supposition = new Supposition(context, string, node, lineIndex, statement, procedureCall);
       }, context);
     }, json, context);
 

package/src/element/rule.js

@@ -55,11 +55,9 @@ export default define(class Rule extends Element {
     return metavariableNodeMatches;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext();
-
     await this.break(context);
 
     const ruleString = this.getString(); ///
@@ -67,7 +65,7 @@ export default define(class Rule extends Element {
     context.trace(`Verifying the '${ruleString}' rule...`);
 
     await enclose(async (context) => {
-      const labelsVerify = this.verifyLabels();
+      const labelsVerify = this.verifyLabels(context);
 
       if (labelsVerify) {
         const premisesVerify = await this.verifyPremises(context);
@@ -97,11 +95,10 @@ export default define(class Rule extends Element {
     return verifies;
   }
 
-  verifyLabel(label) {
+  verifyLabel(context, label) {
     let labelVerifies;
 
-    const context = this.getContext(),
-          ruleString = this.getString(),  ///
+    const ruleString = this.getString(),  ///
           labelString = label.getString();
 
     context.trace(`Verifying the '${ruleString}' rule's '${labelString}' label...`);
@@ -115,16 +112,15 @@ export default define(class Rule extends Element {
     return labelVerifies;
   }
 
-  verifyLabels() {
+  verifyLabels(context) {
     let labelsVerify;
 
-    const context = this.getContext(),
-          ruleString = this.getString();  ///
+    const ruleString = this.getString();  ///
 
     context.trace(`Verifying the '${ruleString}' rule's labels...`);
 
     labelsVerify = this.labels.every((label) => {
-      const labelVerifies = this.verifyLabel(label);
+      const labelVerifies = this.verifyLabel(context, label);
 
       if (labelVerifies) {
         return true;

package/src/element/section.js

@@ -42,11 +42,10 @@ export default define(class Section extends Element {
     return sectionNode;
   }
 
-  async verify() {
+  async verify(context) {
     let verifies = false;
 
-    const context = this.getContext(),
-          sectionString = this.getString();  ///
+    const sectionString = this.getString();  ///
 
     context.trace(`Verifying the '${sectionString}' section...`);