occam-verify-cli 1.0.686 → 1.0.688

package/src/element/frame.js

@@ -3,16 +3,18 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
-import { assumptionsToAssumptionsJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { assumptionsFromJSON, metavariableFromJSON, assumptionsToAssumptionsJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Frame extends Element {
-  constructor(context, string, node, assumptions, metavairable) {
+  constructor(context, string, node, assumptions, metavariable) {
     super(context, string, node);
 
     this.assumptions = assumptions;
-    this.metavariable = metavairable;
+    this.metavariable = metavariable;
   }
 
   getAssumptions() {
@@ -363,6 +365,17 @@ export default define(class Frame extends Element {
   static name = "Frame";
 
   static fromJSON(json, context) {
-    debugger
+    const frame = literally((context) => {
+      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);
+
+      return frame;
+    }, context);
+
+    return frame;
   }
 });

package/src/element/parameter.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { nameToNameJSON, identifierToIdentifierJSON } from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateParameter } from "../process/instantiate";
+import { nameFromJSON, nameToNameJSON, identifierFromJSON, identifierToIdentifierJSON } from "../utilities/json";
 
 export default define(class Parameter extends Element {
   constructor(context, string, node, name, identifier) {
@@ -65,6 +67,17 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    debugger
+    const parameter = literally((context) => {
+      const { string } = json,
+            parameterNode = instantiateParameter(string, context),
+            node = parameterNode,  ///
+            name = nameFromJSON(json, context),
+            identifier = identifierFromJSON(json, context),
+            parameter = new Parameter(context, string, node, name, identifier);
+
+      return parameter;
+    }, context);
+
+    return parameter;
   }
 });

package/src/element/procedureCall.js

@@ -4,7 +4,9 @@ import { Element } from "occam-languages";
 import { termsUtilities } from "occam-furtle";
 
 import { define } from "../elements";
-import { parametersToParametersJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateProcedureCall } from "../process/instantiate";
+import { parametersFromJSON, parametersToParametersJSON, procedureReferenceFromJSON, procedureReferenceToProcedureReferenceJSON } from "../utilities/json";
 
 const { termsFromPrimitives } = termsUtilities;
 
@@ -129,6 +131,17 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    debugger
+    const procedureCall = literally((context) => {
+      const { string } = json,
+            procedureCallNode = instantiateProcedureCall(string, context),
+            node = procedureCallNode,  ///
+            parameters = parametersFromJSON(json, context),
+            procedureReference = procedureReferenceFromJSON(json, context),
+            procedureCall = new ProcedureCall(context, string, node, parameters, procedureReference);
+
+      return procedureCall;
+    }, context);
+
+    return procedureCall;
   }
 });

package/src/element/procedureReference.js

@@ -3,11 +3,14 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {nameToNameJSON} from "../utilities/json";
+import { literally } from "../utilities/context";
+import { nameFromJSON, nameToNameJSON } from "../utilities/json";
+import { instantiateProcedureReference } from "../process/instantiate";
 
 export default define(class ProcedureReference extends Element {
   constructor(context, string, node, name) {
     super(context, string, node);
+
     this.name = name;
   }
 
@@ -43,6 +46,16 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   static fromJSON(json, context) {
-    debugger
+    const procedureReference = literally((context) => {
+      const { string } = json,
+            procedureReferenceNode = instantiateProcedureReference(string, context),
+            node = procedureReferenceNode,  ///
+            name = nameFromJSON(json, context),
+            procedureReference = new ProcedureReference(context, string, node, name);
+
+      return procedureReference;
+    }, context);
+
+    return procedureReference;
   }
 });

package/src/element/proofAssertion/supposition.js

