occam-verify-cli 0.0.678 → 0.0.679

package/src/verifier/nodes/statementForMetavariable/conclusion.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import StatementForMetavariableNodesVerifier from "../../../verifier/nodes/statementForMetavariable";
+
+class ConclusionStatementForMetavariableNodesVerifier extends StatementForMetavariableNodesVerifier {
+  static createSubstitutions = false;
+}
+
+const conclusionStatementForMetavariableNodesVerifier = new ConclusionStatementForMetavariableNodesVerifier();
+
+export default conclusionStatementForMetavariableNodesVerifier;

package/src/verifier/nodes/statementForMetavariable/premise.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import StatementForMetavariableNodesVerifier from "../../../verifier/nodes/statementForMetavariable";
+
+class PremiseStatementForMetavariableNodesVerifier extends StatementForMetavariableNodesVerifier {
+  static createSubstitutions = true;
+}
+
+const premiseStatementForMetavariableNodesVerifier = new PremiseStatementForMetavariableNodesVerifier();
+
+export default premiseStatementForMetavariableNodesVerifier;

package/src/verifier/{statementForMetavariable.js → nodes/statementForMetavariable.js}

@@ -1,16 +1,16 @@
 "use strict";
 
-import Verifier from "../verifier";
-import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+import NodesVerifier from "../../verifier/nodes";
+import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
-import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/query";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
+import { nodeQuery } from "../../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../../utilities/query";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-export default class StatementForMetavariableVerifier extends Verifier {
+export default class StatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
@@ -40,11 +40,11 @@ export default class StatementForMetavariableVerifier extends Verifier {
         } else {
           const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
                 nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-                nodesA = nonTerminalNodeAChildNodes, ///
-                nodesB = nonTerminalNodeBChildNodes, ///
-                nodesMatch = this.verifyNodes(nodesA, nodesB, substitutions, fileContextA, proofContextB);
+                childNodesA = nonTerminalNodeAChildNodes, ///
+                childNodesB = nonTerminalNodeBChildNodes, ///
+                childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, proofContextB);
 
-          nonTerminalNodeVerified = nodesMatch;  ///
+          nonTerminalNodeVerified = childNodesVerified;  ///
         }
       } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
         nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, proofContextB);

package/src/verifier/nodes/term.js

