occam-verify-cli 0.0.678 → 0.0.680

package/src/verify/statement.js

@@ -1,189 +1,51 @@
 "use strict";
 
-import Verifier from "../verifier";
 import Equality from "../equality";
-import verifyTerm from "../verify/term";
-import equalityCombinator from "../ocmbinator/equality";
+import verifyTerms from "../verify/terms";
 import bracketedCombinator from "../ocmbinator/bracketed";
-import verifyTypeInference from "../verify/typeInference";
-import verifyTypeAssertion from "../verify/assertion/type";
-
-import { objectType } from "../type";
-import { termVerifier } from "../verify/term";
-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);
+import verifyTypeAssertion from "../verify/typeAssertion";
+import statementNodesVerifier from "../verifier/nodes/statement";
 
-    if (termNode === null) {
-      const argumentString = context.nodeAsString(argumentNode);
+import { nodeQuery } from "../utilities/query";
 
-      context.error(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
-    } else {
-      const types = [],
-            termVerified = verifyTerm(termNode, types, context);
+const typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
-      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();
-
-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);
-
-    statementVerified = statementVerifiedAsTypeInference; ///
-  }
-
-  if (!statementVerified) {
-    const statementVerifiedAsTypeAssertion = verifyStatementAsTypeAssertion(statementNode, assignments, derived, context);
+  context.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-    statementVerified = statementVerifiedAsTypeAssertion; ///
-  }
+  const verifyStatementFunctions = [
+    verifyStatementAsEquality,
+    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 +54,131 @@ 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) {
+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);
 
-  return statementVerifiedAgainstCombinator;
-}
-
-function verifyStatementAsTypeInference(statementNode, derived, context) {
-  let statementVerifiedAsTypeInference = false;
-
-  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);
-    } else {
-      const typeInferenceVerified = verifyTypeInference(typeInferenceNode, context);
+  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
 
-      statementVerifiedAsTypeInference = typeInferenceVerified; ///
-    }
+  if (statementVerifiedAgainstCombinator) {
+    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementVerifiedAsTypeInference;
+  return statementVerifiedAgainstCombinator;
 }
 
