occam-verify-cli 1.0.935 → 1.0.937

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.935",
+  "version": "1.0.937",
   "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.200",
+    "occam-furtle": "^3.0.203",
     "occam-grammars": "^1.3.524",
-    "occam-languages": "^0.0.204",
+    "occam-languages": "^0.0.206",
     "occam-lexers": "^23.1.44",
     "occam-model": "^1.0.506",
-    "occam-nominal": "^1.0.106",
+    "occam-nominal": "^1.0.107",
     "occam-parsers": "^23.1.50",
     "occam-server": "^7.0.7"
   },

package/src/action/verify.js

@@ -13,7 +13,7 @@ const { last } = arrayUtilities,
       { createReleaseContexts, verifyReleaseContexts, initialiseReleaseContexts } = verificationUtilities;
 
 export default async function verifyAction(name, log) {
-  const callback = async (context, filePath, lineIndex) => {
+  const callback = async (context, breakPoint) => {
           ///
         },
         releaseContexts = [],

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, lineIndex, term, frame, negated, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, frame, negated, statement) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.frame = frame;
@@ -253,7 +253,7 @@ export default define(class ContainedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               containedAssertionNode = instantiateContainedAssertion(string, context),
               node = containedAssertionNode,  ///
               term = termFromContainedAssertionNode(containedAssertionNode, context),
@@ -263,7 +263,7 @@ export default define(class ContainedAssertion extends Assertion {
 
         context = null;
 
-        containedAssertion = new ContainedAssertion(context, string, node, lineIndex, term, frame, negated, statement);
+        containedAssertion = new ContainedAssertion(context, string, node, breakPoint, term, frame, negated, statement);
       }, context);
     }
 

package/src/element/assertion/defined.js

@@ -10,8 +10,8 @@ import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "..
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode, definedAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class DefinedAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, frame, negated) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, frame, negated) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.frame= frame;
@@ -221,7 +221,7 @@ export default define(class DefinedAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///
               term = termFromJDefinedAssertionNode(definedAssertionNode, context),
@@ -230,7 +230,7 @@ export default define(class DefinedAssertion extends Assertion {
 
         context = null;
 
-        definedAssertion = new DefinedAssertion(context, string, node, lineIndex, term, frame, negated);
+        definedAssertion = new DefinedAssertion(context, string, node, breakPoint, term, frame, negated);
       }, 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, lineIndex, term, propertyRelation) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, propertyRelation) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.propertyRelation = propertyRelation;
@@ -226,7 +226,7 @@ export default define(class PropertyAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///
               term = termFromPropertyAssertionNode(propertyAssertionNode, context),
@@ -234,7 +234,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         context = null;
 
-        propertyAssertion = new PropertyAssertion(context, string, node, lineIndex, term, propertyRelation);
+        propertyAssertion = new PropertyAssertion(context, string, node, breakPoint, term, propertyRelation);
       }, context);
     }
 

package/src/element/assertion/signature.js