@@ -0,0 +1,111 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import { first } from "../../utilities/array";
+import { ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!");
+
+class TermNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const ruleName = nonTerminalNode.getRuleName(), ///
+          constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === constructorRuleName) {
+      switch (ruleName) {
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = constructorNonTerminalNode, ///
+                argumentVerified = verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead),
+                argumentNodeVerified = argumentVerified;  ///
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const termNodesVerifier = new TermNodesVerifier();
+
+export default termNodesVerifier;
+
+export function verifyArgument(argumentNode, constructorArgumentNode, context, verifyAhead) {
+  let argumentVerified = false;
+
+  const argumentString = context.nodeAsString(argumentNode);
+
+  context.trace(`Verifying the '${argumentString}' argument...`, argumentNode);
+
+  const typeNode = typeNodeQuery(argumentNode);
+
+  if (typeNode !== null) {
+    context.info(`The '${argumentString}' argument should be a term, not a type`, argumentNode);
+  } else {
+    const termNode = termNodeQuery(argumentNode);
+
+    if (!argumentVerified) {
+      const constructorTermNode = termNodeQuery(constructorArgumentNode);
+
+      if (constructorTermNode !== null) {
+        const node = termNode,  ///
+              constructorNode = constructorTermNode,  ///
+              nodeVerified = this.verifyNode(node, constructorNode, context, verifyAhead);
+
+        argumentVerified = nodeVerified;  ///
+      }
+    }
+
+    if (!argumentVerified) {
+      const constructorTypeNode = typeNodeQuery(constructorArgumentNode);
+
+      if (constructorTypeNode !== null) {
+        const { verifyTerm } = termNodesVerifier,
+              types = [],
+              termVerified = verifyTerm(termNode, types, context, () => {
+                let verifiedAhead = false;
+
+                const constructorTypeName = typeNameFromTypeNode(constructorTypeNode),
+                      firstType = first(types),
+                      termType = firstType, ///
+                      termTypeName = termType.getName(),
+                      constructorType = context.findTypeByTypeName(constructorTypeName),
+                      termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(constructorType);
+
+                if (termTypeEqualToOrSubTypeOfType) {
+                  const termString = context.nodeAsString(termNode);
+
+                  context.trace(`The '${termTypeName}' type of the '${termString}' term is equal to or a sub-type of the '${constructorTypeName}' type in the constructor.`, argumentNode);
+
+                  verifiedAhead = verifyAhead();
+                }
+
+                return verifiedAhead;
+              });
+
+        argumentVerified = termVerified;  ///
+      }
+    }
+  }
+
+  if (argumentVerified) {
+    context.debug(`...verified the '${argumentString}' argument.`, argumentNode);
+  }
+
+  return argumentVerified;
+}

package/src/verifier/nodes/termForVariable/consequent.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TermForVariableNodesVerifier from "../../../verifier/nodes/termForVariable";
+
+class ConsequentTermForVariableNodesVerifier extends TermForVariableNodesVerifier {
+  static createSubstitutions = false;
+}
+
+const consequentTermForVariableNodesVerifier = new ConsequentTermForVariableNodesVerifier();
+
+export default consequentTermForVariableNodesVerifier;

package/src/verifier/nodes/termForVariable/supposition.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import TermForVariableNodesVerifier from "../../../verifier/nodes/termForVariable";
+
+class SuppositionTermForVariableNodesVerifier extends TermForVariableNodesVerifier {
+  static createSubstitutions = true;
+}
+
+const suppositionTermForVariableNodesVerifier = new SuppositionTermForVariableNodesVerifier();
+
+export default suppositionTermForVariableNodesVerifier;

package/src/verifier/{termForVariable.js → nodes/termForVariable.js}

@@ -1,17 +1,17 @@
 "use strict";
 
-import Verifier from "../verifier";
-import verifyTerm from "../verify/term";
-import TermForVariableSubstitution from "../substitution/termForVariable";
+import verifyTerm from "../../verify/term";
+import NodesVerifier from "../../verifier/nodes";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
 
-import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-import { TERM_RULE_NAME } from "../ruleNames";
-import { variableNameFromVariableNode } from "../utilities/query";
+import { first } from "../../utilities/array";
+import { nodeQuery } from "../../utilities/query";
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { variableNameFromVariableNode } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-export default class TermForVariableVerifier extends Verifier {
+export default class TermForVariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, proofContextA, proofContextB) {
     let nonTerminalNodeVerified = false;
 
@@ -83,7 +83,7 @@ export default class TermForVariableVerifier extends Verifier {
           const types = [],
                 context = proofContextB, ///
                 termNode = termNodeB, ///
-                termVerified = verifyTerm(termNode, types, context);
+                termVerified = verifyTerm(termNode, types, context, verifyAhead);
 
           if (termVerified) {
             const firstType = first(types),

package/src/verifier/nodes.js

@@ -0,0 +1,111 @@
+"use strict";
+
+export default class NodesVerifier {
+  verifyNode(nodeA, nodeB, ...remainingArguments) {
+    let nodeVerified = false;
+
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode(),
+          nodeANonTerminalNode = nodeA.isNonTerminalNode(),
+          nodeBNonTerminalNode = nodeB.isNonTerminalNode();
+
+    if (false) {
+      ///
+    } else if (nodeATerminalNode && nodeBTerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeVerified = this.verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+
+      nodeVerified = terminalNodeVerified;  ///
+    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+
+      nodeVerified = nonTerminalNodeVerified; ///
+    }
+
+    return nodeVerified;
+  }
+
+  verifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesVerify = false;
+
+    const childNodesALength = childNodesA.length,
+          childNodesBLength = childNodesB.length;
+
+    if (childNodesALength === childNodesBLength) {
+      const index = 0,
+            childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+
+      childNodesVerify = childNodesVerifyAhead; ///
+    }
+
+    return childNodesVerify;
+  }
+
+  verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesVerify;
+
+    const verifyAhead = remainingArguments.pop(), ///
+          childNodesALength = childNodesA.length;
+
+    if (index === childNodesALength) {
+      const verifiedAhead = verifyAhead();
+
+      childNodesVerify = verifiedAhead; ///
+    } else {
+      const childNodeA = childNodesA[index],
+            childNodeB = childNodesB[index],
+            nodeA = childNodeA, ///
+            nodeB = childNodeB, ///
+            nodeVerified = this.verifyNode(nodeA, nodeB, ...remainingArguments, () => {
+              index++;
+
+              remainingArguments.push(verifyAhead); ///
+
+              const childNodesVerifyAhead = this.verifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+
+              return childNodesVerifyAhead;
+            });
+
+      childNodesVerify = nodeVerified;  ///
+    }
+
+    return childNodesVerify;
+  }
+
+  verifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+    let terminalNodeVerified = false;
+
+    const matches = terminalNodeA.match(terminalNodeB);
+
+    if (matches) {
+      const verifyAhead = remainingArguments.pop(),
+            verifiedAhead = verifyAhead();
+
+      terminalNodeVerified = verifiedAhead;  ///
+    }
+
+    return terminalNodeVerified;
+  }
+
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeVerified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerify = this.verifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+
+      nonTerminalNodeVerified = childNodesVerify; ///
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}

package/src/verify/assertion/type.js

@@ -15,14 +15,14 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
 
   const typeAssertionString = context.nodeAsString(typeAssertionNode);
 
-  context.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
+  context.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
         typePresent = context.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The '${typeName}' type is not present.`, typeAssertionNode);
+    context.info(`The '${typeName}' type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
       const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assignments, derived, context);
