occam-verify-cli 0.0.538 → 0.0.540

package/src/conjecture.js

@@ -7,7 +7,7 @@ import { CONJECTURE_KIND } from "./kinds";
 export default class Conjecture extends AxiomLemmaTheoremConjecture {
   static kind = CONJECTURE_KIND;
 
-  static fromJSON(json, context) { return AxiomLemmaTheoremConjecture.fromJSON(Conjecture, json, context); }
+  static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Conjecture, json, fileContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Conjecture, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Conjecture, labels, suppositions, consequence, proofContext); }
 }

package/src/consequence.js

@@ -13,10 +13,10 @@ export default class Consequence {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode, substitutions) {
+  matchStatementNode(statementNode, substitutions, proofContext) {
     const nonTerminalNodeA = this.statementNode,  ///
           nonTerminalNodeB = statementNode,  ///
-          nonTerminalNodeVerified = consequenceTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          nonTerminalNodeVerified = consequenceTermForVariableVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContext),
           statementNodeMatches = nonTerminalNodeVerified; ///
 
     return statementNodeMatches;

package/src/constructor.js

@@ -54,11 +54,11 @@ export default class Constructor {
     return json;
   }
 
-  static fromJSON(json, context) {
+  static fromJSONAndFileContext(json, fileContext) {
     const { term } = json,
           termString = term,  ///
-          lexer = context.getLexer(),
-          parser = context.getParser(),
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
           termNode = termNodeFromTermString(termString, lexer, parser);
 
     let { type } = json;
@@ -68,11 +68,11 @@ export default class Constructor {
 
       json = typeJSON;  ///
 
-      type = Type.fromJSON(json, context);
+      type = Type.fromJSONAndFileContext(json, fileContext);
 
       const typeName = type.getName();
 
-      type = context.findTypeByTypeName(typeName); ///
+      type = fileContext.findTypeByTypeName(typeName); ///
     }
 
     const constructor = new Constructor(termNode, type);

package/src/context/file.js

@@ -2,11 +2,37 @@
 
 import { rewriteNodes } from "occam-grammar-utilities";
 
-import { push } from "../utilities/array";
+import Type from "../type";
+import Rule from "../rule";
+import Axiom from "../axiom";
+import Lemma from "../lemma";
+import Theorem from "../theorem";
+import Variable from "../variable";
+import Conjecture from "../conjecture";
+import Combinator from "../combinator";
+import Constructor from "../constructor";
+import Metavariable from "../metavariable";
+
+import { push, filter } from "../utilities/array";
+import { statementMetaType } from "../metaType";
 import { nodeAsString, nodesAsString } from "../utilities/string";
+import { TYPE_KIND,
+         RULE_KIND,
+         AXIOM_KIND,
+         LEMMA_KIND,
+         THEOREM_KIND,
+         VARIABLE_KIND,
+         CONJECTURE_KIND,
+         COMBINATOR_KIND,
+         CONSTRUCTOR_KIND,
+         METAVARIABLE_KIND } from "../kinds";
+
+const metaTypes = [
+  statementMetaType
+];
 
 export default class FileContext {
-  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables) {
+  constructor(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, variables, conjectures, combinators, constructors, metavariables) {
     this.releaseContext = releaseContext;
     this.filePath = filePath;
     this.tokens = tokens;
@@ -16,10 +42,10 @@ export default class FileContext {
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
+    this.variables = variables;
     this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
-    this.variables = variables;
     this.metavariables = metavariables;
   }
 
@@ -78,6 +104,12 @@ export default class FileContext {
       push(labels, theoremLabels);
     });
 
+    this.conjectures.forEach((conjecture) => {
+      const conjectureLabels = conjecture.getLabels();
+
+      push(labels, conjectureLabels);
+    });
+
     if (includeRelease) {
       const releaseContextLabels = this.releaseContext.getLabels();
 
@@ -157,6 +189,14 @@ export default class FileContext {
     return theorems;
   }
 
+  getVariables(includeRelease = true) {
+    return this.variables;
+  }
+
+  getMetaTypes(includeRelease = true) {
+    return metaTypes;
+  }
+
   getConjectures(includeRelease = true) {
     const conjectures = [];
 
@@ -199,39 +239,35 @@ export default class FileContext {
     return constructors;
   }
 
-  getVariables() {
-    return this.variables;
-  }
-
-  getMetavariables() {
+  getMetavariables(includeRelease = true) {
     return this.metavariables;
   }
 
-  findTypeByTypeName(typeName) {
-    const types = this.getTypes(),
-          type = types.find((type) => {
-            const matches = type.matchTypeName(typeName);
+  findLabelByLabelName(labelName) {
+    const name = labelName,  ///
+          labels = this.getLabels(),
+          label = labels.find((label) => {
+            const matches = label.matchName(name);
 
             if (matches) {
               return true;
             }
           }) || null;
 
-    return type;
+    return label;
   }
 
-  findLabelByLabelName(labelName) {
-    const name = labelName,  ///
-          labels = this.getLabels(),
-          label = labels.find((label) => {
-            const matches = label.matchName(name);
+  findTypeByTypeName(typeName) {
+    const types = this.getTypes(),
+          type = types.find((type) => {
+            const matches = type.matchTypeName(typeName);
 
             if (matches) {
               return true;
             }
           }) || null;
 
-    return label;
+    return type;
   }
 
   findRuleByReferenceName(referenceName) {
@@ -290,6 +326,33 @@ export default class FileContext {
     return theorem;
   }
 
+  findVariableByVariableName(variableName) {
+    const name = variableName,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const matches = variable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  findMetaTypeByMetaTypeName(metaTypeName) {
+    const metaTypes = this.getMetaTypes(),
+          metaType = metaTypes.find((metaType) => {
+            const matches = metaType.matchMetaTypeName(metaTypeName);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metaType;
+  }
+
   findConjectureByReferenceName(referenceName) {
     const labelName = referenceName,  ///
           conjectures = this.getConjectures(),
@@ -304,6 +367,20 @@ export default class FileContext {
     return conjecture;
   }
 
+  findMetavariableByMetavariableName(metavariableName) {
+    const name = metavariableName,  ///
+          metavariables = this.getMetavariables(),
+          metavariable = metavariables.find((metavariable) => {
+            const matches = metavariable.matchName(name);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
   isLabelPresentByLabelName(labelName) {
     const label = this.findLabelByLabelName(labelName),
           labelPresent = (label !== null);
@@ -318,43 +395,36 @@ export default class FileContext {
     return typePresent;
   }
 
-  nodeAsString(node) {
-    const string = nodeAsString(node, this.tokens);
+  isVariablePresentByVariableName(variableName) {
+    const variable = this.findVariableByVariableName(variableName),
+          variablePresent = (variable !== null);
 
-    return string;
+    return variablePresent;
   }
 
-  nodesAsString(node) {
-    const string = nodesAsString(node, this.tokens);
+  isMetavariablePresentByMetavariableName(metavariableName) {
+    const metavariable = this.findMetavariableByMetavariableName(metavariableName),
+          metavariablePresent = (metavariable !== null);
 
-    return string;
+    return metavariablePresent;
   }
 
-  findVariableByVariableName(variableName) {
-    const name = variableName,  ///
-          variables = this.getVariables(),
-          variable = variables.find((variable) => {
-            const matches = variable.matchName(name);
-
-            if (matches) {
-              return true;
-            }
-          }) || null;
+  matchStatement(statementNode) {
+    const statementMatches = false;
 
-    return variable;
+    return statementMatches;
   }
 
-  isVariablePresentByVariableName(variableName) {
-    const variable = this.findVariableByVariableName(variableName),
-          variablePresent = (variable !== null);
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
 
-    return variablePresent;
+    return string;
   }
 
-  matchStatement(statementNode) {
-    const statementMatches = false;
+  nodesAsString(node) {
+    const string = nodesAsString(node, this.tokens);
 
-    return statementMatches;
+    return string;
   }
 
   addType(type) {
@@ -378,9 +448,24 @@ export default class FileContext {
   }
 
   addVariable(variable) {
+    const variableName = variable.getName();
+
+    filter(this.variables, (variable) => {
+      const name = variable.getName(),
+            nameVariableName = (name === variableName);
+
+      if (!nameVariableName) {
+        return true;
+      }
+    });
+
     this.variables.push(variable);
   }
 
+  addConjecture(conjecture) {
+    this.conjectures.push(conjecture);
+  }
+
   addCombinator(combinator) {
     this.combinators.push(combinator);
   }
@@ -389,6 +474,21 @@ export default class FileContext {
     this.constructors.push(constructor);
   }
 
+  addMetavariable(metavariable) {
+    const metavariableName = metavariable.getName();
+
+    filter(this.metavariables, (metavariable) => {
+      const name = metavariable.getName(),
+            nameMetavariableName = (name === metavariableName);
+
+      if (!nameMetavariableName) {
+        return true;
+      }
+    });
+
+    this.metavariables.push(metavariable);
+  }
+
   trace(message, node) { this.releaseContext.trace(message, node, this.tokens, this.filePath); }
 
   debug(message, node) { this.releaseContext.debug(message, node, this.tokens, this.filePath); }
@@ -434,6 +534,12 @@ export default class FileContext {
       json.push(theoremJSON);
     });
 
+    this.variables.forEach((variable) => {
+      const variableJSON = variable.toJSON(this.tokens);
+
+      json.push(variableJSON)
+    });
+
     this.conjectures.forEach((conjecture) => {
       const conjectureJSON = conjecture.toJSON(this.tokens);
 
@@ -452,9 +558,106 @@ export default class FileContext {
       json.push(constructorJSON)
     });
 
+    this.metavariables.forEach((metavariable) => {
+      const metavariableJSON = metavariable.toJSON(this.tokens);
+
+      json.push(metavariableJSON)
+    });
+
     return json;
   }
 
+  static fromJSON(json) {
+    const jsonArray = json, ///
+          fileContext = this; ///
+
+    jsonArray.forEach((json) => {
+      const { kind } = json;
+
+      switch (kind) {
+        case TYPE_KIND: {
+          const type = Type.fromJSONAndFileContext(json, fileContext);
+
+          this.types.push(type);
+
+          break;
+        }
+
+        case RULE_KIND: {
+          const rule = Rule.fromJSONAndFileContext(json, fileContext);
+
+          this.rules.push(rule);
+
+          break;
+        }
+
+        case AXIOM_KIND: {
+          const axiom = Axiom.fromJSONAndFileContext(json, fileContext);
+
+          this.axioms.push(axiom);
+
+          break;
+        }
+
+        case LEMMA_KIND: {
+          const lemma = Lemma.fromJSONAndFileContext(json, fileContext);
+
+          this.lemmas.push(lemma);
+
+          break;
+        }
+
+        case THEOREM_KIND: {
+          const theorem = Theorem.fromJSONAndFileContext(json, fileContext);
+
+          this.theorems.push(theorem);
+
+          break;
+        }
+
+        case VARIABLE_KIND: {
+          const variable = Variable.fromJSONAndFileContext(json, fileContext);
+
+          this.variables.push(variable);
+
+          break;
+        }
+
+        case CONJECTURE_KIND: {
+          const conjecture = Conjecture.fromJSONAndFileContext(json, fileContext);
+
+          this.conjectures.push(conjecture);
+
+          break;
+        }
+
+        case COMBINATOR_KIND: {
+          const combinator = Combinator.fromJSONAndFileContext(json, fileContext);
+
+          this.combinators.push(combinator);
+
+          break;
+        }
+
+        case CONSTRUCTOR_KIND: {
+          const constructor = Constructor.fromJSONAndFileContext(json, fileContext);
+
+          this.constructors.push(constructor);
+
+          break;
+        }
+
+        case METAVARIABLE_KIND: {
+          const metavariable = Metavariable.fromJSONAndFileContext(json, fileContext);
+
+          this.metavariables.push(metavariable);
+
+          break;
+        }
+      }
+    });
+  }
+
   static fromReleaseContextAndFilePath(releaseContext, filePath) {
     const file = releaseContext.getFile(filePath),
           content = file.getContent(),
@@ -472,12 +675,12 @@ export default class FileContext {
           axioms = [],
           lemmas = [],
           theorems = [],
+          variables = [],
           conjectures = [],
           combinators = [],
           constructors = [],
-          variables = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, variables, metavariables);
+          fileContext = new FileContext(releaseContext, filePath, tokens, node, types, rules, axioms, lemmas, variables, theorems, conjectures, combinators, constructors, metavariables);
 
     return fileContext;
   }

package/src/context/metaproof.js

@@ -108,7 +108,7 @@ class MetaproofContext {
     return metavariable;
   }
 
-  isMetavariablePresentByVariableName(metavariableName) {
+  isMetavariablePresentByMetavariableName(metavariableName) {
     const metavariable = this.findMetavariableByMetavariableName(metavariableName),
           metavariablePresent = (metavariable !== null);