occam-verify-cli 1.0.650 → 1.0.655

package/src/element/declaration/complexType.js

@@ -27,6 +27,55 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return complexTypeDeclarationNode;
   }
 
+  async verify() {
+    let verifies = false;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const complexTypeDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
+
+    if (this.prefixed) {
+      const typeString = this.type.getString();
+
+      context.trace(`The '${typeString}' type is prefixed.`);
+    } else {
+      const typeVerifies = this.verifyType();
+
+      if (typeVerifies) {
+        const superTypesVerify = this.verifySuperTypes();
+
+        if (superTypesVerify) {
+          const propertiesVerify = this.verifyProperties();
+
+          if (propertiesVerify) {
+            const typePrefix = context.getTypePrefix();
+
+            if (typePrefix !== null) {
+              const typePrefixName = typePrefix.getName(),
+                    prefixName = typePrefixName;  ///
+
+              this.type.setPrefixName(prefixName);
+            }
+
+            context.addType(this.type);
+
+            verifies = true;
+          }
+        }
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyType() {
     let typeVerifies = false;
 
@@ -263,54 +312,5 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return propertyNominalTypeNameVerifies;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const complexTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
-
-    if (this.prefixed) {
-      const typeString = this.type.getString();
-
-      context.trace(`The '${typeString}' type is prefixed.`);
-    } else {
-      const typeVerifies = this.verifyType();
-
-      if (typeVerifies) {
-        const superTypesVerify = this.verifySuperTypes();
-
-        if (superTypesVerify) {
-          const propertiesVerify = this.verifyProperties();
-
-          if (propertiesVerify) {
-            const typePrefix = context.getTypePrefix();
-
-            if (typePrefix !== null) {
-              const typePrefixName = typePrefix.getName(),
-                    prefixName = typePrefixName;  ///
-
-              this.type.setPrefixName(prefixName);
-            }
-
-            context.addType(this.type);
-
-            verifies = true;
-          }
-        }
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "ComplexTypeDeclaration";
 });

package/src/element/declaration/constructor.js

@@ -32,6 +32,38 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorDeclarationNode;
   }
 
+  async verify() {
+    let verifies = false;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const constructorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+
+    const typeVerified = this.verifyType();
+
+    if (typeVerified) {
+      const constructorVerifies = this.verifyConstructor();
+
+      if (constructorVerifies) {
+        this.constructor.setType(this.type);
+
+        context.addConstructor(this.constructor);
+
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyType() {
     let typeVerifies = false;
 
@@ -86,37 +118,5 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorVerifies;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const constructorDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const typeVerified = this.verifyType();
-
-    if (typeVerified) {
-      const constructorVerifies = this.verifyConstructor();
-
-      if (constructorVerifies) {
-        this.constructor.setType(this.type);
-
-        context.addConstructor(this.constructor);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "ConstructorDeclaration";
 });

package/src/element/declaration/metavariable.js

@@ -20,6 +20,32 @@ export default define(class MetavariableDeclaration extends Declaration {
     return this.metavariable;
   }
 
+  async verify() {
+    let verifies;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const metavariableDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
+
+    const metavariableVerifies = this.verifyMetavariable();
+
+    if (metavariableVerifies) {
+      context.addMetavariable(this.metavariable);
+
+      verifies = true;
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyMetavariable() {
     let metavariableVerifies = false;
 
@@ -91,31 +117,5 @@ export default define(class MetavariableDeclaration extends Declaration {
     return metavariableTypeVerified;
   }
 
-  async verify() {
-    let verifies;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const metavariableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
-
-    const metavariableVerifies = this.verifyMetavariable();
-
-    if (metavariableVerifies) {
-      context.addMetavariable(this.metavariable);
-
-      verifies = true;
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "MetavariableDeclaration";
 });

package/src/element/declaration/simpleType.js

@@ -34,6 +34,40 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return simpleTypeDeclarationNode;
   }
 
+  async verify() {
+    let verifies = false;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const simpleTypeDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
+
+    const typeVerifies = this.verifyType();
+
+    if (typeVerifies) {
+      const superTypesVerify = this.verifySuperTypes();
+
+      if (superTypesVerify) {
+        const typePrefixVerifies = this.verifyTypePrefix();
+
+        if (typePrefixVerifies) {
+          context.addType(this.type);
+
+          verifies = true;
+        }
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyType() {
     let typeVerifies = false;
 
@@ -168,39 +202,5 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typePrefixVerifies;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const simpleTypeDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration...`);
-
-    const typeVerifies = this.verifyType();
-
-    if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes();
-
-      if (superTypesVerify) {
-        const typePrefixVerifies = this.verifyTypePrefix();
-
-        if (typePrefixVerifies) {
-          context.addType(this.type);
-
-          verifies = true;
-        }
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "SimpleTypeDeclaration";
 });

package/src/element/declaration/typePrefix.js

@@ -22,6 +22,41 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return typePrefixDeclarationNode;
   }
 
+  async verify() {
+    let verifies = false;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const typePrefixDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
+
+    const includeRelease = true,
+          includeDependencies = false,
+          types = context.getTypes(includeRelease, includeDependencies),
+          typesLength = types.length;
+
+    if (typesLength === 0) {
+      const typePrefixVerifies = this.verifyTypePrefix();
+
+      if (typePrefixVerifies) {
+        context.addTypePrefix(this.typePrefix);
+
+        verifies = true;
+      }
+    } else {
+      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`);
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyTypePrefix() {
     let typePrefixVerifies = false;
 
@@ -60,40 +95,5 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return typePrefixVerifies;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const typePrefixDeclarationString = this.getString();  ///
-
-    context.trace(`Verifying the '${typePrefixDeclarationString}' type prefix declaration...`);
-
-    const includeRelease = true,
-          includeDependencies = false,
-          types = context.getTypes(includeRelease, includeDependencies),
-          typesLength = types.length;
-
-    if (typesLength > 0) {
-      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`);
-    } else {
-      const typePrefixVerifies = this.verifyTypePrefix();
-
-      if (typePrefixVerifies) {
-        context.addTypePrefix(this.typePrefix);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${typePrefixDeclarationString}' type prefix declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "TypePrefixDeclaration";
 });

package/src/element/declaration/variable.js

@@ -32,6 +32,36 @@ export default define(class VariableDeclaration extends Declaration {
     return typePrefixDeclarationNode;
   }
 
+  async verify() {
+    let verifies = false;
+
+    const context = this.getContext();
+
+    await this.break(context);
+
+    const variableDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
+
+    const typeVerifies = this.verifyType();
+
+    if (typeVerifies) {
+      const variableVerifies = this.verifyVariable();
+
+      if (variableVerifies) {
+        context.addVariable(this.variable);
+
+        verifies = true;
+      }
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
+    }
+
+    return verifies;
+  }
+
   verifyType() {
     let typeVerifies = false;
 
@@ -94,35 +124,5 @@ export default define(class VariableDeclaration extends Declaration {
     return variableVerifies;
   }
 
-  async verify() {
-    let verifies = false;
-
-    const context = this.getContext();
-
-    await this.break(context);
-
-    const variableDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${variableDeclarationString}' variable declaration...`);
-
-    const typeVerifies = this.verifyType();
-
-    if (typeVerifies) {
-      const variableVerifies = this.verifyVariable();
-
-      if (variableVerifies) {
-        context.addVariable(this.variable);
-
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${variableDeclarationString}' variable declaration.`);
-    }
-
-    return verifies;
-  }
-
   static name = "VariableDeclaration";
 });

package/src/element/deduction.js

@@ -140,11 +140,6 @@ export default define(class Deduction extends Element {
   static name = "Deduction";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context),
-          string = statement.getString();
-
-    const deduction = new Deduction(context, string, statement);
-
-    return deduction;
+    debugger
   }
 });

package/src/element/equivalences.js

@@ -5,7 +5,7 @@ import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
 import { EMPTY_STRING } from "../constants";
-import { variablesFromTerm } from "./term";
+import { variablesFromTerm } from "../utilities/equivalence";
 
 const { push, separate } = arrayUtilities;
 

package/src/element/frame.js

@@ -363,20 +363,6 @@ export default define(class Frame extends Element {
   static name = "Frame";
 
   static fromJSON(json, context) {
-    let frame = null;
-
-    if (json !== null) {
-      const { Assumption } =elements,
-            assumption = Assumption.fromJSON(json, context),
-            assumptions = [
-              assumption
-            ],
-            string = null,
-            node = null;
-
-      frame = new Frame(string, node, assumptions);
-    }
-
-    return frame;
+    debugger
   }
 });

package/src/element/hypothesis.js

@@ -23,6 +23,28 @@ export default define(class Hypothesis extends Element {
     return hypothesisNode;
   }
 
+  compareProofAssertion(proofAssertion, context) {
+    let comparesToProofAssertion = false;
+
+    const hypothesisString = this.getString(), ///
+          proofAssertionString = proofAssertion.getString();
+
+    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`);
+
+    const proofAssertionStatement = proofAssertion.getStatement(),
+          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
+
+    if (statementEqualToStepStatement) {
+      comparesToProofAssertion = true;
+    }
+
+    if (comparesToProofAssertion) {
+      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`);
+    }
+
+    return comparesToProofAssertion;
+  }
+
   async verify(context) {
     let verifies = false;
 
@@ -64,28 +86,6 @@ export default define(class Hypothesis extends Element {
     return verifies;
   }
 
-  compareProofAssertion(proofAssertion, context) {
-    let comparesToProofAssertion = false;
-
-    const hypothesisString = this.getString(), ///
-          proofAssertionString = proofAssertion.getString();
-
-    context.trace(`Is the '${hypothesisString}' hypothesis equal to the '${proofAssertionString}' proof assertion...`);
-
-    const proofAssertionStatement = proofAssertion.getStatement(),
-          statementEqualToStepStatement = this.statement.isEqualTo(proofAssertionStatement);
-
-    if (statementEqualToStepStatement) {
-      comparesToProofAssertion = true;
-    }
-
-    if (comparesToProofAssertion) {
-      context.trace(`...the '${hypothesisString}' hypothesis is equal to the '${proofAssertionString}' proof assertion.`);
-    }
-
-    return comparesToProofAssertion;
-  }
-
   toJSON() {
     const statementJSON = statementToStatementJSON(this.statement),
           statement = statementJSON,  ///
@@ -99,17 +99,6 @@ export default define(class Hypothesis extends Element {
   static name = "Hypothesis";
 
   static fromJSON(json, context) {
-    const statement = statementFromJSON(json, context);
-
-    let string;
-
-    if (statement !== null) {
-      string = statement.getString();
-    }
-
-    const node = null,
-          hypothesis = new Hypothesis(context, string, node, statement);
-
-    return hypothesis;
+    debugger
   }
 });

package/src/element/label.js

@@ -3,7 +3,10 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateLabel } from "../process/instantiate";
+import { metavariableToMetavariableJSON } from "../utilities/json";
+import { metavariableFromMetavariableNode } from "../utilities/element";
 
 export default define(class Label extends Element {
   constructor(context, string, node, metavariable) {
@@ -75,7 +78,9 @@ export default define(class Label extends Element {
   toJSON() {
     const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
           metavariable = metavariableJSON,  ///
+          string = this.getString(),
           json = {
+            string,
             metavariable
           };
 
@@ -85,11 +90,23 @@ export default define(class Label extends Element {
   static name = "Label";
 
   static fromJSON(json, context) {
-    const metavariable = metavariableFromJSON(json, context),
-          string = metavariable.getString(),
-          node = metavariable.getNode(),
-          label = new Label(context, string, node, metavariable);
+    const label = literally((context) => {
+      const { string } = json,
+            labelNode = instantiateLabel(string, context),
+            metavariable = metavariableFromLabelNode(labelNode, context),
+            node = labelNode, ///
+            label = new Label(context, string, node, metavariable);
+
+      return label;
+    }, context);
 
     return label;
   }
 });
+
+function metavariableFromLabelNode(labelNode, context) {
+  const metavariableNode = labelNode.getMetavariableNode(),
+        metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+  return metavariable;
+}