occam-verify-cli 0.0.940 → 0.0.942

package/src/verify/conjecture.js

@@ -4,6 +4,7 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -43,10 +44,12 @@ export default function verifyConjecture(conjectureNode, fileContext) {
               consequent = firstConsequent; ///
 
         if (proofNode !== null) {
-          verifyProof(proofNode, consequent, localContext);
+          const substitutions = Substitutions.fromNothing();
+
+          verifyProof(proofNode, consequent, substitutions, localContext);
         }
 
-        const substitutions = [],
+        const substitutions = Substitutions.fromNothing(),
               conjecture = Conjecture.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
         fileContext.addConjecture(conjecture);

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/lemma.js

@@ -4,6 +4,7 @@ import Lemma from "../lemma";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,11 +46,11 @@ export default function verifyLemma(lemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 lemma = Lemma.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addLemma(lemma);

package/src/verify/metaLemma.js

@@ -4,6 +4,7 @@ import MetaLemma from "../metaLemma";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -45,7 +46,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {

package/src/verify/metatheorem.js

@@ -4,6 +4,7 @@ import verifyProof from "../verify/proof";
 import Metatheorem from "../metatheorem";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -41,7 +42,7 @@ export default function verifyMetatheorem(metatheoremNode, fileContext) {
         const proofNode = proofNodeQuery(metatheoremNode),
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               statementNode = consequent.getStatementNode(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 

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/rule.js

@@ -9,6 +9,7 @@ import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
+import Substitutions from "../substitutions";
 
 const proofNodeQuery = nodeQuery("/rule/proof!"),
       labelNodesQuery = nodesQuery("/rule/label"),
@@ -45,7 +46,7 @@ export default function verifyRule(ruleNode, fileContext) {
               conclusion = firstConclusion; ///
 
         if (proofNode !== null) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 statementNode = conclusion.getStatementNode();
 
           proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);

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/theorem.js

@@ -4,6 +4,7 @@ import Theorem from "../theorem";
 import verifyProof from "../verify/proof";
 import verifyLabels from "../verify/labels";
 import LocalContext from "../context/local";
+import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
 import verifySuppositions from "../verify/suppositions";
 
@@ -42,11 +43,11 @@ export default function verifyTheorem(theoremNode, fileContext) {
               firstConsequent = first(consequents),
               consequent = firstConsequent, ///
               statementNode = consequent.getStatementNode(),
-              substitutions = [],
+              substitutions = Substitutions.fromNothing(),
               proofVerified = verifyProof(proofNode, statementNode, substitutions, localContext);
 
         if (proofVerified) {
-          const substitutions = [],
+          const substitutions = Substitutions.fromNothing(),
                 theorem = Theorem.fromLabelsSuppositionsConsequentSubstitutionsAndFileContext(labels, suppositions, consequent, substitutions, fileContext);
 
           fileContext.addTheorem(theorem);

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;
 }