occam-verify-cli 0.0.679 → 0.0.680

package/src/verify/metastatement.js

@@ -2,7 +2,7 @@
 
 import metastatementNodeVerifier from "../verifier/node/metastatement";
 
-function verifyMetastatement(metastatementNode, derived, metaproofContext, verifyAhead) {
+function verifyMetastatement(metastatementNode, derived, metaproofContext) {
   let metastatementVerified;
 
   const metastatementString = metaproofContext.nodeAsString(metastatementNode);
@@ -14,7 +14,7 @@ function verifyMetastatement(metastatementNode, derived, metaproofContext, verif
   ];
 
   metastatementVerified = verifyMetastatementFunctions.some((verifyStatementFunction) => {
-    const metastatementVerified = verifyStatementFunction(metastatementNode, derived, metaproofContext, verifyAhead);
+    const metastatementVerified = verifyStatementFunction(metastatementNode, derived, metaproofContext);
 
     if (metastatementVerified) {
       return true;
@@ -34,7 +34,7 @@ Object.assign(verifyMetastatement, {
 
 export default verifyMetastatement;
 
-function verifyStandaloneMetastatement(metastatementNode, derived, metaproofContext, verifyAhead) {
+function verifyStandaloneMetastatement(metastatementNode, derived, metaproofContext) {
   let standaloneMetastatementVerified;
 
   const metastatementString = metaproofContext.nodeAsString(metastatementNode);
@@ -42,7 +42,11 @@ function verifyStandaloneMetastatement(metastatementNode, derived, metaproofCont
   metaproofContext.trace(`Verifying the '${metastatementString}' standalone metastatement...`, metastatementNode);
 
   const nonTerminalNode = metastatementNode, ///
-        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, metaproofContext);
+        nonTerminalNodeVerified = metastatementNodeVerifier.verifyNonTerminalNode(nonTerminalNode, metaproofContext, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
 
   standaloneMetastatementVerified = nonTerminalNodeVerified;  ///
 

package/src/verify/metavariable.js

@@ -15,7 +15,7 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
         metavariablePresent = fileContext.isMetavariablePresentByMetavariableName(metavariableName);
 
   if (metavariablePresent) {
-    fileContext.info(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
+    fileContext.debug(`The metavariable '${metavariableName}' is already present.`, metavariableNode);
   } else {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
           metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName),

package/src/verify/statement.js

@@ -1,20 +1,14 @@
 "use strict";
 
 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 verifyTypeAssertion from "../verify/typeAssertion";
 import statementNodesVerifier from "../verifier/nodes/statement";
 
 import { nodeQuery } from "../utilities/query";
-import { first, second } from "../utilities/array";
 
-const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
-      rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!"),
-      typeInferenceNodeQuery = nodeQuery("/statement/typeInference!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
+const typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
 function verifyStatement(statementNode, assignments, derived, context, verifyAhead) {
   let statementVerified;
@@ -25,7 +19,6 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
 
   const verifyStatementFunctions = [
     verifyStatementAsEquality,
-    verifyStatementAsTypeInference,
     verifyStatementAsTypeAssertion,
     verifyStatementAgainstCombinators
   ];
@@ -72,7 +65,7 @@ export function verifyStatementAgainstCombinators(statementNode, assignments, de
   return statementVerifiedAgainstCombinators;
 }
 
-export function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
+function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
   let statementVerifiedAgainstCombinator;
 
   const statementString = context.nodeAsString(statementNode),
@@ -94,160 +87,98 @@ export function verifyStatementAgainstCombinator(statementNode, combinator, cont
   return statementVerifiedAgainstCombinator;
 }
 
-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.info(`The '${typeInferenceString}' type inference can only be derived.`, typeInferenceNode);
-    } else {
-      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, 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 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);
+    if (statementVerifiedAsTypeAssertion) {
+      context.debug(`...verified the '${statementString}' statement as a type assertion.`, statementNode);
+    }
   }
 
   return statementVerifiedAsTypeAssertion;
 }
 
 function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAsEquality;
-
-  const statementString = context.nodeAsString(statementNode);
+  let statementVerifiedAsEquality = false;
 
-  context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+  const equality = Equality.fromStatementNode(statementNode);
 
-  const combinator = equalityCombinator,  ///
-        statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, () => {
-          let verifiedAhead;
+  if (equality !== null) {
+    const statementString = context.nodeAsString(statementNode);
 
-          const verifyStatementAsEqualityFunctions = [
-            verifyStatementAsDerivedEquality,
-            verifyStatementAsEqualTerms
-          ];
+    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
 
-          verifiedAhead = verifyStatementAsEqualityFunctions.some((verifyStatementAsEqualityFunction) => {
-            const statementVerified = verifyStatementAsEqualityFunction(statementNode, derived, context, verifyAhead);
+    const verifyStatementAsEqualityFunctions = [
+      verifyStatementAsDerivedEquality,
+      verifyStatementAsStandaloneEquality
+    ];
 
-            if (statementVerified) {
-              return true;
-            }
-          });
+    statementVerifiedAsEquality = verifyStatementAsEqualityFunctions.some((verifyStatementAsEqualityFunction) => {
+      const statementVerified = verifyStatementAsEqualityFunction(statementNode, equality, derived, context, verifyAhead);
 
-          return verifiedAhead;
-        });
+      if (statementVerified) {
+        return true;
+      }
+    });
 
-  statementVerifiedAsEquality = statementVerifiedAgainstCombinator; ///
-
-  if (statementVerifiedAsEquality) {
-    context.debug(`...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) {
+function verifyStatementAsDerivedEquality(statementNode, equality, derived, context, verifyAhead) {
   let verifiedStatementAsDerivedEquality = false;
 
-  const statementString = context.nodeAsString(statementNode);
+  if (derived) {
+    const statementString = context.nodeAsString(statementNode);
 
-  context.trace(`Verifying the '${statementString}' statement as a derived equality...`, statementNode);
+    context.trace(`Verifying the '${statementString}' derived equality...`, statementNode);
 
-  if (derived) {
-    const equality = Equality.fromStatementNode(statementNode),
-          equalities = context.getEqualities(),
+    const equalities = context.getEqualities(),
           equalityVerified = equality.verify(equalities, context, verifyAhead);
 
     verifiedStatementAsDerivedEquality = equalityVerified;  ///
-  }
 
-  if (verifiedStatementAsDerivedEquality) {
-    context.debug(`...verified the '${statementString}' statement as a derived equality.`, statementNode);
+    if (verifiedStatementAsDerivedEquality) {
+      context.debug(`...verified the '${statementString}' derived equality.`, statementNode);
+    }
   }
 
   return verifiedStatementAsDerivedEquality;
 }
 
-function verifyStatementAsEqualTerms(statementNode, derived, context, verifyAhead) {
-  let statementVerifiedAsEqualTerms;
+function verifyStatementAsStandaloneEquality(statementNode, equality, derived, context, verifyAhead) {
+  let statementVerifiedAsStandaloneEquality = false;
 
-  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 (!derived) {
+    const statementString = context.nodeAsString(statementNode);
 
-                  if (!leftTypeEqualToOrSubTypeOfOfSuperTypeOfRightType) {
-                    const leftTypeName = leftType.getName(),
-                          rightTypeName = rightType.getName(),
-                          leftTermString = context.nodeAsString(leftTermNode),
-                          rightTermString = context.nodeAsString(rightTermNode);
+    context.trace(`Verifying the '${statementString}' statement as a standalone equality...`, statementNode);
 
-                    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();
-                  }
+    const leftTermNode = equality.getLeftTermNode(),
+          rightTermNode = equality.getRightTermNode(),
+          termsVerified = verifyTerms(leftTermNode, rightTermNode, context, verifyAhead);
 
-                  return verifiedAhead;
-                });
+    statementVerifiedAsStandaloneEquality = termsVerified; ///
 
-          verifiedAhead = rightTermVerified;  ///
-
-          return verifiedAhead;
-        });
-
-  statementVerifiedAsEqualTerms = leftTermVerified; ///
-
-  if (statementVerifiedAsEqualTerms) {
-    context.trace(`...verified the '${statementString}' statement as equal terms.`, statementNode);
+    if (statementVerifiedAsStandaloneEquality) {
+      context.trace(`...verified the '${statementString}' statement as a standalone equality.`, statementNode);
+    }
   }
 
-  return statementVerifiedAsEqualTerms;
+  return statementVerifiedAsStandaloneEquality;
 }

package/src/verify/term.js

@@ -28,11 +28,7 @@ function verifyTerm(termNode, types, context, verifyAhead) {
   });
 
   if (termVerified) {
-    const firstType = first(types),
-          type = firstType, ///
-          typeName = type.getName();
-
-    context.debug(`...verified the '${termString}' term, which has been given the '${typeName}' type.`, termNode);
+    context.debug(`...verified the '${termString}' term.`, termNode);
   }
 
   return termVerified;
@@ -63,13 +59,13 @@ export function verifyTermAgainstConstructors(termNode, types, context, verifyAh
 export function verifyTermAsVariable(termNode, variables, context, verifyAhead) {
   let termVerifiedAsVariable = false;
 
-  const termString = context.nodeAsString(termNode);
-
-  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
-
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode !== null) {
+    const termString = context.nodeAsString(termNode);
+
+    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
+
     const variableName = variableNameFromVariableNode(variableNode),
           variablePresent = context.isVariablePresentByVariableName(variableName);
 
@@ -82,12 +78,16 @@ export function verifyTermAsVariable(termNode, variables, context, verifyAhead)
 
       verifiedAhead = verifyAhead();
 
+      if (!verifiedAhead) {
+        variables.pop();
+      }
+
       termVerifiedAsVariable = verifiedAhead; ///
     }
-  }
 
-  if (termVerifiedAsVariable) {
-    context.debug(`...verified the '${termString}' term as a variable.`, termNode);
+    if (termVerifiedAsVariable) {
+      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
+    }
   }
 
   return termVerifiedAsVariable;
@@ -113,6 +113,10 @@ function verifyTermAgainstConstructor(termNode, types, constructor, context, ver
 
           verifiedAhead = verifyAhead();
 
+          if (!verifiedAhead) {
+            types.pop();
+          }
+
           return verifiedAhead;
         });
 
@@ -144,6 +148,10 @@ function verifyTermAsStandaloneVariable(termNode, types, context, verifyAhead) {
 
           verifiedAhead = verifyAhead();
 
+          if (!verifiedAhead) {
+            types.pop();
+          }
+
           return verifiedAhead;
         });
 

package/src/verify/termAsConstructor.js

@@ -33,7 +33,7 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
       if (type !== null) {
         termVerifiedAsConstructor = true;
       } else {
-        fileContext.info(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
+        fileContext.debug(`The '${termString}' constructor's '${typeName}' type is not present.`, termNode);
       }
     }
 

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

@@ -15,7 +15,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
         typePresent = fileContext.isTypePresentByTypeName(typeName);
 
   if (typePresent) {
-    fileContext.info(`The type '${typeName}' is already present.`, typeNode);
+    fileContext.debug(`The type '${typeName}' is already present.`, typeNode);
   } else {
     let type;
 
@@ -27,7 +27,7 @@ export default function verifyType(typeNode, superTypeNode, fileContext) {
       const superType = fileContext.findTypeByTypeName(superTypeName);
 
       if (superType === null) {
-        fileContext.info(`The super-type '${superTypeName}' is not present.`, typeNode);
+        fileContext.debug(`The super-type '${superTypeName}' is not present.`, typeNode);
       } else {
         type = Type.fromTypeNameAndSuperType(typeName, superType);
       }

package/src/verify/typeAssertion.js

@@ -0,0 +1,164 @@
+"use strict";
+
+import Variable from "../variable";
+import Assignment from "../assignment";
+
+import { first } from "../utilities/array";
+import { nodeQuery, typeNameFromTypeNode } from "../utilities/query";
+import { verifyTermAsVariable, verifyTermAgainstConstructors } from "../verify/term";
+
+const termNodeQuery = nodeQuery("/typeAssertion/term!"),
+      typeNodeQuery = nodeQuery("/typeAssertion/type!");
+
+export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead) {
+  let typeAssertionVerified = false;
+
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
+
+  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
+
+  const typeNode = typeNodeQuery(typeAssertionNode),
+        typeName = typeNameFromTypeNode(typeNode),
+        assertedTypeName = typeName,  ///
+        assertedType = context.findTypeByTypeName(assertedTypeName);
+
+  if (assertedType === null) {
+    context.debug(`The '${typeName}' asserted type is not present.`, typeAssertionNode);
+  } else {
+    const verifyTypeAssertionFunctions = [
+      verifyVariableTypeAssertion,
+      verifyTermTypeAssertion
+    ];
+
+    typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
+      const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead);
+
+      if (typeAssertionVerified) {
+        return true;
+      }
+    });
+  }
+
+  if (typeAssertionVerified) {
+    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+  }
+
+  return typeAssertionVerified;
+}
+
+export function verifyVariableTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
+  let variableTypeAssertionVerified;
+
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
+
+  context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);
+
+  const variables = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+          let verifiedAhead = false;
+
+          const firstVariable = first(variables),
+                variable = firstVariable, ///
+                variableName = variable.getName(),
+                variableType = variable.getType();
+
+          if (derived) {
+            const assertedTypeEqualToOrSuperTypeOfVariableType = assertedType.isEqualToOrSuperTypeOf(variableType);
+
+            if (!assertedTypeEqualToOrSuperTypeOfVariableType) {
+              const assertedTypeName = assertedType.getName(),
+                    variableTypeName = variableType.getName();
+
+              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+            } else {
+              verifiedAhead = verifyAhead();
+            }
+          } else {
+            const assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+
+            if (!assertedTypeEqualToOrSubTypeOfVariableType) {
+              const assertedTypeName = assertedType.getName(),
+                    variableTypeName = variableType.getName();
+
+              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+            } else {
+              const name = variableName,  ///
+                    type = assertedType,  ///
+                    variable = Variable.fromNameAndType(name, type),
+                    assignment = Assignment.fromVariable(variable);
+
+              assignments.push(assignment);
+
+              verifiedAhead = verifyAhead();
+
+              if (!verifiedAhead) {
+                assignments.pop();
+              }
+            }
+          }
+
+          return verifiedAhead;
+        });
+
+  variableTypeAssertionVerified = termVerifiedAsVariable; ///
+
+  if (variableTypeAssertionVerified) {
+    context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);
+  }
+
+  return variableTypeAssertionVerified;
+}
+
+function verifyTermTypeAssertion(typeAssertionNode, assertedType, assignments, derived, context, verifyAhead) {
+  let termTypeAssertionVerified;
+
+  const typeAssertionString = context.nodeAsString(typeAssertionNode);
+
+  context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);
+
+  const types = [],
+        termNode = termNodeQuery(typeAssertionNode),
+        termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context, () => {
+          let verifiedAhead = false;
+
+          const firstType = first(types),
+                termType = firstType; ///
+
+          if (derived) {
+            const assertedTypeIsEqualToOrSuperTypeOfTermType = assertedType.isEqualToOrSuperTypeOf(termType);
+
+            if (!assertedTypeIsEqualToOrSuperTypeOfTermType) {
+              const termString = context.nodeAsString(termNode),
+                    termTypeName = termType.getName(),
+                    assertedTypeName = assertedType.getName();
+
+              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+            } else {
+              verifiedAhead = verifyAhead();
+            }
+          } else {
+            const assertedTypeIsEqualToOrSubTypeOfTermType = assertedType.isEqualToOrSubTypeOf(termType);
+
+            if (!assertedTypeIsEqualToOrSubTypeOfTermType) {
+              const termString = context.nodeAsString(termNode),
+                    termTypeName = termType.getName(),
+                    assertedTypeName = assertedType.getName();
+
+              context.debug(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+            } else {
+              verifiedAhead = verifyAhead();
+            }
+          }
+
+          return verifiedAhead;
+        });
+
+  termTypeAssertionVerified = termVerifiedAgainstConstructors;  ///
+
+  if (termTypeAssertionVerified) {
+    context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);
+  }
+
+  return termTypeAssertionVerified;
+}

package/src/verify/variable.js

@@ -16,7 +16,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
         variablePresent = fileContext.isVariablePresentByVariableName(variableName);
 
   if (variablePresent) {
-    fileContext.info(`The variable '${variableName}' is already present.`, variableNode);
+    fileContext.debug(`The variable '${variableName}' is already present.`, variableNode);
   } else {
     let variable;
 
@@ -31,7 +31,7 @@ export default function verifyVariable(variableNode, typeNode, fileContext) {
       const type = fileContext.findTypeByTypeName(typeName);
 
       if (type === null) {
-        fileContext.info(`The '${variableName}' variable's '${typeName}' type is not present.`, variableNode);
+        fileContext.debug(`The '${variableName}' variable's '${typeName}' type is not present.`, variableNode);
       } else {
         const name = variableName;  ///
 

package/lib/node/statement/combinator/equality.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return _default;
-    }
-});
-var _equality = /*#__PURE__*/ _interop_require_default(require("../../../tokens/statement/combinator/equality"));
-var _node = require("../../../utilities/node");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-var equalityCombinatorStatementNode = (0, _node.statementNodeFromUnqualifiedStatementTokens)(_equality.default);
-var _default = equalityCombinatorStatementNode;
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9ub2RlL3N0YXRlbWVudC9jb21iaW5hdG9yL2VxdWFsaXR5LmpzIl0sInNvdXJjZXNDb250ZW50IjpbIlwidXNlIHN0cmljdFwiO1xuXG5pbXBvcnQgdW5xdWFsaWZpZWRFcXVhbGl0eUNvbWJpbmF0b3JTdGF0ZW1lbnRUb2tlbnMgZnJvbSBcIi4uLy4uLy4uL3Rva2Vucy9zdGF0ZW1lbnQvY29tYmluYXRvci9lcXVhbGl0eVwiO1xuXG5pbXBvcnQgeyBzdGF0ZW1lbnROb2RlRnJvbVVucXVhbGlmaWVkU3RhdGVtZW50VG9rZW5zIH0gZnJvbSBcIi4uLy4uLy4uL3V0aWxpdGllcy9ub2RlXCI7XG5cbmNvbnN0IGVxdWFsaXR5Q29tYmluYXRvclN0YXRlbWVudE5vZGUgPSBzdGF0ZW1lbnROb2RlRnJvbVVucXVhbGlmaWVkU3RhdGVtZW50VG9rZW5zKHVucXVhbGlmaWVkRXF1YWxpdHlDb21iaW5hdG9yU3RhdGVtZW50VG9rZW5zKTtcblxuZXhwb3J0IGRlZmF1bHQgZXF1YWxpdHlDb21iaW5hdG9yU3RhdGVtZW50Tm9kZTtcbiJdLCJuYW1lcyI6WyJlcXVhbGl0eUNvbWJpbmF0b3JTdGF0ZW1lbnROb2RlIiwic3RhdGVtZW50Tm9kZUZyb21VbnF1YWxpZmllZFN0YXRlbWVudFRva2VucyIsInVucXVhbGlmaWVkRXF1YWxpdHlDb21iaW5hdG9yU3RhdGVtZW50VG9rZW5zIl0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFRQTs7O2VBQUE7OzsrREFOeUQ7b0JBRUc7Ozs7OztBQUU1RCxJQUFNQSxrQ0FBa0NDLElBQUFBLGlEQUEyQyxFQUFDQyxpQkFBNEM7SUFFaEksV0FBZUYifQ==