occam-verify-cli 1.0.696 → 1.0.703

package/src/element/assertion/satisfies.js

@@ -3,6 +3,9 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
+import { instantiateSatisfiesAssertion } from "../../process/instantiate";
+import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode } from "../../utilities/element";
 
 export default define(class SatisfiesAssertion extends Assertion {
   constructor(context, string, node, signature, reference) {
@@ -155,8 +158,6 @@ export default define(class SatisfiesAssertion extends Assertion {
   }
 
   toJSON() {
-    debugger
-
     const { name } = this.constructor,
           string = this.getString(),
           json = {
@@ -175,7 +176,17 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              definedAssertionNode = instantiateSatisfiesAssertion(string, context),
+              node = definedAssertionNode,  ///
+              signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
+              reference = referenceFromJSatisfiesAssertionNode(definedAssertionNode, context);
+
+        context = null;
+
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
+      }, context);
     }
 
     return satisfiesAssertion;

package/src/element/assertion/subproof.js

@@ -7,7 +7,6 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
 import { unifyStatement } from "../../process/unify";
-import { statementsToStatementsJSON } from "../../utilities/json";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
 const { match } = arrayUtilities;
@@ -116,13 +115,10 @@ export default define(class SubproofAssertion extends Assertion {
 
   toJSON() {
     const { name } = this.constructor,
-          statementJSON = statementsToStatementsJSON(this.statements),
-          statements = statementJSON, ///
           string = this.getString(),
           json = {
             name,
-            string,
-            statements
+            string
           };
 
     return json;
@@ -142,6 +138,8 @@ export default define(class SubproofAssertion extends Assertion {
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
               node = subproofAssertionNode; ///
 
+        context = null;
+
         subproorAssertion = new SubproofAssertion(context, string, node, statements);
       }, context);
     }

package/src/element/assertion/type.js

@@ -3,8 +3,11 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
+import { typeFromJSON } from "../../utilities/json";
+import { termFromTypeAssertionNode } from "../../utilities/element";
+import { instantiateSubproofAssertion } from "../../process/instantiate";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
-import {termToTermJSON} from "../../utilities/json";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -190,18 +193,13 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   toJSON() {
-    debugger
-
     const { name } = this.constructor,
-          termJSON = termToTermJSON(this.term),
           typeJSON = typeToTypeJSON(this.type),
-          term = termJSON,  ///
           type = typeJSON,  ///
           string = this.getString(),
           json = {
-            string,
             name,
-            term,
+            string,
             type
           };
 
@@ -216,7 +214,17 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              typeAssertionNode = instantiateSubproofAssertion(string, context),
+              term = termFromTypeAssertionNode(typeAssertionNode, context),
+              type = typeFromJSON(json, context),
+              node = typeAssertionNode; ///
+
+        context = null;
+
+        typeAssertion = new TypeAssertion(context, string, node, term, type);
+      }, context);
     }
 
     return typeAssertion;

package/src/element/assumption.js

@@ -3,8 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateAssumption } from "../process/instantiate";
 import { unifyStatementIntrinsically } from "../process/unify";
-import { referenceFromJSON, referenceToReferenceJSON } from "../utilities/json";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -319,12 +320,45 @@ export default define(class Assumption extends Element {
   }
 
   toJSON() {
-    debugger
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
   }
 
   static name = "Assumption";
 
   static fromJSON(json, context) {
-    debugger
+    const assumption = literally((context) => {
+      const { string } = json,
+            assumptionNode = instantiateAssumption(string, context),
+            node = assumptionNode,  ///
+            reference = referenceFromAssumptionNode(assumptionNode, context),
+            statement = statementFromAssumptionNode(assumptionNode, context);
+
+      context = null; ///
+
+      const assumption = new Assumption(context, string, node, reference, statement);
+
+      return assumption;
+    }, context);
+
+    return assumption;
   }
 });
+
+function referenceFromAssumptionNode(assumptionNode, context) {
+  const metavariableNode = assumptionNode.getMetavariableNode(context),
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+  return reference;
+}
+
+function statementFromAssumptionNode(assumptionNode, context) {
+  const statementNode = assumptionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}

package/src/element/combinator.js

@@ -5,18 +5,14 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateCombinator } from "../process/instantiate";
+import { ephemeralContextFromJSON } from "../utilities/json";
 import { verifyStatementAsCombinator } from "../process/verify";
+import { statementFromCombinatorNode } from "../utilities/element";
 import { unifyStatementWithCombinator } from "../process/unify";
