occam-verify-cli 0.0.678 → 0.0.680

package/src/verify/term.js

@@ -1,222 +1,165 @@
 "use strict";
 
-import Verifier from "../verifier";
+import termNodesVerifier from "../verifier/nodes/term";
 
 import { first } from "../utilities/array";
-import { objectType } from "../type";
-import { OBJECT_TYPE_NAME } from "../typeNames";
-import { ARGUMENT_RULE_NAME } from "../ruleNames";
-import { nodeQuery, typeNameFromTypeNode, variableNameFromVariableNode } from "../utilities/query";
+import { nodeQuery, variableNameFromVariableNode } from "../utilities/query";
 
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      variableNodeQuery = nodeQuery("/term/variable!");
+const variableNodeQuery = nodeQuery("/term/variable!");
 
-class TermVerifier extends Verifier {
-  verifyTerminalNode(terminalNode, constructorTerminalNode, context) {
-    let terminalNodeVerified = false;
+function verifyTerm(termNode, types, context, verifyAhead) {
+  let termVerified;
 
-    const matches = terminalNode.match(constructorTerminalNode);
-
-    if (matches) {
-      terminalNodeVerified = true;
-    }
-
-    return terminalNodeVerified;
-  }
-
-  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context) {
-    let nonTerminalNodeVerified = false;
-
-    const ruleName = nonTerminalNode.getRuleName(), ///
-          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
-
-    if (ruleName === constructorRuleName) {
-      switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = constructorNonTerminalNode, ///
-                argumentNodeVerified = this.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
-
-          nonTerminalNodeVerified = argumentNodeVerified; ///
+  const termString = context.nodeAsString(termNode);
 
-          break;
-        }
+  context.trace(`Verifying the '${termString}' term...`, termNode);
 
-        default: {
-          const childNodes = nonTerminalNode.getChildNodes(),
-                constructorChildNodes = constructorNonTerminalNode.getChildNodes(),
-                nodes = childNodes, ///
-                constructorNodes = constructorChildNodes, ///
-                nodesVerified = this.verifyNodes(nodes, constructorNodes, context);
+  const verifyTermFunctions = [
+    verifyTermAsStandaloneVariable,
+    verifyTermAgainstConstructors
+  ];
 
-          nonTerminalNodeVerified = nodesVerified; ///
+  termVerified = verifyTermFunctions.some((verifyTermFunction) => {
+    const termVerified = verifyTermFunction(termNode, types, context, verifyAhead);
 
-          break;
-        }
-      }
+    if (termVerified) {
+      return true;
     }
+  });
 
-    return nonTerminalNodeVerified;
+  if (termVerified) {
+    context.debug(`...verified the '${termString}' term.`, termNode);
   }
 
-  verifyArgumentNode(argumentNode, constructorArgumentNode, context) {
-    let argumentNodeVerified = false;
+  return termVerified;
+}
 
-    const typeNode = typeNodeQuery(argumentNode);
+Object.assign(termNodesVerifier, {
+  verifyTerm
+});
 
-    if (typeNode !== null) {
-      const argumentString = context.nodeAsString(argumentNode);
+export default verifyTerm;
 
-      context.error(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
-    } else {
-      const termNode = termNodeQuery(argumentNode),
-            constructorTermNode = termNodeQuery(constructorArgumentNode),
-            constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+export function verifyTermAgainstConstructors(termNode, types, context, verifyAhead) {
+  let termVerifiedAgainstConstructors;
 
-      if (false) {
-        ///
-      } else if (constructorTermNode !== null) {
-        const node = termNode,  ///
-              constructorNode = constructorTermNode,  ///
-              nodeVerified = this.verifyNode(node, constructorNode, context);
+  const constructors = context.getConstructors();
 
-        argumentNodeVerified = nodeVerified;  ///
-      } else if (constructorTypeNode !== null) {
-        const types = [],
-              termVerified = verifyTerm(termNode, types, context);
+  termVerifiedAgainstConstructors = constructors.some((constructor) => {
+    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead);
 
-        if (termVerified) {
-          const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
-                firstType = first(types),
-                termType = firstType, ///
-                termTypeName = termType.getName(),
-                constructorType = (constructorTypeName === OBJECT_TYPE_NAME) ?
-                                    objectType :
-                                      context.findTypeByTypeName(constructorTypeName),
-                termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+    if (termVerifiedAgainstConstructor) {
+      return true;
+    }
+  });
 
-          if (termTypeEqualToOrSubTypeOfType) {
-            const termString = context.nodeAsString(termNode);
+  return termVerifiedAgainstConstructors;
+}
 
-            context.trace(`The '${termTypeName}' type of the '${termString}' term is equal to or a sub-type of the '${constructorTypeName}' type in the constructor.`, argumentNode);
+export function verifyTermAsVariable(termNode, variables, context, verifyAhead) {
+  let termVerifiedAsVariable = false;
 
-            argumentNodeVerified = true;
-          }
-        }
-      }
-    }
+  const variableNode = variableNodeQuery(termNode);
 
-    return argumentNodeVerified;
-  }
-}
+  if (variableNode !== null) {
+    const termString = context.nodeAsString(termNode);
 
-export const termVerifier = new TermVerifier();
+    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
-export default function verifyTerm(termNode, types, context) {
-  let termVerified = false;
+    const variableName = variableNameFromVariableNode(variableNode),
+          variablePresent = context.isVariablePresentByVariableName(variableName);
 
-  const termString = context.nodeAsString(termNode);
+    if (variablePresent) {
+      let verifiedAhead;
 
-  context.debug(`Verifying the '${termString}' term...`, termNode);
+      const variable = context.findVariableByVariableName(variableName);
 
-  if (!termVerified) {
-    const variables = [],
-          termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
+      variables.push(variable);
 
-    if (termVerifiedAsVariable) {
-      const firstVariable = first(variables),
-            variable = firstVariable, ///
-            type = variable.getType();
+      verifiedAhead = verifyAhead();
 
-      types.push(type);
+      if (!verifiedAhead) {
+        variables.pop();
+      }
 
-      termVerified = true;
+      termVerifiedAsVariable = verifiedAhead; ///
     }
-  }
-
-  if (!termVerified) {
-    const termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
 
-    if (termVerifiedAgainstConstructors) {
-      termVerified = true;
+    if (termVerifiedAsVariable) {
+      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
     }
   }
 
-  if (termVerified) {
-    const firstType = first(types),
-          type = firstType, ///
-          typeName = type.getName();
+  return termVerifiedAsVariable;
+}
 
-    context.debug(`Verified the '${termString}' term, which has type '${typeName}'.`, termNode);
-  }
+function verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead) {
+  let termVerifiedAgainstConstructor;
 
-  return termVerified;
-}
+  const termString = context.nodeAsString(termNode),
+        constructorString = constructor.getString();
 
-export function verifyTermAgainstConstructors(termNode, types, context) {
-  let termVerifiedAgainstConstructors = false;
+  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
-  const termString = context.nodeAsString(termNode);
+  const constructorTermNode = constructor.getTermNode(),
+        nonTerminalNNdeA = termNode,  ///
+        nonTerminalNodeB = constructorTermNode,  ///
+        nodeVerified = termNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
+          let verifiedAhead;
+
+          const type = constructor.getType();
 
-  context.trace(`Verifying the '${termString}' term against constructors...`, termNode);
+          types.push(type);
 
-  const constructors = context.getConstructors(),
-        constructor = constructors.find((constructor) => {
-          const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, constructor, context);
+          verifiedAhead = verifyAhead();
 
-          if (termVerifiedAgainstConstructor) {
-            return true;
+          if (!verifiedAhead) {
+            types.pop();
           }
-        }) || null;
 
-  if (constructor !== null) {
-    const type = constructor.getType();
+          return verifiedAhead;
+        });
 
-    types.push(type);
+  termVerifiedAgainstConstructor = nodeVerified;  ///
 
-    termVerifiedAgainstConstructors = true;
+  if (termVerifiedAgainstConstructor) {
+    context.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
   }
 
-  return termVerifiedAgainstConstructors;
+  return termVerifiedAgainstConstructor;
 }
 
-export function verifyTermAgainstConstructor(termNode, constructor, context) {
-  const termString = context.nodeAsString(termNode),
-        constructorString = constructor.getString();
+function verifyTermAsStandaloneVariable(termNode, types, context, verifyAhead) {
+  let termVerifiedAsStandaloneVariable;
 
-  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor.`, termNode);
-
-  const constructorTermNode = constructor.getTermNode(),
-        nonTerminalNNdeA = termNode,  ///
-        nonTerminalNodeB = constructorTermNode,  ///
-        nodeVerified = termVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context),
-        termVerifiedAgainstConstructor = nodeVerified;  ///
+  const termString = context.nodeAsString(termNode);
 
-  return termVerifiedAgainstConstructor;
-}
+  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
 
-export function verifyTermAsVariable(termNode, variables, context) {
-  let termVerifiedAsVariable = false;
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+          let verifiedAhead;
 
-  const termString = context.nodeAsString(termNode);
+          const firstVariable = first(variables),
+                variable = firstVariable, ///
+                type = variable.getType();
 
-  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+          types.push(type);
 
-  const variableNode = variableNodeQuery(termNode);
+          verifiedAhead = verifyAhead();
 
-  if (variableNode !== null) {
-    const variableName = variableNameFromVariableNode(variableNode),
-          variablePresent = context.isVariablePresentByVariableName(variableName);
+          if (!verifiedAhead) {
+            types.pop();
+          }
 
-    if (variablePresent) {
-      const variable = context.findVariableByVariableName(variableName);
+          return verifiedAhead;
+        });
 
-      variables.push(variable);
+  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
 
-      termVerifiedAsVariable = true;
-    }
+  if (termVerifiedAsStandaloneVariable) {
+    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
   }
 
-  return termVerifiedAsVariable;
+  return termVerifiedAsStandaloneVariable;
 }

package/src/verify/termAsConstructor.js

@@ -1,27 +1,28 @@
 "use strict";
 
-import verifyTerm from "../verify/term";
 import Constructor from "../constructor";
+import termAsConstructorNodeVerifier from "../verifier/node/termAsConstructor";
 
-import { first } from "../utilities/array";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../ruleNames";
-
-const typeNodeQuery = nodeQuery("/argument/type"),
-      termNodeQuery = nodeQuery("/argument/term");
+import { typeNameFromTypeNode } from "../utilities/query";
 
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
-  let type = null;
+  const termString = fileContext.nodeAsString(termNode);
+
+  fileContext.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
-  const nonTerminalNode = termNode,  ///
-        termString = fileContext.nodeAsString(termNode);
+  const nonTerminalNode = termNode, ///
+        childNodes = nonTerminalNode.getChildNodes(),
+        childNodesVerified = termAsConstructorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+          const verifiedAhead = true;
 
-  const childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, fileContext);
+          return verifiedAhead;
+        });
 
   if (childNodesVerified) {
+    let type = null;
+
     if (typeNode === null) {
       termVerifiedAsConstructor = true;
     } else {
@@ -32,137 +33,21 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.error(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
+        fileContext.debug(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
       }
     }
-  }
 
-  if (termVerifiedAsConstructor) {
-    const tokens = fileContext.getTokens(),
-          constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
+    if (termVerifiedAsConstructor) {
+      const tokens = fileContext.getTokens(),
+            constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
 
-    fileContext.addConstructor(constructor);
+      fileContext.addConstructor(constructor);
+    }
   }
 
   if (termVerifiedAsConstructor) {
-    fileContext.info(`Verified the '${termString}' constructor.`, termNode);
+    fileContext.debug(`...verified the '${termString}' term as a constructor.`, termNode);
   }
 
   return termVerifiedAsConstructor;
 }
-
-function verifyNode(node, fileContext) {
-  let nodeVerified;
-
-  const nodeTerminalNode = node.isTerminalNode();
-
-  if (nodeTerminalNode) {
-    const terminalNode = node,  ///
-          terminalNodeVerified = verifyTerminalNode(terminalNode, fileContext);
-
-    nodeVerified = terminalNodeVerified;  ///
-  } else {
-    const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = verifyNonTerminalNode(nonTerminalNode, fileContext);
-
-    nodeVerified = nonTerminalNodeVerified; ///
-  }
-
-  return nodeVerified;
-}
-
-function verifyChildNodes(childNodes, fileContext) {
-  const childNodesVerified = childNodes.every((childNode) => {
-    const node = childNode, ///
-          nodeVerified = verifyNode(node, fileContext);
-
-    if (nodeVerified) {
-      return true;
-    }
-  });
-
-  return childNodesVerified;
-}
-
-function verifyTerminalNode(terminalNode, fileContext) {
-  const terminalNodeVerified = true;
-
-  return terminalNodeVerified;
-}
-
-function verifyNonTerminalNode(nonTerminalNode, fileContext) {
-  let nonTerminalNodeVerified;
-
-  const ruleName = nonTerminalNode.getRuleName();
-
-  switch (ruleName) {
-    case ARGUMENT_RULE_NAME: {
-      const argumentNode = nonTerminalNode, ///
-            argumentNodeVerified = verifyArgumentNode(argumentNode, fileContext);
-
-      nonTerminalNodeVerified = argumentNodeVerified; ///
-
-      break;
-    }
-
-    case TERM_RULE_NAME: {
-      const termNode = nonTerminalNode, ///
-            types = [],
-            context = fileContext,  ///
-            termVerified = verifyTerm(termNode, types, context);
-
-      if (termVerified) {
-        const firstType = first(types),
-              type = firstType; ///
-
-        if (type !== null) {
-          const termString = fileContext.nodeAsString(termNode);
-
-          fileContext.error(`The type of the constructor's compound '${termString}' term node is not null.`, termNode);
-        } else {
-          nonTerminalNodeVerified = true; ///
-        }
-      }
-
-      break;
-    }
-
-    default: {
-      const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, fileContext);
-
-      nonTerminalNodeVerified = childNodesVerified; ///
-
-      break;
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyArgumentNode(argumentNode, fileContext) {
-  let argumentNodeVerified = false;
-
-  const typeNode = typeNodeQuery(argumentNode),
-        termNode = termNodeQuery(argumentNode);
-
-  if (false) {
-    ///
-  } else if (typeNode !== null) {
-    const typeName = typeNameFromTypeNode(typeNode),
-          typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-    if (!typePresent) {
-      fileContext.error(`The type '${typeName}' is not present.`, argumentNode);
-    }
-
-    argumentNodeVerified = typePresent; ///
-  } else if (termNode !== null) {
-    const node = termNode,  ///
-          nodeVerified = verifyNode(node, fileContext);
-
-    argumentNodeVerified = nodeVerified;  ///
-  }
-
-  return argumentNodeVerified;
-}