@@ -38,7 +38,7 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   }
 
   if (typeAssertionVerified) {
-    context.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
+    context.debug(`...verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
   return typeAssertionVerified;
@@ -52,13 +52,17 @@ export function verifyVariableTypeAssertion(typeAssertionNode, assignments, deri
         termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context);
 
   if (termVerifiedAsVariable) {
+    const typeAssertionString = context.nodeAsString(typeAssertionNode);
+
+    context.trace(`Verifying the '${typeAssertionString}' variable type assertion...`, typeAssertionNode);
+
     const typeNode = typeNodeQuery(typeAssertionNode),
           typeName = typeNameFromTypeNode(typeNode),
           assertedTypeName = typeName,  ///
           assertedType = context.findTypeByTypeName(assertedTypeName);
 
     if (assertedType === null) {
-      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
+      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
       const firstVariable = first(variables),
             variable = firstVariable, ///
@@ -72,7 +76,7 @@ export function verifyVariableTypeAssertion(typeAssertionNode, assignments, deri
           const assertedTypeName = assertedType.getName(),
                 variableTypeName = variableType.getName();
 
-          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
         } else {
           variableTypeAssertionVerified = true;
         }
@@ -83,7 +87,7 @@ export function verifyVariableTypeAssertion(typeAssertionNode, assignments, deri
           const assertedTypeName = assertedType.getName(),
                 variableTypeName = variableType.getName();
 
-          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
+          context.info(`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,  ///
@@ -96,6 +100,10 @@ export function verifyVariableTypeAssertion(typeAssertionNode, assignments, deri
         }
       }
     }
+
+    if (variableTypeAssertionVerified) {
+      context.debug(`...verified the '${typeAssertionString}' variable type assertion.`, typeAssertionNode);
+    }
   }
 
   return variableTypeAssertionVerified;
@@ -109,13 +117,17 @@ function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
         termVerifiedAgainstConstructors = verifyTermAgainstConstructors(termNode, types, context);
 
   if (termVerifiedAgainstConstructors) {
+    const typeAssertionString = context.nodeAsString(typeAssertionNode);
+
+    context.trace(`Verifying the '${typeAssertionString}' term type assertion...`, typeAssertionNode);
+
     const typeNode = typeNodeQuery(typeAssertionNode),
           typeName = typeNameFromTypeNode(typeNode),
           assertedTypeName = typeName,  ///
           assertedType = context.findTypeByTypeName(assertedTypeName);
 
     if (assertedType === null) {
-      context.error(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
+      context.info(`The '${assertedTypeName}' asserted type is not present.`, typeAssertionNode);
     } else {
       const firstType = first(types),
             termType = firstType; ///
@@ -128,7 +140,7 @@ function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
                 termTypeName = termType.getName(),
                 assertedTypeName = assertedType.getName();
 
-          context.error(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+          context.info(`The '${assertedTypeName}' asserted type is not equal to or a super-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
         } else {
           termTypeAssertionVerified = true;
         }
@@ -140,12 +152,16 @@ function verifyTermTypeAssertion(typeAssertionNode, derived, context) {
                 termTypeName = termType.getName(),
                 assertedTypeName = assertedType.getName();
 
-          context.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
+          context.info(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${termString}' term's '${termTypeName}' type.`, typeAssertionNode);
         } else {
           termTypeAssertionVerified = true;
         }
       }
     }
+
+    if (termTypeAssertionVerified) {
+      context.debug(`...verified the '${typeAssertionString}' term type assertion.`, typeAssertionNode);
+    }
   }
 
   return termTypeAssertionVerified;

package/src/verify/axiom.js

@@ -20,7 +20,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
+  fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -54,7 +54,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   }
 
   if (axiomVerified) {
-    fileContext.info(`Verified the '${labelsString}' axiom.`, axiomNode);
+    fileContext.debug(`...verified the '${labelsString}' axiom.`, axiomNode);
   }
 
   return axiomVerified;

package/src/verify/conclusion.js

@@ -13,7 +13,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
 
   const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
-  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
+  metaproofContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
         unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode),
