occam-verify-cli 0.0.939 → 0.0.941

package/src/verifier/topLevel.js

@@ -0,0 +1,160 @@
+"use strict";
+
+import Verifier from "../verifier";
+import verifyError from "../verify/error";
+import verifyRule from "../verify/rule";
+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 verifyCombinatorDeclaration from "../verify/declaration/combinator";
+import verifyConstructorDeclaration from "../verify/declaration/constructor";
+import verifyMetavariableDeclaration from "../verify/declaration/metavariable";
+
+import { nodeQuery } from "../utilities/query";
+
+const errorNodeQuery = nodeQuery("/error"),
+      ruleNodeQuery = nodeQuery("/rule!"),
+      axiomNodeQuery = nodeQuery("/axiom!"),
+      lemmaNodeQuery = nodeQuery("/lemma!"),
+      theoremNodeQuery = nodeQuery("/theorem!"),
+      metaLemmaNodeQuery = nodeQuery("/metaLemma!"),
+      conjectureNodeQuery = nodeQuery("/conjecture!"),
+      metatheoremNodeQuery = nodeQuery("/metatheorem!"),
+      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration!"),
+      variableDeclarationNodeQuery = nodeQuery("/variableDeclaration!"),
+      combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration!"),
+      constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration!"),
+      metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration!");
+
+class TopLevelVerifier extends Verifier {
+  verify(node, fileContext) {
+    let verified;
+
+    const nonTerminalNode = node, ///
+          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          });
+
+    verified = nonTerminalNodeVerified;  ///
+
+    return verified;
+  }
+
+  static maps = [
+    {
+      nodeQuery: errorNodeQuery,
+      verify: (errorNode, fileContext) => {
+        const errorVerified = verifyError(errorNode, fileContext);
+
+        return errorVerified;
+      }
+    },
+    {
+      nodeQuery: ruleNodeQuery,
+      verify: (ruleNode, fileContext) => {
+        const ruleVerified = verifyRule(ruleNode, fileContext);
+
+        return ruleVerified;
+      }
+    },
+    {
+      nodeQuery: axiomNodeQuery,
+      verify: (axiomNode, fileContext) => {
+        const axiomVerified = verifyAxiom(axiomNode, fileContext);
+
+        return axiomVerified;
+      }
+    },
+    {
+      nodeQuery: lemmaNodeQuery,
+      verify: (lemmaNode, fileContext) => {
+        const lemmaVerified = verifyLemma(lemmaNode, fileContext);
+
+        return lemmaVerified;
+      }
+    },
+    {
+      nodeQuery: theoremNodeQuery,
+      verify: (theoremNode, fileContext) => {
+        const theoremVerified = verifyTheorem(theoremNode, fileContext);
+
+        return theoremVerified;
+      }
+    },
+    {
+      nodeQuery: metaLemmaNodeQuery,
+      verify: (metaLemmaNode, fileContext) => {
+        const metaLemmaVerified = verifyMetaLemma(metaLemmaNode, fileContext);
+
+        return metaLemmaVerified;
+      }
+    },
+    {
+      nodeQuery: conjectureNodeQuery,
+      verify: (conjectureNode, fileContext) => {
+        const conjectureVerified = verifyConjecture(conjectureNode, fileContext);
+
+        return conjectureVerified;
+      }
+    },
+    {
+      nodeQuery: metatheoremNodeQuery,
+      verify: (metatheoremNode, fileContext) => {
+        const metatheoremVerified = verifyMetatheorem(metatheoremNode, fileContext);
+
+        return metatheoremVerified;
+      }
+    },
+    {
+      nodeQuery: typeDeclarationNodeQuery,
+      verify: (typeDeclarationNode, fileContext) => {
+        const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
+
+        return typeDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: variableDeclarationNodeQuery,
+      verify: (variableDeclarationNode, fileContext) => {
+        const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, fileContext);
+
+        return variableDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: combinatorDeclarationNodeQuery,
+      verify: (combinatorDeclarationNode, fileContext) => {
+        const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext);
+
+        return combinatorDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: constructorDeclarationNodeQuery,
+      verify: (constructorDeclarationNode, fileContext) => {
+        const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
+
+        return constructorDeclarationVerified;
+      }
+    },
+    {
+      nodeQuery: metavariableDeclarationNodeQuery,
+      verify: (metavariableDeclarationNode, fileContext) => {
+        const metavariableDeclarationVerified = verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext);
+
+        return metavariableDeclarationVerified;
+      }
+    }
+  ];
+}
+
+const topLevelVerifier = new TopLevelVerifier();
+
+export default topLevelVerifier;