package/src/verify/terms.js

@@ -0,0 +1,54 @@
+"use strict";
+
+import verifyTerm from "../verify/term";
+
+import { first, second } from "../utilities/array";
+
+export default function verifyTerms(leftTermNode, rightTermNode, context, verifyAhead) {
+  let termsVerified;
+
+  const leftTermString = context.nodeAsString(leftTermNode),
+        rightTermString = context.nodeAsString(rightTermNode);
+
+  context.trace(`Verifying the '${leftTermString}' and '${rightTermString}' terms...`, leftTermNode);
+
+  const types = [],
+        leftTermVerified = verifyTerm(leftTermNode, types, context, () => {
+          let verifiedAhead;
+
+          const rightTermVerified = verifyTerm(rightTermNode, types, context, () => {
+            let verifiedAhead = false;
+
+            const firstType = first(types),
+                  secondType = second(types),
+                  leftType = firstType, ///
+                  rightType = secondType, ///
+                  leftTypeEqualToOrSubTypeOfOfSuperTypeOfRightType = leftType.isEqualToOrSubTypeOfOfSuperTypeOf(rightType);
+
+            if (!leftTypeEqualToOrSubTypeOfOfSuperTypeOfRightType) {
+              const leftTypeName = leftType.getName(),
+                    rightTypeName = rightType.getName(),
+                    leftTermString = context.nodeAsString(leftTermNode),
+                    rightTermString = context.nodeAsString(rightTermNode);
+
+              context.debug(`The left '${leftTermString}' term's '${leftTypeName}' type is not equal to, a sub-type of nor a super-type of the right '${rightTermString}' term's '${rightTypeName}' type.`, statementNode);
+            } else {
+              verifiedAhead = verifyAhead();
+            }
+
+            return verifiedAhead;
+          });
+
+          verifiedAhead = rightTermVerified;  ///
+
+          return verifiedAhead;
+        });
+
+  if (termsVerified) {
+    context.debug(`...verified the '${leftTermString}' and '${rightTermString}' terms.`, leftTermNode);
+  }
+
+  termsVerified = leftTermVerified; ///
+
+  return termsVerified
+}

