occam-verify-cli 0.0.677 → 0.0.679

package/src/verify/statement.js

@@ -1,189 +1,58 @@
 "use strict";
 
-import Verifier from "../verifier";
 import Equality from "../equality";
 import verifyTerm from "../verify/term";
 import equalityCombinator from "../ocmbinator/equality";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeInference from "../verify/typeInference";
 import verifyTypeAssertion from "../verify/assertion/type";
+import statementNodesVerifier from "../verifier/nodes/statement";
 
-import { objectType } from "../type";
-import { termVerifier } from "../verify/term";
+import { nodeQuery } from "../utilities/query";
 import { first, second } from "../utilities/array";
-import { OBJECT_TYPE_NAME } from "../typeNames";
-import { STATEMENT_META_TYPE } from "../metaTypes";
-import { verifyTermAsVariable } from "../verify/term";
-import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
-import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
-
-const termNodeQuery = nodeQuery("/argument/term!"),
-      typeNodeQuery = nodeQuery("/argument/type!"),
-      metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      typeInferenceNodeQuery = nodeQuery("/statement/typeInference!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
-
-class StatementVerifier extends Verifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context) {
-    let nonTerminalNodeVerified = false;
-
-    const nonTerminalNode = nonTerminalNodeA, ///
-          combinatorNonTerminalNode = nonTerminalNodeB; ///
-
-    const ruleName = nonTerminalNode.getRuleName(), ///
-          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
-
-    if (ruleName === combinatorRuleName) {
-      switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context);
-
-          nonTerminalNodeVerified = argumentNodeVerified; ///
-
-          break;
-        }
-
-        case META_ARGUMENT_RULE_NAME: {
-          const metaArgumentNode = nonTerminalNode, ///
-                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context);
-
-          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
-
-          break;
-        }
-
-        default: {
-          const childNodes = nonTerminalNode.getChildNodes(),
-                combinatorChildNodes = combinatorNonTerminalNode.getChildNodes(),
-                nodesA = childNodes, ///
-                nodesB = combinatorChildNodes, ///
-                nodesVerified = this.verifyNodes(nodesA, nodesB, context);
-
-          nonTerminalNodeVerified = nodesVerified; ///
-
-          break;
-        }
-      }
-    }
-
-    return nonTerminalNodeVerified;
-  }
-
-  verifyArgumentNode(argumentNode, combinatorArgumentNode, context) {
-    let argumentNodeVerified = false;
-
-    const termNode = termNodeQuery(argumentNode);
-
-    if (termNode === null) {
-      const argumentString = context.nodeAsString(argumentNode);
-
-      context.error(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
-    } else {
-      const types = [],
-            termVerified = verifyTerm(termNode, types, context);
-
-      if (termVerified) {
-        const firstType = first(types),
-              termType = firstType, ///
-              typeNode = typeNodeQuery(combinatorArgumentNode),
-              typeName = typeNameFromTypeNode(typeNode),
-              type = (typeName === OBJECT_TYPE_NAME) ?
-                       objectType :  ///
-                         context.findTypeByTypeName(typeName),
-              statementTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
-
-        if (statementTypeEqualToOrSubTypeOfType) {
-          argumentNodeVerified = true;
-        }
-      }
-    }
-
-    return argumentNodeVerified;
-  }
-
-  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, context) {
-    let metaArgumentNodeVerified = false;
-
-    const statementNode = statementNodeQuery(metaArgumentNode),
-          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
 
-    if (statementNode === null) {
-      const metaArgumentString = context.nodeAsString(metaArgumentNode);
-
-      context.error(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-    } else {
-      if (combinatorMetaTYpeNode === null) {
-        const combinatorMetaargumentString = context.nodeAsString(combinatorMetaargumentNode);
-
-        context.error(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
-      } else {
-        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-              content = combinatorMetaTypeTerminalNode.getContent(),
-              contentStatementMetaType = (content === STATEMENT_META_TYPE);
-
-        if (!contentStatementMetaType) {
-          context.error(`Expected the meta-type to be 'Statement' but got '${content}'.`, metaArgumentNode);
-        } else {
-          metaArgumentNodeVerified = true;
-        }
-      }
-    }
-
-    return metaArgumentNodeVerified;
-  }
-}
-
-export const statementVerifier = new StatementVerifier();
+const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
+      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
+      typeInferenceNodeQuery = nodeQuery("/statement/typeInference!"),
+      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-export default function verifyStatement(statementNode, assignments, derived, context) {
-  let statementVerified = false;
+function verifyStatement(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerified;
 
   const statementString = context.nodeAsString(statementNode);
 
-  context.debug(`Verifying the '${statementString}' statement...`, statementNode);
-
-  if (!statementVerified) {
-    const statementVerifiedAgainstCombinators = verifyStatementAgainstCombinators(statementNode, context);
-
-    statementVerified = statementVerifiedAgainstCombinators;  ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsTypeInference = verifyStatementAsTypeInference(statementNode, derived, context);
+  context.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-    statementVerified = statementVerifiedAsTypeInference; ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
-
-    statementVerified = statementVerifiedAsTypeAssertion; ///
-  }
+  const verifyStatementFunctions = [
+    verifyStatementAsEquality,
+    verifyStatementAsTypeInference,
+    verifyStatementAsTypeAssertion,
+    verifyStatementAgainstCombinators
+  ];
 
-  if (!statementVerified) {
-    const statementVerifiedAsEquality = verifyStatementAsEquality(statementNode, derived, context);
+  statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+    const statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
 
-    statementVerified = statementVerifiedAsEquality;  //
-  }
+    if (statementVerified) {
+      return true;
+    }
+  });
 
   if (statementVerified) {
-    context.debug(`Verified the '${statementString}' statement.`, statementNode);
+    context.debug(`...verified the '${statementString}' statement.`, statementNode);
   }
 
   return statementVerified;
 }
 
