occam-verify-cli 1.0.936 → 1.0.938

package/src/element/hypothesis.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { declare, attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Hypothesis extends Element {
@@ -105,13 +106,21 @@ export default define(class Hypothesis extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            breakPoint = this.getBreakPoint(),
-            json = {
-              context,
-              string,
-              breakPoint
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -122,9 +131,10 @@ export default define(class Hypothesis extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, breakPoint } = json,
+        const { string } = json,
               hypothesisNode = instantiateHypothesis(string, context),
               node = hypothesisNode,  ///
+              breakPoint = breakPointFromJSON(json),
               statement = statementFromHypothesisNode(hypothesisNode, context);
 
         hypothesis = new Hypothesis(context, string, node, breakPoint, statement);

package/src/element/judgement.js

@@ -7,6 +7,7 @@ import { instantiateJudgement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
 import { judgementFromStatementNode } from "../utilities/element";
 import { judgementAssignmentFromJudgement } from "../process/assign";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class Judgement extends Element {
   constructor(context, string, node, breakPoint, frame, assumption) {
@@ -244,21 +245,30 @@ export default define(class Judgement extends Element {
   static name = "Judgement";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             judgementNode = instantiateJudgement(string, context),
             node = judgementNode,  ///
+            breakPoint = breakPointFromJSON(json),
             frame = frameFromJudgementNode(judgementNode, context),
             assumption = assumptionFromJudgementNode(judgementNode, context);
 

package/src/element/label.js

@@ -4,6 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { labelFromLabelNode, metavariableFromLabelNode } from "../utilities/element";
 import { ablate, attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
@@ -128,13 +129,21 @@ export default define(class Label extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            breakPoint = this.getBreakPoint(),
-            json = {
-              context,
-              string,
-              breakPoint
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -147,9 +156,10 @@ export default define(class Label extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, breakPoint } = json,
+        const { string } = json,
               labelNode = instantiateLabel(string, context),
               node = labelNode, ///
+              breakPoint = breakPointFromJSON(json),
               metavariable = metavariableFromLabelNode(labelNode, context);
 
         label = new Label(context, string, node, breakPoint, metavariable);

package/src/element/metaType.js

@@ -3,6 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class MetaType extends Element {
   constructor(context, string, node, breakPoint, name) {
@@ -37,12 +38,20 @@ export default define(class MetaType extends Element {
   static name = "MetaType";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }

package/src/element/metavariable.js

@@ -5,11 +5,12 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { EMPTY_STRING } from "../constants";
+import { instantiate } from "../utilities/context";
 import { instantiateMetavariable } from "../process/instantiate";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode, metavariableFromStatementNode } from "../utilities/element";
 
 export default define(class Metavariable extends Element {
@@ -615,13 +616,21 @@ export default define(class Metavariable extends Element {
   toJSON() {
     const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///
-          string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint,
-            metaType
-          };
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint,
+      metaType
+    };
 
     return json;
   }
@@ -630,9 +639,10 @@ export default define(class Metavariable extends Element {
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             metavariableNode = instantiateMetavariable(string, context),
             node = metavariableNode,  ///
+            breakPoint = breakPointFromJSON(json),
             name = nameFromMetavariableNode(metavariableNode, context),
             term = termFromMetavariableNode(metavariableNode, context),
             type = typeFromMetavariableNode(metavariableNode, context),

package/src/element/parameter.js

@@ -6,6 +6,7 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateParameter } from "../process/instantiate";
 import { nameFromParaneterNode, identifierFromParameterNode } from "../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class Parameter extends Element {
   constructor(context, string, node, breakPoint, name, identifier) {
@@ -52,21 +53,30 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             parameterNode = instantiateParameter(string, context),
             node = parameterNode,  ///
+            breakPoint = breakPointFromJSON(json),
             name = nameFromParaneterNode(parameterNode, context),
             identifier = identifierFromParameterNode(parameterNode, context);
 

package/src/element/procedureCall.js

@@ -6,6 +6,7 @@ import { termsUtilities } from "occam-furtle";
 import { define } from "../elements";
 import { instantiate, evaluate } from "../utilities/context";
 import { instantiateProcedureCall } from "../process/instantiate";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { parametersFromProcedureCallNode, procedureReferenceFromProcedureCallNode } from "../utilities/element";
 
 const { termsFromPrimitives } = termsUtilities;
@@ -121,21 +122,30 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             procedureCallNode = instantiateProcedureCall(string, context),
             node = procedureCallNode,  ///
+            breakPoint = breakPointFromJSON(json),
             parameters = parametersFromProcedureCallNode(json, context),
             procedureReference = procedureReferenceFromProcedureCallNode(json, context);
 

package/src/element/procedureReference.js

@@ -6,6 +6,7 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateProcedureReference } from "../process/instantiate";
 import { nameFromProcedureReferenceNode } from "../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class ProcedureReference extends Element {
   constructor(context, string, node, breakPoint, name) {
@@ -34,21 +35,30 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             procedureReferenceNode = instantiateProcedureReference(string, context),
             node = procedureReferenceNode,  ///
+            breakPoint = breakPointFromJSON(json),
             name = nameFromProcedureReferenceNode(procedureReferenceNode, context);
 
       context = null;

package/src/element/proofAssertion/premise.js

@@ -5,6 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } from "../../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../../utilities/breakPoint";
 import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Premise extends ProofAssertion {
@@ -287,13 +288,21 @@ export default define(class Premise extends ProofAssertion {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            breakPoint = this.getBreakPoint(),
-            json = {
-              context,
-              string,
-              breakPoint
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -306,9 +315,10 @@ export default define(class Premise extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, breakPoint } = json,
+        const { string } = json,
               premiseNode = instantiatePremise(string, context),
               node = premiseNode,  ///
+              breakPoint = breakPointFromJSON(json),
               statement = statementFromPremiseNode(premiseNode, context),
               procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 

package/src/element/proofAssertion/supposition.js

@@ -5,6 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
 import { procedureCallFromSuppositionNode } from "../../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../../utilities/breakPoint";
 import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Supposition extends ProofAssertion {
@@ -310,13 +311,21 @@ export default define(class Supposition extends ProofAssertion {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            breakPoint = this.getBreakPoint(),
-            json = {
-              context,
-              string,
-              breakPoint
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -329,9 +338,10 @@ export default define(class Supposition extends ProofAssertion {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, breakPoint } = json,
+        const { string } = json,
               suppositionNode = instantiateSupposition(string, context),
               node = suppositionNode,  ///
+              breakPoint = breakPointFromJSON(json),
               statement = statementFromSuppositionNode(suppositionNode, context),
               procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 

package/src/element/property.js

@@ -7,6 +7,7 @@ import { instantiate } from "../utilities/context";
 import { instantiateProperty } from "../process/instantiate";
 import { nameFromPropertyNode } from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class Property extends Element {
   constructor(context, string, node, breakPoint, name, type) {
@@ -217,9 +218,17 @@ export default define(class Property extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          type = typeJSON,  ///
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const type = typeJSON,  ///
           json = {
             string,
             breakPoint,
@@ -233,9 +242,10 @@ export default define(class Property extends Element {
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             propertyNode = instantiateProperty(string, context),
             node = propertyNode,  ///
+            breakPoint = breakPointFromJSON(json),
             name = nameFromPropertyNode(propertyNode, context),
             type = typeFromJSON(json, context);
 

package/src/element/propertyRelation.js

@@ -6,6 +6,7 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiatePropertyRelation } from "../process/instantiate";
 import { propertyFromPropertyRelationNode } from "../utilities/element";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
 export default define(class PropertyRelation extends Element {
   constructor(context, string, node, breakPoint, term, property) {
@@ -148,21 +149,30 @@ export default define(class PropertyRelation extends Element {
   static name = "PropertyRelation";
 
   toJSON() {
-    const string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          json = {
-            string,
-            breakPoint
-          };
+    const string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const json = {
+      string,
+      breakPoint
+    };
 
     return json;
   }
 
   static fromJSON(json, context) {
     return instantiate((context) => {
-      const { string, breakPoint } = json,
+      const { string } = json,
             propertyRelationNode = instantiatePropertyRelation(string, context),
             node = propertyRelationNode,  ///
+            breakPoint = breakPointFromJSON(json),
             term = termFromPropertyRelationNode(propertyRelationNode, context),
             property = propertyFromPropertyRelationNode(propertyRelationNode, context);
 

package/src/element/reference.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { join, ablate, attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { referenceFromReferenceNode, metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
@@ -293,13 +294,21 @@ export default define(class Reference extends Element {
     const context = this.getContext();
 
     return serialise((context) => {
-      const string = this.getString(),
-            breakPoint = this.getBreakPoint(),
-            json = {
-              context,
-              string,
-              breakPoint
-            };
+      const string = this.getString();
+
+      let breakPoint;
+
+      breakPoint = this.getBreakPoint();
+
+      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+      breakPoint = breakPointJSON;  ///
+
+      const json = {
+        context,
+        string,
+        breakPoint
+      };
 
       return json;
     }, context);
@@ -312,9 +321,10 @@ export default define(class Reference extends Element {
 
     unserialise((json, context) => {
       instantiate((context) => {
-        const { string, breakPoint } = json,
+        const { string } = json,
               referenceNode = instantiateReference(string, context),
               node = referenceNode,  ///
+              breakPoint = breakPointFromJSON(json),
               metavariable = metavariableFromReferenceNode(referenceNode, context),
               topLevelMetaAssertion = topLevelMetaAssertionFromReferenceNode(referenceNode, context);
 

package/src/element/rule.js

@@ -5,6 +5,7 @@ import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
 import { enclose } from "../utilities/context";
+import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 import { labelsFromJSON, premisesFromJSON, conclusionFromJSON, labelsToLabelsJSON, premisesToPremisesJSON, conclusionToConclusionJSON } from "../utilities/json";
 
 const { reverse } = arrayUtilities,
@@ -316,9 +317,17 @@ export default define(class Rule extends Element {
     const labelsJSON = labelsToLabelsJSON(this.labels),
           premisesJSON = premisesToPremisesJSON(this.premises),
           conclusionJSON = conclusionToConclusionJSON(this.conclusion),
-          string = this.getString(),
-          breakPoint = this.getBreakPoint(),
-          labels = labelsJSON,  ///
+          string = this.getString();
+
+    let breakPoint;
+
+    breakPoint = this.getBreakPoint();
+
+    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
+
+    breakPoint = breakPointJSON;  ///
+
+    const labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
           json = {
@@ -335,9 +344,10 @@ export default define(class Rule extends Element {
   static name = "Rule";
 
   static fromJSON(json, context) {
-    const { string, breakPoint } = json,
+    const { string } = json,
           node = null,
           proof = null,
+          breakPoint = breakPointFromJSON(json),
           labels = labelsFromJSON(json, context),
           premises = premisesFromJSON(json, context),
           conclusion = conclusionFromJSON(json, context),