occam-verify-cli 0.0.1011 → 0.0.1012

package/src/declaration/type.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import Type from "../type";
+
+export default class TypeDeclaration {
+  constructor(fileContext, type) {
+    this.fileContext = fileContext;
+    this.type = type;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getType() {
+    return this.type;
+  }
+
+  getString() { return this.type.getString(); }
+
+  verify() {
+    let verified = false;
+
+    const typeDeclarationString = this.getString(); ///
+
+    this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+
+    const typeVerified = this.type.verify(this.fileContext);
+
+    if (typeVerified) {
+      this.fileContext.addType(this.type);
+
+      verified = true;
+    }
+
+    if (verified) {
+      this.fileContext.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+    }
+
+    return verified;
+  }
+
+  static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
+    const type = Type.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
+          typeDeclaration = new TypeDeclaration(fileContext, type);
+
+    return typeDeclaration;
+  }
+}

package/src/error.js

@@ -0,0 +1,35 @@
+"use strict";
+
+export default class Error {
+  constructor(fileContext, string) {
+    this.fileContext = fileContext;
+    this.string = string;
+  }
+
+  getFileContext() {
+    return this.fileContext;
+  }
+
+  getString() {
+    return this.string;
+  }
+
+  verify(errorNode) {
+    let verified = false;
+
+    const errorString = this.string;  ///
+
+    this.fileContext.debug(`The '${errorString}' error cannot be verified.`, errorNode);
+
+    return verified;
+  }
+
+  static fromErrorNode(errorNode, fileContext) {
+    const node = errorNode, ///
+          string = fileContext.nodeAsString(node),
+          error = new Error(fileContext, string);
+
+    return error;
+  }
+}
+

package/src/rule.js

@@ -90,15 +90,15 @@ export default class Rule {
     return proofStepsUnified;
   }
 