-export function verifyStatementAgainstCombinators(statementNode, context) {
-  let statementVerifiedAgainstCombinators = false;
+Object.assign(verifyStatement, {
+  statementNodesVerifier
+});
 
-  const statementString = context.nodeAsString(statementNode);
+export default verifyStatement;
 
-  context.trace(`Verifying the '${statementString}' statement against combinators.`, statementNode);
+export function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAgainstCombinators;
 
   let combinators = context.getCombinators();
 
@@ -192,186 +61,193 @@ export function verifyStatementAgainstCombinators(statementNode, context) {
     ...combinators
   ];
 
-  const combinator = combinators.find((combinator, index) => {
-    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+  statementVerifiedAgainstCombinators = combinators.some((combinator) => {
+    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
 
     if (statementVerifiedAgainstCombinator) {
       return true;
     }
-  }) || null;
-
-  if (combinator !== null) {
-    statementVerifiedAgainstCombinators = true;
-  }
+  });
 
   return statementVerifiedAgainstCombinators;
 }
 
-export function verifyStatementAgainstCombinator(statementNode, combinator, context) {
+export function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
+  let statementVerifiedAgainstCombinator;
+
   const statementString = context.nodeAsString(statementNode),
         combinatorString = combinator.getString();
 
-  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
 
   const combinatorStatementNode = combinator.getStatementNode(),
         nonTerminalNodeA = statementNode, ///
         nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context),
-        statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+        nonTerminalNodeVerified = statementNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+
+  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+
+  if (statementVerifiedAgainstCombinator) {
+    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+  }
 
   return statementVerifiedAgainstCombinator;
 }
 