-function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context) {
+function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context, verifyAhead) {
   let statementVerifiedAsTypeAssertion = false;
 
   const typeAssertionNode = typeAssertionNodeQuery(statementNode);
 
   if (typeAssertionNode !== null) {
-    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context);
+    const statementString = context.nodeAsString(statementNode);
+
+    context.trace(`Verifying the '${statementString}' statement as a type assertion...`, statementNode);
+
+    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) {
+function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
   let statementVerifiedAsEquality = false;
 
-  const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
+  const equality = Equality.fromStatementNode(statementNode);
 
-  if (statementVerifiedAgainstCombinator) {
-    const equality = Equality.fromStatementNode(statementNode);
-
-    if (derived) {
-      const equalities = context.getEqualities(),
-            equalityVerified = equality.verify(equalities, context);
-
-      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 (equality !== null) {
+    const statementString = context.nodeAsString(statementNode);
+
+    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+
+    const verifyStatementAsEqualityFunctions = [
+      verifyStatementAsDerivedEquality,
+      verifyStatementAsStandaloneEquality
+    ];
+
+    statementVerifiedAsEquality = verifyStatementAsEqualityFunctions.some((verifyStatementAsEqualityFunction) => {
+      const statementVerified = verifyStatementAsEqualityFunction(statementNode, equality, derived, context, verifyAhead);
+
+      if (statementVerified) {
+        return true;
       }
+    });
+
+    if (statementVerifiedAsEquality) {
+      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
     }
   }
 
-  if (statementVerifiedAsEquality) {
+  return statementVerifiedAsEquality;
+}
+
+function verifyStatementAsDerivedEquality(statementNode, equality, derived, context, verifyAhead) {
+  let verifiedStatementAsDerivedEquality = false;
+
+  if (derived) {
     const statementString = context.nodeAsString(statementNode);
 
-    context.info(`Verified the '${statementString}' statement as an equality.`, statementNode);
+    context.trace(`Verifying the '${statementString}' derived equality...`, statementNode);
+
+    const equalities = context.getEqualities(),
+          equalityVerified = equality.verify(equalities, context, verifyAhead);
+
+    verifiedStatementAsDerivedEquality = equalityVerified;  ///
+
+    if (verifiedStatementAsDerivedEquality) {
+      context.debug(`...verified the '${statementString}' derived equality.`, statementNode);
+    }
   }
 
-  return statementVerifiedAsEquality;
+  return verifiedStatementAsDerivedEquality;
+}
+
+function verifyStatementAsStandaloneEquality(statementNode, equality, derived, context, verifyAhead) {
+  let statementVerifiedAsStandaloneEquality = false;
+
+  if (!derived) {
+    const statementString = context.nodeAsString(statementNode);
+
+    context.trace(`Verifying the '${statementString}' statement as a standalone equality...`, statementNode);
+
+    const leftTermNode = equality.getLeftTermNode(),
+          rightTermNode = equality.getRightTermNode(),
+          termsVerified = verifyTerms(leftTermNode, rightTermNode, context, verifyAhead);
+
+    statementVerifiedAsStandaloneEquality = termsVerified; ///
+
+    if (statementVerifiedAsStandaloneEquality) {
+      context.trace(`...verified the '${statementString}' statement as a standalone equality.`, statementNode);
+    }
+  }
+
+  return statementVerifiedAsStandaloneEquality;
 }

package/src/verify/statementAsCombinator.js

@@ -1,22 +1,22 @@
 "use strict";
 
 import Combinator from "../combinator";
-import verifyTerm from "../verify/term";
-import verifyStatement from "../verify/statement";
-
-import { typeNameFromTypeNode } from "../utilities/query";
-import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import statementAsCombinatorNodeVerifier from "../verifier/node/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
   let statementVerifiedAsCombinator = false;
 
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.debug(`Verifying the '${statementString}' combinator....`, statementNode);
+  fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
 
-  const nonTerminalNode = statementNode,  ///
+  const nonTerminalNode = statementNode, ///
         childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = verifyChildNodes(childNodes, fileContext);
+        childNodesVerified = statementAsCombinatorNodeVerifier.verifyChildNodes(childNodes, fileContext, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
 
   if (childNodesVerified) {
     const tokens = fileContext.getTokens(),
@@ -28,128 +28,8 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
   }
 
   if (statementVerifiedAsCombinator) {
-    fileContext.info(`Verified the '${statementString}' combinator.`, statementNode);
+    fileContext.debug(`...verified the '${statementString}' statement as a combinator.`, statementNode);
   }
 
   return statementVerifiedAsCombinator;
 }
-
-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 TYPE_RULE_NAME: {
-      const typeNode = nonTerminalNode, ///
-            typeNodeVerified = verifyTypeNode(typeNode, fileContext);
-
-      nonTerminalNodeVerified = typeNodeVerified; ///
-
-      break;
-    }
-
-    case TERM_RULE_NAME: {
-      const termNode = nonTerminalNode, ///
-            termNodeVerified = verifyTermNode(termNode, fileContext);
-
-      nonTerminalNodeVerified = termNodeVerified; ///
-
-      break;
-    }
-
-    case STATEMENT_RULE_NAME: {
-      const statmentNode = nonTerminalNode, ///
-            statmentNodeVerified = verifyStatementNode(statmentNode, fileContext);
-
-      nonTerminalNodeVerified = statmentNodeVerified; ///
-
-      break;
-    }
-
-    default: {
-      const childNodes = nonTerminalNode.getChildNodes(),
-            childNodesVerified = verifyChildNodes(childNodes, fileContext);
-
-      nonTerminalNodeVerified = childNodesVerified; ///
-
-      break;
-    }
-  }
-
-  return nonTerminalNodeVerified;
-}
-
-function verifyTypeNode(typeNode, fileContext) {
-  let typeNodeVerified = false;
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    fileContext.error(`The type '${typeName}' not present.`, typeNode);
-  } else {
-    typeNodeVerified = true;
-  }
-
-  return typeNodeVerified;
-}
-
-function verifyTermNode(termNode, fileContext) {
-  const types = [],
-        context = fileContext,  ///
-        termVerified = verifyTerm(termNode, types, context),
-        termNodeVerified = termVerified;  ///
-
-  return termNodeVerified;
-}
-
-function verifyStatementNode(statementNode, fileContext) {
-  const context = fileContext,  ///
-        derived = false,
-        assignments = [],
-        statementVerified = verifyStatement(statementNode, assignments, derived, context),
-        statementNodeVerified = statementVerified;  ///
-
-  return statementNodeVerified;
-}
-

package/src/verify/supposition.js

@@ -14,7 +14,7 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
   const suppositionString = proofContext.nodeAsString(suppositionNode);
 
-  proofContext.debug(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
+  proofContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
         assignments = [],
@@ -38,7 +38,7 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
   }
 
   if (suppositionVerified) {
-    proofContext.info(`Verified the '${suppositionString}' supposition.`, suppositionNode);
+    proofContext.debug(`...verified the '${suppositionString}' supposition.`, suppositionNode);
   }
 
   return suppositionVerified;