-  verify(fileContext) {
+  verify() {
     let verified = false;
 
     const labelsString = labelsStringFromLabels(this.labels);
 
-    fileContext.trace(`Verifying the '${labelsString}' rule...`);
+    this.fileContext.trace(`Verifying the '${labelsString}' rule...`);
 
     const labelsVerified = this.labels.every((label) => {
-      const labelVVerified = label.verify(fileContext);
+      const labelVVerified = label.verify(this.fileContext);
 
       if (labelVVerified) {
         return true;
@@ -106,7 +106,7 @@ export default class Rule {
     });
 
     if (labelsVerified) {
-      const localContext = LocalContext.fromFileContext(fileContext),
+      const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);
 
@@ -130,7 +130,7 @@ export default class Rule {
           if (proofVerified) {
             const rule = this;  ///
 
-            fileContext.addRule(rule);
+            this.fileContext.addRule(rule);
 
             verified = true;
           }
@@ -139,7 +139,7 @@ export default class Rule {
     }
 
     if (verified) {
-      fileContext.debug(`...verified the '${labelsString}' rule.`);
+      this.fileContext.debug(`...verified the '${labelsString}' rule.`);
     }
 
     return verified;

package/src/ruleNames.js

@@ -3,3 +3,4 @@
 export const TERM_RULE_NAME = "term";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
+export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";

package/src/statement.js

@@ -75,18 +75,18 @@ class Statement {
     return unifiedWithMetaType;
   }
 
-  verifyAsCombinator(localContext) {
+  verifyAsCombinator(fileContext) {
     let verifiedAsCombinator;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    localContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
+    fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`);
 
-    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, localContext);
+    verifiedAsCombinator = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
     if (verifiedAsCombinator) {
-      localContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
+      fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
     }
 
     return verifiedAsCombinator;

package/src/term.js

@@ -1,16 +1,25 @@
 "use strict";
 
+import shim from "./shim";
+import termAsConstructorVerifier from "./verifier/termAsConstructor";
+
 import { filter } from "./utilities/array";
 import { nodesQuery } from "./utilities/query"
+import { termNodeFromTermString } from "./utilities/node";
 
 const variableNodesQuery = nodesQuery("//variable");
 
-export default class Term {
-  constructor(node, type) {
+class Term {
+  constructor(string, node, type) {
+    this.string = string;
     this.node = node;
     this.type = type;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getNode() {
     return this.node;
   }
@@ -81,10 +90,116 @@ export default class Term {
     return implicitlyGrounded;
   }
 
-  static fromTermNodeAndType(termNode, type) {
+  verify(localContext, verifyAhead) {
+    let verified = false;
+
+    debugger
+
+    return verified;
+  }
+
+  verifyType(fileContext) {
+    let typeVerified;
+
+    if (this.type === null) {
+      typeVerified = true;
+    } else {
+      const typeName = this.type.getName();
+
+      fileContext.trace(`Verifying the '${typeName}' type...`);
+
+      const type = fileContext.findTypeByTypeName(typeName);
+
+      if (type === null) {
+        fileContext.debug(`The '${typeName}' type is missing.`);
+      } else {
+        this.type = type; ///
+
+        typeVerified = true;
+      }
+
+      if (typeVerified) {
+        fileContext.debug(`...verified the '${typeName}' type.`);
+      }
+    }
+
+    return typeVerified;
+  }
+
+  verifyAsConstructor(fileContext) {
+    let verifiedAsConstructor;
+
+    const termNode = this.node,  ///
+          termString = this.string;  ///
+
+    fileContext.trace(`Verifying the '${termString}' term as a constructor...`);
+
+    verifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
+
+    if (verifiedAsConstructor) {
+      fileContext.debug(`...verified the '${termString}' term as a constructor.`, termNode);
+    }
+
+    return verifiedAsConstructor;
+  }
+
+  toJSON() {
+    const typeJSON = (this.type !== null) ?
+                       this.type.toJSON() :
+                         null,
+          string = this.string,
+          type = typeJSON,  ///
+          json = {
+            string,
+            type
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          termString = string,  ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          termNode = termNodeFromTermString(termString, lexer, parser),
+          node = termNode;
+
+    let { type } = json;
+
+    const typeJSON = type;  ///
+
+    json = typeJSON;  ///
+
+    type = (json !== null) ?
+            Type.fromJSON(json, fileContext) :
+              null;
+
+    const term = new Term(string, node, type);
+
+    return term;
+  }
+
+  static fromTermNode(termNode, fileContext) {
+    const node = termNode,  ///
+          string = fileContext.nodeAsString(node),
+          type = null,
+          term = new Term(string, node, type);
+
+    return term;
+  }
+
+  static fromTermNodeAndType(termNode, type, fileContext) {
     const node = termNode,  ///
-          term = new Term(node, type);
+          string = fileContext.nodeAsString(node),
+          term = new Term(string, node, type);
 
     return term;
   }
 }
+
+Object.assign(shim, {
+  Term
+});
+
+export default Term;

package/src/type.js

@@ -1,15 +1,25 @@
 "use strict";
 
-import { OBJECT_TYPE_NAME } from "./typeNames";
+import shim from "./shim";
 
+import { nodeQuery } from "./utilities/query";
+import { OBJECT_TYPE_NAME } from "./typeNames";
 import { typeNameFromTypeNode } from "./utilities/name";
 
-export default class Type {
-  constructor(name, superType) {
+const typeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
+      superTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
+
+class Type {
+  constructor(string, name, superType) {
+    this.string = string;
     this.name = name;
     this.superType = superType;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getName() {
     return this.name;
   }
@@ -111,36 +121,122 @@ export default class Type {
     return typeNodeMatches;
   }
 
-  asString(tokens, noSuperType = false) {
-    let string;
+  verify(fileContext) {
+    let verified = false;
 
-    if (noSuperType) {
-      string = `${this.name}`;
+    const typeString = this.string; ///
+
+    fileContext.trace(`Verifying the '${typeString}' type...`);
+
+    const typePresent = fileContext.isTypePresentByTypeName(this.name);
+
+    if (typePresent) {
+      fileContext.debug(`The type '${typeString}' is already present.`);
     } else {
-      const superTypeName = this.superType.getName();
+      if (this.superType === null) {
+        verified = true;
+      } else {
+        const name = this.superType.getName(),
+              superTypePresent = fileContext.isTypePresentByTypeName(name);
+
+        if (superTypePresent) {
+          verified = true;
+        } else {
+          const superTypeString = this.superType.getString();
+
+          fileContext.debug(`The super-type '${superTypeString}' is not present.`);
+        }
+      }
+    }
 
-      string = `${this.name}:${superTypeName}`;
+    if (verified) {
+      fileContext.debug(`...verified the '${typeString}' type.`);
     }
 
-    return string;
+    return verified;
+  }
+
+  toJSON() {
+    const superTypeJSON = (this.superType !== null) ?
+                            this.superType.toJSON() :
+                              null,
+          name = this.name,
+          superType = superTypeJSON,  ///
+          json = {
+            name,
+            superType
+          };
+
+    return json;
   }
 
-  static fromTypeName(typeName) {
-    const name = typeName,  ///
-          superType = objectType, ///
-          type = new Type(name, superType);
+  static fromJSON(json, fileContext) {
+    const { name } = json;
+
+    let { superType } = json;
+
+    const superTypeJSON = superType;  ///
+
+    json = superTypeJSON; ///
+
+    superType = (json !== null) ?
+                   Type.fromJSON(json, fileContext) :
+                      null;
+
+    const typeName = name,  ///
+          string = stringFromTypeNameAndSuperType(typeName, superType),
+          type = new Type(string, name, superType);
+
+    return type;
+  }
+
+  static fromTypeNode(typeNode) {
+    let type = null;
+
+    if (typeNode !== null) {
+      const typeName = typeNameFromTypeNode(typeNode),
+            name = typeName,  ///
+            string = name,  ///
+            superType = null;
+
+      type = new Type(string, name, superType);
+    }
 
     return type;
   }
 
-  static fromTypeNameAndSuperType(typeName, superType) {
-    const name = typeName,  ///
-          type = new Type(name, superType);
+  static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
+    const typeNode = typeNodeQuery(typeDeclarationNode),
+          superTypeNode = superTypeNodeQuery(typeDeclarationNode),
+          typeName = typeNameFromTypeNode(typeNode),
+          superType = Type.fromTypeNode(superTypeNode),
+          string = stringFromTypeNameAndSuperType(typeName, superType),
+          name = typeName,  ///
+          type = new Type(string, name, superType);
 
     return type;
   }
 }
 
+function stringFromTypeNameAndSuperType(typeName, superType) {
+  let string = typeName;  ///
+
+  if (superType !== null) {
+    const typeString = string,  ///
+          superTypeString = superType.getString();
+
+    string = `${typeString}:${superTypeString}`;
+  }
+
+  return string;
+}
+
+Object.assign(shim, {
+  Type
+});
+
+export default Type;
+
 class ObjectType extends Type {
   static fromNothing() {
     const name = OBJECT_TYPE_NAME,

package/src/utilities/node.js

@@ -6,21 +6,26 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { TERM_RULE_NAME,
          METAVARIABLE_RULE_NAME,
-         UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
-import { termTokensFromTermString,
-         metavariableTokensFromMetavariableString,
-         unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
+         UNQUALIFIED_STATEMENT_RULE_NAME,
+         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
+import { metavariableTokensFromMetavariableString,
+         unqualifiedStatementTokensFromUnqualifiedStatementString,
+         constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
 const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
+const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const termTokens = termTokensFromTermString(termString, lexer),
-        termNode = termNodeFromTermTokens(termTokens, parser);
+  const constructorDeclarationString = `Constructor ${termString}
+`,
+        constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer),
+        constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
+        termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
 
   return termNode;
 }
@@ -72,6 +77,14 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifi
   return unqualifiedStatementNode;
 }
 
+export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
+  const tokens = constructorDeclarationTokens,  ///
+        ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
+        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
+
+  return constructorDeclarationNode;
+}
+
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = nominalParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],

package/src/utilities/tokens.js

@@ -30,6 +30,13 @@ export function unqualifiedStatementTokensFromUnqualifiedStatementString(unquali
   return unqualifiedStatementTokens;
 }
 
+export function constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer) {
+  const content = constructorDeclarationString,  ///
+        constructorDeclarationTokens = tokensFromContentAndLexer(content, lexer);
+
+  return constructorDeclarationTokens;
+}
+
 function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);
 

package/src/verifier/termAsConstructor.js

@@ -2,7 +2,6 @@
 
 import shim from "../shim";
 import Verifier from "../verifier";
-import verifyType from "../verify/type";
 import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
@@ -31,10 +30,10 @@ class TermAsConstructorVerifier extends Verifier {
     {
       nodeQuery: termNodeQuery,
       verify: (termNode, fileContext, verifyAhead) => {
-        const { verifyTerm } = shim,
-              terms = [],
+        const { Term } = shim,
+              term = Term.fromTermNode(termNode, fileContext),
               localContext = LocalContext.fromFileContext(fileContext),
-              termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
+              termVerified = term.verify(localContext, verifyAhead);
 
         return termVerified;
       }
@@ -42,8 +41,10 @@ class TermAsConstructorVerifier extends Verifier {
     {
       nodeQuery: typeNodeQuery,
       verify: (typeNode, fileContext, verifyAhead) => {
-        const localContext = LocalContext.fromFileContext(fileContext),
-              typeVerified = verifyType(typeNode, localContext, verifyAhead);
+        const { Type } = shim,
+              type = Type.fromTypeNode(typeNode, fileContext),
+              localContext = LocalContext.fromFileContext(fileContext),
+              typeVerified = type.verify(localContext, verifyAhead);
 
         return typeVerified;
       }

package/src/verifier/topLevel.js

@@ -1,20 +1,20 @@
 "use strict";
 
 import Rule from "../rule";
+import Error from "../error";
+import TypeDeclaration from "../declaration/type";
 import CombinatorDeclaration from "../declaration/combinator";
+import ConstructorDeclaration from "../declaration/constructor";
 import MetavariableDeclaration from "../declaration/metavariable";
 
 import Verifier from "../verifier";
-import verifyError from "../verify/error";
 import verifyAxiom from "../verify/axiom";
 import verifyLemma from "../verify/lemma";
 import verifyTheorem from "../verify/theorem";
 import verifyMetaLemma from "../verify/metaLemma";
 import verifyConjecture from "../verify/conjecture";
 import verifyMetatheorem from "../verify/metatheorem";
-import verifyTypeDeclaration from "../verify/declaration/type";
 import verifyVariableDeclaration from "../verify/declaration/variable";
-import verifyConstructorDeclaration from "../verify/declaration/constructor";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -48,7 +48,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: errorNodeQuery,
       verify: (errorNode, fileContext) => {
-        const errorVerified = verifyError(errorNode, fileContext);
+        const error = Error.fromErrorNode(errorNode, fileContext),
+              errorVerified = error.verify();
 
         return errorVerified;
       }
@@ -57,7 +58,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: ruleNodeQuery,
       verify: (ruleNode, fileContext) => {
         const rule = Rule.fromRuleNode(ruleNode, fileContext),
-              ruleVerified = rule.verify(fileContext);
+              ruleVerified = rule.verify();
 
         return ruleVerified;
       }
@@ -113,7 +114,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: typeDeclarationNodeQuery,
       verify: (typeDeclarationNode, fileContext) => {
-        const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
+        const typeDeclaration = TypeDeclaration.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
+              typeDeclarationVerified = typeDeclaration.verify();
 
         return typeDeclarationVerified;
       }
@@ -130,7 +132,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: combinatorDeclarationNodeQuery,
       verify: (combinatorDeclarationNode, fileContext) => {
         const combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
-              combinatorDeclarationVerified = combinatorDeclaration.verify(fileContext);
+              combinatorDeclarationVerified = combinatorDeclaration.verify();
 
         return combinatorDeclarationVerified;
       }
@@ -138,7 +140,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: constructorDeclarationNodeQuery,
       verify: (constructorDeclarationNode, fileContext) => {
-        const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
+        const constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+              constructorDeclarationVerified = constructorDeclaration.verify();
 
         return constructorDeclarationVerified;
       }
@@ -147,7 +150,7 @@ class TopLevelVerifier extends Verifier {
       nodeQuery: metavariableDeclarationNodeQuery,
       verify: (metavariableDeclarationNode, fileContext) => {
         const metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
-              metavariableDeclarationVerified = metavariableDeclaration.verify(fileContext);
+              metavariableDeclarationVerified = metavariableDeclaration.verify();
 
         return metavariableDeclarationVerified;
       }

package/lib/tokens/combinatorFrame/bracketed.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _metaTypeNames = require("../../metaTypeNames");
-var _tokens = require("../../utilities/tokens");
-var bracketedCombinatorFrameString = "(".concat(_metaTypeNames.FRAME_META_TYPE_NAME, ")");
-var bracketedCombinatorFrameTokens = (0, _tokens.fromTokensFromFrameString)(bracketedCombinatorFrameString);
-var _default = bracketedCombinatorFrameTokens;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90b2tlbnMvY29tYmluYXRvckZyYW1lL2JyYWNrZXRlZC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHsgRlJBTUVfTUVUQV9UWVBFX05BTUUgfSBmcm9tIFwiLi4vLi4vbWV0YVR5cGVOYW1lc1wiO1xuaW1wb3J0IHsgZnJvbVRva2Vuc0Zyb21GcmFtZVN0cmluZyB9IGZyb20gXCIuLi8uLi91dGlsaXRpZXMvdG9rZW5zXCI7XG5cbmNvbnN0IGJyYWNrZXRlZENvbWJpbmF0b3JGcmFtZVN0cmluZyA9IGAoJHtGUkFNRV9NRVRBX1RZUEVfTkFNRX0pYDtcblxuY29uc3QgYnJhY2tldGVkQ29tYmluYXRvckZyYW1lVG9rZW5zID0gZnJvbVRva2Vuc0Zyb21GcmFtZVN0cmluZyhicmFja2V0ZWRDb21iaW5hdG9yRnJhbWVTdHJpbmcpXG5cbmV4cG9ydCBkZWZhdWx0IGJyYWNrZXRlZENvbWJpbmF0b3JGcmFtZVRva2VucztcbiJdLCJuYW1lcyI6WyJicmFja2V0ZWRDb21iaW5hdG9yRnJhbWVTdHJpbmciLCJGUkFNRV9NRVRBX1RZUEVfTkFNRSIsImJyYWNrZXRlZENvbWJpbmF0b3JGcmFtZVRva2VucyIsImZyb21Ub2tlbnNGcm9tRnJhbWVTdHJpbmciXSwibWFwcGluZ3MiOiJBQUFBOzs7OytCQVNBOzs7ZUFBQTs7OzZCQVBxQztzQkFDSztBQUUxQyxJQUFNQSxpQ0FBaUMsQUFBQyxJQUF3QixPQUFyQkMsbUNBQW9CLEVBQUM7QUFFaEUsSUFBTUMsaUNBQWlDQyxJQUFBQSxpQ0FBeUIsRUFBQ0g7SUFFakUsV0FBZUUifQ==