@@ -311,7 +311,7 @@ export default define(class Supposition extends ProofAssertion {
   static name = "Supposition";
 
   static fromJSON(json, context) {
-    const premise = literally((context) => {
+    const supposition = literally((context) => {
       const { string } = json,
             suppositionNode = instantiateSupposition(string, context),
             node = suppositionNode,  ///
@@ -321,13 +321,13 @@ export default define(class Supposition extends ProofAssertion {
 
       context = ephemeralContext; ///
 
-      const premise = new Supposition(context, string, node, statement, procedureCall);
+      const supposition = new Supposition(context, string, node, statement, procedureCall);
 
-      return premise;
+      return supposition;
 
     }, context);
 
-    return premise;
+    return supposition;
   }
 });
 

package/src/element/term.js

@@ -245,7 +245,6 @@ export default define(class Term extends Element {
             term = new Term(context, string, node, type);
 
       return term;
-
     }, context);
 
     return term;

package/src/element/variable.js

@@ -5,7 +5,14 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { typeToTypeJSON, identifierToIdentifierJSON, propertyRelationsToPropertyRelationsJSON } from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateVariable } from "../process/instantiate";
+import { typeFromJSON,
+         typeToTypeJSON,
+         identifierFromJSON,
+         propertyRelationsFromJSON,
+         identifierToIdentifierJSON,
+         propertyRelationsToPropertyRelationsJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
   constructor(context, string, node, type, identifier, propertyRelations) {
@@ -208,6 +215,18 @@ export default define(class Variable extends Element {
   static name = "Variable";
 
   static fromJSON(json, context) {
-    debugger
+    const variable = literally((context) => {
+      const { string } = json,
+            variableNode = instantiateVariable(string, context),
+            node = variableNode,  ///
+            type = typeFromJSON(json, context),
+            identifier = identifierFromJSON(json, context),
+            propertyRelations = propertyRelationsFromJSON(json, context),
+            variable = new Variable(context, string, node, type, identifier, propertyRelations);
+
+      return variable;
+    }, context);
+
+    return variable;
   }
 });

package/src/process/instantiate.js

@@ -1,8 +1,12 @@
 "use strict";
 
 import { ruleFromRuleName } from "../utilities/bnf";
-import { LABEL_RULE_NAME,
+import { TERM_RULE_NAME,
+         FRAME_RULE_NAME,
+         LABEL_RULE_NAME,
          PREMISE_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         PARAMETER_RULE_NAME,
          STATEMENT_RULE_NAME,
          REFERENCE_RULE_NAME,
          COMBINATOR_RULE_NAME,
@@ -10,14 +14,22 @@ import { LABEL_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         PROCEDURE_CALL_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
          TERM_SUBSTITUTION_RULE_NAME,
-         FRAME_SUBSTITUTION_RULE_NAME,
          SUBPROOF_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         PROCEDURE_REFERENCE_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
-const labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
+const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
+      framePlaceholderRule = ruleFromRuleName(FRAME_RULE_NAME),
+      labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
       premisePlaceholderRule = ruleFromRuleName(PREMISE_RULE_NAME),
+      variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
+      parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
       statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
       referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
       combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
@@ -25,12 +37,20 @@ const labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
       metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
-      subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
+      procedureCalllaceholderRule = ruleFromRuleName(PROCEDURE_CALL_RULE_NAME),
+      definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
+      subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
       frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
+      procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
+      containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
+export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+
+export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+
 export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
 
 export function instantiatePremise(string, context) {
@@ -40,6 +60,10 @@ export function instantiatePremise(string, context) {
   return instantiate(premisePlaceholderRule, string, context);
 }
 
+export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
+
+export function instantiateParameter(string, context) { return instantiate(parameterPlaceholderRule, string, context); }
+
 export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
 
 export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
@@ -59,12 +83,20 @@ export function instantiateEquivalence(string, context) { return instantiate(equ
 
 export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
 
+export function instantiateProcedureCall(string, context) { return instantiate(procedureCalllaceholderRule, string, context); }
+
+export function instantiateDefinedAssertion(string, context) { return instantiate(definedAssertionPlaceholderRule, string, context); }
+
 export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateSubproofAssertion(string, context) { return instantiate(subproofAssertionlaceholderRule, string, context); }
 
 export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
 
+export function instantiateProcedureReference(string, context) { return instantiate(procedureReferencelaceholderRule, string, context); }
+
+export function instantiateContainedAssertion(string, context) { return instantiate(containedAssertionPlaceholderRule, string, context); }
+
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }

package/src/utilities/json.js

@@ -28,13 +28,15 @@ export function nameFromJSON(json, context) {
 export function termFromJSON(json, context) {
   let { term } = json;
 
-  const termJSON = term;  ///
+  if (term !== null) {
+    const termJSON = term;  ///
 
-  json = termJSON;  ///
+    json = termJSON;  ///
 
-  const { Term } = elements;
+    const { Term } = elements;
 
-  term = Term.fromJSON(json, context);
+    term = Term.fromJSON(json, context);
+  }
 
   return term;
 }
@@ -56,6 +58,28 @@ export function typeFromJSON(json, context) {
   return type;
 }
 
+export function frameFromJSON(json, context) {
+  let { frame } = json;
+
+  if (frame !== null) {
+    const frameJSON = frame;  ///
+
+    json = frameJSON;  ///
+
+    const { Frame } = elements;
+
+    frame = Frame.fromJSON(json, context);
+  }
+
+  return frame;
+}
+
+export function negatedFromJSON(json, context) {
+  const { negated } = json;
+
+  return negated;
+}
+
 export function metaTypeFromJSON(json, context) {
   let { metaType } = json;
 
@@ -127,6 +151,16 @@ export function referenceFromJSON(json, context) {
   return reference;
 }
 
+export function identifierFromJSON(json, context) {
+  let { identifier } = json;
+
+  const identifierJSON = identifier;  ///
+
+  identifier = identifierJSON;  ///
+
+  return identifier;
+}
+
 export function conclusionFromJSON(json, context) {
   let { conclusion } = json;
 
@@ -243,11 +277,11 @@ export function framesFromJSON(json, context) {
   let { frames } = json;
 
   const { Frame } = elements,
-        framesJSON = frames; ///
+    framesJSON = frames; ///
 
   frames = framesJSON.map((frameJSON) => {
     const json = frameJSON,  ///
-          frame = Frame.fromJSON(json, context);
+      frame = Frame.fromJSON(json, context);
 
     return frame;
   });
@@ -644,6 +678,22 @@ export function ephemeralContextFromJSON(json, context) {
   return emphemeralContext;
 }
 
+export function propertyRelationsFromJSON(json, context) {
+  let { propertyRelations } = json;
+
+  const { PropertyRelation } = elements,
+        propertyRelationsJSON = propertyRelations; ///
+
+  propertyRelations = propertyRelationsJSON.map((propertyRelationJSON) => {
+    const json = propertyRelationJSON,  ///
+          propertyRelation = PropertyRelation.fromJSON(json, context);
+
+    return propertyRelation;
+  });
+
+  return propertyRelations;
+}
+
 export function nameToNameJSON(name) {
   const nameJSON = name;  ///
 

package/src/utilities/string.js

@@ -203,7 +203,7 @@ export function typeStringFromTypeNameTypePrefixNameAndSuperTypes(typeName, type
 export function procedureCallStringFromProcedureReferenceAndParameters(procedureReference, parameters) {
   const procedureReferenceName = procedureReference.getName(),
         parametersString = parametersStringFromParameters(parameters),
-        procedureCallString = `${procedureReferenceName}(${parametersString})`;
+        procedureCallString = `@${procedureReferenceName}(${parametersString})`;
 
   return procedureCallString;
 }