occam-verify-cli 0.0.697 → 0.0.700

package/src/context/local.js

@@ -1,12 +1,10 @@
 "use strict";
 
 import Variable from "../variable";
-import Equality from "../equality";
 import Collection from "../collection";
-import fileMixins from "../mixins/file";
-import loggingMixins from "../mixins/logging";
+import contextMixins from "../mixins/context";
 
-import { last, filter } from "../utilities/array";
+import { last } from "../utilities/array";
 import { mergeCollections, findCollectionByType, findCollectionByTerm, findCollectionByTerms } from "../utilities/collection";
 
 class LocalContext {
@@ -25,8 +23,8 @@ class LocalContext {
     let variables = this.context.getVariables();
 
     variables = [ ///
-      ...variables,
-      ...this.variables
+      ...this.variables,
+      ...variables
     ];
 
     return variables;
@@ -36,8 +34,8 @@ class LocalContext {
     let proofSteps = this.context.getProofSteps();
 
     proofSteps = [  ///
-      ...proofSteps,
-      ...this.proofSteps
+      ...this.proofSteps,
+      ...proofSteps
     ];
 
     return proofSteps;
@@ -69,15 +67,17 @@ class LocalContext {
   getMetavariables() { return this.context.getMetavariables(); }
 
   addEquality(equality) {
+    let equalityAdded;
+
     const equalityReflexive = equality.isReflexive();
 
     if (equalityReflexive) {
-      ///
+      equalityAdded = true; ///
     } else {
       const leftTerm = equality.getLeftTerm(),
             rightTerm = equality.getRightTerm(),
-            leftCollection = this.findCollectionByTerm(leftTerm),
-            rightCollection = this.findCollectionByTerm(rightTerm);
+            leftCollection = findCollectionByTerm(this.collections, leftTerm),
+            rightCollection = findCollectionByTerm(this.collections, rightTerm);
 
       if (false) {
         ///
@@ -85,37 +85,51 @@ class LocalContext {
         const collection = Collection.fromEquality(equality);
 
         this.addCollection(collection);
+
+        equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection === null)) {
         const term = rightTerm, ///
               collection = leftCollection;  ///
 
         collection.addTerm(term);
+
+        equalityAdded = true;
       } else if ((leftCollection === null) && (rightCollection !== null)) {
         const term = leftTerm, ///
               collection = rightCollection;  ///
 
         collection.addTerm(term);
+
+        equalityAdded = true;
       } else if ((leftCollection !== null) && (rightCollection !== null)) {
 
         debugger
 
       }
     }
+
+    return equalityAdded;
   }
 
   addVariable(variable) {
-    const variableName = variable.getName();
+    let variableAdded = false;
 
-    filter(this.variables, (variable) => {
-      const name = variable.getName(),
-            nameVariableName = (name === variableName);
+    const node = variable.getNode(),
+          variablePresent = this.variables.some((variable) => {
+            const nodeMatches = variable.matchNode(node);
 
-      if (!nameVariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!variablePresent) {
+      this.variables.push(variable);
+
+      variableAdded = true;
+    }
 
-    this.variables.push(variable);
+    return variableAdded;
   }
 
   addProofStep(proofStep) {
@@ -169,11 +183,11 @@ class LocalContext {
     return collection;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
+            const matches = variable.matchNode(node);
 
             if (matches) {
               return true;
@@ -183,8 +197,8 @@ class LocalContext {
     return variable;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
+  isVariablePresentByVariableNode(variableNode) {
+    const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
 
     return variablePresent;
@@ -291,7 +305,6 @@ class LocalContext {
   }
 }
 
-Object.assign(LocalContext.prototype, fileMixins);
-Object.assign(LocalContext.prototype, loggingMixins);
+Object.assign(LocalContext.prototype, contextMixins);
 
 export default LocalContext;

package/src/context/localMeta.js

@@ -1,9 +1,8 @@
 "use strict";
 
-import fileMixins from "../mixins/file";
-import loggingMixins from "../mixins/logging";
+import contextMixins from "../mixins/context";
 
-import { last, filter } from "../utilities/array";
+import { last } from "../utilities/array";
 
 class LocalMetaContext {
   constructor(context, metavariables, metaproofSteps) {
@@ -20,8 +19,8 @@ class LocalMetaContext {
     let metavariables = this.context.getMetavariables();
 
     metavariables = [ ///
+      ...this.metavariables,
       ...metavariables,
-      this.metavariables
     ]
 
     return metavariables;
@@ -31,8 +30,8 @@ class LocalMetaContext {
     let metaproofSteps = this.context.getMetaproofSteps();
 
     metaproofSteps = [  ///
-      ...metaproofSteps,
-      ...this.metaproofSteps
+      ...this.metaproofSteps,
+      ...metaproofSteps
     ];
 
     return metaproofSteps;
@@ -53,18 +52,24 @@ class LocalMetaContext {
   }
 
   addMetavariable(metavariable) {
-    const metavariableName = metavariable.getName();
+    let metavariableAdded = false;
 
-    filter(this.metavariables, (metavariable) => {
-      const name = metavariable.getName(),
-            nameMetavariableName = (name === metavariableName);
+    const node = metavariable.getName(),
+          metavariablePresent = this.metavariables.some((metavariable) => {
+            const nodeMatches = metavariable.matchNode(node);
 
-      if (!nameMetavariableName) {
-        return true;
-      }
-    });
+            if (nodeMatches) {
+              return true;
+            }
+          });
+
+    if (!metavariablePresent) {
+      this.metavariables.push(metavariable);
+
+      metavariableAdded = true;
+    }
 
-    this.metavariables.push(metavariable);
+    return metavariableAdded;
   }
 
   addMetaproofStep(metaproofStep) {
@@ -93,11 +98,11 @@ class LocalMetaContext {
     return metastatementMatches;
   }
 
-  findMetavariableByMetavariableName(metavariableName) {
-    const name = metavariableName,  ///
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchName(name);
+            const matches = metavariable.matchNode(node);
 
             if (matches) {
               return true;
@@ -107,8 +112,8 @@ class LocalMetaContext {
     return metavariable;
   }
 
-  isMetavariablePresentByMetavariableName(metavariableName) {
-    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+  isMetavariablePresentByMetavariableNode(metavariableNode) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -134,7 +139,6 @@ class LocalMetaContext {
   }
 }
 
-Object.assign(LocalMetaContext.prototype, fileMixins);
-Object.assign(LocalMetaContext.prototype, loggingMixins);
+Object.assign(LocalMetaContext.prototype, contextMixins);
 
 export default LocalMetaContext;

package/src/context/release.js

@@ -277,18 +277,15 @@ export default class ReleaseContext {
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
-    types = [ ///
-      ...types,
-      objectType
-    ];
+    types.push(objectType);
 
     const type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+      const matches = type.matchTypeName(typeName);
 
-            if (matches) {
-              return true;
-            }
-          }) || null;
+      if (matches) {
+        return true;
+      }
+    }) || null;
 
     return type;
   }

package/src/equality.js

@@ -1,11 +1,16 @@
 "use strict";
 
 export default class Equality {
-  constructor(leftTerm, rightTerm) {
+  constructor(node, leftTerm, rightTerm) {
+    this.node = node;
     this.leftTerm = leftTerm;
     this.rightTerm = rightTerm;
   }
 
+  getNode() {
+    return this.node;
+  }
+
   getLeftTerm() {
     return this.leftTerm;
   }
@@ -21,15 +26,17 @@ export default class Equality {
     return reflexive;
   }
 
-  static fromLeftTermAndRightTerm(leftTerm, rightTerm) {
+  static fromEqualityNodeLeftTermAndRightTerm(equalityNode, leftTerm, rightTerm) {
     let equality = null;
 
     const leftTermType = leftTerm.getType(),
           rightTermType = rightTerm.getType(),
-          leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOfOrSuperTypeOf(rightTermType);
+          leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+
+    if (leftTermTypeComparableToRightTermType) {
+      const node = equalityNode;  ///
 
-    if (leftTermTypeEqualToSubTypeOfOrSuperTypeOfRightTermType) {
-      equality = new Equality(leftTerm, rightTerm);
+      equality = new Equality(node, leftTerm, rightTerm);
     }
 
     return equality;

package/src/metaType.js

@@ -57,16 +57,6 @@ export default class MetaType {
 
     return metaType;
   }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    let metaType;
-
-    const { name } = json;
-
-    metaType = new MetaType(name);
-
-    return metaType;
-  }
 }
 
 class StatementMetaType extends MetaType {
@@ -79,3 +69,13 @@ class StatementMetaType extends MetaType {
 }
 
 export const statementMetaType = StatementMetaType.fromNothing();
+
+export function metaTypeFromJSONAndFileContext(json, fileContext) {
+  let metaType;
+
+  const { name } = json;
+
+  metaType = new MetaType(name);
+
+  return metaType;
+}

package/src/metavariable.js

@@ -1,33 +1,35 @@
 "use strict";
 
-import MetaType from "./metaType";
+import { nodeAsString } from "./utilities/string";
+import { metaTypeFromJSONAndFileContext } from "./metaType";
 
 export default class Metavariable {
-  constructor(name, metaType) {
-    this.name = name;
+  constructor(node, metaType) {
+    this.node = node;
     this.metaType = metaType;
   }
 
-  getName() {
-    return this.name;
+  getNode() {
+    return this.node;
   }
 
   getMetaType() {
     return this.metaType;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchNode(node) {
+    const nodeMatches = this.node.match(node);
 
-    return nameMatches;
+    return nodeMatches;
   }
 
   toJSON(tokens) {
     const metaTypeJSON = this.metaType.toJSON(tokens),
-          name = this.name, ///
           metaType = metaTypeJSON,  ///
+          string = nodeAsString(this.node, tokens),
+          node = string,  ///
           json = {
-            name,
+            node,
             metaType
           };
 
@@ -35,32 +37,32 @@ export default class Metavariable {
   }
 
   asString(tokens) {
-    const metaTypeName = this.metaType.getName(),
-          string = `${this.name}:${metaTypeName}`;
+    const metaTypeName = this.metaType.getName();
 
-    return string;
-  }
+    let string = nodeAsString(this.node, tokens);
 
-  static fromNameAndMetaType(name, metaType) {
-    const metavariable = new Metavariable(name, metaType);
+    string = `${string}:${metaTypeName}`;
 
-    return metavariable;
+    return string;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { name } = json;
+    const { node } = json;
 
     let { metaType } = json;
 
     json = metaType;  ///
 
-    metaType = MetaType.fromJSONAndFileContext(json, fileContext);
+    metaType = metaTypeFromJSONAndFileContext(json, fileContext);
 
-    const metaTypeName = metaType.getName();
+    const metavariable = new Metavariable(node, metaType);
 
-    metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName); ///
+    return metavariable;
+  }
 
-    const metavariable = new Metavariable(name, metaType);
+  static fromMetavariableNodeAndMetaType(metavariableNode, metaType) {
+    const node = metavariableNode,  ///
+          metavariable = new Metavariable(node, metaType);
 
     return metavariable;
   }

package/src/mixins/{file.js → context.js}

@@ -1,5 +1,17 @@
 "use strict";
 
+function trace(node, message) { this.context.trace(node, message); }
+
+function debug(node, message) { this.context.debug(node, message); }
+
+function info(node, message) { this.context.info(node, message); }
+
+function warning(node, message) { this.context.warning(node, message); }
+
+function error(node, message) { this.context.error(node, message); }
+
+function fatal(node, message) { this.context.fatal(node, message); }
+
 function getAxioms() { return this.context.getAxioms(); }
 
 function getLemmas() { return this.context.getLemmas(); }
@@ -34,7 +46,13 @@ function nodeAsString(node) { return this.context.nodeAsString(node); }
 
 function nodesAsString(node) { return this.context.nodesAsString(node); }
 
-const fileMixins = {
+const contextMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal,
   getAxioms,
   getLemmas,
   getTheorems,
@@ -54,4 +72,4 @@ const fileMixins = {
   nodesAsString
 };
 
-export default fileMixins;
+export default contextMixins;

package/src/ruleNames.js

@@ -13,7 +13,9 @@ export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
+export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
+export const METAVARIABLE_DECLARATION_RULE_NAME = "metavariableDeclaration";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution/metastatementForMetavariable.js

@@ -3,19 +3,25 @@
 import { bracketedMetastatementChildNodeFromMetastatementNode } from "../utilities/metaproof";
 
 export default class MetastatementForMetavariableSubstitution {
-  constructor(metavariableName, metastatementNode) {
-    this.metavariableName = metavariableName;
+  constructor(metavariableNode, metastatementNode) {
+    this.metavariableNode = metavariableNode;
     this.metastatementNode = metastatementNode;
   }
 
-  getMetavariableName() {
-    return this.metavariableName;
+  getMetavariableNode() {
+    return this.metavariableNode;
   }
 
   getMetastatementNode() {
     return this.metastatementNode;
   }
 
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
   matchMetastatementNode(metastatementNode) {
     let metastatementNodeMatches;
 
@@ -34,15 +40,15 @@ export default class MetastatementForMetavariableSubstitution {
     return metastatementNodeMatches;
   }
 
-  static fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode) {
-    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
+  static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
+    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
 
     const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 
     if (bracketedMetastatementChildNode !== null) {
       const metastatementNode = bracketedMetastatementChildNode; ///
 
-      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableName, metastatementNode);
+      metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
     }
 
     return metastatementForMetavariableSubstitution;

package/src/substitution/statementForMetavariable.js

@@ -3,13 +3,13 @@
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution {
-  constructor(metavariableName, statementNode) {
-    this.metavariableName = metavariableName;
+  constructor(metavariableNode, statementNode) {
+    this.metavariableNode = metavariableNode;
     this.statementNode = statementNode;
   }
 
-  getMetavariableName() {
-    return this.metavariableName;
+  getMetavariableNode() {
+    return this.metavariableNode;
   }
 
   getStatementNode() {
@@ -34,15 +34,21 @@ export default class StatementForMetavariableSubstitution {
     return statementNodeMatches;
   }
 
-  static fromMetavariableNameAndStatementNode(metavariableName, statementNode) {
-    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+
+    return metavariableNodeMatches;
+  }
+
+  static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
 
     const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
     if (bracketedStatementChildNode !== null) {
       const statementNode = bracketedStatementChildNode; ///
 
-      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableName, statementNode);
+      statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode);
     }
 
     return statementForMetavariableSubstitution;

package/src/substitution/termForVariable.js

@@ -1,13 +1,13 @@
 "use strict";
 
 export default class TermForVariableSubstitution {
-  constructor(variableName, termNode) {
-    this.variableName = variableName;
+  constructor(variableNode, termNode) {
+    this.variableNode = variableNode;
     this.termNode = termNode;
   }
 
-  getVariableName() {
-    return this.variableName;
+  getVariableNode() {
+    return this.variableNode;
   }
 
   getTermNode() {
@@ -15,15 +15,19 @@ export default class TermForVariableSubstitution {
   }
 
   matchTermNode(termNode) {
-    let termNodeMatches;
-
-    termNodeMatches = this.termNode.match(termNode);
+    const termNodeMatches = this.termNode.match(termNode);
 
     return termNodeMatches;
   }
 
-  static fromVariableNameAndTermNode(variableName, termNode) {
-    const termForVariableSubstitution = new TermForVariableSubstitution(variableName, termNode);
+  matchVariableNode(variableNode) {
+    const variableNodeMatches = this.variableNode.match(variableNode);
+
+    return variableNodeMatches;
+  }
+
+  static fromVariableNodeAndTermNode(variableNode, termNode) {
+    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
 
     return termForVariableSubstitution;
   }