occam-verify-cli 1.0.611 → 1.0.612

package/src/element/assertion/property.js

@@ -22,6 +22,13 @@ export default define(class PropertyAssertion extends Assertion {
     return this.propertyRelation;
   }
 
+  getPropertyAssertionNode() {
+    const node = this.getNode(),
+          propertyAssertionNode = node; ///
+
+    return propertyAssertionNode;
+  }
+
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 

package/src/element/assertion/satisfies.js

@@ -20,6 +20,13 @@ export default define(class SatisfiesAssertion extends Assertion {
     return this.reference;
   }
 
+  getSatisfiesAssertionNode() {
+    const node = this.getNode(),
+          satisfiesAssertionNode = node;  ///
+
+    return satisfiesAssertionNode;
+  }
+
   compareSubstitutions(substitutions, context) { return this.signature.compareSubstitutions(substitutions, context); }
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }

package/src/element/assertion/subproof.js

@@ -20,6 +20,13 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
+  getSubproofAssertionNode() {
+    const node = this.getNode(),
+          subproofAssertionNode = node; ///
+
+    return subproofAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 

package/src/element/assertion/type.js

@@ -22,6 +22,13 @@ export default define(class TypeAssertion extends Assertion {
     return this.type;
   }
 
+  getTypeAssertionNBode() {
+    const node = this.getNode(),
+          typeAssertionNode = node; ///
+
+    return typeAssertionNode;
+  }
+
   verify(assignments, stated, context) {
     let verifies = false;
 

package/src/element/assumption.js

@@ -33,9 +33,9 @@ export default define(class Assumption extends Element {
     context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
 
     const statement = substitution.getStatement(),
-          metavariable = substitution.getMetavariable(generalContext, specificContext),
+          metavariableName = substitution.getMetavariableName(),
           statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariable(metavariable);
+          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariableName(metavariableName);
 
     if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
       comparesToSubstituion = true;

package/src/element/combinator/bracketed.js

@@ -5,6 +5,13 @@ import Combinator from "../combinator";
 import { define } from "../../elements";
 
 export default define(class BracketedCombinator extends Combinator {
+  getBracketedCombinatorNode() {
+    const node = this.getNode(),
+          bracketedCombinatorNode = node; ///
+
+    return bracketedCombinatorNode;
+  }
+
   unifyStatement(statement, assignments, stated, context) {
     let statementUnifies;
 

package/src/element/constructor/bracketed.js

@@ -6,6 +6,13 @@ import Constructor from "../constructor";
 import { define } from "../../elements";
 
 export default define(class BracketedConstructor extends Constructor {
+  getBracketedConstructorNode() {
+    const node = this.getNode(),
+          bracketedConstructorNode = node;  ///
+
+    return bracketedConstructorNode;
+  }
+
   unifyTerm(term, context, verifyForwards) {
     let termUnifies;
 

package/src/element/declaration/combinator.js

@@ -15,6 +15,13 @@ export default define(class CombinatorDeclaration extends Declaration {
     return this.combinator;
   }
 
+  getCombinatorDeclarationNode() {
+    const node = this.getNode(),
+          combinatorDeclarationNode = node; ///
+
+    return combinatorDeclarationNode;
+  }
+
   async verify() {
     let verifies = false;
 

package/src/element/declaration/complexType.js

@@ -20,6 +20,13 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     return this.prefixed;
   }
 
+  getComplexTypeDeclarationNode() {
+    const node = this.getNode(),
+          complexTypeDeclarationNode = node;  ///
+
+    return complexTypeDeclarationNode;
+  }
+
   verifyType() {
     let typeVerifies = false;
 

package/src/element/declaration/constructor.js

@@ -16,31 +16,11 @@ export default define(class ConstructorDeclaration extends Declaration {
     return this.constructor;
   }
 
-  async verify() {
-    let verifies;
-
-    const context = this.getContext(),
-          constructorDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const constructorTypeVerifies = this.verifyConstructorType();
-
-    if (constructorTypeVerifies) {
-      const constructorValidates = this.verifyConstructor();
-
-      if (constructorValidates) {
-        context.addConstructor(this.constructor);
+  getConstructorDeclarationNode() {
+    const node = this.getNode(),
+          constructorDeclarationNode = node;  ///
 
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
-
-    return verifies;
+    return constructorDeclarationNode;
   }
 
   verifyConstructor() {
@@ -110,5 +90,32 @@ export default define(class ConstructorDeclaration extends Declaration {
     return constructorTypeVerifies;
   }
 
+  async verify() {
+    let verifies;
+
+    const context = this.getContext(),
+          constructorDeclarationString = this.getString(); ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+
+    const constructorTypeVerifies = this.verifyConstructorType();
+
+    if (constructorTypeVerifies) {
+      const constructorValidates = this.verifyConstructor();
+
+      if (constructorValidates) {
+        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

@@ -5,21 +5,21 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class MetavariableDeclaration extends Declaration {
-  constructor(context, string, node, metavariable, metaType) {
+  constructor(context, string, node, metaType, metavariable) {
     super(context, string, node);
 
-    this.metavariable = metavariable;
     this.metaType = metaType;
-  }
-
-  getMetavariable() {
-    return this.metavariable;
+    this.metavariable = metavariable;
   }
 
   getMetaType() {
     return this.metaType;
   }
 
+  getMetavariable() {
+    return this.metavariable;
+  }
+
   verifyMetavariable() {
     let metavariableVerifies = false;
 

package/src/element/declaration/simpleType.js

@@ -16,6 +16,13 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return this.type;
   }
 
+  getSimpleTypeDeclarationNode() {
+    const node = this.getNode(),
+          simpleTypeDeclarationNode = node; ///
+
+    return simpleTypeDeclarationNode;
+  }
+
   isPrefixed() {
     return this.prefixed;
   }

package/src/element/declaration/typePrefix.js

@@ -15,6 +15,13 @@ export default define(class TypePrefixDeclaration extends Declaration {
     return this.typePrefix;
   }
 
+  getTypePrefixDeclarationNode() {
+    const node = this.getNode(),
+          typePrefixDeclarationNode = node; ///
+
+    return typePrefixDeclarationNode;
+  }
+
   verifyTypePrefix() {
     let typePrefixVerifies = false;
 

package/src/element/declaration/variable.js

@@ -5,26 +5,33 @@ import Declaration from "../declaration";
 import { define } from "../../elements";
 
 export default define(class VariableDeclaration extends Declaration {
-  constructor(context, string, node, variable, type, provisional) {
+  constructor(context, string, node, type, variable, provisional) {
     super(context, string, node);
 
-    this.variable = variable;
     this.type = type;
+    this.variable = variable;
     this.provisional = provisional;
   }
 
-  getVariable() {
-    return this.variable;
-  }
-
   getType() {
     return this.type;
   }
 
+  getVariable() {
+    return this.variable;
+  }
+
   isProvisional() {
     return this.provisional;
   }
 
+  getVariableDeclarationNode() {
+    const node = this.getNode(),
+          typePrefixDeclarationNode = node; ///
+
+    return typePrefixDeclarationNode;
+  }
+
   verifyType() {
     let typeVerifies = false;
 

package/src/element/metavariable.js

@@ -126,13 +126,13 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
+    const frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
 
     if (frameMetavariableUnifies) {
       frameUnifies = true;
     } else {
-      const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
       if (simpleSubstitution !== null) {
         const substitution = simpleSubstitution,  ///
@@ -143,6 +143,7 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { FrameSubstitution } = elements,
+              metavariable = this, ///
               frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context),
               framesubstitutionValidates = frameSubstitution.validate(generalContext, specificContext);
 
@@ -236,16 +237,16 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
-    const metavariable = this, ///
-          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
+    const referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
 
     if (referenceMetavariableUnifies) {
       referenceUnifies = true;
     } else {
-      const simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariable(metavariable);
+      const metavariableName = this.getMetavariableName(),
+            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
 
       if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable),
+        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
               substitution = simpleSubstitution,  ///
               substitutionReferenceEqualToReference = substitution.isReferenceEqualToReference(reference);
 
@@ -254,6 +255,7 @@ export default define(class Metavariable extends Element {
         }
       } else {
         const { ReferenceSubstitution } = elements,
+              metavariable = this, ///
               referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context),
               substitution = referenceSubstitution; ///
 

package/src/element/proofAssertion/premise.js

@@ -17,6 +17,13 @@ export default define(class Premise extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getPremiseNode() {
+    const node = this.getNode(),
+          premiseNode = node; ///
+
+    return premiseNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/proofAssertion/step.js

@@ -27,6 +27,13 @@ export default define(class Step extends ProofAssertion {
     return this.satisfiesAssertion;
   }
 
+  getStepNode() {
+    const node = this.getNode(),
+          stepNode = node;  ///
+
+    return stepNode;
+  }
+
   isSatisfied() {
     const satisfied = (this.satisfiesAssertion !== null);
 

package/src/element/proofAssertion/supposition.js

@@ -17,6 +17,13 @@ export default define(class Supposition extends ProofAssertion {
     return this.procedureCall;
   }
 
+  getSuppositionNode() {
+    const node = this.getNode(),
+          suppositionNode = node; ///
+
+    return suppositionNode;
+  }
+
   isStated() {
     const stated = true; ///
 

package/src/element/substitution/frame.js

@@ -24,6 +24,13 @@ export default define(class FrameSubstitution extends Substitution {
     return this.replacementFrame;
   }
 
+  getFrameSubstitutionNode() {
+    const node = this.getNode(),
+          frameSubstitutionNode = node; ///
+
+    return frameSubstitutionNode;
+  }
+
   getTargetNode() {
     const targetFrameNode = this.targetFrame.getNode(),
           tergetNode = targetFrameNode; ///
@@ -145,7 +152,7 @@ export default define(class FrameSubstitution extends Substitution {
     replacementFrameValidates = this.replacementFrame.validate(assignments, stated, context);
 
     if (replacementFrameValidates) {
-      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame...`);
+      context.debug(`...validated the '${frameSubstitutionString}' frame subtitution's '${replacementFrameString}' replacement frame.`);
     }
 
     return replacementFrameValidates;

package/src/element/substitution/reference.js

@@ -24,6 +24,13 @@ export default define(class ReferenceSubstitution extends Substitution {
     return this.replacementReference;
   }
 
+  getReferenceSubstitutionNode() {
+    const node = this.getNode(),
+          referenceSubstitution = node; ///
+
+    return referenceSubstitution;
+  }
+
   getTargetNode() {
     const targetReferenceNode = this.targetReference.getNode(),
           tergetNode = targetReferenceNode; ///
@@ -139,7 +146,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     replacementReferenceValidates = this.replacementReference.validate(context);
 
     if (replacementReferenceValidates) {
-      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference...`);
+      context.debug(`...validated the '${referenceSubstitutionString}' reference subtitution's '${replacementReferenceString}' replacement reference.`);
     }
 
     return replacementReferenceValidates;

package/src/element/substitution/statement.js

@@ -37,21 +37,15 @@ export default define(class StatementSubstitution extends Substitution {
     return this.replacementStatement;
   }
 
-  getMetavariable(generalContext, specificContext) {
-    let metavariable = null;
+  getStatementSubstitutionNode() {
+    const node = this.getNode(),
+          statementSubstitutionNode = node; ///
 
-    const targetStatementNode = this.targetStatement.getNode(),
-          metavariableName = targetStatementNode.getMetavariableName();
-
-    if (metavariableName !== null) {
-      const context = generalContext; ///
-
-      metavariable = context.findMetavariableByMetavariableName(metavariableName);
-    }
-
-    return metavariable;
+    return statementSubstitutionNode;
   }
 
+  getMtavariableName() { return this.targetStatement.getMtavariableName(); }
+
   getTargetNode() {
     const targetStatementNode = this.targetStatement.getNode(),
           targetNode = targetStatementNode; ///
@@ -194,7 +188,7 @@ export default define(class StatementSubstitution extends Substitution {
     replacementStatementValidates = this.replacementStatement.validate(assignments, stated, context);
 
     if (replacementStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement.`);
     }
 
     return replacementStatementValidates;
@@ -252,11 +246,11 @@ export default define(class StatementSubstitution extends Substitution {
 
     context = generalContext; ///
 
-    const metavariable = this.getMetavariable(generalContext, specificContext);
+    const metavariableName = this.getMetavariableName();
 
     context = specificContext;  ///
 
-    const simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+    const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
     context = this.getContext();
 

package/src/element/substitution/term.js

@@ -25,6 +25,13 @@ export default define(class TermSubstitution extends Substitution {
     return this.replacementTerm;
   }
 
+  getTermSubstitutionNode() {
+    const node = this.getNode(),
+          termSubstitutionNode = node;  ///
+
+    return termSubstitutionNode;
+  }
+
   getTargetNode() {
     const targetTermNode = this.targetTerm.getNode(),
           tergetNode = targetTermNode; ///

package/src/utilities/element.js

@@ -621,7 +621,7 @@ export function variableDeclarationFromVariableDeclarationNode(variableDeclarati
         variableNode = variableDeclarationNode.getVariableNode(),
         type = typeFromTypeNode(typeNode, context),
         variable = variableFromVariableNode(variableNode, context),
-        variableDeclaration = new VariableDeclaration(context, string, node, variable, type, provisional);
+        variableDeclaration = new VariableDeclaration(context, string, node, type, variable, provisional);
 
   return variableDeclaration;
 }
@@ -708,7 +708,7 @@ export function metavariableDeclarationFromMetavariableDeclarationNode(metavaria
         string = context.nodeAsString(node),
         metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
         metavariable = metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-        metavariableDeclaration = new MetavariableDeclaration(context, string, node, metavariable, metaType);
+        metavariableDeclaration = new MetavariableDeclaration(context, string, node, metaType, metavariable);
 
   return metavariableDeclaration;
 }

package/src/utilities/substitutions.js

@@ -107,26 +107,22 @@ export function statementFromStatementAndSubstitutions(statement, generalContext
   return statement;
 }
 
-export function metavariablesFromSubstitutions(substitutions, generalContext, specificContext) {
-  const metavariables = [];
+export function metavariableNamesFromSubstitutions(substitutions) {
+  const metavariableNames = [];
 
   substitutions.forEach((substitution) => {
-    const context = generalContext, ///
-          metavariableName = substitution.getMetavariableName(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+    const metavariableName = substitution.getMetavariableName();
 
-    if (metavariable !== null) {
-      metavariables.push(metavariable);
+    if (metavariableName !== null) {
+      metavariableNames.push(metavariableName);
     }
   });
 
-  compress(metavariables, (metavariableA, metavariableB) => {
-    const metavariableComparesToMetavariableB = metavariableB.compare(metavariableA);
-
-    if (!metavariableComparesToMetavariableB) {
+  compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
+    if (metavariableNameB !== metavariableNameB) {
       return true;
     }
   });
 
-  return metavariables;
+  return metavariableNames;
 }

package/src/utilities/unification.js

@@ -144,9 +144,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
   let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
-    const { Substitutions } = elements,
-          topLevelAssertion = context.findTopLevelAssertionByReference(reference),
-          generalSubstitutions = substitutions; ///
+    const topLevelAssertion = context.findTopLevelAssertionByReference(reference);
 
     if (topLevelAssertion !== null) {
       const statementString = statement.getString(),
@@ -155,7 +153,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
       context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion...`);
 
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-            statementAndSubproofOrProofAssertionsUnify = topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
+            statementAndSubproofOrProofAssertionsUnify = await topLevelAssertion.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
         const metavariable = reference.getMetavariable();