@@ -29,7 +29,7 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
   }
 
   if (conclusionVerified) {
-    metaproofContext.info(`Verified the '${conclusionString}' conclusion.`, conclusionNode);
+    metaproofContext.debug(`...verified the '${conclusionString}' conclusion.`, conclusionNode);
   }
 
   return conclusionVerified;

package/src/verify/conjecture.js

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

package/src/verify/consequent.js

@@ -13,7 +13,7 @@ export default function verifyConsequent(consequentNode, consequents, proofConte
 
   const consequentString = proofContext.nodeAsString(consequentNode);
 
-  proofContext.debug(`Verifying the '${consequentString}' consequent...`, consequentNode);
+  proofContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
 
   const derived = false,
         assignments = [],
@@ -30,7 +30,7 @@ export default function verifyConsequent(consequentNode, consequents, proofConte
   }
 
   if (consequentVerified) {
-    proofContext.info(`Verified the '${consequentString}' consequent.`, consequentNode);
+    proofContext.debug(`...verified the '${consequentString}' consequent.`, consequentNode);
   }
 
   return consequentVerified;

package/src/verify/declaration/combinator.js

@@ -10,9 +10,17 @@ export default function verifyCombinatorDeclaration(combinatorDeclarationNode, f
   let combinatorDeclarationVerified;
 
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
-        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
+        statementString = fileContext.nodeAsString(statementNode);
+
+  fileContext.trace(`Verifying the '${statementString}' combinator declaration...`, combinatorDeclarationNode);
+
+  const statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
 
   combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
 
+  if (combinatorDeclarationVerified) {
+    fileContext.debug(`...verified the '${statementString}' combinator declaration.`, combinatorDeclarationNode);
+  }
+
   return combinatorDeclarationVerified;
 }

package/src/verify/declaration/constructor.js

@@ -3,6 +3,7 @@
 import verifyTermAsConstructor from "../../verify/termAsConstructor";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
@@ -12,9 +13,22 @@ export default function verifyConstructorDeclaration(constructorDeclarationNode,
 
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
-        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
+        termString = fileContext.nodeAsString(termNode),
+        typeString = fileContext.nodeAsString(typeNode);
+
+  (typeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${termString}' constructor declaration...`, constructorDeclarationNode) :
+      fileContext.trace(`Verifying the '${termString}:${typeString}' constructor declaration...`, constructorDeclarationNode);
+
+  const termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
 
   constructorDeclarationVerified = termVerifiedAsConstructor; ///
 
+  if (constructorDeclarationVerified) {
+    (typeString === EMPTY_STRING) ?
+      fileContext.debug(`...verified the '${termString}' constructor declaration.`, constructorDeclarationNode) :
+        fileContext.debug(`...verified the '${termString}:${typeString}' constructor declaration.`, constructorDeclarationNode);
+  }
+
   return constructorDeclarationVerified;
 }

package/src/verify/declaration/metavariable.js

@@ -12,9 +12,17 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
 
   const metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
         metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
-        metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
+        metavariableString = fileContext.nodeAsString(metaTypeNode);
+
+  fileContext.trace(`Verifying the '${metavariableString}' metavariable declaration...`, metavariableDeclarationNode);
+
+  const metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
 
   metavariableDeclarationVerified = metavariableVVerified;  ///
 
+  if (metavariableDeclarationVerified) {
+    fileContext.debug(`...verified the '${metavariableString}' metavariable declaration.`, metavariableDeclarationNode);
+  }
+
   return metavariableDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -3,6 +3,7 @@
 import verifyType from "../../verify/type";
 
 import { nodeQuery } from "../../utilities/query";
+import { EMPTY_STRING } from "../../constants";
 
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
@@ -13,11 +14,23 @@ export default function verifyTypeDeclaration(typeDeclarationNode, fileContext)
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
-        superTypeNode = secondTypeNode; ///
+        superTypeNode = secondTypeNode, ///
+        typeString = fileContext.nodeAsString(typeNode),
+        superTypeString = fileContext.nodeAsString(superTypeNode);
+
+  (superTypeString === EMPTY_STRING) ?
+    fileContext.trace(`Verifying the '${typeString}' type declaration...`, typeDeclarationNode) :
+      fileContext.trace(`Verifying the '${typeString}:${superTypeString}' type declaration...`, typeDeclarationNode);
 
   const typeVerified = verifyType(typeNode, superTypeNode, fileContext);
 
   typeDeclarationVerified = typeVerified; ///
 
+  if (typeDeclarationVerified) {
+    (superTypeString === EMPTY_STRING) ?
+      fileContext.trace(`...verified the '${typeString}' type declaration.`, typeDeclarationNode) :
+        fileContext.trace(`...verified the '${typeString}:${superTypeString}' type declaration.`, typeDeclarationNode);
+  }
+
   return typeDeclarationVerified;
 }