occam-verify-cli 1.0.935 → 1.0.937

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, lineIndex, statement, procedureCall) {
-    super(context, string, node, lineIndex, statement);
+  constructor(context, string, node, breakPoint, statement, procedureCall) {
+    super(context, string, node, breakPoint, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -287,13 +287,21 @@ export default define(class Premise extends ProofAssertion {
     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);
@@ -306,13 +314,13 @@ export default define(class Premise extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               premiseNode = instantiatePremise(string, context),
               node = premiseNode,  ///
               statement = statementFromPremiseNode(premiseNode, context),
               procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 
-        premise = new Premise(context, string, node, lineIndex, statement, procedureCall);
+        premise = new Premise(context, string, node, breakPoint, 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, lineIndex, statement, reference, signatureAssertion) {
-    super(context, string, node, lineIndex, statement);
+  constructor(context, string, node, breakPoint, statement, reference, signatureAssertion) {
+    super(context, string, node, breakPoint, statement);
 
     this.reference = reference;
     this.signatureAssertion = signatureAssertion;

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, lineIndex, statement, procedureCall) {
-    super(context, string, node, lineIndex, statement);
+  constructor(context, string, node, breakPoint, statement, procedureCall) {
+    super(context, string, node, breakPoint, statement);
 
     this.procedureCall = procedureCall;
   }
@@ -310,13 +310,21 @@ export default define(class Supposition extends ProofAssertion {
     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);
@@ -329,13 +337,13 @@ export default define(class Supposition extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               suppositionNode = instantiateSupposition(string, context),
               node = suppositionNode,  ///
               statement = statementFromSuppositionNode(suppositionNode, context),
               procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 
-        supposition = new Supposition(context, string, node, lineIndex, statement, procedureCall);
+        supposition = new Supposition(context, string, node, breakPoint, statement, procedureCall);
       }, context);
     }, json, context);
 

package/src/element/proofAssertion.js

@@ -5,8 +5,8 @@ import { Element } from "occam-languages";
 import { equateStatements } from "../process/equate";
 
 export default class ProofAssertion 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;
   }

package/src/element/property.js

@@ -9,8 +9,8 @@ import { nameFromPropertyNode } from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Property extends Element {
-  constructor(context, string, node, lineIndex, name, type) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, name, type) {
+    super(context, string, node, breakPoint);
 
     this.name = name;
     this.type = type;
@@ -217,12 +217,20 @@ export default define(class Property extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          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 = {
             string,
-            lineIndex,
+            breakPoint,
             type
           };
 
@@ -233,7 +241,7 @@ export default define(class Property extends Element {
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, lineIndex } = json,
+      const { string, breakPoint } = json,
             propertyNode = instantiateProperty(string, context),
             node = propertyNode,  ///
             name = nameFromPropertyNode(propertyNode, context),
@@ -241,7 +249,7 @@ export default define(class Property extends Element {
 
       context = null;
 
-      const property = new Property(context, string, node, lineIndex, name, type);
+      const property = new Property(context, string, node, breakPoint, name, type);
 
       return property;
     }, context);

package/src/element/propertyRelation.js

@@ -8,8 +8,8 @@ import { instantiatePropertyRelation } from "../process/instantiate";
 import { propertyFromPropertyRelationNode } from "../utilities/element";
 
 export default define(class PropertyRelation extends Element {
-  constructor(context, string, node, lineIndex, term, property) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, term, property) {
+    super(context, string, node, breakPoint);
 
     this.term = term;
     this.property = property;
@@ -148,19 +148,27 @@ export default define(class PropertyRelation extends Element {
   static name = "PropertyRelation";
 
   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,
             propertyRelationNode = instantiatePropertyRelation(string, context),
             node = propertyRelationNode,  ///
             term = termFromPropertyRelationNode(propertyRelationNode, context),
@@ -168,7 +176,7 @@ export default define(class PropertyRelation extends Element {
 
       context = null;
 
-      const propertyRelation = new PropertyRelation(context, string, node, lineIndex, term, property);
+      const propertyRelation = new PropertyRelation(context, string, node, breakPoint, term, property);
 
       return propertyRelation;
     }, context);

package/src/element/reference.js

@@ -9,8 +9,8 @@ import { join, ablate, attempt, serialise, reconcile, unserialise, instantiate }
 import { referenceFromReferenceNode, metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
-  constructor(context, string, node, lineIndex, metavariable, topLevelMetaAssertion) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, metavariable, topLevelMetaAssertion) {
+    super(context, string, node, breakPoint);
 
     this.metavariable = metavariable;
     this.topLevelMetaAssertion = topLevelMetaAssertion;
@@ -293,13 +293,21 @@ export default define(class Reference 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);
@@ -312,13 +320,13 @@ export default define(class Reference extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               referenceNode = instantiateReference(string, context),
               node = referenceNode,  ///
               metavariable = metavariableFromReferenceNode(referenceNode, context),
               topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context);
 
-        reference = new Reference(context, string, node, lineIndex, metavariable, topLevelMetaAssertion);
+        reference = new Reference(context, string, node, breakPoint, metavariable, topLevelMetaAssertion);
       }, context);
     }, json, context);
 

package/src/element/rule.js

@@ -11,8 +11,8 @@ const { reverse } = arrayUtilities,
       { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default define(class Rule extends Element {
-  constructor(context, string, node, lineIndex, proof, labels, premises, conclusion) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, proof, labels, premises, conclusion) {
+    super(context, string, node, breakPoint);
 
     this.proof = proof;
     this.labels = labels;
@@ -316,14 +316,22 @@ export default define(class Rule extends Element {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           premisesJSON = premisesToPremisesJSON(this.premises),
           conclusionJSON = conclusionToConclusionJSON(this.conclusion),
-          string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          labels = labelsJSON,  ///
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPoint.toJSON();
+
+    breakPoint = breakPointJSON;  ///
+
+    const labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
           json = {
             string,
-            lineIndex,
+            breakPoint,
             labels,
             premises,
             conclusion
@@ -335,13 +343,13 @@ export default define(class Rule extends Element {
   static name = "Rule";
 
   static fromJSON(json, context) {
-    const { string, lineIndex } = json,
+    const { string, breakPoint } = json,
           node = null,
           proof = null,
           labels = labelsFromJSON(json, context),
           premises = premisesFromJSON(json, context),
           conclusion = conclusionFromJSON(json, context),
-          rule = new Rule(context, string, node, lineIndex, proof, labels, premises, conclusion);
+          rule = new Rule(context, string, node, breakPoint, proof, labels, premises, conclusion);
 
     return rule;
   }

package/src/element/section.js

@@ -8,8 +8,8 @@ import {enclose} from "../utilities/context";
 const { asyncEvery } = asynchronousUtilities;
 
 export default define(class Section extends Element {
-  constructor(context, string, node, lineIndex, hypotheses, topLevelAssertion) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, hypotheses, topLevelAssertion) {
+    super(context, string, node, breakPoint);
 
     this.hypotheses = hypotheses;
     this.topLevelAssertion = topLevelAssertion;

package/src/element/signature.js

@@ -11,8 +11,8 @@ import { join, ablate, attempt, reconcile, serialise, unserialise, instantiate }
 const { match } = arrayUtilities;
 
 export default define(class Signature extends Element {
-  constructor(context, string, node, lineIndex, terms) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, terms) {
+    super(context, string, node, breakPoint);
 
     this.terms = terms;
   }
@@ -233,13 +233,21 @@ export default define(class Signature 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);
@@ -250,12 +258,12 @@ export default define(class Signature extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, lineIndex } = json,
+        const { string, breakPoint } = json,
               signatureNode = instantiateSignature(string, context),
               node = signatureNode,  ///
               terms = termsFromSignatureNode(signatureNode, context);
 
-        signature = new Signature(context, string, node, lineIndex, terms);
+        signature = new Signature(context, string, node, breakPoint, terms);
       }, context);
     }, json, context);
 

package/src/element/statement.js

@@ -393,25 +393,33 @@ export default define(class Statement extends Element {
   static name = "Statement";
 
   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,
             statementNode = instantiateStatement(string, context),
             node = statementNode; ///
 
       context = null;
 
-      const statement = new Statement(context, string, node, lineIndex);
+      const statement = new Statement(context, string, node, breakPoint);
 
       return statement;
     }, context);

package/src/element/subDerivation.js

@@ -9,8 +9,8 @@ const { last } = arrayUtilities,
       { asyncEvery } = asynchronousUtilities;
 
 export default define(class SubDerivation extends Element {
-  constructor(context, string, node, lineIndex, subproofOrProofAssertions) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, subproofOrProofAssertions) {
+    super(context, string, node, breakPoint);
 
     this.subproofOrProofAssertions = subproofOrProofAssertions;
   }

package/src/element/subproof.js

@@ -8,8 +8,8 @@ import { enclose } from "../utilities/context";
 const { asyncEvery } = asynchronousUtilities;
 
 export default define(class Subproof extends Element {
-  constructor(context, string, node, lineIndex, suppositions, subDerivation) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, suppositions, subDerivation) {
+    super(context, string, node, breakPoint);
 
     this.suppositions = suppositions;
     this.subDerivation = subDerivation;

package/src/element/substitution/frame.js

@@ -9,8 +9,8 @@ import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities
 import { ablate, ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class FrameSubstitution extends Substitution {
-  constructor(contexts, string, node, lineIndex, targetFrame, replacementFrame) {
-    super(contexts, string, node, lineIndex);
+  constructor(contexts, string, node, breakPoint, targetFrame, replacementFrame) {
+    super(contexts, string, node, breakPoint);
 
     this.targetFrame = targetFrame;
     this.replacementFrame = replacementFrame;
@@ -195,7 +195,7 @@ export default define(class FrameSubstitution extends Substitution {
         const context = specificContext;  ///
 
         instantiate((context) => {
-          const { string, lineIndex } = json,
+          const { string, breakPoint } = json,
                 specificContext = context,  ///
                 contexts = [
                   generalContext,
@@ -206,7 +206,7 @@ export default define(class FrameSubstitution extends Substitution {
                 targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
                 replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context);
 
-          frameSubstitutionn = new FrameSubstitution(contexts, string, node, lineIndex, targetFrame, replacementFrame);
+          frameSubstitutionn = new FrameSubstitution(contexts, string, node, breakPoint, targetFrame, replacementFrame);
         }, context);
       }, json, context);
     }

package/src/element/substitution/reference.js

@@ -9,8 +9,8 @@ import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../u
 import { ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class ReferenceSubstitution extends Substitution {
-  constructor(context, string, node, lineIndex, targetReference, replacementReference) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, targetReference, replacementReference) {
+    super(context, string, node, breakPoint);
 
     this.targetReference = targetReference;
     this.replacementReference = replacementReference;
@@ -200,7 +200,7 @@ export default define(class ReferenceSubstitution extends Substitution {
         const context = specificContext;  ///
 
         instantiate((context) => {
-          const { string, lineIndex } = json,
+          const { string, breakPoint } = json,
                 specificContext = context,  ///
                 contexts = [
                   generalContext,
@@ -211,7 +211,7 @@ export default define(class ReferenceSubstitution extends Substitution {
                 targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
                 replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
 
-          referenceSubstitutionn = new ReferenceSubstitution(contexts, string, node, lineIndex, targetReference, replacementReference);
+          referenceSubstitutionn = new ReferenceSubstitution(contexts, string, node, breakPoint, targetReference, replacementReference);
         }, context);
       }, json, context);
     }

package/src/element/substitution/statement.js

@@ -11,8 +11,8 @@ import { join, ablates, manifest, attempts, descend, reconcile, instantiate, uns
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
-  constructor(contexts, string, node, lineIndex, resolved, substitution, targetStatement, replacementStatement) {
-    super(contexts, string, node, lineIndex);
+  constructor(contexts, string, node, breakPoint, resolved, substitution, targetStatement, replacementStatement) {
+    super(contexts, string, node, breakPoint);
 
     this.resolved = resolved;
     this.substitution = substitution;
@@ -360,7 +360,7 @@ export default define(class StatementSubstitution extends Substitution {
         const context = specificContext;  ///
 
         instantiate((context) => {
-          const { string, lineIndex } = json,
+          const { string, breakPoint } = json,
                 specificContext = context,  ///
                 contexts = [
                   generalContext,
@@ -373,7 +373,7 @@ export default define(class StatementSubstitution extends Substitution {
                 targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
                 replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context);
 
-          statementSubstitutionn = new StatementSubstitution(contexts, string, node, lineIndex, resolved, substitution, targetStatement, replacementStatement);
+          statementSubstitutionn = new StatementSubstitution(contexts, string, node, breakPoint, resolved, substitution, targetStatement, replacementStatement);
         }, context);
       }, json, context);
     }

package/src/element/substitution/term.js

@@ -10,8 +10,8 @@ import { termSubstitutionStringFromTermAndVariable } from "../../utilities/strin
 import { ablate, ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
-  constructor(context, string, node, lineIndex, targetTerm, replacementTerm) {
-    super(context, string, node, lineIndex);
+  constructor(context, string, node, breakPoint, targetTerm, replacementTerm) {
+    super(context, string, node, breakPoint);
 
     this.targetTerm = targetTerm;
     this.replacementTerm = replacementTerm;
@@ -204,7 +204,7 @@ export default define(class TermSubstitution extends Substitution {
         const context = specificContext;  ///
 
         instantiate((context) => {
-          const { string, lineIndex } = json,
+          const { string, breakPoint } = json,
                 specificContext = context,  ///
                 contexts = [
                   generalContext,
@@ -215,7 +215,7 @@ export default define(class TermSubstitution extends Substitution {
                 targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
                 replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context);
 
-          termSubstitutionn = new TermSubstitution(contexts, string, node, lineIndex, targetTerm, replacementTerm);
+          termSubstitutionn = new TermSubstitution(contexts, string, node, breakPoint, targetTerm, replacementTerm);
         }, context);
       }, json, context);
     }