@@ -8,8 +8,8 @@ import { instantiateSignatureAssertion } from "../../process/instantiate";
 import { signatureFromSignatureAssertionNode, referenceFromSignatureAssertionNode, signatureAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class SignatureAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, signature, reference) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, signature, reference) {
+    super(context, string, node, breakPoint);
 
     this.signature = signature;
     this.reference = reference;
@@ -211,7 +211,7 @@ export default define(class SignatureAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               definedAssertionNode = instantiateSignatureAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromSignatureAssertionNode(definedAssertionNode, context),
@@ -219,7 +219,7 @@ export default define(class SignatureAssertion extends Assertion {
 
         context = null;
 
-        signatureAssertion = new SignatureAssertion(context, string, node, lineIndex, signature, reference);
+        signatureAssertion = new SignatureAssertion(context, string, node, breakPoint, 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, lineIndex, statements) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statements) {
+    super(context, string, node, breakPoint);
 
     this.statements = statements;
   }
@@ -300,14 +300,14 @@ export default define(class SubproofAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
               node = subproofAssertionNode; ///
 
         context = null;
 
-        subproorAssertion = new SubproofAssertion(context, string, node, lineIndex, statements);
+        subproorAssertion = new SubproofAssertion(context, string, node, breakPoint, statements);
       }, context);
     }
 

package/src/element/assertion/type.js

@@ -11,8 +11,8 @@ import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 import { termFromTypeAssertionNode, typeAssertionFromStatementNode } from "../../utilities/element";
 
 export default define(class TypeAssertion extends Assertion {
-  constructor(context, string, node, lineIndex, term, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, type) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.type = type;
@@ -220,13 +220,21 @@ export default define(class TypeAssertion extends Assertion {
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           name = this.getName(),
-          string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          type = typeJSON,
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPoint.toJSON();
+
+    breakPoint = breakPointJSON;  ///
+
+    const type = typeJSON,
           json = {
             name,
             string,
-            lineIndex,
+            breakPoint,
             type
           };
 
@@ -242,7 +250,7 @@ export default define(class TypeAssertion extends Assertion {
 
     if (this.name === name) {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
               type = typeFromJSON(json, context),
@@ -250,7 +258,7 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        typeAssertion = new TypeAssertion(context, string, node, lineIndex, term, type);
+        typeAssertion = new TypeAssertion(context, string, node, breakPoint, term, type);
       }, context);
     }
 

package/src/element/assertion.js

@@ -42,13 +42,21 @@ export default class Assertion extends Element {
 
   toJSON() {
     const name = this.getName(),
-          string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          json = {
-            name,
-            string,
-            lineIndex
-          };
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPoint.toJSON();
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      name,
+      string,
+      breakPoint
+    };
 
     return json;
   }

package/src/element/assumption/metaLevel.js

@@ -11,8 +11,8 @@ import { metaLevelAssumptionStringFromReferenceAndStatement } from "../../utilit
 import { join, ablate, attempt, descend, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelAssumption extends Element {
-  constructor(context, string, node, lineIndex, reference, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, reference, statement) {
+    super(context, string, node, breakPoint);
 
     this.reference = reference;
     this.statement = statement;
@@ -285,13 +285,21 @@ export default define(class MetaLevelAssumption extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            lineIndex = this.getLineIndex(),
-            json = {
-              context,
-              string,
-              lineIndex
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPoint.toJSON();
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -304,13 +312,13 @@ export default define(class MetaLevelAssumption extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               metaLevelAssumptionNode = instantiateMetaLevelAssumption(string, context),
               node = metaLevelAssumptionNode,  ///
               reference = referenceFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context),
               statement = statementFromMetaLevelAssumptionNode(metaLevelAssumptionNode, context);
 
-        metaLevelAssumption = new MetaLevelAssumption(context, string, node, lineIndex, reference, statement);
+        metaLevelAssumption = new MetaLevelAssumption(context, string, node, breakPoint, reference, statement);
       }, context);
     }, json, context);
 

package/src/element/assumption.js

@@ -7,8 +7,8 @@ import {instantiate, reconcile} from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
 
 export default define(class Assumption extends Element {
-  constructor(context, string, node, lineIndex, reference, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, reference, statement) {
+    super(context, string, node, breakPoint);
 
     this.reference = reference;
     this.statement = statement;
@@ -247,24 +247,32 @@ export default define(class Assumption extends Element {
   static name = "Assumption";
 
   toJSON() {
-    const string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          json = {
-            string,
-            lineIndex
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPoint.toJSON();
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, lineIndex } = json,
+      const { string, breakPoint } = json,
             assumptionNode = instantiateAssumption(string, context),
             node = assumptionNode,  ///
             reference = referenceFromAssumptionNode(assumptionNode, context),
             statement = statementFromAssumptionNode(assumptionNode, context),
-            assumption = new Assumption(context, string, node, lineIndex, reference, statement);
+            assumption = new Assumption(context, string, node, breakPoint, 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, lineIndex, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statement) {
+    super(context, string, node, breakPoint);
 
     this.statement = statement;
   }
@@ -105,13 +105,21 @@ export default define(class Combinator extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            lineIndex = this.getLineIndex(),
-            json = {
-              context,
-              string,
-              lineIndex
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPoint.toJSON();
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -124,12 +132,12 @@ export default define(class Combinator extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               combinatorNode = instantiateCombinator(string, context),
               node = combinatorNode,  ///
               statement = statementFromCombinatorNode(combinatorNode, context);
 
-        combinator = new Combinator(context, string, node, lineIndex, statement);
+        combinator = new Combinator(context, string, node, breakPoint, 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, lineIndex, statement) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, statement) {
+    super(context, string, node, breakPoint);
 
     this.statement = statement;
   }
@@ -134,13 +134,21 @@ export default define(class Conclusion extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            lineIndex = this.getLineIndex(),
-            json = {
-              context,
-              string,
-              lineIndex
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPoint.toJSON();
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -153,12 +161,12 @@ export default define(class Conclusion extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               conclusionNode = instantiateConclusion(string, context),
               node = conclusionNode,  ///
               statement = statementFromConclusionNode(conclusionNode, context);
 
-        conclusion = new Conclusion(context, string, node, lineIndex, statement);
+        conclusion = new Conclusion(context, string, node, breakPoint, statement);
       }, context);
     }, json, context);
 

package/src/element/constructor.js

@@ -12,8 +12,8 @@ import { provisionallyStringFromProvisional } from "../utilities/string";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
-  constructor(context, string, node, lineIndex, term, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, type) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.type = type;
@@ -154,13 +154,21 @@ export default define(class Constructor extends Element {
     return serialise((context) => {
       const includeType = false,
             typeJSON = typeToTypeJSON(this.type),
-            string = this.getString(includeType),
-            lineIndex = this.getLineIndex(),
-            type = typeJSON,  ///
+            string = this.getString(includeType);
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPoint.toJSON();
+
+      breakPoint = breakPointJSON;  ///
+
+      const type = typeJSON,  ///
             json = {
               context,
               string,
-              lineIndex,
+              breakPoint,
               type
             };
 
@@ -175,13 +183,13 @@ export default define(class Constructor extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               constructorNode = instantiateConstructor(string, context),
               node = constructorNode, ///
               term = termFromConstructorNode(constructorNode, context),
               type = typeFromJSON(json, context);
 
-        constructor = new Constructor(context, string, node, lineIndex, term, type);
+        constructor = new Constructor(context, string, node, breakPoint, 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, lineIndex, combinator) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, combinator) {
+    super(context, string, node, breakPoint);
 
     this.combinator = combinator;
   }

package/src/element/declaration/complexType.js

@@ -10,8 +10,8 @@ import { baseTypeFromNothing } from "../../utilities/type";
 const { asyncEvery } = asynchronousUtilities;
 
 export default define(class ComplexTypeDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, superTypes, provisional, propertyDeclarations) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, superTypes, provisional, propertyDeclarations) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.superTypes = superTypes;

package/src/element/declaration/constructor.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class ConstructorDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, provisional, constructor) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, provisional, constructor) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.provisional = provisional;

package/src/element/declaration/metavariable.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class MetavariableDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, metaType, metavariable) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, metaType, metavariable) {
+    super(context, string, node, breakPoint);
 
     this.metaType = metaType;
     this.metavariable = metavariable;

package/src/element/declaration/property.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class PropertyDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, property, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, property, type) {
+    super(context, string, node, breakPoint);
 
     this.property = property;
     this.type = type;

package/src/element/declaration/simpleType.js

@@ -6,8 +6,8 @@ import { define } from "../../elements";
 import { baseTypeFromNothing } from "../../utilities/type";
 
 export default define(class SimpleTypeDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, superTypes, provisional) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, superTypes, provisional) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.superTypes = superTypes;

package/src/element/declaration/typePrefix.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class TypePrefixDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, typePrefix) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, typePrefix) {
+    super(context, string, node, breakPoint);
 
     this.typePrefix = typePrefix;
   }

package/src/element/declaration/variable.js

@@ -5,8 +5,8 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class VariableDeclaration extends Declaration {
-  constructor(context, string, node, lineIndex, type, variable, provisional) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, type, variable, provisional) {
+    super(context, string, node, breakPoint);
 
     this.type = type;
     this.variable = variable;