-import {
-  statementFromJSON,
-  ephemeralContextFromJSON,
-  statementToStatementJSON,
-  procedureCallToProcedureCallJSON
-} from "../utilities/json";
 
 export default define(class Combinator extends Element {
   constructor(context, string, node, statement) {
-    super(context, string, node)
+    super(context, string, node);
 
     this.statement = statement;
   }
@@ -93,13 +89,10 @@ export default define(class Combinator extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -112,7 +105,7 @@ export default define(class Combinator extends Element {
       const { string } = json,
             combinatorNode = instantiateCombinator(string, context),
             node = combinatorNode,  ///
-            statement = statementFromJSON(json, context),
+            statement = statementFromCombinatorNode(combinatorNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/conclusion.js

@@ -5,7 +5,8 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
-import { statementFromJSON, ephemeralContextFromJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromConclusionNode } from "../utilities/element";
+import { ephemeralContextFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
@@ -131,13 +132,10 @@ export  default define(class Conclusion extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -150,7 +148,7 @@ export  default define(class Conclusion extends Element {
       const { string } = json,
             conclusionNode = instantiateConclusion(string, context),
             node = conclusionNode,  ///
-            statement = statementFromJSON(json, context),
+            statement = statementFromConclusionNode(conclusionNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/constructor.js

@@ -6,8 +6,9 @@ import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
 import { verifyTermAsConstructor } from "../process/verify";
+import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
-import { termFromJSON, termToTermJSON, ephemeralContextFromJSON } from "../utilities/json";
+import { termToTermJSON, ephemeralContextFromJSON } from "../utilities/json";
 
 export default define(class Constructor extends Element {
   constructor(context, string, node, term) {
@@ -29,20 +30,17 @@ export default define(class Constructor extends Element {
 
   getType() { return this.term.getType(); }
 
-  getString() {
+  getString(includeType = true) {
     let string;
 
-    const type = this.getType();
-
-    if (type === null) {
-      const termString = this.term.getString();
-
-      string = termString;  ///
-    } else {
-      const typeString = type.getString(),
+    if (includeType) {
+      const type = this.getType(),
+            typeString = type.getString(),
             termString = this.term.getString();
 
       string = `${termString}.${typeString}`;
+    } else {
+      string = super.getString();
     }
 
     return string;
@@ -53,7 +51,8 @@ export default define(class Constructor extends Element {
   verify(context) {
     let verifies = false;
 
-    const constructorString = this.getString();  ///
+    const includeType = false,
+          constructorString = this.getString(includeType);
 
     context.trace(`Verifying the '${constructorString}' constructor...`);
 
@@ -113,12 +112,22 @@ export default define(class Constructor extends Element {
   }
 
   toJSON() {
-    const termJSON = termToTermJSON(this.term),
-          string = this.getString(),
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
+    const includeType = false,
+          termJSON = termToTermJSON(this.term),
+          string = this.getString(includeType),
           term = termJSON,  ///
           json = {
-            term,
-            string
+            context,
+            string,
+            term
           };
 
     return json;
@@ -131,7 +140,7 @@ export default define(class Constructor extends Element {
       const { string } = json,
             constructorNode = instantiateConstructor(string, context),
             node = constructorNode, ///
-            term = termFromJSON(json, context),
+            term = termFromConstructorNode(constructorNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/declaration/constructor.js

@@ -104,7 +104,8 @@ export default define(class ConstructorDeclaration extends Declaration {
     let constructorVerifies;
 
     const context = this.getContext(),
-          constructorString = this.constructor.getString(),
+          includeType = false,
+          constructorString = this.constructor.getString(includeType),
           constructorDeclarationString = this.getString();  ///
 
     context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);

package/src/element/declaration/simpleType.js

@@ -54,9 +54,13 @@ export default define(class SimpleTypeDeclaration extends Declaration {
         const typePrefixVerifies = this.verifyTypePrefix();
 
         if (typePrefixVerifies) {
-          context.addType(this.type);
+          const propertiesVerifies = this.verifyProperties();
 
-          verifies = true;
+          if (propertiesVerifies) {
+            context.addType(this.type);
+
+            verifies = true;
+          }
         }
       }
     }
@@ -163,7 +167,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
       if (superTypesLength === 0) {
         const baseType = baseTypeFromNothing(),
-          superTyupe = baseType;  ///
+              superTyupe = baseType;  ///
 
         superTypes.push(superTyupe);
       }
@@ -182,8 +186,8 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     let typePrefixVerifies = false;
 
     const context = this.getContext(),
-          typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///;
+      typeString = this.type.getString(),
+      simpleTypeDeclarationString = this.getString(); ///;
 
     context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's prefix...`);
 
@@ -192,7 +196,7 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     if (!typePrefixed) {
       typePrefixVerifies = true;
     } else {
-      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type is prefixed.`);
+      context.debug(`The '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type is prefixed.`);
     }
 
     if (typePrefixVerifies) {
@@ -202,5 +206,25 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typePrefixVerifies;
   }
 
+  verifyProperties() {
+    let propertiesVerify = true;  ///
+
+    const context = this.getContext(),
+          typeString = this.type.getString(),
+          simpleTypeDeclarationString = this.getString(); ///;
+
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties...`);
+
+    const properties = [];
+
+    this.type.setProperties(properties);
+
+    if (propertiesVerify) {
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties.`);
+    }
+
+    return propertiesVerify;
+  }
+
   static name = "SimpleTypeDeclaration";
 });

package/src/element/deduction.js

@@ -5,7 +5,8 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
-import { statementToStatementJSON, ephemeralContextFromJSON } from "../utilities/json";
+import { ephemeralContextFromJSON } from "../utilities/json";
+import { statementFromDeductionNode } from "../utilities/element";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, statement) {
@@ -156,13 +157,10 @@ export default define(class Deduction extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -173,9 +171,9 @@ export default define(class Deduction extends Element {
   static fromJSON(json, context) {
     const duduction = literally((context) => {
       const { string } = json,
-            duductionNode = instantiateDeduction(string, context),
-            node = duductionNode,  ///
-            statement = statementFromJSON(json, context),
+            deductionNode = instantiateDeduction(string, context),
+            node = deductionNode,  ///
+            statement = statementFromDeductionNode(deductionNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/equality.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { equateTerms } from "../process/equate";
+import { instantiateEquality } from "../process/instantiate";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
@@ -271,4 +273,45 @@ export default define(class Equality extends Element {
   }
 
   static name = "Equality";
+
+  toJSON() {
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, context) {
+    const equality = literally((context) => {
+      const { string } = json,
+            equalityNode = instantiateEquality(string, context),
+            node = equalityNode,  ///
+            leftTerm = leftTermFromEqualityNode(equalityNode, context),
+            rightTerm = rightTermFromEqualityNode(equalityNode, context);
+
+      context = null;
+
+      const equality = new Equality(context, string, node, leftTerm, rightTerm);
+
+      return equality;
+    }, context);
+
+    return equality;
+  }
 });
+
+function leftTermFromEqualityNode(equalityNode, context) {
+  const leftTermNode = equalityNode.getLeftTermNode(),
+        leftTerm = context.findTermByTermNode(leftTermNode);
+
+  return leftTerm;
+}
+
+function rightTermFromEqualityNode(equalityNode, context) {
+  const rightTermNode = equalityNode.getLeftTermNode(),
+        rightTerm = context.findTermByTermNode(rightTermNode);
+
+  return rightTerm;
+}

package/src/element/frame.js

@@ -6,8 +6,8 @@ import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { metavariableFromFrameNode } from "../utilities/element";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
-import { assumptionsFromJSON, metavariableFromJSON, assumptionsToAssumptionsJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -348,15 +348,9 @@ export default define(class Frame extends Element {
   }
 
   toJSON() {
-    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
-          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
-          metavariable = metavariableJSON,  ///
-          assumptions = assumptionsJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            assumptions,
-            metavariable
+            string
           };
 
     return json;
@@ -369,9 +363,12 @@ export default define(class Frame extends Element {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
             node = frameNode,  ///
-            assumptions = assumptionsFromJSON(json, context),
-            metavariable = metavariableFromJSON(json, context),
-            frame = new Frame(context, string, node, assumptions, metavariable);
+            assumptions = assumptionsFromFrameNode(frameNode, context),
+            metavariable = metavariableFromFrameNode(frameNode, context);
+
+      context = null;
+
+      const frame = new Frame(context, string, node, assumptions, metavariable);
 
       return frame;
     }, context);
@@ -379,3 +376,15 @@ export default define(class Frame extends Element {
     return frame;
   }
 });
+
+function assumptionsFromFrameNode(frameNode, context) {
+  const assumptionNodes = frameNode.getAssumptionNodes(),
+        assumptions = assumptionNodes.map((assumptionNode) => {
+          const assumption = context.findAssumptionByAssumptionNode(assumptionNode);
+
+          return assumption;
+        });
+
+  return assumptions;
+}
+

package/src/element/hypothesis.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import {literally} from "../utilities/context";
+import { instantiateHypothesis } from "../process/instantiate";
+import { statementFromHypothesisNode } from "../utilities/element";
 
 export default define(class Hypothesis extends Element {
   constructor(context, string, node, statement) {
@@ -87,12 +89,9 @@ export default define(class Hypothesis extends Element {
   }
 
   toJSON() {
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            statement
+            string
           };
 
     return json;
@@ -101,6 +100,19 @@ export default define(class Hypothesis extends Element {
   static name = "Hypothesis";
 
   static fromJSON(json, context) {
-    debugger
+    const hypothesis = literally((context) => {
+      const { string } = json,
+            hypothesisNode = instantiateHypothesis(string, context),
+            node = hypothesisNode,  ///
+            statement = statementFromHypothesisNode(hypothesisNode, context);
+
+      context = null;
+
+      const hypothesis = new Hypothesis(context, string, node, statement);
+
+      return hypothesis;
+    }, context);
+
+    return hypothesis;
   }
 });