occam-verify-cli 0.0.870 → 0.0.872

package/src/context/file.js

@@ -115,6 +115,12 @@ export default class FileContext {
       push(labels, conjectureLabels);
     });
 
+    this.metatheorems.forEach((metatheorem) => {
+      const metatheoremLabels = metatheorem.getLabels();
+
+      push(labels, metatheoremLabels);
+    });
+
     if (includeRelease) {
       const releaseContextLabels = this.releaseContext.getLabels();
 
@@ -308,8 +314,62 @@ export default class FileContext {
     return type;
   }
 
-  findLabelByLabelNode(labelNode) {
-    const name = labelNode,  ///
+  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 nodeMatches = variable.matchNode(node);
+
+            if (nodeMatches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  findMetaTypeByMetaTypeNode(metaTypeNode) {
+    const metaTypes = this.getMetaTypes(),
+          metaType = metaTypes.find((metaType) => {
+            const matches = metaType.matchMetaTypeNode(metaTypeNode);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metaType;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode) {
+    const node = metavariableNode,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchNode(node);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  findLabelByLabelMetavariableNode(labelMetavariableNode) {
+    const name = labelMetavariableNode,  ///
           labels = this.getLabels(),
           label = labels.find((label) => {
             const matches = label.matchNode(name);
@@ -322,12 +382,12 @@ export default class FileContext {
     return label;
   }
 
-  findRuleByLabelNode(labelNode) {
+  findRuleByLabelMetavariableNode(labelMetavariableNode) {
     const rules = this.getRules(),
           rule = rules.find((rule) => {
-            const ruleMatchesLabelNode = rule.matchLabelNode(labelNode);
+            const ruleMatchesLabelMetavariableNode = rule.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (ruleMatchesLabelNode) {
+            if (ruleMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -335,12 +395,12 @@ export default class FileContext {
     return rule;
   }
 
-  findAxiomByLabelNode(labelNode) {
+  findAxiomByLabelMetavariableNode(labelMetavariableNode) {
     const axioms = this.getAxioms(),
           axiom = axioms.find((axiom) => {
-            const axiomMatchesLabelNode = axiom.matchLabelNode(labelNode);
+            const axiomMatchesLabelMetavariableNode = axiom.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (axiomMatchesLabelNode) {
+            if (axiomMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -348,12 +408,12 @@ export default class FileContext {
     return axiom;
   }
 
-  findLemmaByLabelNode(labelNode) {
+  findLemmaByLabelMetavariableNode(labelMetavariableNode) {
     const lemmas = this.getLemmas(),
           lemma = lemmas.find((lemma) => {
-            const lemmaMatchesLabelNode = lemma.matchLabelNode(labelNode);
+            const lemmaMatchesLabelMetavariableNode = lemma.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (lemmaMatchesLabelNode) {
+            if (lemmaMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -361,12 +421,12 @@ export default class FileContext {
     return lemma;
   }
 
-  findTheoremByLabelNode(labelNode) {
+  findTheoremByLabelMetavariableNode(labelMetavariableNode) {
     const theorems = this.getTheorems(),
           theorem = theorems.find((theorem) => {
-            const theoremMatchesLabelNode = theorem.matchLabelNode(labelNode);
+            const theoremMatchesLabelMetavariableNode = theorem.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (theoremMatchesLabelNode) {
+            if (theoremMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -374,12 +434,12 @@ export default class FileContext {
     return theorem;
   }
 
-  findMetaLemmaByLabelNode(labelNode) {
+  findMetaLemmaByLabelMetavariableNode(labelMetavariableNode) {
     const metaLemmas = this.getMetaLemmas(),
           metaLemma = metaLemmas.find((metaLemma) => {
-            const metaLemmaMatchesLabelNode = metaLemma.matchLabelNode(labelNode);
+            const metaLemmaMatchesLabelMetavariableNode = metaLemma.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (metaLemmaMatchesLabelNode) {
+            if (metaLemmaMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -387,39 +447,12 @@ export default class FileContext {
     return metaLemma;
   }
 
-  findVariableByVariableNode(variableNode) {
-    const node = variableNode,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const nodeMatches = variable.matchNode(node);
-
-            if (nodeMatches) {
-              return true;
-            }
-          }) || null;
-
-    return variable;
-  }
-
-  findMetaTypeByMetaTypeNode(metaTypeNode) {
-    const metaTypes = this.getMetaTypes(),
-          metaType = metaTypes.find((metaType) => {
-            const matches = metaType.matchMetaTypeNode(metaTypeNode);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metaType;
-  }
-
-  findConjectureByLabelNode(labelNode) {
+  findConjectureByLabelMetavariableNode(labelMetavariableNode) {
     const conjectures = this.getConjectures(),
           conjecture = conjectures.find((conjecture) => {
-            const conjectureMatchesLabelNode = conjecture.matchLabelNode(labelNode);
+            const conjectureMatchesLabelMetavariableNode = conjecture.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (conjectureMatchesLabelNode) {
+            if (conjectureMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -427,26 +460,12 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode) {
-    const node = metavariableNode,  ///
-          metavariables = this.getMetavariables(),
-          metavariable = metavariables.find((metavariable) => {
-            const matches = metavariable.matchNode(node);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
-
-    return metavariable;
-  }
-
-  findMetatheoremByLabelNode(labelNode) {
+  findMetatheoremByLabelMetavariableNode(labelMetavariableNode) {
     const metatheorems = this.getMetatheorems(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const metatheoremMatchesLabelNode = metatheorem.matchLabelNode(labelNode);
+            const metatheoremMatchesLabelMetavariableNode = metatheorem.matchLabelMetavariableNode(labelMetavariableNode);
 
-            if (metatheoremMatchesLabelNode) {
+            if (metatheoremMatchesLabelMetavariableNode) {
               return true;
             }
           }) || null;
@@ -468,11 +487,11 @@ export default class FileContext {
     return typePresent;
   }
 
-  isLabelPresentByLabelNode(labelNode) {
-    const label = this.findLabelByLabelNode(labelNode),
-          labelPresent = (label !== null);
+  isMetavariablePresentByName(name) {
+    const metavariable = this.findMetavariableByName(name),
+          metavariablePresent = (metavariable !== null);
 
-    return labelPresent;
+    return metavariablePresent;
   }
 
   isVariablePresentByVariableNode(variableNode) {
@@ -482,6 +501,13 @@ export default class FileContext {
     return variablePresent;
   }
 
+  isLabelPresentByLabelMetavariableNode(labelMetavariableNode) {
+    const label = this.findLabelByLabelMetavariableNode(labelMetavariableNode),
+          labelPresent = (label !== null);
+
+    return labelPresent;
+  }
+
   isMetavariablePresentByMetavariableNode(metavariableNode) {
     const metavariable = this.findMetavariableByMetavariableNode(metavariableNode),
           metavariablePresent = (metavariable !== null);
@@ -583,9 +609,9 @@ export default class FileContext {
   addMetavariable(metavariable) {
     let metavariableAdded = false;
 
-    const node = metavariable.getNode(),
+    const name = metavariable.getName(),
           metavariablePresent = this.metavariables.some((metavariable) => {
-            const nodeMatches = metavariable.matchNode(node);
+            const nodeMatches = metavariable.matchName(name);
 
             if (nodeMatches) {
               return true;
@@ -727,11 +753,11 @@ export default class FileContext {
           lemmasJSON = lemmas,  ///
           theoremsJSON = theorems,  ///
           variablesJSON = variables,  ///
-          metaLemmasJSON = metaLemmas || [],  ///
+          metaLemmasJSON = metaLemmas,  ///
           conjecturesJSON = conjectures,  ///
           combinatorsJSON = combinators,  ///
           constructorsJSON = constructors,  ///
-          metatheoremsJSON = metatheorems || [],  ///
+          metatheoremsJSON = metatheorems,  ///
           metavariablesJSON = metavariables;  ///
 
     typesJSON.forEach((typeJSON) => {

package/src/label.js

@@ -1,8 +1,7 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { labelNameFromLabelNode } from "./utilities/name";
-import { labelNodeFromLabelString } from "./utilities/node";
+import { metavariableNodeFromMetavariableString } from "./utilities/node";
 
 export default class Label {
   constructor(node) {
@@ -32,19 +31,19 @@ export default class Label {
     return json;
   }
 
-  static fromLabelNode(labelNode) {
-    const node = labelNode, ///
+  static fromMetavariableNode(metavariableNode) {
+    const node = metavariableNode, ///
           variable = new Label(node);
 
     return variable;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const labelString = json, ///
+    const metavariableString = json, ///
           lexer  = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          labelNode = labelNodeFromLabelString(labelString, lexer, parser),
-          node = labelNode, ///
+          metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+          node = metavariableNode, ///
           label = new Label(node);
 
     return label;

package/src/metaLemmaMetatheorem.js

@@ -32,19 +32,6 @@ export default class MetaLemmaMetatheorem {
     return this.localContext;
   }
 
-  matchLabelNode(labelNode) {
-    const labelNodeMatches = this.labels.some((label) => {
-      const node = labelNode, ///
-            labelMatchesNode = label.matchNode(node);
-
-      if (labelMatchesNode) {
-        return true;
-      }
-    });
-
-    return labelNodeMatches;
-  }
-
   matchMetastatement(metastatementNode, metastatementLocalContext) {
     let metastatementNatches;
 
@@ -79,6 +66,19 @@ export default class MetaLemmaMetatheorem {
     return metastatementNatches;
   }
 
+  matchLabelMetavariableNode(labelMetavariableNode) {
+    const labelMetavariableNodeMatches = this.labels.some((label) => {
+      const node = labelMetavariableNode, ///
+            labelMatchesNode = label.matchNode(node);
+
+      if (labelMatchesNode) {
+        return true;
+      }
+    });
+
+    return labelMetavariableNodeMatches;
+  }
+
   toJSON(tokens) {
     const labelsJSON = this.labels.map((label) => {
             const labelJSON = label.toJSON(tokens);

package/src/metaType/context.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import MetaType from "../metaType";
+
+import { CONTEXT_META_TYPE_NAME } from "../metaTypeNames";
+
+class ContextMetaType extends MetaType {
+  static fromNothing() {
+    const name = CONTEXT_META_TYPE_NAME,
+          contextMetaType = new ContextMetaType(name);
+
+    return contextMetaType;
+  }
+}
+
+const contextMetaType = ContextMetaType.fromNothing();
+
+export default contextMetaType;

package/src/metaType/label.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import MetaType from "../metaType";
+
+import { LABEL_META_TYPE_NAME } from "../metaTypeNames";
+
+class LabelMetaType extends MetaType {
+  static fromNothing() {
+    const name = LABEL_META_TYPE_NAME,
+          labelMetaType = new LabelMetaType(name);
+
+    return labelMetaType;
+  }
+}
+
+const labelMetaType = LabelMetaType.fromNothing();
+
+export default labelMetaType;

package/src/metaType/statement.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import MetaType from "../metaType";
+
+import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+
+class StatementMetaType extends MetaType {
+  static fromNothing() {
+    const name = STATEMENT_META_TYPE_NAME,
+          statementMetaType = new StatementMetaType(name);
+
+    return statementMetaType;
+  }
+}
+
+const statementMetaType = StatementMetaType.fromNothing();
+
+export default statementMetaType;

package/src/metaType.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import { metaTypeNameFromMetaTypeNode } from "./utilities/name";
-import { CONTEXT_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 
 export default class MetaType {
   constructor(name) {
@@ -68,28 +67,6 @@ export default class MetaType {
   }
 }
 
-class ContextMetaType extends MetaType {
-  static fromNothing() {
-    const name = CONTEXT_META_TYPE_NAME,
-          contextMetaType = new ContextMetaType(name);
-
-    return contextMetaType;
-  }
-}
-
-class StatementMetaType extends MetaType {
-  static fromNothing() {
-    const name = STATEMENT_META_TYPE_NAME,
-          statementMetaType = new StatementMetaType(name);
-
-    return statementMetaType;
-  }
-}
-
-export const contextMetaType = ContextMetaType.fromNothing();
-
-export const statementMetaType = StatementMetaType.fromNothing();
-
 export function metaTypeFromJSONAndFileContext(json, fileContext) {
   let metaType;
 

package/src/metaTypeNames.js

@@ -1,4 +1,5 @@
 "use strict";
 
-export const CONTEXT_META_TYPE_NAME = "Context";
 export const STATEMENT_META_TYPE_NAME = "Statement";
+export const CONTEXT_META_TYPE_NAME = "Context";
+export const LABEL_META_TYPE_NAME = "Label";

package/src/metaTypes.js

@@ -1,8 +1,11 @@
 "use strict";
 
-import { contextMetaType, statementMetaType } from "./metaType";
+import labelMetaType from "./metaType/label";
+import contextMetaType from "./metaType/context";
+import statementMetaType from "./metaType/statement";
 
 const metaTypes = [
+  labelMetaType,
   contextMetaType,
   statementMetaType
 ];

package/src/metavariable.js

@@ -1,11 +1,18 @@
 "use strict";
 
+import { nodeQuery } from "./utilities/query";
 import { nodeAsString } from "./utilities/string";
+import { nameFromMetavariableNode } from "./utilities/name";
 import { metaTypeFromJSONAndFileContext } from "./metaType";
+import { metavariableNodeFromMetavariableString } from "./utilities/node";
+
+const typeNodeQuery = nodeQuery("/metavariable/argument!/type!");
 
 export default class Metavariable {
-  constructor(node, metaType) {
+  constructor(node, name, termType, metaType) {
     this.node = node;
+    this.name = name;
+    this.termType = termType;
     this.metaType = metaType;
   }
 
@@ -13,21 +20,42 @@ export default class Metavariable {
     return this.node;
   }
 
+  getName() {
+    return this.name;
+  }
+
+  getTermType() {
+    return this.termType;
+  }
+
   getMetaType() {
     return this.metaType;
   }
 
+  matchName(name) {
+    const nameMatches = (this.name === name);
+
+    return nameMatches;
+  }
+
   matchNode(node) {
-    const nodeMatches = this.node.match(node);
+    let nodeMatches;
+
+    const metavariableNode = node,  ///
+          name = nameFromMetavariableNode(metavariableNode);
+
+    if (this.name === name) {
+      nodeMatches = true;
+    }
 
     return nodeMatches;
   }
 
   toJSON(tokens) {
     const metaTypeJSON = this.metaType.toJSON(tokens),
-          metaType = metaTypeJSON,  ///
           string = nodeAsString(this.node, tokens),
-          node = string,  ///
+          node = string,  //
+          metaType = metaTypeJSON,  ///
           json = {
             node,
             metaType
@@ -41,13 +69,20 @@ export default class Metavariable {
 
     let string = nodeAsString(this.node, tokens);
 
-    string = `${string}:${metaTypeName}`;
+    string = `${string}:${metaTypeName}`; ///
 
     return string;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { node } = json;
+    let { node } = json;
+
+    const lexer  = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          variableString = node,  ///
+          metavariableNode = metavariableNodeFromMetavariableString(variableString, lexer, parser);
+
+    node = metavariableNode;  ///
 
     let { metaType } = json;
 
@@ -55,15 +90,30 @@ export default class Metavariable {
 
     metaType = metaTypeFromJSONAndFileContext(json, fileContext);
 
-    const metavariable = new Metavariable(node, metaType);
+    const name = nameFromMetavariableNode(metavariableNode),
+          termType = termTypeFromMetavariableNode(metavariableNode, fileContext),
+          metavariable = new Metavariable(node, name, termType, metaType);
 
     return metavariable;
   }
 
-  static fromMetavariableNodeAndMetaType(metavariableNode, metaType) {
-    const node = metavariableNode,  ///
-          metavariable = new Metavariable(node, metaType);
+  static fromNodeNameTermTypeAndMetaType(node, name, termType, metaType) {
+    const metavariable = new Metavariable(node, name, termType, metaType);
 
     return metavariable;
   }
 }
+
+function termTypeFromMetavariableNode(metavariableNode, fileContext) {
+  let termType = null;
+
+  const typeNode = typeNodeQuery(metavariableNode);
+
+  if (typeNode !== null) {
+      const type = fileContext.findTypeByTypeNode(typeNode);
+
+      termType = type;  ///
+  }
+
+  return termType;
+}

package/src/mixins/context.js

@@ -26,25 +26,29 @@ function getConstructors() { return this.context.getConstructors(); }
 
 function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-function findTypeByTypeNode(labelNode) { return this.context.findTypeByTypeNode(labelNode); }
+function findTypeByTypeNode(labelMetavariableNode) { return this.context.findTypeByTypeNode(labelMetavariableNode); }
 
-function findLabelByLabelNode(labelNode) { return this.context.findLabelByLabelNode(labelNode); }
+function findMetavariableByName(name) { return this.context.findMetavariableByName(name); }
 
-function findRuleByLabelNode(labelNode) { return this.context.findRuleByLabelNode(labelNode); }
+function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-function findAxiomByLabelNode(labelNode) { return this.context.findAxiomByLabelNode(labelNode); }
+function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
 
-function findLemmaByLabelNode(labelNode) { return this.context.findLemmaByLabelNode(labelNode); }
+function isMetavariablePresentByName(name) { return this.context.isMetavariablePresentByName(name); }
 
-function findTheoremByLabelNode(labelNode) { return this.context.findTheoremByLabelNode(labelNode); }
+function findLabelByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLabelByLabelMetavariableNode(labelMetavariableNode); }
 
-function findConjectureByLabelNode(labelNode) { return this.context.findConjectureByLabelNode(labelNode); }
+function findRuleByLabelMetavariableNode(labelMetavariableNode) { return this.context.findRuleByLabelMetavariableNode(labelMetavariableNode); }
 
-function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+function findAxiomByLabelMetavariableNode(labelMetavariableNode) { return this.context.findAxiomByLabelMetavariableNode(labelMetavariableNode); }
 
-function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
+function findLemmaByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLemmaByLabelMetavariableNode(labelMetavariableNode); }
+
+function findTheoremByLabelMetavariableNode(labelMetavariableNode) { return this.context.findTheoremByLabelMetavariableNode(labelMetavariableNode); }
+
+function findConjectureByLabelMetavariableNode(labelMetavariableNode) { return this.context.findConjectureByLabelMetavariableNode(labelMetavariableNode); }
 
-function isLabelPresentByLabelNode(labelNode) { return this.context.isLabelPresentByLabelNode(labelNode); }
+function isLabelPresentByLabelMetavariableNode(labelMetavariableNode) { return this.context.isLabelPresentByLabelMetavariableNode(labelMetavariableNode); }
 
 function nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -65,15 +69,17 @@ const contextMixins = {
   getConstructors,
   findTypeByTypeName,
   findTypeByTypeNode,
-  findLabelByLabelNode,
-  findRuleByLabelNode,
-  findAxiomByLabelNode,
-  findLemmaByLabelNode,
-  findTheoremByLabelNode,
-  findConjectureByLabelNode,
+  findMetavariableByName,
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
-  isLabelPresentByLabelNode,
+  isMetavariablePresentByName,
+  findLabelByLabelMetavariableNode,
+  findRuleByLabelMetavariableNode,
+  findAxiomByLabelMetavariableNode,
+  findLemmaByLabelMetavariableNode,
+  findTheoremByLabelMetavariableNode,
+  findConjectureByLabelMetavariableNode,
+  isLabelPresentByLabelMetavariableNode,
   nodeAsString,
   nodesAsString
 };