-function verifyStatementAsTypeInference(statementNode, derived, context) {
+function verifyStatementAsTypeInference(statementNode, assignments, derived, context, verifyAhead) {
   let statementVerifiedAsTypeInference = false;
 
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement as a type inference...`, statementNode);
+
   const typeInferenceNode = typeInferenceNodeQuery(statementNode);
 
   if (typeInferenceNode !== null) {
     if (!derived) {
       const typeInferenceString = context.nodeAsString(typeInferenceNode);
 
-      context.error(`The '${typeInferenceString}' type inference can only be derived.`, typeInferenceNode);
+      context.info(`The '${typeInferenceString}' type inference can only be derived.`, typeInferenceNode);
     } else {
-      const typeInferenceVerified = verifyTypeInference(typeInferenceNode, context);
+      const typeInferenceVerified = verifyTypeInference(typeInferenceNode, context, verifyAhead);
 
       statementVerifiedAsTypeInference = typeInferenceVerified; ///
     }
   }
 
+  if (statementVerifiedAsTypeInference) {
+    context.debug(`...verified the '${statementString}' statement as a type inference.`, statementNode);
+  }
+
   return statementVerifiedAsTypeInference;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context) {
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context, verifyAhead) {
   let statementVerifiedAsTypeAssertion = false;
 
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
+
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context);
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead);
 
     statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
   }
 
+  if (statementVerifiedAsTypeAssertion) {
+    context.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
+  }
+
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, derived, context) {
-  let statementVerifiedAsEquality = false;
+function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsEquality;
+
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
   const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, () => {
+          let verifiedAhead;
 
-  if (statementVerifiedAgainstCombinator) {
-    const equality = Equality.fromStatementNode(statementNode);
+          const verifyStatementAsEqualityFunctions = [
+            verifyStatementAsDerivedEquality,
+            verifyStatementAsEqualTerms
+          ];
 
-    if (derived) {
-      const equalities = context.getEqualities(),
-            equalityVerified = equality.verify(equalities, context);
+          verifiedAhead = verifyStatementAsEqualityFunctions.some((verifyStatementAsEqualityFunction) => {
+            const statementVerified = verifyStatementAsEqualityFunction(statementNode, derived, context, verifyAhead);
 
-      statementVerifiedAsEquality = equalityVerified;  ///
-    } else {
-      const variables = [],
-            leftTermNode = equality.getLeftTermNode(),
-            rightTermNode = equality.getRightTermNode(),
-            leftTermVerifiedAsVariable = verifyTermAsVariable(leftTermNode, variables, context),
-            rightTermVerifiedAsVariable = verifyTermAsVariable(rightTermNode, variables, context);
-
-      if (leftTermVerifiedAsVariable && rightTermVerifiedAsVariable) {
-        const firstVariable = first(variables),
-              secondVariable = second(variables),
-              leftVariable = firstVariable, ///
-              rightVariable = secondVariable, ///
-              leftVariableName = leftVariable.getName(),
-              leftVariableType = leftVariable.getType(),
-              rightVariableName = rightVariable.getName(),
-              rightVariableType = rightVariable.getType(),
-              leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType = leftVariableType.isEqualToOrSubTypeOfOfSuperTypeOf(rightVariableType);
-
-        if (!leftVariableTypeEqualToOrSubTypeOfOfSuperTypeOfRightVariableType) {
-          const leftVariableTypeName = leftVariableType.getName(),
-                rightVariableTypeName = rightVariableType.getName();
-
-          context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to, a sub-type of or a super-type of the right '${rightVariableName}' variable's '${rightVariableTypeName}' type.`, statementNode);
-        } else {
-          statementVerifiedAsEquality = true;
-        }
-      } else if (leftTermVerifiedAsVariable) {
-        const types = [];
-
-        verifyTerm(rightTermNode, types, context);
-
-        const firstType = first(types),
-              firstVariable = first(variables),
-              leftVariable = firstVariable, ///
-              rightTermType = firstType,  ///
-              leftVariableName = leftVariable.getName(),
-              leftVariableType = leftVariable.getType(),
-              leftVariableTypeEqualToOrSuperTypeOfRightTermType = leftVariableType.isEqualToOrSuperTypeOf(rightTermType);
-
-        if (!leftVariableTypeEqualToOrSuperTypeOfRightTermType) {
-          const rightTermString = context.nodeAsString(rightTermNode),
-                rightTermTypeName = rightTermType.getName(),
-                leftVariableTypeName = leftVariableType.getName();
-
-          context.error(`The left '${leftVariableName}' variable's '${leftVariableTypeName}' type is not equal to or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
-        } else {
-          statementVerifiedAsEquality = true;
-        }
-      } else if (rightTermVerifiedAsVariable) {
-        const types = [];
-
-        verifyTerm(leftTermNode, types, context);
-
-        const firstType = first(types),
-              firstVariable = first(variables),
-              leftTermType = firstType,  ///
-              rightVariable = firstVariable, ///
-              rightVariableName = rightVariable.getName(),
-              rightVariableType = rightVariable.getType(),
-              rightVariableTypeEqualToOrSuperTypeOfRightTermType = rightVariableType.isEqualToOrSuperTypeOf(leftTermType);
-
-        if (!rightVariableTypeEqualToOrSuperTypeOfRightTermType) {
-          const leftTermString = context.nodeAsString(leftTermNode),
-                leftTermTypeName = leftTermType.getName(),
-                rightVariableTypeName = rightVariableType.getName();
-
-          context.error(`The right '${rightVariableName}' variable's '${rightVariableTypeName}' type is not equal to or a super-type of the left '${leftTermString}' term's '${leftTermTypeName}' type.`, statementNode);
-        } else {
-          statementVerifiedAsEquality = true;
-        }
-      } else {
-        const types = [];
-
-        verifyTerm(leftTermNode, types, context);
-
-        verifyTerm(rightTermNode, types, context);
-
-        const firstType = first(types),
-              secondType = second(types),
-              leftTermType = firstType, ///
-              rightTermType = secondType, ///
-              leftTermTypeEqualToOrSubTypeOfOfSuperTypeOf = leftTermType.isEqualToOrSubTypeOfOfSuperTypeOf(rightTermType);
-
-        if (!leftTermTypeEqualToOrSubTypeOfOfSuperTypeOf) {
-          const leftTermString = context.nodeAsString(leftTermNode),
-                rightTermString = context.nodeAsString(rightTermNode),
-                leftTermTypeName = leftTermType.getName(),
-                rightTermTypeName = rightTermType.getName();
-
-          context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to, a sub-type of or a super-type of the right '${rightTermString}' term's '${rightTermTypeName}' type.`, statementNode);
-        } else {
-          statementVerifiedAsEquality = true;
-        }
-      }
-    }
-  }
+            if (statementVerified) {
+              return true;
+            }
+          });
 
