occam-verify-cli 0.0.1002 → 0.0.1005

package/src/context/file.js

@@ -1,6 +1,18 @@
 "use strict";
 
+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 metaTypes from "../metaTypes";
+import MetaLemma from "../metaLemma";
+import Conjecture from "../conjecture";
+import Combinator from "../combinator";
+import Constructor from "../constructor";
+import Metatheorem from "../metatheorem";
+import Metavariable from "../metavariable";
 import topLevelVerifier from "../verifier/topLevel";
 
 import { push } from "../utilities/array";
@@ -348,8 +360,9 @@ export default class FileContext {
     return label;
   }
 
-  findRuleByMetavariableNode(metavariableNode) {
+  findRuleByReference(reference) {
     const rules = this.getRules(),
+          metavariableNode = reference.getMetavariableNode(),
           rule = rules.find((rule) => {
             const metavariableNodeMatches = rule.matchMetavariableNode(metavariableNode);
 
@@ -361,8 +374,9 @@ export default class FileContext {
     return rule;
   }
 
-  findAxiomByMetavariableNode(metavariableNode) {
+  findAxiomByReference(reference) {
     const axioms = this.getAxioms(),
+          metavariableNode = reference.getMetavariableNode(),
           axiom = axioms.find((axiom) => {
             const metavariableNodeMatches = axiom.matchMetavariableNode(metavariableNode);
 
@@ -374,8 +388,9 @@ export default class FileContext {
     return axiom;
   }
 
-  findLemmaByMetavariableNode(metavariableNode) {
+  findLemmaByReference(reference) {
     const lemmas = this.getLemmas(),
+          metavariableNode = reference.getMetavariableNode(),
           lemma = lemmas.find((lemma) => {
             const metavariableNodeMatches = lemma.matchMetavariableNode(metavariableNode);
 
@@ -387,8 +402,9 @@ export default class FileContext {
     return lemma;
   }
 
-  findTheoremByMetavariableNode(metavariableNode) {
+  findTheoremByReference(reference) {
     const theorems = this.getTheorems(),
+          metavariableNode = reference.getMetavariableNode(),
           theorem = theorems.find((theorem) => {
             const metavariableNodeMatches = theorem.matchMetavariableNode(metavariableNode);
 
@@ -400,8 +416,9 @@ export default class FileContext {
     return theorem;
   }
 
-  findMetaLemmaByMetavariableNode(metavariableNode) {
+  findMetaLemmaByReference(reference) {
     const metaLemmas = this.getMetaLemmas(),
+          metavariableNode = reference.getMetavariableNode(),
           metaLemma = metaLemmas.find((metaLemma) => {
             const metavariableNodeMatches = metaLemma.matchMetavariableNode(metavariableNode);
 
@@ -413,8 +430,9 @@ export default class FileContext {
     return metaLemma;
   }
 
-  findConjectureByMetavariableNode(metavariableNode) {
+  findConjectureByReference(reference) {
     const conjectures = this.getConjectures(),
+          metavariableNode = reference.getMetavariableNode(),
           conjecture = conjectures.find((conjecture) => {
             const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
 
@@ -426,8 +444,9 @@ export default class FileContext {
     return conjecture;
   }
 
-  findMetatheoremByMetavariableNode(metavariableNode) {
+  findMetatheoremByReference(reference) {
     const metatheorems = this.getMetatheorems(),
+          metavariableNode = reference.getMetavariableNode(),
           metatheorem = metatheorems.find((metatheorem) => {
             const metavariableNodeMatches = metatheorem.matchMetavariableNode(metavariableNode);
 
@@ -606,8 +625,6 @@ export default class FileContext {
 
   error(message, node) { this.releaseContext.error(message, node, this.tokens, this.filePath); }
 
-  fatal(message, node) { this.releaseContext.fatal(message, node, this.tokens, this.filePath); }
-
   reset() {
     this.types = [];
     this.rules = [];
@@ -649,15 +666,210 @@ export default class FileContext {
 
   toJSON() {
     const filePath =  this.filePath,
-          fileContent = this.fileContent,
+          types = this.types.map((type) => {
+            const typeJSON = type.toJSON();
+
+            type = typeJSON; ///
+
+            return type;
+          }),
+          rules = this.rules.map((rule) => {
+            const ruleJSON = rule.toJSON();
+
+            rule = ruleJSON; ///
+
+            return rule;
+          }),
+          axioms = this.axioms.map((axiom) => {
+            const axiomJSON = axiom.toJSON();
+
+            axiom = axiomJSON; ///
+
+            return axiom;
+          }),
+          lemmas = this.lemmas.map((lemma) => {
+            const lemmaJSON = lemma.toJSON();
+
+            lemma = lemmaJSON; ///
+
+            return lemma;
+          }),
+          theorems = this.theorems.map((theorem) => {
+            const theoremJSON = theorem.toJSON();
+
+            theorem = theoremJSON; ///
+
+            return theorem;
+          }),
+          variables = this.variables.map((variable) => {
+            const variableJSON = variable.toJSON();
+
+            variable = variableJSON;  ///
+
+            return variable;
+          }),
+          metaLemmas = this.metaLemmas.map((metaLemma) => {
+            const metaLemmaJSON = metaLemma.toJSON();
+
+            metaLemma = metaLemmaJSON; ///
+
+            return metaLemma;
+          }),
+          conjectures = this.conjectures.map((conjecture) => {
+            const conjectureJSON = conjecture.toJSON();
+
+            conjecture = conjectureJSON; ///
+
+            return conjecture;
+          }),
+          combinators = this.combinators.map((combinator) => {
+            const combinatorJSON = combinator.toJSON();
+
+            combinator = combinatorJSON; ///
+
+            return combinator;
+          }),
+          constructors = this.constructors.map((constructor) => {
+            const constructorJSON = constructor.toJSON();
+
+            constructor = constructorJSON;  ///
+
+            return constructor;
+          }),
+          metatheorems = this.metatheorems.map((metatheorem) => {
+            const metatheoremJSON = metatheorem.toJSON();
+
+            metatheorem = metatheoremJSON; ///
+
+            return metatheorem;
+          }),
+          metavariables = this.metavariables.map((metavariable) => {
+            const metavariableJSON = metavariable.toJSON();
+
+            metavariable = metavariableJSON;  ///
+
+            return metavariable;
+          }),
           json = {
             filePath,
-            fileContent
+            types,
+            rules,
+            axioms,
+            lemmas,
+            theorems,
+            variables,
+            metaLemmas,
+            conjectures,
+            combinators,
+            constructors,
+            metatheorems,
+            metavariables
           };
 
     return json;
   }
 
+  static fromJSON(json) {
+    const { types, rules, axioms, lemmas, theorems, metaLemmas, variables, conjectures, combinators, constructors, metatheorems, metavariables } = json,
+          fileContext = this, ///
+          typesJSON = types,  ///
+          rulesJSON = rules,  ///
+          axiomsJSON = axioms,  ///
+          lemmasJSON = lemmas,  ///
+          theoremsJSON = theorems,  ///
+          variablesJSON = variables,  ///
+          metaLemmasJSON = metaLemmas,  ///
+          conjecturesJSON = conjectures,  ///
+          combinatorsJSON = combinators,  ///
+          constructorsJSON = constructors,  ///
+          metatheoremsJSON = metatheorems,  ///
+          metavariablesJSON = metavariables;  ///
+
+    typesJSON.forEach((typeJSON) => {
+      const json = typeJSON,  ///
+            type = Type.fromJSON(json, fileContext);
+
+      this.types.push(type);
+    });
+
+    rulesJSON.forEach((ruleJSON) => {
+      const json = ruleJSON,  ///
+            rule = Rule.fromJSON(json, fileContext);
+
+      this.rules.push(rule);
+    });
+
+    axiomsJSON.forEach((axiomJSON) => {
+      const json = axiomJSON,  ///
+            axiom = Axiom.fromJSON(json, fileContext);
+
+      this.axioms.push(axiom);
+    });
+
+    lemmasJSON.forEach((lemmaJSON) => {
+      const json = lemmaJSON,  ///
+            lemma = Lemma.fromJSON(json, fileContext);
+
+      this.lemmas.push(lemma);
+    });
+
+    theoremsJSON.forEach((theoremJSON) => {
+      const json = theoremJSON,  ///
+            theorem = Theorem.fromJSON(json, fileContext);
+
+      this.theorems.push(theorem);
+    });
+
+    variablesJSON.forEach((variableJSON) => {
+      const json = variableJSON,  ///
+            variable = Variable.fromJSON(json, fileContext);
+
+      this.variables.push(variable);
+    });
+
+    metaLemmasJSON.forEach((metaLemmaJSON) => {
+      const json = metaLemmaJSON,  ///
+            metaLemma = MetaLemma.fromJSON(json, fileContext);
+
+      this.metaLemmas.push(metaLemma);
+    });
+
+    conjecturesJSON.forEach((conjectureJSON) => {
+      const json = conjectureJSON,  ///
+            conjecture = Conjecture.fromJSON(json, fileContext);
+
+      this.conjectures.push(conjecture);
+    });
+
+    combinatorsJSON.forEach((combinatorJSON) => {
+      const json = combinatorJSON,  ///
+            combinator = Combinator.fromJSON(json, fileContext);
+
+      this.combinators.push(combinator);
+    });
+
+    constructorsJSON.forEach((constructorJSON) => {
+      const json = constructorJSON,  ///
+            constructor = Constructor.fromJSON(json, fileContext);
+
+      this.constructors.push(constructor);
+    });
+
+    metatheoremsJSON.forEach((metatheoremJSON) => {
+      const json = metatheoremJSON,  ///
+            metatheorem = Metatheorem.fromJSON(json, fileContext);
+
+      this.metatheorems.push(metatheorem);
+    });
+
+    metavariablesJSON.forEach((metavariableJSON) => {
+      const json = metavariableJSON,  ///
+            metavariable = Metavariable.fromJSON(json, fileContext);
+
+      this.metavariables.push(metavariable);
+    });
+  }
+
   static fromFileAndReleaseContext(file, releaseContext) {
     const fileContent = file.getContent(),
           filePath = file.getPath(),

package/src/context/local.js

@@ -88,8 +88,6 @@ class LocalContext {
     return lastProofStep;
   }
 
-  getTokens() { return this.context.getTokens(); }
-
   getAxioms() { return this.context.getAxioms(); }
 
   getLemmas() { return this.context.getLemmas(); }
@@ -377,29 +375,29 @@ class LocalContext {
     return metavariable;
   }
 
-  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
-
-  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
+  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetaTypeByMetaTypeNode(metaTypeNode) { return this.context.findMetaTypeByMetaTypeNode(metaTypeNode); }
+  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+
+  findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-  findRuleByMetavariableNode(metavariableNode) { return this.context.findRuleByMetavariableNode(metavariableNode); }
+  findTypeByTypeNode(typeNode) { return this.context.findTypeByTypeNode(typeNode); }
 
-  findAxiomByMetavariableNode(metavariableNode) { return this.context.findAxiomByMetavariableNode(metavariableNode); }
+  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
 
-  findLemmaByMetavariableNode(metavariableNode) { return this.context.findLemmaByMetavariableNode(metavariableNode); }
+  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
 
-  findTheoremByMetavariableNode(metavariableNode) { return this.context.findTheoremByMetavariableNode(metavariableNode); }
+  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
 
-  findMetaLemmaByMetavariableNode(metavariableNode) { return this.context.findMetaLemmaByMetavariableNode(metavariableNode); }
+  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
 
-  findConjectureByMetavariableNode(metavariableNode) { return this.context.findConjectureByMetavariableNode(metavariableNode); }
+  findMetaLemmaByReference(reference) { return this.context.findMetaLemmaByReference(reference); }
 
-  findMetatheoremByMetavariableNode(metavariableNode) { return this.context.findMetatheoremByMetavariableNode(metavariableNode); }
+  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
+  findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
 
   nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -415,8 +413,6 @@ class LocalContext {
 
   error(message, node) { this.context.error(message, node); }
 
-  fatal(message, node) { this.context.fatal(node, message); }
-
   static fromFileContext(fileContext) {
     const context = fileContext,  ///
           variables = [],

package/src/context/release.js

@@ -10,8 +10,8 @@ import { tail, push, leftDifference } from "../utilities/array";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { isFilePathFlorenceFilePath } = filePathUtilities,
-      { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
-      { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
   constructor(log, name, entries, released, lexer, parser, verified, initialised, fileContexts, customGrammar, loggingDisabled, dependencyReleaseContexts) {
@@ -456,61 +456,44 @@ export default class ReleaseContext {
     this.log.error(message, node, tokens, filePath);
   }
 
-  fatal(message, node = null, tokens = null, filePath = null) {
-    if (this.loggingDisabled) {
-      return;
-    }
-
-    this.log.fatal(message, node, tokens, filePath);
-  }
-
-  initialise(releaseContexts, verbose) {
-    let initialised;
-
+  initialise(releaseContexts) {
     const combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
-          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar),
-          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+          nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar),
+          nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.lexer = florenceLexer; ///
+    this.lexer = nominalLexer; ///
 
-    this.parser = florenceParser; ///
+    this.parser = nominalParser; ///
 
     this.dependencyReleaseContexts = tail(releaseContexts);
 
     if (this.released) {
-      const verified = this.verify(verbose);
+      const releaseContext = this,  ///
+            fileContexts = fileContextsFromEntries(this.entries, releaseContext);
 
-      initialised = verified;  ///
-    } else {
-      initialised = true;
-    }
+      initialiseFileContexts(fileContexts, releaseContext);
 
-    this.initialised = initialised;
+      this.fileContexts = fileContexts;
+    }
 
-    return initialised;
+    this.initialised = true;
   }
 
-  verify(verbose = true) {
-    let verified;
+  verify() {
+    let verified = false;
 
-    const releaseContext = this;
+    const releaseContext = this,  ///
+          fileContexts = fileContextsFromEntries(this.entries, releaseContext),
+          fileContextsVerified = verifyFileContexts(fileContexts, releaseContext);
 
-    if (!verbose) {
-      releaseContext.disableLogging();
-    }
-
-    this.fileContexts = fileContextsFromEntries(this.entries, releaseContext);
-
-    const fileContextsVerified = verifyFileContexts(this.fileContexts, releaseContext);
+    if (fileContextsVerified) {
+      this.fileContexts = fileContexts;
 
-    verified = fileContextsVerified;  ///
+      this.verified = true;
 
-    if (!verbose) {
-      releaseContext.enableLogging();
+      verified = true;
     }
 
-    this.verified = verified;
-
     return verified;
   }
 
@@ -583,6 +566,41 @@ function verifyFileContexts(fileContexts, releaseContext) {
   return fileContextsVerified;
 }
 
+function initialiseFileContexts(fileContexts, releaseContext) {
+  fileContexts = [  ///
+    ...fileContexts
+  ];
+
+  for (;;) {
+    const fileContextsLength = fileContexts.length;
+
+    if (fileContextsLength === 0) {
+      break;
+    }
+
+    const initialisedFileContexts = [];
+
+    fileContexts.forEach((fileContext) => {
+      const initialised = fileContext.initialise(releaseContext);
+
+      if (initialised) {
+        const initialisedFileContext = fileContext;  ///
+
+        initialisedFileContexts.push(initialisedFileContext);
+      }
+    });
+
+    const initialisedFileContextsLength = initialisedFileContexts.length,
+          fileInitialised = (initialisedFileContextsLength > 0);
+
+    if (!fileInitialised) {
+      break;
+    }
+
+    leftDifference(fileContexts, initialisedFileContexts);
+  }
+}
+
 function fileContextsFromEntries(entries, releaseContext) {
   const fileContexts = [];