occam-verify-cli 0.0.968 → 0.0.971

package/src/context/file.js

@@ -288,9 +288,9 @@ export default class FileContext {
     types.push(objectType);
 
     const type = types.find((type) => {
-      const matches = type.matchTypeName(typeName);
+      const typeNameMatches = type.matchTypeName(typeName);
 
-      if (matches) {
+      if (typeNameMatches) {
         return true;
       }
     }) || null;
@@ -304,9 +304,9 @@ export default class FileContext {
     types.push(objectType);
 
     const type = types.find((type) => {
-      const matches = type.matchTypeNode(typeNode);
+      const nodeMatches = type.matchTypeNode(typeNode);
 
-      if (matches) {
+      if (nodeMatches) {
         return true;
       }
     }) || null;
@@ -314,26 +314,13 @@ export default class FileContext {
     return type;
   }
 
-  findMetavariableByName(name) {
-    const metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchName(name);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const variableMatchesNode = variable.matchNode(node);
+            const nodeMatches = variable.matchNode(node);
 
-            if (variableMatchesNode) {
+            if (nodeMatches) {
               return true;
             }
           }) || null;
@@ -344,9 +331,9 @@ export default class FileContext {
   findMetaTypeByMetaTypeNode(metaTypeNode) {
     const metaTypes = this.getMetaTypes(),
           metaType = metaTypes.find((metaType) => {
-            const matches = metaType.matchMetaTypeNode(metaTypeNode);
+            const metaTypeNodeMatches = metaType.matchMetaTypeNode(metaTypeNode);
 
-            if (matches) {
+            if (metaTypeNodeMatches) {
               return true;
             }
           }) || null;
@@ -357,9 +344,9 @@ export default class FileContext {
   findLabelByMetavariableNode(metavariableNode) {
     const labels = this.getLabels(),
           label = labels.find((label) => {
-            const matches = label.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-            if (matches) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -370,9 +357,9 @@ export default class FileContext {
   findRuleByMetavariableNode(metavariableNode) {
     const rules = this.getRules(),
           rule = rules.find((rule) => {
-            const ruleMatchesMetavariableNode = rule.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = rule.matchMetavariableNode(metavariableNode);
 
-            if (ruleMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -383,9 +370,9 @@ export default class FileContext {
   findAxiomByMetavariableNode(metavariableNode) {
     const axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
-            const axiomMatchesMetavariableNode = axiom.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = axiom.matchMetavariableNode(metavariableNode);
 
-            if (axiomMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -396,9 +383,9 @@ export default class FileContext {
   findLemmaByMetavariableNode(metavariableNode) {
     const lemmas = this.getLemmas(),
           lemma = lemmas.find((lemma) => {
-            const lemmaMatchesMetavariableNode = lemma.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = lemma.matchMetavariableNode(metavariableNode);
 
-            if (lemmaMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -409,9 +396,9 @@ export default class FileContext {
   findTheoremByMetavariableNode(metavariableNode) {
     const theorems = this.getTheorems(),
           theorem = theorems.find((theorem) => {
-            const theoremMatchesMetavariableNode = theorem.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = theorem.matchMetavariableNode(metavariableNode);
 
-            if (theoremMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -422,9 +409,9 @@ export default class FileContext {
   findMetaLemmaByMetavariableNode(metavariableNode) {
     const metaLemmas = this.getMetaLemmas(),
           metaLemma = metaLemmas.find((metaLemma) => {
-            const metaLemmaMatchesMetavariableNode = metaLemma.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = metaLemma.matchMetavariableNode(metavariableNode);
 
-            if (metaLemmaMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -435,9 +422,9 @@ export default class FileContext {
   findConjectureByMetavariableNode(metavariableNode) {
     const conjectures = this.getConjectures(),
           conjecture = conjectures.find((conjecture) => {
-            const conjectureMatchesMetavariableNode = conjecture.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
 
-            if (conjectureMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -448,9 +435,9 @@ export default class FileContext {
   findMetatheoremByMetavariableNode(metavariableNode) {
     const metatheorems = this.getMetatheorems(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremMatchesMetavariableNode = metatheorem.matchMetavariableNode(metavariableNode);
+            const metavariableNodeMatches = metatheorem.matchMetavariableNode(metavariableNode);
 
-            if (metatheoremMatchesMetavariableNode) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -459,12 +446,25 @@ export default class FileContext {
   }
 
   findMetavariableByMetavariableNode(metavariableNode) {
-    const node = metavariableNode,  ///
+    const metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode);
+
+            if (metavariableNodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node);
+            const nameMatches = metavariable.matchName(name);
 
-            if (matches) {
+            if (nameMatches) {
               return true;
             }
           }) || null;
@@ -486,13 +486,6 @@ export default class FileContext {
     return typePresent;
   }
 
-  isMetavariablePresentByName(name) {
-    const metavariable = this.findMetavariableByName(name),
-          metavariablePresent = (metavariable !== null);
-
-    return metavariablePresent;
-  }
-
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
@@ -507,6 +500,13 @@ export default class FileContext {
     return labelPresent;
   }
 
+  isMetavariablePresentByMetavariableName(metavariablename) {
+    const metavariable = this.findMetavariableByMetavariableName(metavariablename),
+          metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
   isMetavariablePresentByMetavariableNode(metavariableNode) {
     const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
@@ -590,14 +590,8 @@ export default class FileContext {
   addMetavariable(metavariable) {
     let metavariableAdded = false;
 
-    const name = metavariable.getName(),
-          metavariablePresent = this.metavariables.some((metavariable) => {
-            const metavariableMatchesNode = metavariable.matchName(name);
-
-            if (metavariableMatchesNode) {
-              return true;
-            }
-          });
+    const metavariableName = metavariable.getName(),
+          metavariablePresent = this.isMetavariablePresentByMetavariableName(metavariableName);
 
     if (!metavariablePresent) {
       this.metavariables.push(metavariable);

package/src/context/local.js

@@ -211,14 +211,8 @@ class LocalContext {
   addMetavariable(metavariable) {
     let metavariableAdded = false;
 
-    const node = metavariable.getName(),
-          metavariablePresent = this.metavariables.some((metavariable) => {
-            const metavariableMatchesNode = metavariable.matchNode(node);
-
-            if (metavariableMatchesNode) {
-              return true;
-            }
-          });
+    const metavariableName = metavariable.getName(),
+          metavariablePresent = this.isMetavariablePresentByMetavariableName(metavariableName);
 
     if (!metavariablePresent) {
       this.metavariables.push(metavariable);
@@ -276,9 +270,10 @@ class LocalContext {
     groundedTermsAndDefinedVariablesFromFromEquivalences(equivalences, groundedTerms, definedVariables, context);
 
     const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-            const termMatchesGroundedTerm = term.match(groundedTerm);
+            const groundedTermNode = groundedTerm.getNode(),
+                  groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
-            if (termMatchesGroundedTerm) {
+            if (groundedTermNodeMatches) {
               return true;
             }
           }),
@@ -307,6 +302,20 @@ class LocalContext {
     return variableDefined;
   }
 
+  isMetavariableDefined(metavariable) {
+    const judgements = this.getJudgements(),
+          metavariableNode = metavariable.getNode(),
+          metavariableDefined = judgements.some((judgement) => {
+            const metavariableNodeMatchesJudgement = judgement.matchMetavariableNode(metavariableNode);
+
+            if (metavariableNodeMatchesJudgement) {
+              return true;
+            }
+          });
+
+    return metavariableDefined
+  }
+
   isVariablePresentByVariableNode(variableNode) {
     const variable = this.findVariableByVariableNode(variableNode),
           variablePresent = (variable !== null);
@@ -325,24 +334,19 @@ class LocalContext {
 
   isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
 
-  isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
-
   isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
-          metavariablePresent = (metavariable !== null);
+  isMetavariablePresentByMetavariableName(metavariableName) { return this.context.isMetavariablePresentByMetavariableName(metavariableName); }
 
-    return metavariablePresent;
-  }
+  isMetavariablePresentByMetavariableNode(metavariableNode) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode); }
 
   findVariableByVariableNode(variableNode) {
     const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const matches = variable.matchNode(node);
+            const nodeMatches = variable.matchNode(node);
 
-            if (matches) {
+            if (nodeMatches) {
               return true;
             }
           }) || null;
@@ -364,13 +368,12 @@ class LocalContext {
   }
 
   findMetavariableByMetavariableNode(metavariableNode) {
-    const node = metavariableNode,  ///
-          localContext = this,  ///
+    const localContext = this,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node, localContext);
+            const metavariableNodeMatches = metavariable.matchMetavariableNode(metavariableNode, localContext);
 
-            if (matches) {
+            if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
@@ -382,8 +385,6 @@ class LocalContext {
 
   findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
-  findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
-
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
   findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
@@ -402,21 +403,23 @@ class LocalContext {
 
   findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
 
+  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+
   nodeAsString(node) { return this.context.nodeAsString(node); }
 
   nodesAsString(node) { return this.context.nodesAsString(node); }
 
-  trace(node, message) { this.context.trace(node, message); }
+  trace(message, node) { this.context.trace(message, node); }
 
-  debug(node, message) { this.context.debug(node, message); }
+  debug(message, node) { this.context.debug(message, node); }
 
-  info(node, message) { this.context.info(node, message); }
+  info(message, node) { this.context.info(message, node); }
 
-  warning(node, message) { this.context.warning(node, message); }
+  warning(message, node) { this.context.warning(message, node); }
 
-  error(node, message) { this.context.error(node, message); }
+  error(message, node) { this.context.error(message, node); }
 
-  fatal(node, message) { this.context.fatal(node, message); }
+  fatal(message, node) { this.context.fatal(node, message); }
 
   static fromFileContext(fileContext) {
     const context = fileContext,  ///

package/src/context/release.js

@@ -377,9 +377,9 @@ export default class ReleaseContext {
     types.push(objectType);
 
     const type = types.find((type) => {
-      const matches = type.matchTypeName(typeName);
+      const typeNameMatches = type.matchTypeName(typeName);
 
-      if (matches) {
+      if (typeNameMatches) {
         return true;
       }
     }) || null;

package/src/declaration.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchStatementModuloBrackets } from "./utilities/match";
+import { stripBracketsFromStatement } from "./utilities/brackets";
 
 export default class Declaration {
   constructor(metavariableNode, statementNode) {
@@ -27,30 +27,32 @@ export default class Declaration {
   }
 
   unifyMetavariable(metavariableNode) {
-    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
-    return matchesMetavariableNode;
+    return metavariableNodeMatches;
   }
 
   unifyStatement(statementNode) {
-    const statementNodeA = statementNode, ///
-          statementNodeB = this.statementNode,  ///
-          statementMatches = matchStatementModuloBrackets(statementNodeA, statementNodeB),
-          matchesStatementNode = statementMatches;  ///
+    statementNode = stripBracketsFromStatement(statementNode); ///
 
-    return matchesStatementNode;
+    const statementNodeMatches = this.statementNode.match(statementNode),
+          statementUnified = statementNodeMatches;  ///
+
+    return statementUnified;
   }
 
   unifyMetaLemmaOrMetatheorem(metaLemmaMetatheorem) {
     const consequent = metaLemmaMetatheorem.getConsequent(),
           statementNode = consequent.getStatementNode(),
-          matches = this.statementNode.match(statementNode),
-          metaLemmaOrMetaTheoremUnified = matches;  ///
+          statementNodeMatches = this.statementNode.match(statementNode),
+          metaLemmaOrMetaTheoremUnified = statementNodeMatches;  ///
 
     return metaLemmaOrMetaTheoremUnified;
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+    statementNode = stripBracketsFromStatement(statementNode); ///
+
     const declaration = new Declaration(metavariableNode, statementNode);
 
     return declaration;

package/src/equivalence.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import { nodeQuery } from "./utilities/query";
+import { stripBracketsFromTerm } from "./utilities/brackets";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
@@ -49,14 +50,14 @@ export default class Equivalence {
     const typeB = type; ///
 
     const typeAEqualToTypeB = typeA.isEqualTo(typeB),
-          matchesType = typeAEqualToTypeB;  ///
+          typeMatches = typeAEqualToTypeB;  ///
 
-    return matchesType;
+    return typeMatches;
   }
 
   matchTerm(term) {
     const termA = term, ///
-          matchesTerm = this.terms.some((term) => {
+          termMatches = this.terms.some((term) => {
             const termB = term, ///
                   termAMatchesTermB = termA.match(termB);
 
@@ -65,39 +66,38 @@ export default class Equivalence {
             }
           });
 
-    return matchesTerm;
+    return termMatches;
   }
 
   matchTerms(terms) {
-    const matchesTerms = terms.every((term) => {
-      const matchesTerm = this.matchTerm(term);
+    const termsMatch = terms.every((term) => {
+      const termMatches = this.matchTerm(term);
 
-      if (matchesTerm) {
+      if (termMatches) {
         return true;
       }
     })
 
-    return matchesTerms;
+    return termsMatch;
   }
 
   matchTermNode(termNode) {
-    const termNodeA = termNode, ///
-          matchesTermNode = this.terms.some((term) => {
-            const termNode = term.getNode(),
-                  termNodeB = termNode, ///
-                  termNodeAMatchesTermB = termNodeA.match(termNodeB);
+    termNode = stripBracketsFromTerm(termNode); ///
 
-            if (termNodeAMatchesTermB) {
-              return true;
-            }
-          });
+    const termNodeMatches = this.terms.some((term) => {
+      const termNodeMatches = term.matchTermNode(termNode);
+
+      if (termNodeMatches) {
+        return true;
+      }
+    });
 
-    return matchesTermNode;
+    return termNodeMatches;
   }
 
   matchVariableNode(variableNode) {
     const variableNodeA = variableNode, ///
-          matchesVariableNode = this.terms.some((term) => {
+          variableNodeMatches = this.terms.some((term) => {
             const termNode = term.getNode(),
                   variableNode = variableNodeQuery(termNode);
 
@@ -111,19 +111,19 @@ export default class Equivalence {
             }
           });
 
-    return matchesVariableNode;
+    return variableNodeMatches;
   }
 
   matchTermNodes(termNodes) {
-    const matchesTermNodes = termNodes.every((termNode) => {
-      const matchesTermNode = this.matchTermNode(termNode);
+    const termNodesMatch = termNodes.every((termNode) => {
+      const termNodeMatches = this.matchTermNode(termNode);
 
-      if (matchesTermNode) {
+      if (termNodeMatches) {
         return true;
       }
     });
 
-    return matchesTermNodes;
+    return termNodesMatch;
   }
 
   getGroundedTerms(definedVariables, groundedTerms, localContext) {
@@ -132,9 +132,10 @@ export default class Equivalence {
 
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-          const termMatchesGroundedTerm = term.match(groundedTerm);
+          const groundedTermNode = groundedTerm.getNode(),
+                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
 
-          if (termMatchesGroundedTerm) {
+          if (groundedTermNodeMatches) {
             return true;
           }
         })

package/src/judgement.js

@@ -22,9 +22,9 @@ export default class Judgement {
   getDeclarations() { return this.frame.getDeclarations(); }
 
   matchMetavariableNode(metavariableNode) {
-    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
-    return matchesMetavariableNode;
+    return metavariableNodeMatches;
   }
 
   unifyMetaLemmaOrmetatheorem(metaLemmaMetatheorem) { return this.frame.unifyMetaLemmaOrmetatheorem(metaLemmaMetatheorem); }

package/src/label.js

@@ -12,9 +12,9 @@ export default class Label {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const matches = this.metavariableNode.match(metavariableNode);
+    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
-    return matches;
+    return metavariableNodeMatches;
   }
 
   asString(tokens) {

package/src/log.js

@@ -2,7 +2,7 @@
 
 import { levels } from "necessary";
 
-import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/lineIndex";
+import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/message";
 
 const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
 

package/src/metaType.js

@@ -25,23 +25,23 @@ export default class MetaType {
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
 
-    return matchesName;
+    return nameMatches;
   }
 
   matchMetaTypeName(metaTypeName) {
-    const matchesMetaTypeName = (this.name === metaTypeName);
+    const metaTypeNameMatches = (this.name === metaTypeName);
 
-    return matchesMetaTypeName;
+    return metaTypeNameMatches;
   }
 
   matchMetaTypeNode(metaTypeNode) {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          matchesMetaTypeName = this.matchMetaTypeName(metaTypeName),
-          matchesMetaTypeNode = matchesMetaTypeName;  ///
+          metaTypeNameMatches = this.matchMetaTypeName(metaTypeName),
+          metaTypeNodeMatches = metaTypeNameMatches;  ///
 
-    return matchesMetaTypeNode;
+    return metaTypeNodeMatches;
   }
 
   asString(tokens) {

package/src/metavariable.js

@@ -4,7 +4,7 @@ import verifyTermGivenType from "./verify/termGivenType";
 
 import { nodeQuery } from "./utilities/query";
 import { nodeAsString } from "./utilities/string";
-import { nameFromMetavariableNode } from "./utilities/name";
+import { metavariableNameFromMetavariableNode } from "./utilities/name";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term!"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type!");
@@ -40,19 +40,19 @@ export default class Metavariable {
   }
 
   matchName(name) {
-    const matchesName = (this.name === name);
+    const nameMatches = (this.name === name);
 
-    return matchesName;
+    return nameMatches;
   }
 
-  matchNode(node, localContext) {
+  matchMetavariableNode(metavariableNode, localContext) {
     let matchesNode = false;
 
-    const metavariableNode = node,  ///
-          typeNode = typeNodeQuery(metavariableNode);
+    const typeNode = typeNodeQuery(metavariableNode);
 
     if (typeNode === null) {
-      const name = nameFromMetavariableNode(metavariableNode);
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            name = metavariableName;  ///
 
       if (this.name === name) {
         const termNode = termNodeQuery(metavariableNode);

package/src/node/term/bracketed.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { termNodeFromTermString } from "../../utilities/node";
+
+const bracketedTermString = "(n)";
+
+const bracketedTermNode = termNodeFromTermString(bracketedTermString);
+
+export default bracketedTermNode;