occam-verify-cli 1.0.612 → 1.0.631

package/src/element/assertion/property.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { variableAssignmentFromVariable } from "../../process/assign";
+import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
 
 export default define(class PropertyAssertion extends Assertion {
   constructor(context, string, node, term, propertyRelation) {
@@ -76,7 +75,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         if (propertyRelationVerifies) {
           let validatesWhenStated = false,
-            validatesWhenDerived = false;
+              validatesWhenDerived = false;
 
           if (stated) {
             validatesWhenStated = this.validateWhenStated(assignments, context);
@@ -91,12 +90,12 @@ export default define(class PropertyAssertion extends Assertion {
       }
 
       if (validates) {
-        if (stated) {
-          this.assign(assignments, context);
-        }
-      }
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
+        this.assign(assignments, stated, context);
 
-      if (validates) {
         context.debug(`...validated the '${propertyAssertionString}' property assertion.`);
       }
     }
@@ -172,30 +171,20 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
-    let variable;
-
-    const { Variable } = elements,
-          termNode = this.term.getNode();
-
-    variable = Variable.fromTermNode(termNode, context);
-
-    if (variable !== null) {
-      const variableIdentifier = variable.getIdentifier();
-
-      variable = context.findVariableByVariableIdentifier(variableIdentifier);
-
-      variable = Variable.fromVariableAndPropertyRelation(variable, this.propertyRelation);
+    if (!stated) {
+      return;
+    }
 
-      const variableAssignment = variableAssignmentFromVariable(variable),
-            assignment = variableAssignment;  ///
+    const propertyAssertion = this, ///
+          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context),
+          assignment = variableAssigment; ///
 
-      assignments.push(assignment);
-    }
+    assignments.push(assignment);
   }
 
   static name = "PropertyAssertion";

package/src/element/assertion/satisfies.js

@@ -54,6 +54,10 @@ export default define(class SatisfiesAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${satisfiesAssertionString}' satisfies assertion.`);
       }
     }

package/src/element/assertion/subproof.js

@@ -48,6 +48,10 @@ export default define(class SubproofAssertion extends Assertion {
       }
 
       if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
         context.debug(`...validated the '${subproofAssertionString}' subproof assertion.`);
       }
     }

package/src/element/assertion/type.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import elements from "../../elements";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { variableAssignmentFromVariable } from "../../process/assign";
+import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -29,49 +28,57 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  verify(assignments, stated, context) {
-    let verifies = false;
+  validate(assignments, stated, context) {
+    let validates = false;
 
-    let typeAssertionString = this.getString();  ///
+    const typeAssertionString = this.getString();  ///
 
-    context.trace(`Verifying the '${typeAssertionString}' type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' type assertion...`);
 
-    const typeVerifies = this.verifyType(context);
+    const valid = this.isValid();
 
-    if (typeVerifies) {
-      let verifiesWhenStated = false,
-          verifiesWhenDerived = false;
+    if (valid) {
+      validates = true;
 
-      if (stated) {
-        verifiesWhenStated = this.verifyWhenStated(assignments, context);
-      } else {
-        verifiesWhenDerived = this.verifyWhenDerived(context);
-      }
+      context.debug(`...the '${typeAssertionString}' type assertion is already valid.`);
+    } else {
+      const typeValidates = this.validateType(context);
 
-      if (verifiesWhenStated || verifiesWhenDerived) {
-        verifies = true;
-      }
-    }
+      if (typeValidates) {
+        let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+        if (stated) {
+          validatesWhenStated = this.validateWhenStated(assignments, context);
+        } else {
+          validatesWhenDerived = this.validateWhenDerived(context);
+        }
 
-    if (verifies) {
-      if (stated) {
-        this.assign(assignments, context);
+        if (validatesWhenStated || validatesWhenDerived) {
+          validates = true;
+        }
       }
-    }
 
-    if (verifies) {
-      context.debug(`...verified the '${typeAssertionString}' type assertion.`);
+      if (validates) {
+        const assertion = this; ///
+
+        context.addAssertion(assertion);
+
+        this.assign(assignments, stated, context);
+
+        context.debug(`...verified the '${typeAssertionString}' type assertion.`);
+      }
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyType(context) {
-    let typeVerifies;
+  validateType(context) {
+    let typeValidates;
 
     const typeString = this.type.getString();
 
-    context.trace(`Verifying the '${typeString}' type...`);
+    context.trace(`Validating the '${typeString}' type...`);
 
     const nominalTypeName = this.type.getNominalTypeName(),
           type = context.findTypeByNominalTypeName(nominalTypeName);
@@ -79,58 +86,58 @@ export default define(class TypeAssertion extends Assertion {
     if (type !== null) {
       this.type = type;
 
-      typeVerifies = true;
+      typeValidates = true;
     } else {
       context.debug(`The '${typeString}' type is not present.`);
     }
 
-    if (typeVerifies) {
+    if (typeValidates) {
       context.debug(`...verified the '${typeString}' type.`);
     }
 
-    return typeVerifies;
+    return typeValidates;
   }
 
-  verifyWhenStated(assignments, context) {
-    let verifiesWhenStated = false;
+  validateWhenStated(assignments, context) {
+    let validatesWhenStated = false;
 
     const typeAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const termVerifies = this.term.verify(context, () => {
-      let verifiesForwards;
+    const termValidates = this.term.validate(context, () => {
+      let validatesForwards;
 
       const termType = this.term.getType(),
             typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
 
       if (typeEqualToOrSubTypeOfTermType) {
-        verifiesForwards = true;
+        validatesForwards = true;
       }
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
-    if (termVerifies) {
-      verifiesWhenStated = true;
+    if (termValidates) {
+      validatesWhenStated = true;
     }
 
-    if (verifiesWhenStated) {
+    if (validatesWhenStated) {
       context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
     }
 
-    return verifiesWhenStated;
+    return validatesWhenStated;
   }
 
-  verifyWhenDerived(context) {
-    let verifiesWhenDerived;
+  validateWhenDerived(context) {
+    let validatesWhenDerived;
 
     const typeAssertionString = this.getString(); ///
 
-    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
+    context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const termVerifies = this.term.verify(context, () => {
-      let verifiesForwards = false;
+    const termValidates = this.term.validate(context, () => {
+      let validatesForwards = false;
 
       const termType = this.term.getType(),
             termTypeProvisional = termType.isProvisional();
@@ -138,52 +145,35 @@ export default define(class TypeAssertion extends Assertion {
       if (!termTypeProvisional) {
         const typeEqualToOrSuperTypeOfTermType = this.type.isEqualToOrSuperTypeOf(termType);
 
-        verifiesForwards = typeEqualToOrSuperTypeOfTermType; ///
+        validatesForwards = typeEqualToOrSuperTypeOfTermType; ///
       }
 
-      return verifiesForwards;
+      return validatesForwards;
     });
 
-    verifiesWhenDerived = termVerifies; ///
+    validatesWhenDerived = termValidates; ///
 
-    if (verifiesWhenDerived) {
+    if (validatesWhenDerived) {
       context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
     }
 
-    return verifiesWhenDerived;
+    return validatesWhenDerived;
   }
 
-  assign(assignments, context) {
+  assign(assignments, stated, context) {
     if (assignments === null) {
       return;
     }
 
-    const { Type, Variable } = elements,
-          termNode = this.term.getNode();
-
-    let type,
-        provisional;
-
-    provisional = this.type.isProvisional();
-
-    if (!provisional) {
-      type = this.type;
-    } else {
-      provisional = false;
-
-      type = Type.fromTypeAndProvisional(this.type, provisional);
+    if (!stated) {
+      return;
     }
 
-    const singularVariableNode = termNode.getSingularVariableNode();
+    const typeAssertion = this, ///
+          variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context),
+          assignment = variableAssigment;  ///
 
-    if (singularVariableNode !== null) {
-      const variableNode = singularVariableNode,  ///
-            variable = Variable.fromVariableNodeAndType(variableNode, type, context),
-            variableAssignment = variableAssignmentFromVariable(variable),
-            assignment = variableAssignment;  ///
-
-      assignments.push(assignment);
-    }
+    assignments.push(assignment);
   }
 
   static name = "TypeAssertion";

package/src/element/assertion.js

@@ -3,10 +3,6 @@
 import { Element } from "occam-languages";
 
 export default class Assertion extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
-
   getAssertionNode() {
     const node = this.getNode(),
           assertionNode = node; ///
@@ -21,9 +17,9 @@ export default class Assertion extends Element {
 
     const assertionNodeB = assertionNode, ///
           assertionNodeAAMatchesAssertionBNodeB = assertionNodeA.match(assertionNodeB),
-          equalTo = assertionNodeAAMatchesAssertionBNodeB; ///
+          assertionNodeMatches = assertionNodeAAMatchesAssertionBNodeB; ///
 
-    return equalTo;
+    return assertionNodeMatches;
   }
 
   isValid(context) {
@@ -36,8 +32,8 @@ export default class Assertion extends Element {
 
   isEqualTo(assertion) {
     const assertionNode = assertion.getNode(),
-      assertionNodeMatches = this.matchAssertionNode(assertionNode),
-      equalTo = assertionNodeMatches;  ///
+          assertionNodeMatches = this.matchAssertionNode(assertionNode),
+          equalTo = assertionNodeMatches;  ///
 
     return equalTo;
   }

package/src/element/assumption.js

@@ -14,16 +14,35 @@ export default define(class Assumption extends Element {
     this.reference = reference;
   }
 
+  getReference() {
+    return this.reference;
+  }
+
   getStatement() {
     return this.statement;
   }
 
-  getReference() {
-    return this.reference;
+  getAssumptionNode() {
+    const node = this.getNode(),
+          assumptionNode = node;  ///
+
+    return assumptionNode;
   }
 
   getMetavariable() { return this.reference.getMetavariable(); }
 
+  matchAssumptionNode(assumptionode) {
+    const assumptionodeA = assumptionode; ///
+
+    assumptionode = this.getAssumptionNode();
+
+    const assumptionodeB = assumptionode, ///
+          assumptionodeAAMatchesAssumptionBNodeB = assumptionodeA.match(assumptionodeB),
+          assumptionodeMatches = assumptionodeAAMatchesAssumptionBNodeB; ///
+
+    return assumptionodeMatches;
+  }
+
   compareSubstitution(substitution, context) {
     let comparesToSubstituion = false;
 
@@ -48,6 +67,14 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
+  isValid(context) {
+    const assumptionNode = this.getAssumptionNode(),
+          assumptionPresent = context.isAssumptionPresentByAssumptionNode(assumptionNode),
+          valid = assumptionPresent;  ///
+
+    return valid;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 
@@ -55,29 +82,41 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const referenceValidates = this.validateReference(assignments, stated, context);
+    const valid = this.isValid(context);
 
-    if (referenceValidates) {
-      const statementValidates = this.validateStatement(assignments, stated, context);
+    if (valid) {
+      validates = true;
 
-      if (statementValidates) {
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
+      context.debug(`...the '${assumptionString}' assumption is already valid.`);
+    } else {
+      const referenceValidates = this.validateReference(assignments, stated, context);
 
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
+      if (referenceValidates) {
+        const statementValidates = this.validateStatement(assignments, stated, context);
 
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
+        if (statementValidates) {
+          let validatesWhenStated = false,
+              validatesWhenDerived = false;
+
+          if (stated) {
+            validatesWhenStated = this.validateWhenStated(assignments, context);
+          } else {
+            validatesWhenDerived = this.validateWhenDerived(context);
+          }
+
+          if (validatesWhenStated || validatesWhenDerived) {
+            validates = true;
+          }
         }
       }
-    }
 
-    if (validates) {
-      context.debug(`...validated the '${assumptionString}' assumption.`);
+      if (validates) {
+        const assumption = this;  ///
+
+        context.addAssumption(assumption);
+
+        context.debug(`...validated the '${assumptionString}' assumption.`);
+      }
     }
 
     return validates;

package/src/element/combinator.js

@@ -18,6 +18,13 @@ export default define(class Combinator extends Element {
     return this.statement;
   }
 
+  getConbinatorNode() {
+    const node = this.getNode(),
+          combinatorNode = node;  ///
+
+    return combinatorNode;
+  }
+
   verify() {
     let verifies;
 

package/src/element/conclusion.js

@@ -17,6 +17,13 @@ export  default define(class Conclusion extends Element {
     return this.statement;
   }
 
+  getConclusionNode() {
+    const node = this.getNode(),
+          conclusionNode = node;  ///
+
+    return conclusionNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/constructor.js

@@ -17,6 +17,13 @@ export default define(class Constructor extends Element {
     return this.term;
   }
 
+  getConclusionNode() {
+    const node = this.getNode(),
+          constructorNode = node;  ///
+
+    return constructorNode;
+  }
+
   isProvisional() { return this.term.isProvisional(); }
 
   getType() { return this.term.getType(); }

package/src/element/declaration.js

@@ -3,7 +3,5 @@
 import { Element } from "occam-languages";
 
 export default class Declaration extends Element {
-  constructor(context, string, node) {
-    super(context, string, node);
-  }
+  ///
 }

package/src/element/deduction.js

@@ -17,6 +17,13 @@ export default define(class Deduction extends Element {
     return this.statement;
   }
 
+  getDeductionNode() {
+    const node = this.getNode(),
+          deductionNode = node; ///
+
+    return deductionNode;
+  }
+
   verify(context) {
     let verifies = false;
 

package/src/element/derivation.js

@@ -21,6 +21,13 @@ export default define(class Derivation extends Element {
     return this.subproofOrProofAssertions;
   }
 
+  getDerivationNode() {
+    const node = this.getNode(),
+          derivationNode = node;  ///
+
+    return derivationNode;
+  }
+
   getLastProofAssertion() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
           lastProofAssertion = lastSubproofOrProofAssertion;  ///
@@ -36,13 +43,11 @@ export default define(class Derivation extends Element {
             subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(assignments, context);
 
       if (subproofOrProofAssertionVerifies) {
-        const assignmentsAssigned = assignAssignments(assignments, context);
+        assignAssignments(assignments, context);
 
-        if (assignmentsAssigned) {
-          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
+        context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          return true;
-        }
+        return true;
       }
     });