package/src/verify/theorem.js

@@ -22,7 +22,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' theorem...`, theoremNode);
+  fileContext.trace(`Verifying the '${labelsString}' theorem...`, theoremNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -61,7 +61,7 @@ export default function verifyTheorem(theoremNode, fileContext) {
   }
 
   if (theoremVerified) {
-    fileContext.info(`Verified the '${labelsString}' theorem.`, theoremNode);
+    fileContext.debug(`...verified the '${labelsString}' theorem.`, theoremNode);
   }
 
   return theoremVerified;

package/src/verify/type.js

@@ -7,12 +7,15 @@ import { typeNameFromTypeNode } from "../utilities/query";
 export default function verifyType(typeNode, superTypeNode, fileContext) {
   let typeVerified = false;
 
+  const typeString = fileContext.nodeAsString(typeNode);
+
+  fileContext.trace(`Verifying the '${typeString}' type.`);
+
   const typeName = typeNameFromTypeNode(typeNode),
-        typeString = fileContext.nodeAsString(typeNode),
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    fileContext.error(`The type '${typeName}' is already present.`, typeNode);
+    fileContext.debug(`The type '${typeName}' is already present.`, typeNode);
   } else {
     let type;
 
@@ -24,7 +27,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
       const superType = fileContext.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        fileContext.error(`The super-type '${superTypeName}' is not present.`, typeNode);
+        fileContext.debug(`The super-type '${superTypeName}' is not present.`, typeNode);
       } else {
         type = Type.fromTypeNameAndSuperType(typeName, superType);
       }
@@ -38,7 +41,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
   }
 
   if (typeVerified) {
-    fileContext.info(`Verified the '${typeString}' type.`, typeNode);
+    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
   }
 
   return typeVerified;