occam-verify-cli 1.0.825 → 1.0.827

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.825",
+  "version": "1.0.827",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,12 +12,12 @@
   "dependencies": {
     "argumentative": "^2.0.47",
     "necessary": "^17.1.7",
-    "occam-furtle": "^3.0.179",
+    "occam-furtle": "^3.0.180",
     "occam-grammars": "^1.3.520",
-    "occam-languages": "^0.0.175",
+    "occam-languages": "^0.0.178",
     "occam-lexers": "^23.1.44",
     "occam-model": "^1.0.505",
-    "occam-nominal": "^1.0.90",
+    "occam-nominal": "^1.0.91",
     "occam-parsers": "^23.1.50",
     "occam-server": "^7.0.6"
   },

package/src/element/assertion/contained.js

@@ -13,8 +13,8 @@ import { termFromContainedAssertionNode,
          containedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class ContainedAssertion extends Assertion {
-  constructor(context, string, node, term, frame, negated, statement) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, term, frame, negated, statement) {
+    super(context, string, node, lineIndex);
 
     this.term = term;
     this.frame = frame;
@@ -243,6 +243,12 @@ export default define(class ContainedAssertion extends Assertion {
     return unifiesIndependently;
   }
 
+  toJSON() {
+    const json = super.toJSON();
+
+    return json;
+  }
+
   static name = "ContainedAssertion";
 
   static fromJSON(json, context) {
@@ -252,7 +258,7 @@ export default define(class ContainedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               containedAssertionNode = instantiateContainedAssertion(string, context),
               node = containedAssertionNode,  ///
               term = termFromContainedAssertionNode(containedAssertionNode, context),
@@ -262,7 +268,7 @@ export default define(class ContainedAssertion extends Assertion {
 
         context = null;
 
-        containedAssertion = new ContainedAssertion(context, string, node, term, frame, negated, statement);
+        containedAssertion = new ContainedAssertion(context, string, node, lineIndex, term, frame, negated, statement);
       }, context);
     }
 

package/src/element/assertion/property.js

@@ -9,8 +9,8 @@ import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
 import { termFromPropertyAssertionNode, propertyAssertionFromStatementNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
 
 export default define(class PropertyAssertion extends Assertion {
-  constructor(context, string, node, term, propertyRelation) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, term, propertyRelation) {
+    super(context, string, node, lineIndex);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -203,6 +203,12 @@ export default define(class PropertyAssertion extends Assertion {
     context.addAssignment(variableAssigment);
   }
 
+  toJSON() {
+    const json = super.toJSON();
+
+    return json;
+  }
+
   static name = "PropertyAssertion";
 
   static fromJSON(json, context) {
@@ -212,7 +218,7 @@ export default define(class PropertyAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///
               term = termFromPropertyAssertionNode(propertyAssertionNode, context),
@@ -220,7 +226,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         context = null;
 
-        propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
+        propertyAssertion = new PropertyAssertion(context, string, node, lineIndex, term, propertyRelation);
       }, context);
     }
 

package/src/element/assertion/satisfies.js

@@ -8,8 +8,8 @@ import { instantiateSatisfiesAssertion } from "../../process/instantiate";
 import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode, satisfiesAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SatisfiesAssertion extends Assertion {
-  constructor(context, string, node, signature, reference) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, signature, reference) {
+    super(context, string, node, lineIndex);
 
     this.signature = signature;
     this.reference = reference;
@@ -157,6 +157,12 @@ export default define(class SatisfiesAssertion extends Assertion {
     return stepAndSubproofOrProofAssertionsUnify;
   }
 
+  toJSON() {
+    const json = super.toJSON();
+
+    return json;
+  }
+
   static name = "SatisfiesAssertion";
 
   static fromJSON(json, context) {
@@ -165,7 +171,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      instantiate((context) => {const { string } = json,
+      instantiate((context) => {const { string, lineIndex } = json,
               definedAssertionNode = instantiateSatisfiesAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
@@ -173,7 +179,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
         context = null;
 
-        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, lineIndex, signature, reference);
       }, context);
     }
 

package/src/element/assertion/subproof.js

@@ -13,8 +13,8 @@ import { subproofAssertionFromStatementNode } from "../../utilities/element";
 const { last, front, backwardsEvery } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
-  constructor(context, string, node, statements) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, statements) {
+    super(context, string, node, lineIndex);
 
     this.statements = statements;
   }
@@ -289,6 +289,12 @@ export default define(class SubproofAssertion extends Assertion {
     return topLevelMetaAssertionUnifies;
   }
 
+  toJSON() {
+    const json = super.toJSON();
+
+    return json;
+  }
+
   static name = "SubproofAssertion";
 
   static fromJSON(json, context) {
@@ -298,14 +304,14 @@ export default define(class SubproofAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
               node = subproofAssertionNode; ///
 
         context = null;
 
-        subproorAssertion = new SubproofAssertion(context, string, node, statements);
+        subproorAssertion = new SubproofAssertion(context, string, node, lineIndex, statements);
       }, context);
     }
 

package/src/element/assertion/type.js

@@ -10,8 +10,8 @@ import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(context, string, node, term, type) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, term, type) {
+    super(context, string, node, lineIndex);
 
     this.term = term;
     this.type = type;
@@ -193,17 +193,15 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   toJSON() {
-    const { name } = this.constructor,
-          typeJSON = typeToTypeJSON(this.type),
-          type = typeJSON,  ///
-          string = this.getString(),
-          json = {
-            name,
-            string,
-            type
-          };
-
-    return json;
+    const json = super.toJSON();
+
+    const typeJSON = typeToTypeJSON(this.type),
+          type = typeJSON;  ///
+
+    return {
+      ...json,
+      type
+    };
   }
 
   static name = "TypeAssertion";
@@ -215,7 +213,7 @@ export default define(class TypeAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
               type = typeFromJSON(json, context),
@@ -223,7 +221,7 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        typeAssertion = new TypeAssertion(context, string, node, term, type);
+        typeAssertion = new TypeAssertion(context, string, node, lineIndex, term, type);
       }, context);
     }
 

package/src/element/assertion.js

@@ -37,9 +37,11 @@ export default class Assertion extends Element {
   toJSON() {
     const { name } = this.constructor,
           string = this.getString(),
+          lineIndex = this.getLineIndex(),
           json = {
             name,
-            string
+            string,
+            lineIndex
           };
 
     return json;

package/src/element/assumption.js

@@ -8,8 +8,8 @@ import { instantiateAssumption } from "../process/instantiate";
 import { join, reconcile, instantiate } from "../utilities/context";
 
 export default define(class Assumption extends Element {
-  constructor(context, string, node, reference, statement) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, reference, statement) {
+    super(context, string, node, lineIndex);
 
     this.reference = reference;
     this.statement = statement;
@@ -269,8 +269,10 @@ export default define(class Assumption extends Element {
 
   toJSON() {
     const string = this.getString(),
+          lineIndex = this.getLineIndex(),
           json = {
-            string
+            string,
+            lineIndex
           };
 
     return json;
@@ -280,12 +282,12 @@ export default define(class Assumption extends Element {
 
   static fromJSON(json, context) {
     const assumption = instantiate((context) => {
-      const { string } = json,
+      const { string, lineIndex } = json,
             assumptionNode = instantiateAssumption(string, context),
             node = assumptionNode,  ///
             reference = referenceFromAssumptionNode(assumptionNode, context),
             statement = statementFromAssumptionNode(assumptionNode, context),
-            assumption = new Assumption(context, string, node, reference, statement);
+            assumption = new Assumption(context, string, node, lineIndex, reference, statement);
 
       return assumption;
     }, context);

package/src/element/combinator.js

@@ -10,8 +10,8 @@ import { validateStatementAsCombinator } from "../process/validate";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Combinator extends Element {
-  constructor(context, string, node, statement) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, statement) {
+    super(context, string, node, lineIndex);
 
     this.statement = statement;
   }
@@ -107,9 +107,11 @@ export default define(class Combinator extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
+            lineIndex = this.getLineIndex(),
             json = {
               context,
-              string
+              string,
+              lineIndex
             };
 
       return json;
@@ -123,12 +125,12 @@ export default define(class Combinator extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               combinatorNode = instantiateCombinator(string, context),
               node = combinatorNode,  ///
               statement = statementFromCombinatorNode(combinatorNode, context);
 
-        combinator = new Combinator(context, string, node, statement);
+        combinator = new Combinator(context, string, node, lineIndex, statement);
       }, context);
     }, json, context);
 

package/src/element/conclusion.js

@@ -7,8 +7,8 @@ import { instantiateConclusion } from "../process/instantiate";
 import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Conclusion extends Element {
-  constructor(context, string, node, statement) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, statement) {
+    super(context, string, node, lineIndex);
 
     this.statement = statement;
   }
@@ -136,9 +136,11 @@ export default define(class Conclusion extends Element {
 
     return serialise((context) => {
       const string = this.getString(),
+            lineIndex = this.getLineIndex(),
             json = {
               context,
-              string
+              string,
+              lineIndex
             };
 
       return json;
@@ -152,12 +154,12 @@ export default define(class Conclusion extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               conclusionNode = instantiateConclusion(string, context),
               node = conclusionNode,  ///
               statement = statementFromConclusionNode(conclusionNode, context);
 
-        conclusion = new Conclusion(context, string, node, statement);
+        conclusion = new Conclusion(context, string, node, lineIndex, statement);
       }, context);
     }, json, context);
 

package/src/element/constructor.js

@@ -11,8 +11,8 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
-  constructor(context, string, node, term, type) {
-    super(context, string, node, type);
+  constructor(context, string, node, lineIndex, term, type) {
+    super(context, string, node, lineIndex);
 
     this.term = term;
     this.type = type;
@@ -151,10 +151,12 @@ export default define(class Constructor extends Element {
       const includeType = false,
             typeJSON = typeToTypeJSON(this.type),
             string = this.getString(includeType),
+            lineIndex = this.getLineIndex(),
             type = typeJSON,  ///
             json = {
               context,
               string,
+              lineIndex,
               type
             };
 
@@ -169,13 +171,13 @@ export default define(class Constructor extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string } = json,
+        const { string, lineIndex } = json,
               constructorNode = instantiateConstructor(string, context),
               node = constructorNode, ///
               term = termFromConstructorNode(constructorNode, context),
               type = typeFromJSON(json, context);
 
-        constructor = new Constructor(context, string, node, term, type);
+        constructor = new Constructor(context, string, node, lineIndex, term, type);
       }, context);
     }, json, context);
 

package/src/element/declaration/combinator.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class CombinatorDeclaration extends Declaration {
-  constructor(context, string, node, combinator) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, combinator) {
+    super(context, string, node, lineIndex);
 
     this.combinator = combinator;
   }
@@ -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

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class ComplexTypeDeclaration extends Declaration {
-  constructor(context, string, node, type, superTypes) {
-    super(context, string, node);
+  constructor(context, string, node, lineIndex, type, superTypes) {
+    super(context, string, node, lineIndex);
 
     this.type = type;
     this.superTypes = superTypes;
@@ -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...`);