-  if (statementVerifiedAsEquality) {
-    const statementString = context.nodeAsString(statementNode);
+          return verifiedAhead;
+        });
+
+  statementVerifiedAsEquality = statementVerifiedAgainstCombinator; ///
 
-    context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
+  if (statementVerifiedAsEquality) {
+    context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
   }
 
   return statementVerifiedAsEquality;
 }
+
+function verifyStatementAsDerivedEquality(statementNode, derived, context, verifyAhead) {
+  let verifiedStatementAsDerivedEquality = false;
+
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement as a derived equality...`, statementNode);
+
+  if (derived) {
+    const equality = Equality.fromStatementNode(statementNode),
+          equalities = context.getEqualities(),
+          equalityVerified = equality.verify(equalities, context, verifyAhead);
+
+    verifiedStatementAsDerivedEquality = equalityVerified;  ///
+  }
+
+  if (verifiedStatementAsDerivedEquality) {
+    context.debug(`...verified the '${statementString}' statement as a derived equality.`, statementNode);
+  }
+
+  return verifiedStatementAsDerivedEquality;
+}
+
+function verifyStatementAsEqualTerms(statementNode, derived, context, verifyAhead) {
+  let statementVerifiedAsEqualTerms;
+
+  const statementString = context.nodeAsString(statementNode);
+
+  context.trace(`Verifying the '${statementString}' statement as equal terms...`, statementNode);
+
+  const types = [],
+        leftTermNode = leftTermNodeQuery(statementNode),
+        leftTermVerified = verifyTerm(leftTermNode, types, context, () => {
+          let verifiedAhead;
+
+          const rightTermNode = rightTermNodeQuery(statementNode),
+                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.info(`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;
+        });
+
+  statementVerifiedAsEqualTerms = leftTermVerified; ///
+
+  if (statementVerifiedAsEqualTerms) {
+    context.trace(`...verified the '${statementString}' statement as equal terms.`, statementNode);
+  }
+
+  return statementVerifiedAsEqualTerms;
+}