occam-verify-cli 0.0.1002 → 0.0.1005

package/src/supposition.js

@@ -1,72 +1,122 @@
 "use strict";
 
+import ProofStep from "./proofStep";
+import UnqualifiedStatement from "./statement/unqualified";
+
 import metaLevelUnifier from "./unifier/metaLevel";
 
 import { match } from "./utilities/array";
-import { nodeAsString } from "./utilities/string";
+import { assignAssignments } from "./utilities/assignments";
 import { nodeQuery, nodesQuery } from "./utilities/query";
 
 const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement"),
       subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
       subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
       subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Supposition {
-  constructor(statementNode) {
-    this.statementNode = statementNode;
+  constructor(fileContext, unqualifiedStatement) {
+    this.fileContext = fileContext;
+    this.unqualifiedStatement = unqualifiedStatement;
   }
 
-  getStatementNode() {
-    return this.statementNode;
+  getFileContext() {
+    return this.fileContext;
   }
 
-  unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
-    let statementUnified = false;
+  getUnqualifiedStatement() {
+    return this.unqualifiedStatement;
+  }
 
-    if (this.statementNode !== null) {
-      const nodeA = this.statementNode,  ///
-            nodeB = statementNodeB,  ///
-            unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  getString() { return this.unqualifiedStatement.getString(); }
+
+  getStatement() { return this.unqualifiedStatement.getStatement(); }
+
+  // unifyStatement(statementNodeB, substitutions, localContextA, localContextB) {
+  //   let statementUnified = false;
+  //
+  //   if (this.statementNode !== null) {
+  //     const nodeA = this.statementNode,  ///
+  //           nodeB = statementNodeB,  ///
+  //           unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  //
+  //     statementUnified = unified; ///
+  //   }
+  //
+  //   return statementUnified;
+  // }
+
+  // unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
+  //   let subproofUnified = false;
+  //
+  //   if (this.statementNode !== null) {
+  //     const statementNodeA = this.statementNode,
+  //           subproofAssertionNodeA = subproofAssertionNodeQuery(statementNodeA);  ///
+  //
+  //     if (subproofAssertionNodeA !== null) {
+  //       const subproofAssertionStatementNodesA = subproofAssertionStatementNodesQuery(subproofAssertionNodeA),  ///
+  //             subproofSuppositionStatementNodesB = subproofSuppositionStatementNodesQuery(subproofNodeB), ///
+  //             subproofLastProofStepStatementNodeB = subproofLastProofStepStatementNodeQuery(subproofNodeB), ///
+  //             subproofStatementNodesB = [
+  //               ...subproofSuppositionStatementNodesB,
+  //               subproofLastProofStepStatementNodeB
+  //             ];
+  //
+  //       subproofUnified = match(subproofAssertionStatementNodesA, subproofStatementNodesB, (subproofAssertionStatementNodeA, subproofStatementNodeB) => {
+  //         const nodeA = subproofAssertionStatementNodeA,  ///
+  //               nodeB = subproofStatementNodeB, ///
+  //               unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+  //
+  //         if (unified) {
+  //           return true;
+  //         }
+  //       });
+  //     }
+  //   }
+  //
+  //   return subproofUnified;
+  // }
+
+  verify(localContext) {
+    let verified = false;
+
+    const suppositionString = this.getString(); ///
+
+    if (this.unqualifiedStatement !== null) {
+      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
+
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
+
+          localContext.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
 
-      statementUnified = unified; ///
+    } else {
+      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
     }
 
-    return statementUnified;
-  }
-
-  unifySubproof(subproofNodeB, substitutions, localContextA, localContextB) {
-    let subproofUnified = false;
-
-    if (this.statementNode !== null) {
-      const statementNodeA = this.statementNode,
-            subproofAssertionNodeA = subproofAssertionNodeQuery(statementNodeA);  ///
-
-      if (subproofAssertionNodeA !== null) {
-        const subproofAssertionStatementNodesA = subproofAssertionStatementNodesQuery(subproofAssertionNodeA),  ///
-              subproofSuppositionStatementNodesB = subproofSuppositionStatementNodesQuery(subproofNodeB), ///
-              subproofLastProofStepStatementNodeB = subproofLastProofStepStatementNodeQuery(subproofNodeB), ///
-              subproofStatementNodesB = [
-                ...subproofSuppositionStatementNodesB,
-                subproofLastProofStepStatementNodeB
-              ];
-
-        subproofUnified = match(subproofAssertionStatementNodesA, subproofStatementNodesB, (subproofAssertionStatementNodeA, subproofStatementNodeB) => {
-          const nodeA = subproofAssertionStatementNodeA,  ///
-                nodeB = subproofStatementNodeB, ///
-                unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-          if (unified) {
-            return true;
-          }
-        });
-      }
+    if (verified) {
+      localContext.debug(`...verified the '${suppositionString}' supposition.`);
     }
 
-    return subproofUnified;
+    return verified;
   }
 
-  static fromStatementNode(statementNode) {
-    const supposition = new Supposition(statementNode);
+  static fromSuppositionNode(suppositionNode, fileContext) {
+    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+          unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }

package/src/unifier/statementWithCombinator.js

@@ -1,9 +1,9 @@
 "use strict";
 
+import shim from "../shim";
 import Unifier from "../unifier";
 import unifyTermWithType from "../unify/termWithType";
 import unifyFrameWithMetaType from "../unify/frameWithMetaType";
-import unifyStatementWithMetaType from "../unify/statementWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -31,9 +31,12 @@ class StatementWithCombinatorUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
       unify: (statementNodeA, metaTypeNodeB, assignments, stated, localContext) => {
-        const metaTypeNode = metaTypeNodeB, ///
+        const { MetaType, Statement } = shim,
+              metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, stated, localContext);
+              metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
+              statement = Statement.fromStatementNode(statementNode, localContext),
+              statementUnifiedWithMetaType = statement.unifyWithMetaType(metaType, assignments, stated, localContext);
 
         return statementUnifiedWithMetaType;
       }

package/src/unify/metavariableWithFrame.js

@@ -27,7 +27,7 @@ export default function unifyMetavariableWithFrame(metavariableNodeA, frameNodeB
     } else {
       const frameNode = frameNodeB, ///
             metavariableNode = metavariableNodeA, ///
-            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode),
+            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
             substitution = frameForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/metavariableWithStatement.js

@@ -27,7 +27,7 @@ export default function unifyMetavariableWithStatement(metavariableNodeA, statem
     } else {
       const statementNode = statementNodeB, ///
             metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB),
             substitution = statementForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/metavariableWithStatementGivenSubstitution.js

@@ -28,7 +28,7 @@ export default function unifyMetavariableWithStatementGivenSubstitution(metavari
       const statementNode = statementNodeB, ///
             substitutionNode = substitutionNodeA, ///
             metavariableNode = metavariableNodeA, ///
-            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode),
+            statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode, localContextA, localContextB),
             substitution = statementForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/unify/variableWithTerm.js

@@ -24,7 +24,7 @@ export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitu
     } else {
       const termNode = termNodeB, ///
             variableNode = variableNodeA, ///
-            termForVariableSubstitution = TermForVariableSubstitution.fromTernNodeAndVariableNode(termNode, variableNode),
+            termForVariableSubstitution = TermForVariableSubstitution.fromTernNodeAndVariableNode(termNode, variableNode, localContextA, localContextB),
             substitution = termForVariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/utilities/node.js

@@ -2,14 +2,17 @@
 
 import { parsersUtilities } from "occam-custom-grammars";
 
+import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
-import { termTokensFromTermString, statementTokensFromStatementString } from "../utilities/tokens";
+import { TERM_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME } from "../ruleNames";
+import { termTokensFromTermString, unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
 
-const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
+const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+      nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
+
+const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export function termNodeFromTermString(termString, lexer, parser) {
   const termTokens = termTokensFromTermString(termString, lexer),
@@ -19,8 +22,11 @@ export function termNodeFromTermString(termString, lexer, parser) {
 }
 
 export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const statementTokens = statementTokensFromStatementString(statementString, lexer),
-        statementNode = statementNodeFromStatementTokens(statementTokens, parser);
+  const unqualifiedStatementString = `${statementString}
+`,
+        unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+        unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
+        statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   return statementNode;
 }
@@ -33,15 +39,15 @@ export function termNodeFromTermTokens(termTokens, parser) {
   return termNode;
 }
 
-export function statementNodeFromStatementTokens(statementTokens, parser) {
-  const tokens = statementTokens,  ///
-        ruleName = STATEMENT_RULE_NAME,
-        statementNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
+export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
+  const tokens = unqualifiedStatementTokens,  ///
+        ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
+        unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
-  return statementNode;
+  return unqualifiedStatementNode;
 }
 
-function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {
+function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = nominalParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],
         node = parser.parse(tokens, rule);

package/src/utilities/releaseContext.js

@@ -105,12 +105,12 @@ export function initialiseReleaseContext(dependency, context) {
       const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, context);
 
       if (dependencyReleaseContextsInitialised) {
-        const { log, verbose } = context,
+        const { log } = context,
               releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
         log.debug(`Initialising the '${dependencyName}' context...`);
 
-        releaseContextInitialised = releaseContext.initialise(releaseContexts, verbose);
+        releaseContextInitialised = releaseContext.initialise(releaseContexts);
 
         releaseContextInitialised ?
           log.info(`...initialised the '${dependencyName}' context.`) :

package/src/utilities/string.js

@@ -2,6 +2,12 @@
 
 import { COMMA, EMPTY_STRING } from "../constants";
 
+export function trim(string) {
+  string = string.replace(/\s+$/, EMPTY_STRING);  ///
+
+  return string;
+}
+
 export function nodeAsString(node, tokens) {
   let string;
 
@@ -17,8 +23,6 @@ export function nodeAsString(node, tokens) {
     string = nonTerminalNodeAsString(nonTerminalNode, tokens);
   }
 
-  string = string.replace(/\s+$/, EMPTY_STRING);
-
   return string;
 }
 

package/src/utilities/subproof.js

@@ -6,8 +6,8 @@ import { nodeAsString, nodesAsString } from "./string";
 const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
       subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
-export function subproofNodeAsSubproofString(subproofNode, localContext) {
-  const tokens = localContext.getTokens(),
+export function subproofStringFromSubproofNode(subproofNode, fileContext) {
+  const tokens = fileContext.getTokens(),
         subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
         subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
         subproofSuppositionStatementsString = nodesAsString(subproofSuppositionStatementNodes, tokens),

package/src/utilities/tokens.js

@@ -4,10 +4,10 @@ import { lexersUtilities } from "occam-custom-grammars";
 
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 
-const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
+const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+      nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
 export function termTokensFromTermString(termString, lexer) {
   const content = termString, ///
@@ -16,14 +16,14 @@ export function termTokensFromTermString(termString, lexer) {
   return termTokens;
 }
 
-export function statementTokensFromStatementString(statementString, lexer) {
-  const content = statementString,  ///
-        statementTokens = tokensFromContentAndLexer(content, lexer);
+export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
+  const content = unqualifiedStatementString,  ///
+        unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);
 
-  return statementTokens;
+  return unqualifiedStatementTokens;
 }
 
-function tokensFromContentAndLexer(content, lexer = florenceLexer) {
+function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);
 
   return tokens;

package/src/variable.js

@@ -46,16 +46,6 @@ export default class Variable {
     return nodeAndTypeMatch;
   }
 
-  asString(tokens) {
-    const typeName = this.type.getName();
-
-    let string = nodeAsString(this.node, tokens);
-
-    string = `${string}:${typeName}`; ///
-
-    return string;
-  }
-
   static fromVariableNodeAndType(variableNode, type) {
     const node = variableNode,  ///
           variable = new Variable(node, type);

package/src/verifier/metaLevel.js

@@ -25,8 +25,9 @@ class MetaLevelVerifier extends Verifier {
     {
       nodeQuery: statementNodeQuery,
       verify: (statementNode, assignments, stated, localContext) => {
-        const { verifyStatement } = shim,
-              statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
+        const { Statement } = shim,
+              statement = Statement.fromStatementNode(statementNode, localContext),
+              statementVerified = statement.verify(assignments, stated, localContext);
 
         return statementVerified;
       }

package/src/verifier/topLevel.js

@@ -1,17 +1,17 @@
 "use strict";
 
+import Rule from "../rule";
 import Verifier from "../verifier";
 import verifyError from "../verify/error";
-import verifyRule from "../verify/rule";
 import verifyAxiom from "../verify/axiom";
 import verifyLemma from "../verify/lemma";
 import verifyTheorem from "../verify/theorem";
 import verifyMetaLemma from "../verify/metaLemma";
 import verifyConjecture from "../verify/conjecture";
 import verifyMetatheorem from "../verify/metatheorem";
+import CombinatorDeclaration from "../declaration/combinator";
 import verifyTypeDeclaration from "../verify/declaration/type";
 import verifyVariableDeclaration from "../verify/declaration/variable";
-import verifyCombinatorDeclaration from "../verify/declaration/combinator";
 import verifyConstructorDeclaration from "../verify/declaration/constructor";
 import verifyMetavariableDeclaration from "../verify/declaration/metavariable";
 
@@ -55,7 +55,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: ruleNodeQuery,
       verify: (ruleNode, fileContext) => {
-        const ruleVerified = verifyRule(ruleNode, fileContext);
+        const rule = Rule.fromRuleNode(ruleNode, fileContext),
+              ruleVerified = rule.verify(fileContext);
 
         return ruleVerified;
       }
@@ -127,7 +128,8 @@ class TopLevelVerifier extends Verifier {
     {
       nodeQuery: combinatorDeclarationNodeQuery,
       verify: (combinatorDeclarationNode, fileContext) => {
-        const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext);
+        const combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
+              combinatorDeclarationVerified = combinatorDeclaration.verify(fileContext);
 
         return combinatorDeclarationVerified;
       }

package/src/verify/axiom.js

@@ -2,10 +2,9 @@
 
 import Axiom from "../axiom";
 import LocalContext from "../context/local";
-import verifyLabels from "../verify/labels";
 import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
-import verifySuppositions from "../verify/suppositions";
+// import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";

package/src/verify/conjecture.js

@@ -1,12 +1,11 @@
 "use strict";
 
 import Conjecture from "../conjecture";
-import verifyProof from "../verify/proof";
-import verifyLabels from "../verify/labels";
+// import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 import verifyConsequent from "../verify/consequent";
-import verifySuppositions from "../verify/suppositions";
+// import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";

package/src/verify/consequent.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Consequent from "../consequent";
-import verifyStatement from "../verify/statement";
+// import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 

package/src/verify/declaration/combinator.js

@@ -2,25 +2,5 @@
 
 import verifyStatementAsCombinator from "../../verify/statementAsCombinator";
 
-import { nodeQuery } from "../../utilities/query";
-
-const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
-
 export default function verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext) {
-  let combinatorDeclarationVerified;
-
-  const statementNode = statementNodeQuery(combinatorDeclarationNode),
-        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/metavariable.js

@@ -5,7 +5,6 @@ import MetavariableAssignment from "../../assignment/metavariable";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../../utilities/name";
 
 const termNodeQuery = nodeQuery("/argument/term"),
       typeNodeQuery = nodeQuery("/argument/type"),
@@ -21,14 +20,14 @@ export default function verifyMetavariableDeclaration(metavariableDeclarationNod
         metaTypeString = fileContext.nodeAsString(metaTypeNode),
         metavariableString = fileContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${metavariableString}:${metaTypeString}' metavariable declaration...`, metavariableDeclarationNode);
+  fileContext.trace(`Verifying the '${metavariableString}:${metaTypeString}' metavariable declaration...`);
 
   const metavariableVVerified = verifyMetavariable(metavariableNode, metaTypeNode, fileContext);
 
   metavariableDeclarationVerified = metavariableVVerified;  ///
 
   if (metavariableDeclarationVerified) {
-    fileContext.debug(`...verified the '${metavariableString}:${metaTypeString}' metavariable declaration.`, metavariableDeclarationNode);
+    fileContext.debug(`...verified the '${metavariableString}:${metaTypeString}' metavariable declaration.`);
   }
 
   return metavariableDeclarationVerified;
@@ -39,12 +38,12 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
 
   const metavariableString = fileContext.nodeAsString(metavariableNode);
 
-  fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
+  fileContext.trace(`Verifying the '${metavariableString}' metavariable...`);
 
   const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
-    fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
+    fileContext.debug(`The metavariable '${metavariableString}' is already present.`);
   } else {
     const termTypes = [],
           metaTypes = [],
@@ -70,10 +69,7 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
         termType = firstTermType; ///
       }
 
-      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-            node = metavariableNode,  ///
-            name = metavariableName,  ///
-            metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
+      const metavariable = Metavariable.fromMetavariableNodeNameTermTypeAndMetaType(metavariableNode, termType, metaType, fileContext),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);
 
@@ -84,7 +80,7 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
   }
 
   if (metavariableVerified) {
-    fileContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
+    fileContext.debug(`...verified the '${metavariableString}' metavariable.`);
   }
 
   return metavariableVerified;
@@ -103,7 +99,7 @@ function verifyArgument(argumentNode, termTypes, fileContext) {
     } else {
       const termString = fileContext.nodeAsString(termNode);
 
-      fileContext.debug(`The '${termString}' term was found when a type should have been present.`, termNode);
+      fileContext.debug(`The '${termString}' term was found when a type should have been present.`);
     }
     const typeNode = typeNodeQuery(argumentNode);
 
@@ -119,7 +115,7 @@ function verifyArgument(argumentNode, termTypes, fileContext) {
       } else {
         const typeString = fileContext.nodeAsString(typeNode);
 
-        fileContext.debug(`The '${typeString}' type is not present.`, typeNode);
+        fileContext.debug(`The '${typeString}' type is not present.`);
       }
     }
   }

package/src/verify/files.js

@@ -6,7 +6,7 @@ import { filePathUtilities } from "occam-entities";
 
 import { filter, leftDifference } from "../utilities/array";
 
-const { isFilePathFlorenceFilePath } = filePathUtilities;
+const { isFilePathNominalFilePath } = filePathUtilities;
 
 export default function verifyFiles(releaseContext) {
   let filesVerified = false;
@@ -14,9 +14,9 @@ export default function verifyFiles(releaseContext) {
   const filePaths = releaseContext.getFilePaths();
 
   filter(filePaths, (filePath) => {
-    const filePathFlorenceFilePath = isFilePathFlorenceFilePath(filePath);
+    const filePathNominalFilePath = isFilePathNominalFilePath(filePath);
 
-    if (filePathFlorenceFilePath) {
+    if (filePathNominalFilePath) {
       return true;
     }
   })