package/src/verify/declaration/metavariable.js

@@ -1,10 +1,16 @@
 "use strict";
 
-import verifyMetavariable from "../../verify/metavariable";
+import Metavariable from "../../metavariable";
+import MetavariableAssignment from "../../assignment/metavariable";
 
+import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
+import { nameFromMetavariableNode } from "../../utilities/name";
 
-const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
+const termNodeQuery = nodeQuery("/argument/term"),
+      typeNodeQuery = nodeQuery("/argument/type"),
+      argumentNodeQuery = nodeQuery("/metavariable/argument!"),
+      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable");
 
 export default function verifyMetavariableDeclaration(metavariableDeclarationNode, fileContext) {
@@ -27,3 +33,107 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
 
   return metavariableDeclarationVerified;
 }
+
+function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
+  let metavariableVerified = false;
+
+  const metavariableString = fileContext.nodeAsString(metavariableNode);
+
+  fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+
+  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+
+  if (metavariablePresent) {
+    fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
+  } else {
+    const termTypes = [],
+      metaTypes = [],
+      argumentNode = argumentNodeQuery(metavariableNode),
+      argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
+      metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
+
+    if (argumentVerified && metaTypeVerified) {
+      let termType,
+        metaType;
+
+      const firstMetaType = first(metaTypes);
+
+      metaType = firstMetaType; ///
+
+      const termTypesLength = termTypes.length;
+
+      if (termTypesLength === 0) {
+        termType = null;
+      } else {
+        const firstTermType = first(termTypes);
+
+        termType = firstTermType; ///
+      }
+
+      const node = metavariableNode,  ///
+        name = nameFromMetavariableNode(metavariableNode),
+        metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
+        metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
+        metavariableAssigned = metavariableAssignment.assign(fileContext);
+
+      if (metavariableAssigned) {
+        metavariableVerified = true;
+      }
+    }
+  }
+
+  if (metavariableVerified) {
+    fileContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+  }
+
+  return metavariableVerified;
+}
+
+function verifyArgument(argumentNode, termTypes, fileContext) {
+  let argumentVerified = false;
+
+  if (argumentNode === null) {
+    argumentVerified = true;
+  } else {
+    const termNode = termNodeQuery(argumentNode);
+
+    if (termNode === null) {
+
+    } else {
+      const termString = fileContext.nodeAsString(termNode);
+
+      fileContext.debug(`The '${termString}' term was found when a type should have been present.`, termNode);
+    }
+    const typeNode = typeNodeQuery(argumentNode);
+
+    if (typeNode !== null) {
+      const type = fileContext.findTypeByTypeNode(typeNode);
+
+      if (type !== null) {
+        const termType = type;  ///
+
+        termTypes.push(termType);
+
+        argumentVerified = true;
+      } else {
+        const typeString = fileContext.nodeAsString(typeNode);
+
+        fileContext.debug(`The '${typeString}' type is not present.`, typeNode);
+      }
+    }
+  }
+
+  return argumentVerified;
+}
+
+function verifyMetaType(metaTypeNode, metaTypes, fileContext) {
+  let metaTypeVerified;
+
+  const metaType = fileContext.findMetaTypeByMetaTypeNode(metaTypeNode);
+
+  metaTypes.push(metaType);
+
+  metaTypeVerified = true;
+
+  return metaTypeVerified;
+}

package/src/verify/declaration/type.js

@@ -1,9 +1,10 @@
 "use strict";
 
-import verifyType from "../../verify/type";
+import Type from "../../type";
 
 import { nodeQuery } from "../../utilities/query";
 import { EMPTY_STRING } from "../../constants";
+import { typeNameFromTypeNode } from "../../utilities/name";
 
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
@@ -34,3 +35,49 @@ export default function verifyTypeDeclaration(typeDeclarationNode, fileContext)
 
   return typeDeclarationVerified;
 }
+
+function verifyType(typeNode, superTypeNode, fileContext) {
+  let typeVerified = false;
+
+  const typeString = fileContext.nodeAsString(typeNode);
+
+  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
+
+  const typePresent = fileContext.isTypePresentByTypeNode(typeNode);
+
+  if (typePresent) {
+    const typeString = fileContext.nodeAsString(typeNode);
+
+    fileContext.debug(`The type '${typeString}' is already present.`, typeNode);
+  } else {
+    let type;
+
+    const typeName = typeNameFromTypeNode(typeNode);
+
+    if (superTypeNode === null) {
+      type = Type.fromTypeName(typeName);
+    } else {
+      const superType = fileContext.findTypeByTypeNode(superTypeNode);
+
+      if (superType === null) {
+        const superTypeString = fileContext.nodeAsString(superTypeNode);
+
+        fileContext.debug(`The super-type '${superTypeString}' is not present.`, typeNode);
+      } else {
+        type = Type.fromTypeNameAndSuperType(typeName, superType);
+      }
+    }
+
+    if (type !== null) {
+      fileContext.addType(type);
+
+      typeVerified = true;
+    }
+  }
+
+  if (typeVerified) {
+    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
+  }
+
+  return typeVerified;
+}

