occam-verify-cli 0.0.1073 → 0.0.1075

package/src/mixins/term/verify.js

@@ -1,15 +1,16 @@
 "use strict";
 
-import Variable from "../../variable";
+import shim from "../../shim";
 
 import { nodeQuery } from "../../utilities/query";
 
-const variableNodeQuery = nodeQuery("/term/variable");
+const variableNodeQuery = nodeQuery("/term/variable!");
 
 function verifyTermAsVariable(term, localContext, verifyAhead) {
   let termVerifiedAsVariable = false;
 
-  const termNode = term.getNode(),
+  const { Variable } = shim,
+        termNode = term.getNode(),
         variableNode = variableNodeQuery(termNode),
         variable = Variable.fromVariableNode(variableNode, localContext);
 

package/src/premise.js

@@ -3,7 +3,6 @@
 import shim from "./shim";
 import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -162,7 +161,8 @@ class Premise {
   }
 
   static fromPremiseNode(suppositionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           premise = new Premise(fileContext, unqualifiedStatement);
 

package/src/proof.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import Derivation from "./derivation";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation");
 
-export default class Proof {
+class Proof {
   constructor(derivation) {
     this.derivation = derivation;
   }
@@ -47,7 +47,8 @@ export default class Proof {
     let proof = null;
 
     if (proofNode !== null) {
-      const derivationNode = derivationNodeQuery(proofNode),
+      const { Derivation } = shim,
+            derivationNode = derivationNodeQuery(proofNode),
             derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
 
       proof = new Proof(derivation);
@@ -56,3 +57,9 @@ export default class Proof {
     return proof;
   }
 }
+
+Object.assign(shim, {
+  Proof
+});
+
+export default Proof;

package/src/proofStep.js

@@ -1,12 +1,9 @@
 "use strict";
 
 import shim from "./shim";
-import Subproof from "./subproof";
-import Substitutions from "./substitutions";
-import QualifiedStatement from "./statement/qualified";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
+import { assignAssignments } from "./utilities/assignments";
 
 const subproofNodeQuery = nodeQuery("/proofStep|lastProofStep/subproof"),
       qualifiedStatementNodeQuery = nodeQuery("/proofStep|lastProofStep/qualifiedStatement"),
@@ -48,7 +45,8 @@ class ProofStep {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const substitutions = Substitutions.fromNothing();
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing();
 
     if (this.qualifiedStatement !== null) {
       const localContextA = localContext, ///
@@ -91,7 +89,13 @@ class ProofStep {
             assignments = [],
             unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
 
-      verified = unqualifiedStatementVerified;  ///
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          verified = true;
+        }
+      }
     }
 
     if (verified) {
@@ -104,7 +108,8 @@ class ProofStep {
   }
 
   static fromProofStepNode(proofStepNode, fileContext) {
-    const subproofNode = subproofNodeQuery(proofStepNode),
+    const { Subproof, QualifiedStatement, UnqualifiedStatement } = shim,
+          subproofNode = subproofNodeQuery(proofStepNode),
           qualifiedStatementNode = qualifiedStatementNodeQuery(proofStepNode),
           unqualifiedStatementNode = unqualifiedStatementNodeQuery(proofStepNode),
           subproof = Subproof.fromSubproofNode(subproofNode, fileContext),

package/src/reference.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Metavariable from "./metavariable";
+import shim from "./shim";
 import LocalContext from "./context/local";
 
 import { nodeQuery } from "./utilities/query";
@@ -67,7 +67,8 @@ export default class Reference {
   }
 
   static fromReferenceNode(referenceNode, fileContext) {
-    const metavariableNode = metavariableNodeQuery(referenceNode),
+    const { Metavariable } = shim,
+          metavariableNode = metavariableNodeQuery(referenceNode),
           localContext = LocalContext.fromFileContext(fileContext),
           metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
           reference = new Reference(metavariable);

package/src/rule.js

@@ -3,12 +3,7 @@
 import { arrayUtilities } from "necessary";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Premise from "./premise";
-import Conclusion from "./conclusion";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 
 import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -75,7 +70,8 @@ class Rule {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
+    const { Substitutions } = shim,
+          proofSteps = localContext.getProofSteps(),
           substitutions = Substitutions.fromNothing(),
           proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 
@@ -125,15 +121,15 @@ class Rule {
 
     this.fileContext.trace(`Verifying the '${ruleString}' rule...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             premisesVerified = this.premises.every((premise) => {
               const premiseVerified = premise.verify(localContext);
@@ -150,7 +146,8 @@ class Rule {
           let proofVerified = true; ///
 
           if (this.proof !== null) {
-            const substitutions = Substitutions.fromNothing();
+            const { Substitutions } = shim,
+                  substitutions = Substitutions.fromNothing();
 
             proofVerified = this.proof.verify(substitutions, this.conclusion, localContext);
           }
@@ -204,7 +201,8 @@ class Rule {
   }
 
   static fromRuleNode(ruleNode, fileContext) {
-    const proofNode = proofNodeQuery(ruleNode),
+    const { Label, Proof, Premise, Conclusion } = shim,
+          proofNode = proofNodeQuery(ruleNode),
           labelNodes = labelNodesQuery(ruleNode),
           premiseNodes = premiseNodesQuery(ruleNode),
           conclusionNode = conclusionNodeQuery(ruleNode),

package/src/statement/qualified.js

@@ -12,7 +12,7 @@ import { assignAssignments } from "../utilities/assignments";
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement"),
       referenceNodeQuery = nodeQuery("/qualifiedStatement/reference");
 
-export default class QualifiedStatement {
+class QualifiedStatement {
   constructor(string, statement, reference) {
     this.string = string;
     this.statement = statement;
@@ -127,3 +127,9 @@ export default class QualifiedStatement {
     return qualifiedStatement;
   }
 }
+
+Object.assign(shim, {
+  QualifiedStatement
+});
+
+export default QualifiedStatement;

package/src/statement/unqualified.js

@@ -50,7 +50,6 @@ class UnqualifiedStatement {
       if (verified) {
         localContext.debug(`...verified the '${unqualifiedStatementString}' unqualified statement.`);
       }
-
     } else {
       localContext.debug(`Cannot verify the '${unqualifiedStatementString}' unqualified statement because it is nonsense.`);
     }

package/src/statement.js

@@ -171,18 +171,18 @@ class Statement {
     return verified;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const statementNode = this.node,  ///
           statementString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${statementString}' statement at top level...`);
+    fileContext.trace(`Verifying the '${statementString}' statement when declared...`);
 
     verifiedAtTopLevel = statementAsCombinatorVerifier.verifyStatement(statementNode, fileContext);
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${statementString}' statement at top level.`);
+      fileContext.debug(`...verified the '${statementString}' statement when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/subDerivation.js

@@ -10,7 +10,7 @@ const { last } = arrayUtilities;
 
 const proofStepNodesQuery = nodesQuery("/subDerivation/proofStep|lastProofStep");
 
-export default class SubDerivation {
+class SubDerivation {
   constructor(proofSteps) {
     this.proofSteps = proofSteps;
   }
@@ -52,4 +52,10 @@ export default class SubDerivation {
     return subDerivation;
 
   }
-}
+}
+
+Object.assign(shim, {
+  SubDerivation
+});
+
+export default SubDerivation;

package/src/subproof.js

@@ -1,16 +1,16 @@
 "use strict";
 
-import Supposition from "./supposition";
+import shim from "./shim";
+
 import LocalContext from "./context/local";
-import SubDerivation from "./subDerivation";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import {subproofNodeAsSubproofString, subproofStringFromSubproofNode} from "./utilities/subproof";
+import { subproofStringFromSubproofNode } from "./utilities/subproof";
 
 const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default class Subproof {
+class Subproof {
   constructor(string, suppositions, subDerivation) {
     this.string = string;
     this.suppositions = suppositions;
@@ -79,7 +79,8 @@ export default class Subproof {
     let subproof = null;
 
     if (subproofNode !== null) {
-      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+      const { Supposition, SubDerivation } = shim,
+            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
             suppositionNodes = suppositionNodesQuery(subproofNode),
             subDerivationNode = subDerivationNodeQuery(subproofNode),
             string = subproofString,  ///
@@ -96,3 +97,9 @@ export default class Subproof {
     return subproof;
   }
 }
+
+Object.assign(shim, {
+  Subproof
+});
+
+export default Subproof;

package/src/substitution/statementForMetavariable.js

@@ -3,7 +3,6 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
@@ -30,10 +29,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
-  getMetavariableName() {
-    const metavariableName = this.metavariable.getName();
+  getMetavariableNode() {
+    const metavariableNode = this.metavariable.getNode();
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -49,8 +48,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const metavariableName = this.getMetavariableName(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
+    const metavariableNode = this.getMetavariableNode(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
 
     if (simpleSubstitution !== null) {
       const substitution = simpleSubstitution,  ///
@@ -104,7 +103,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   unifyStatement(statement, localContextA, localContextB) {
     let substitution = null;
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing(),
           statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
@@ -128,7 +128,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   matchSubstitutionNode(substitutionNode) {
     let substitutionNodeMatches;
@@ -146,12 +146,12 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   toJSON() {

package/src/substitution.js

@@ -35,10 +35,10 @@ class Substitution {
     return substitutionNode;
   }
 
-  getMetavariableName() {
-    const metavariableName = null;
+  getMetavariableNode() {
+    const metavariableNode = null;
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -90,16 +90,16 @@ class Substitution {
     return variableNameMatches;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = false;
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = false;
 
-    return metavariableNameMatches;
+    return metavariableNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameAndSubstitutionNodeMatches = false;
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {

package/src/substitutions.js

@@ -1,12 +1,14 @@
 "use strict";
 
+import shim from "./shim";
+
 import { arrayUtilities } from "necessary";
 
 import { EMPTY_STRING } from "./constants";
 
 const { find, first, prune, filter, compress } = arrayUtilities;
 
-export default class Substitutions {
+class Substitutions {
   constructor(array, savedArray) {
     this.array = array;
     this.savedArray = savedArray;
@@ -34,24 +36,26 @@ export default class Substitutions {
     return firstSubstitution;
   }
 
-  getMetavariableNames() {
-    const metavariableNames = [];
+  getMetavariableNodes() {
+    const metavariableNodes = [];
 
     this.forEachSubstitution((substitution) => {
-      const metavariableName = substitution.getMetavariableName();
+      const metavariableNode = substitution.getMetavariableNode();
 
-      if (metavariableName !== null) {
-        metavariableNames.push(metavariableName);
+      if (metavariableNode !== null) {
+        metavariableNodes.push(metavariableNode);
       }
     });
 
-    compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
-      if (metavariableNameA === metavariableNameB) {
+    compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
+      const metavariableNodeAMatchesMetavariableNodeB = metavariableNodeB.match(metavariableNodeA);
+
+      if (metavariableNodeAMatchesMetavariableNodeB) {
         return true;
       }
     });
 
-    return metavariableNames;
+    return metavariableNodes;
   }
 
   mapSubstitution(callback) { return this.array.map(callback); }
@@ -102,11 +106,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionByMetavariableName(metavariableName) {
+  findSubstitutionByMetavariableNode(metavariableNode) {
     const substitution = this.findSubstitution((substitution) => {
-      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (metavariableNameMatches) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
@@ -114,11 +118,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionsByMetavariableName(metavariableName) {
+  findSubstitutionsByMetavariableNode(metavariableNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (metavariableNameMatches) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
@@ -126,8 +130,8 @@ export default class Substitutions {
     return substitutions;
   }
 
-  findSimpleSubstitutionByMetavariableName(metavariableName) {
-    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
+  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
           simpleSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionSimple = substitution.isSimple();
 
@@ -141,8 +145,8 @@ export default class Substitutions {
     return simpleSubstitution;
   }
 
-  findComplexSubstitutionsByMetavariableName(metavariableName) {
-    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
+  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
           complexSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionComplex = substitution.isComplex();
 
@@ -154,11 +158,11 @@ export default class Substitutions {
     return complexSubstitutions;
   }
 
-  findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+  findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-            const metavariableNameAndSubstitutionNodeMatch = substitution.matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+            const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
-            if (metavariableNameAndSubstitutionNodeMatch) {
+            if (metavariableNodeAndSubstitutionNodeMatch) {
               return true;
             }
           }),
@@ -168,15 +172,15 @@ export default class Substitutions {
     return substitution;
   }
 
-  isSimpleSubstitutionPresentByMetavariableName(metavariableName) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
+  isSimpleSubstitutionPresentByMetavariableNode(metavariableNode) {
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableNode(metavariableNode),
           simpleSubstitutionPresent = (simpleSubstitution !== null);
 
     return simpleSubstitutionPresent;
   }
 
-  isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const substitution = this.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+  isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const substitution = this.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
           substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
@@ -220,9 +224,9 @@ export default class Substitutions {
   }
 
   resolve(localContextA, localContextB) {
-    const metavariableNames = this.getMetavariableNames(),
-          resolved = metavariableNames.every((metavariableName) => {
-                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
+    const metavariableNodes = this.getMetavariableNodes(),
+          resolved = metavariableNodes.every((metavariableNode) => {
+                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
                               complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
                                 const substitution = complexSubstitution, ///
                                       substitutions = this, ///
@@ -252,7 +256,7 @@ export default class Substitutions {
       ...this.array
     ];
 
-    rightDifference(this.savedArray, array);
+    leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
       this.removeSubstitution(substitution, localContext);
@@ -303,11 +307,15 @@ export default class Substitutions {
   }
 }
 
-function rightDifference(arrayA, arrayB) {
-  filter(arrayB, (elementB) => {
-    const arrayAIncludesElementB = arrayA.includes(elementB);
+Object.assign(shim, {
+  Substitutions
+});
+
+function leftDifference(arrayA, arrayB) {
+  filter(arrayA, (elementA) => {
+    const arrayBIncludesElementA = arrayB.includes(elementA);
 
-    if (!arrayAIncludesElementB) {
+    if (!arrayBIncludesElementA) {
       return true;
     }
   });

package/src/supposition.js

@@ -3,7 +3,6 @@
 import shim from "./shim";
 import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -155,7 +154,8 @@ class Supposition {
   }
 
   static fromSuppositionNode(suppositionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           supposition = new Supposition(fileContext, unqualifiedStatement);
 

package/src/term.js

@@ -213,12 +213,12 @@ class Term {
     return verifiedGivenType;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const termString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${termString}' term at top level...`);
+    fileContext.trace(`Verifying the '${termString}' term when declared...`);
 
     const termNode = this.node, ///
           termVerifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
@@ -230,7 +230,7 @@ class Term {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${termString}' term at top level.`);
+      fileContext.debug(`...verified the '${termString}' term when declared.`);
     }
 
     return verifiedAtTopLevel;