occam-verify-cli 1.0.611 → 1.0.617

package/src/context.js

@@ -33,11 +33,25 @@ export default class Context extends ContextBase {
 
   getFrames() {
     const context = this.getContext(),
-      frames = context.getFrames();
+          frames = context.getFrames();
 
     return frames;
   }
 
+  getStatements() {
+    const context = this.getContext(),
+          statements = context.getStatements();
+
+    return statements;
+  }
+
+  getReferences() {
+    const context = this.getContext(),
+          references = context.getReferences();
+
+    return references;
+  }
+
   getSubstitutions() {
     const context = this.getContext(),
           substitutions = context.getSubstitutions();
@@ -47,7 +61,7 @@ export default class Context extends ContextBase {
 
   getVariables(includeRelease) {
     const context = this.getContext(),
-      variables = context.getVariables(includeRelease);
+          variables = context.getVariables(includeRelease);
 
     return variables;
   }
@@ -59,6 +73,13 @@ export default class Context extends ContextBase {
     return combinators;
   }
 
+  getConstrustors(includeRelease) {
+    const context = this.getContext(),
+          constructors = context.getConstrustors(includeRelease);
+
+    return constructors;
+  }
+
   getMetavariables(includeRelease) {
     const context = this.getContext(),
           metavariables = context.getMetavariables(includeRelease);
@@ -81,20 +102,13 @@ export default class Context extends ContextBase {
     return metavariable;
   }
 
-  findProcedureByName(name) {
+  findProcedureByProcedureName(procedureName) {
     const context = this.getContext(),
-          procedure = context.findProcedureByName(name);
+          procedure = context.findProcedureByProcedureName(procedureName);
 
     return procedure;
   }
 
-  findRuleByReference(reference) {
-    const context = this.getContext(),
-          rule = context.findRuleByReference(reference);
-
-    return rule;
-  }
-
   findFrameByFrameNode(frameNode) {
     const context = this.getContext(),
           frame = context.findFrameByFrameNode(frameNode);
@@ -116,46 +130,46 @@ export default class Context extends ContextBase {
     return reference;
   }
 
-  findTopLevelAssertionByReference(reference) {
+  findVariableByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
-      topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+          variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
-    return topLevelAssertion;
+    return variable;
   }
 
-  findSubstitutionByVariableIdentifier(variableIdentifier) {
+  findSubstitutionByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
+          substitution = context.findSubstitutionByMetavariableName(metavariableName);
 
     return substitution;
   }
 
-  findSubstitutionByMetavariableName(metavariableName) {
+  findMetavariableByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitution = context.findSubstitutionByMetavariableName(metavariableName);
+          metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
-    return substitution;
+    return metavariable;
   }
 
-  findVariableByVariableIdentifier(variableIdentifier) {
+  findSubstitutionByVariableIdentifier(variableIdentifier) {
     const context = this.getContext(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+          substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
 
-    return variable;
+    return substitution;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
+  findSimpleSubstitutionByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          metavariable = context.findMetavariableByMetavariableName(metavariableName);
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-    return metavariable;
+    return simpleSubstitution;
   }
 
-  findSimpleSubstitutionByMetavariable(metavariable) {
+  findComplexSubstitutionsByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          simpleSubstitution = context.findSimpleSubstitutionByMetavariable(metavariable);
+          complexSubstitution = context.findComplexSubstitutionsByMetavariableName(metavariableName);
 
-    return simpleSubstitution;
+    return complexSubstitution;
   }
 
   findSubstitutionByMetavariableNameAndSubstitution(metavariableName, substitution) {
@@ -166,6 +180,20 @@ export default class Context extends ContextBase {
     return substitution;
   }
 
+  findRuleByReference(reference) {
+    const context = this.getContext(),
+          rule = context.findRuleByReference(reference);
+
+    return rule;
+  }
+
+  findTopLevelAssertionByReference(reference) {
+    const context = this.getContext(),
+          topLevelAssertion = context.findTopLevelAssertionByReference(reference);
+
+    return topLevelAssertion;
+  }
+
   isTermPresentByTermNode(termNode) {
     const context = this.getContext(),
           termPresent = context.isTermPresentByTermNode(termNode);
@@ -173,18 +201,18 @@ export default class Context extends ContextBase {
     return termPresent;
   }
 
-  isFramePresentByFrameNode(frameNode) {
+  isProcedurePresentByProcedureName(procedureName) {
     const context = this.getContext(),
-          framePresent = context.isFramePresentByFrameNode(frameNode);
+          procedurePresent = context.isProcedurePresentByProcedureName(procedureName);
 
-    return framePresent;
+    return procedurePresent;
   }
 
-  isJudgementPresentByMetavariableName(metavariableName) {
+  isFramePresentByFrameNode(frameNode) {
     const context = this.getContext(),
-          judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName);
+          framePresent = context.isFramePresentByFrameNode(frameNode);
 
-    return judgementPresent;
+    return framePresent;
   }
 
   isStatementPresentByStatementNode(statementNode) {
@@ -208,18 +236,18 @@ export default class Context extends ContextBase {
     return referencePresent;
   }
 
-  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
+  isJudgementPresentByMetavariableName(metavariableName) {
     const context = this.getContext(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
+          judgementPresent = context.isJudgementPresentByMetavariableName(metavariableName);
 
-    return substitutionPresent;
+    return judgementPresent;
   }
 
-  isProcedurePresentByName(name) {
+  isSubstitutionPresentBySubstitutionNode(substitutionNode) {
     const context = this.getContext(),
-          procedurePresent = context.isProcedurePresentByName(name);
+          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode);
 
-    return procedurePresent;
+    return substitutionPresent;
   }
 
   isLabelPresentByReference(reference) {

package/src/element/assertion/contained.js

@@ -31,6 +31,13 @@ export default define(class ContainedAssertion extends Assertion {
     return this.statement;
   }
 
+  getContainedAssertionNode() {
+    const node = this.getNode(),
+          containedAssertionNode = node;  ///
+
+    return containedAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 

package/src/element/assertion/defined.js

@@ -26,6 +26,13 @@ export default define(class DefinedAssertion extends Assertion {
     return this.negated;
   }
 
+  getDefinedAssertionNode() {
+    const node = this.getNode(),
+          definedAssertionNode = node;  ///
+
+    return definedAssertionNode;
+  }
+
   validate(assignments, stated, context) {
     let validates = false;
 

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/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,12 +14,19 @@ 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(); }
@@ -33,9 +40,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/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/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/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/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/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;  ///