package/src/verify/declaration/variable.js

@@ -1,8 +1,10 @@
 "use strict";
 
-import verifyVariable from "../../verify/variable";
+import Variable from "../../variable";
+import VariableAssignment from "../../assignment/variable";
 
 import { nodeQuery } from "../../utilities/query";
+import { objectType } from "../../type";
 import { EMPTY_STRING } from "../../constants";
 
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
@@ -32,3 +34,50 @@ export default function verifyVariableDeclaration(variableDeclarationNode, fileC
 
   return variableDeclarationVerified;
 }
+
+function verifyVariable(variableNode, typeNode, fileContext) {
+  let variableVerified = false;
+
+  const variableString = fileContext.nodeAsString(variableNode);
+
+  fileContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
+
+  const variablePresent = fileContext.isVariablePresentByVariableNode(variableNode);
+
+  if (variablePresent) {
+    fileContext.debug(`The variable '${variableString}' is already present.`, variableNode);
+  } else {
+    let variable;
+
+    if (typeNode === null) {
+      const type = objectType;
+
+      variable = Variable.fromVariableNodeAndType(variableNode, type);
+    } else {
+      const type = fileContext.findTypeByTypeNode(typeNode);
+
+      if (type === null) {
+        const typeString = fileContext.nodeAsString(typeNode);
+
+        fileContext.debug(`The '${variableString}' variable's '${typeString}' type is not present.`, variableNode);
+      } else {
+        variable = Variable.fromVariableNodeAndType(variableNode, type);
+      }
+    }
+
+    if (variable !== null) {
+      const variableAssignment = VariableAssignment.fromVariable(variable),
+            variableAssigned = variableAssignment.assign(fileContext);
+
+      if (variableAssigned) {
+        variableVerified = true;
+      }
+    }
+  }
+
+  if (variableVerified) {
+    fileContext.debug(`...verified the '${variableString}' variable.`, variableNode);
+  }
+
+  return variableVerified;
+}

package/src/verify/error.js

@@ -0,0 +1,11 @@
+"use strict";
+
+export default function verifyError(errorNode, fileContext) {
+  let errorVerified = false;
+
+  const errorString = fileContext.nodeAsString(errorNode)
+
+  fileContext.debug(`The '${errorString}' cannot be verified.`, errorNode);
+
+  return errorVerified;
+}

package/src/verify/file.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import FileContext from "../context/file";
-import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
-
-import { nodesQuery } from "../utilities/query";
-
-const errorNodesQuery = nodesQuery("/document/error"),
-      topLevelDeclarationNodesQuery = nodesQuery("/document/topLevelDeclaration");
+import topLevelVerifier from "../verifier/topLevel";
 
 export default function verifyFile(filePath, releaseContext) {
   let fileVerified = false;
@@ -16,29 +11,13 @@ export default function verifyFile(filePath, releaseContext) {
   const fileContext = FileContext.fromFilePathAndReleaseContext(filePath, releaseContext),
         node = fileContext.getNode();
 
-  if (node === null) {
-    fileVerified = true;
-  } else {
-    const errorNodes = errorNodesQuery(node),
-          errorNodesLength = errorNodes.length;
-
-    if (errorNodesLength > 0) {
-      releaseContext.warning(`The '${filePath}' file cannot be verified because it contains errors.`);
-    } else {
-      const topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
-            topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
-              const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext);
-
-              if (topLevelDeclarationVerified) {
-                return true;
-              }
-            });
-
-      if (topLevelDeclarationsVerified) {
-        releaseContext.addFileContext(fileContext);
-
-        fileVerified = true;
-      }
+  if (node !== null) {
+    const verified = topLevelVerifier.verify(node, fileContext);
+
+    if (verified) {
+      releaseContext.addFileContext(fileContext);
+
+      fileVerified = true;
     }
   }
 

package/src/verify/metavariable.js

@@ -66,28 +66,6 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
   return metavariableVerified;
 }
 
