occam-verify-cli 1.0.617 → 1.0.631

package/src/context/ephemeral.js

@@ -3,14 +3,17 @@
 import Context from "../context";
 
 export default class EphemeralContext extends Context {
-  constructor(context, terms, frames, statements, assertions, references, substitutions) {
+  constructor(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions) {
     super(context);
 
     this.terms = terms;
     this.frames = frames;
-    this.statements = statements;
+    this.judgements = judgements;
+    this.equalities = equalities;
     this.assertions = assertions;
+    this.statements = statements;
     this.references = references;
+    this.assumptions = assumptions;
     this.substitutions = substitutions;
   }
 
@@ -22,6 +25,14 @@ export default class EphemeralContext extends Context {
     return this.frames;
   }
 
+  getEqualities() {
+    return this.equalities;
+  }
+
+  getJudgements() {
+    return this.judgements;
+  }
+
   getStatements() {
     return this.statements;
   }
@@ -34,6 +45,10 @@ export default class EphemeralContext extends Context {
     return this.references;
   }
 
+  getAssumptions() {
+    return this.assumptions;
+  }
+
   getSubstitutions() {
     return this.substitutions;
   }
@@ -88,6 +103,56 @@ export default class EphemeralContext extends Context {
     }
   }
 
+  addEquality(equality) {
+    const equalityA = equality, ///
+          context = this, ///
+          equalityString = equality.getString();
+
+    context.trace(`Adding the '${equalityString}' equality to the ephemeral context...`);
+
+    const equalityB = this.equalities.find((equality) => {
+      const equalityB = equality, ///
+            equalityAEqualToEqualityB = equalityA.isEqualTo(equalityB);
+
+      if (equalityAEqualToEqualityB) {
+        return true;
+      }
+    }) || null;
+
+    if (equalityB !== null) {
+      context.trace(`The '${equalityString}' equality has already been added to the ephemeral context.`);
+    } else {
+      this.equalities.push(equality);
+
+      context.debug(`...added the '${equalityString}' equality to the ephemeral context.`);
+    }
+  }
+
+  addJudgement(judgement) {
+    const judgementA = judgement, ///
+          context = this, ///
+          judgementString = judgement.getString();
+
+    context.trace(`Adding the '${judgementString}' judgement to the ephemeral context...`);
+
+    const judgementB = this.judgements.find((judgement) => {
+      const judgementB = judgement, ///
+            judgementAEqualToEqualityB = judgementA.isEqualTo(judgementB);
+
+      if (judgementAEqualToEqualityB) {
+        return true;
+      }
+    }) || null;
+
+    if (judgementB !== null) {
+      context.trace(`The '${judgementString}' judgement has already been added to the ephemeral context.`);
+    } else {
+      this.judgements.push(judgement);
+
+      context.debug(`...added the '${judgementString}' judgement to the ephemeral context.`);
+    }
+  }
+
   addStatement(statement) {
     const context = this, ///
           statementA = statement, ///
@@ -163,6 +228,31 @@ export default class EphemeralContext extends Context {
     }
   }
 
+  addAssumption(assumption) {
+    const context = this, ///
+          assumptionA = assumption, ///
+          assumptionString = assumption.getString();
+
+    context.trace(`Adding the '${assumptionString}' assumption to the ephemeral context...`);
+
+    const assumptionB = this.assumptions.find((assumption) => {
+      const assumptionB = assumption, ///
+            assumptionAEqualToAssumptionB = assumptionA.isEqualTo(assumptionB);
+
+      if (assumptionAEqualToAssumptionB) {
+        return true;
+      }
+    }) || null;
+
+    if (assumptionB !== null) {
+      context.trace(`The '${assumptionString}' assumption has already been added to the ephemeral context.`);
+    } else {
+      this.assumptions.push(assumption);
+
+      context.debug(`...added the '${assumptionString}' assumption to the ephemeral context.`);
+    }
+  }
+
   addSubstitution(substitution) {
     const context = this, ///
           substitutionA = substitution, ///
@@ -190,7 +280,7 @@ export default class EphemeralContext extends Context {
 
   findTermByTermNode(termNode) {
     const term = this.terms.find((term) => {
-      const termNodeMatches = term.matchNode(termNode);
+      const termNodeMatches = term.matchTermNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -202,7 +292,7 @@ export default class EphemeralContext extends Context {
 
   findFrameByFrameNode(frameNode) {
     const frame = this.frames.find((frame) => {
-      const frameNodeMatches = frame.matchNode(frameNode);
+      const frameNodeMatches = frame.matchFrameNode(frameNode);
 
       if (frameNodeMatches) {
         return true;
@@ -212,9 +302,33 @@ export default class EphemeralContext extends Context {
     return frame;
   }
 
+  findJudgementByJudgementNode(judgementNode) {
+    const judgement = this.judgements.find((judgement) => {
+      const judgementNodeMatches = judgement.matchJudgementNode(judgementNode);
+
+      if (judgementNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return judgement;
+  }
+
+  findEqualityByEqualityNode(equalityNode) {
+    const equality = this.equalities.find((equality) => {
+      const equalityNodeMatches = equality.matchEqualityNode(equalityNode);
+
+      if (equalityNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return equality;
+  }
+
   findStatementByStatementNode(statementNode) {
     const statement = this.statements.find((statement) => {
-      const statementNodeMatches = statement.matchNode(statementNode);
+      const statementNodeMatches = statement.matchStatementNode(statementNode);
 
       if (statementNodeMatches) {
         return true;
@@ -226,7 +340,7 @@ export default class EphemeralContext extends Context {
 
   findAssertionByAssertionNode(assertionNode) {
     const assertion = this.assertions.find((assertion) => {
-      const assertionNodeMatches = assertion.matchNode(assertionNode);
+      const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
 
       if (assertionNodeMatches) {
         return true;
@@ -236,6 +350,18 @@ export default class EphemeralContext extends Context {
     return assertion;
   }
 
+  findAssumptionByAssumptionNode(assumptionNode) {
+    const assumption = this.assumptions.find((assumption) => {
+      const assumptionNodeMatches = assumption.matchAssumptionNode(assumptionNode);
+
+      if (assumptionNodeMatches) {
+        return true;
+      }
+    }) || null;
+
+    return assumption;
+  }
+
   findReferenceByMetavariableNode(metavariableNode) {
     const reference = this.references.find((reference) => {
       const referenceMatcheMetavariableNode = reference.matchMetavariableNode(metavariableNode);
@@ -250,7 +376,7 @@ export default class EphemeralContext extends Context {
 
   findSubstitutionBySubstitutionNode(substitutionNode) {
     const substitution = this.substitutions.find((substitution) => {
-      const substitutionNodeMatches = substitution.matchNode(substitutionNode);
+      const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
 
       if (substitutionNodeMatches) {
         return true;
@@ -261,73 +387,64 @@ export default class EphemeralContext extends Context {
   }
 
   isTermPresentByTermNode(termNode) {
-    const termPresent = this.terms.some((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    });
+    const term = this.findTermByTermNode(termNode),
+          termPresent = (term !== null);
 
     return termPresent;
   }
 
   isFramePresentByFrameNode(frameNode) {
-    const framePresent = this.frames.some((frame) => {
-      const frameNodeMatches = frame.matchFrameNode(frameNode);
-
-      if (frameNodeMatches) {
-        return true;
-      }
-    });
+    const frame = this.findFrameByFrameNode(frameNode),
+          framePresent = (frame !== null);
 
     return framePresent;
   }
 
-  isStatementPresentByStatementNode(statementNode) {
-    const statementPresent = this.statements.some((statement) => {
-      const statementNodeMatches = statement.matchStatementNode(statementNode);
+  isEqualityPresentByEqualityNode(equalityNode) {
+    const equality = this.findEqualityByEqualityNode(equalityNode),
+          equalityPresent = (equality !== null);
 
-      if (statementNodeMatches) {
-        return true;
-      }
-    });
+    return equalityPresent;
+  }
+
+  isJudgementPresentByJudgementNode(judgementNode) {
+    const judgement = this.findJudgementByJudgementNode(judgementNode),
+          judgementPresent = (judgement !== null);
+
+    return judgementPresent;
+  }
+
+  isStatementPresentByStatementNode(statementNode) {
+    const statement = this.findStatementByStatementNode(statementNode),
+          statementPresent = (statement !== null);
 
     return statementPresent;
   }
 
   isAssertionPresentByAssertionNode(assertionNode) {
-    const assertionPresent = this.assertions.some((assertion) => {
-      const assertionNodeMatches = assertion.matchAssertionNode(assertionNode);
-
-      if (assertionNodeMatches) {
-        return true;
-      }
-    });
+    const assertion = this.findAssertionByAssertionNode(assertionNode),
+          assertionPresent = (assertion !== null);
 
     return assertionPresent;
   }
 
-  isReferencePresentByReferenceNode(referenceNode) {
-    const referencePresent = this.references.some((reference) => {
-      const referenceNodeMatches = reference.matchReferenceNode(referenceNode);
+  isAssumptionPresentByAssumptionNode(assumptionNode) {
+    const assumption = this.findAssumptionByAssumptionNode(assumptionNode),
+          assumptionPresent = (assumption !== null);
 
-      if (referenceNodeMatches) {
-        return true;
-      }
-    });
+    return assumptionPresent;
+  }
+
+  isReferencePresentByMetavariableNode(metavariableNode) {
+    const reference = this.findReferenceByMetavariableNode(metavariableNode),
+          referencePresent = (reference !== null);
 
     return referencePresent;
   }
 
   isSubstitutionPresentBySubstitutionNode(substitutionNode) {
-    const substitutionPresent = this.substitutions.some((substitution) => {
-      const substitutionNodeMatches = substitution.matchSubstitutionNode(substitutionNode);
-
-      if (substitutionNodeMatches) {
-        return true;
-      }
-    });
+    const substitution = this.findSubstitutionBySubstitutionNode(substitutionNode),
+          substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
   }
@@ -335,11 +452,14 @@ export default class EphemeralContext extends Context {
   static fromNothing(context) {
     const terms = [],
           frames = [],
+          judgements = [],
+          equalities = [],
           statements = [],
           assertions = [],
           references = [],
+          assumptions = [],
           substitutions = [],
-          emphemeralContext = new EphemeralContext(context, terms, frames, statements, assertions, references, substitutions);
+          emphemeralContext = new EphemeralContext(context, terms, frames, judgements, equalities, assertions, statements, references, assumptions, substitutions);
 
     return emphemeralContext;
   }