-export function verifyStandaloneMetavariable(metavariableNode, localContext, verifyAhead) {
-  let standaloneMetavariableVerified = false;
-
-  const metavariableString = localContext.nodeAsString(metavariableNode);
-
-  localContext.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
-
-  const metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode);
-
-  if (metavariablePresent) {
-    const verifiedAhead = verifyAhead();
-
-    standaloneMetavariableVerified = verifiedAhead; ///
-  }
-
-  if (standaloneMetavariableVerified) {
-    localContext.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
-  }
-
-  return standaloneMetavariableVerified;
-}
-
 function verifyArgument(argumentNode, termTypes, fileContext) {
   let argumentVerified = false;
 

package/src/verify/statement.js

@@ -54,35 +54,10 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
   return statementVerified;
 }
 
-export function verifyStandaloneStatement(statementNode, localContext, verifyAhead) {
-  let standaloneStatementVerified = false;
-
-  const statementString = localContext.nodeAsString(statementNode);
-
-  localContext.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
-
-  const derived = false,
-        assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
-
-  if (statementVerified) {
-    const verifiedAhead = verifyAhead();
-
-    standaloneStatementVerified = verifiedAhead; ///
-  }
-
-  if (standaloneStatementVerified) {
-    localContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
-  }
-
-  return standaloneStatementVerified;
-}
-
 Object.assign(shim, {
   verifyStatement
 });
 
-
 export default verifyStatement;
 
 function verifyStatementAsMetavariable(statementNode, assignments, derived, localContext) {

package/src/verify/term.js

@@ -39,25 +39,6 @@ function verifyTerm(termNode, terms, localContext, verifyAhead) {
   return termVerified;
 }
 
-export function verifyStandaloneTerm(termNode, localContext, verifyAhead) {
-  let standaloneTermVerified;
-
-  const termString = localContext.nodeAsString(termNode);
-
-  localContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
-
-  const terms = [],
-        termVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
-
-  standaloneTermVerified = termVerified;  ///
-
-  if (standaloneTermVerified) {
-    localContext.debug(`...verified the '${termString}' standalone term.`, termNode);
-  }
-
-  return standaloneTermVerified;
-}
-
 Object.assign(shim, {
   verifyTerm
 });

package/src/verify/type.js

@@ -1,73 +1,23 @@
 "use strict";
 
-import Type from "../type";
-
-import { typeNameFromTypeNode } from "../utilities/name";
-
-export default function verifyType(typeNode, superTypeNode, fileContext) {
+export default function verifyType(typeNode, localContext, verifyAhead) {
   let typeVerified = false;
 
-  const typeString = fileContext.nodeAsString(typeNode);
-
-  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
-
-  const typePresent = fileContext.isTypePresentByTypeNode(typeNode);
-
-  if (typePresent) {
-    const typeString = fileContext.nodeAsString(typeNode);
-
-    fileContext.debug(`The type '${typeString}' is already present.`, typeNode);
-  } else {
-    let type;
-
-    const typeName = typeNameFromTypeNode(typeNode);
-
-    if (superTypeNode === null) {
-      type = Type.fromTypeName(typeName);
-    } else {
-      const superType = fileContext.findTypeByTypeNode(superTypeNode);
-
-      if (superType === null) {
-        const superTypeString = fileContext.nodeAsString(superTypeNode);
-
-        fileContext.debug(`The super-type '${superTypeString}' is not present.`, typeNode);
-      } else {
-        type = Type.fromTypeNameAndSuperType(typeName, superType);
-      }
-    }
-
-    if (type !== null) {
-      fileContext.addType(type);
-
-      typeVerified = true;
-    }
-  }
-
-  if (typeVerified) {
-    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
-  }
-
-  return typeVerified;
-}
-
-export function verifyStandaloneType(typeNode, localContext, verifyAhead) {
-  let standaloneTypeVerified = false;
-
   const typeString = localContext.nodeAsString(typeNode);
 
-  localContext.trace(`Verifying the '${typeString}' standalone type...`, typeNode);
+  localContext.trace(`Verifying the '${typeString}' type...`, typeNode);
 
   const typePresent = localContext.isTypePresentByTypeNode(typeNode);
 
   if (typePresent) {
     const verifiedAhead = verifyAhead();
 
-    standaloneTypeVerified = verifiedAhead; ///
+    typeVerified = verifiedAhead; ///
   }
 
-  if (standaloneTypeVerified) {
-    localContext.debug(`...verified the '${typeString}' standalone type.`, typeNode);
+  if (typeVerified) {
+    localContext.debug(`...verified the '${typeString}' type.`, typeNode);
   }
 
-  return standaloneTypeVerified;
+  return typeVerified;
 }