occam-verify-cli 0.0.317 → 0.0.318

package/src/context/release.js

@@ -2,21 +2,19 @@
 
 import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
 
-import logMixins from "../mixins/log";
-
 import { push } from "../utilities/array";
 import { customGrammarFromRelease, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
 
 const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
-class ReleaseContext {
-  constructor(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
+export default class ReleaseContext {
+  constructor(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts) {
     this.log = log;
     this.release = release;
+    this.callbacks = callbacks;
     this.verified = verified;
     this.customGrammar = customGrammar;
-
     this.fileContexts = fileContexts;
     this.florenceLexer = florenceLexer;
     this.florenceParser = florenceParser;
@@ -31,6 +29,10 @@ class ReleaseContext {
     return this.release;
   }
 
+  getCallbacks() {
+    return this.callbacks;
+  }
+
   isVerified() {
     return this.verified;
   }
@@ -65,6 +67,8 @@ class ReleaseContext {
 
   getDependencies() { return this.release.getDependencies(); }
 
+  matchShortenedVersion(shortenedVersion) { return this.release.matchShortenedVersion(shortenedVersion); }
+
   getRules(releaseNames = []) {
     const name = this.getName(),
           rules = [],
@@ -204,10 +208,32 @@ class ReleaseContext {
     this.fileContexts.push(fileContext);
   }
 
+  setVerified(verified) {
+    this.verified = verified;
+  }
+
   tokenise(content) { return this.florenceLexer.tokenise(content); }
 
   parse(tokens) { return this.florenceParser.parse(tokens); }
 
+  trace(message) { this.log.trace(message); }
+
+  debug(message) { this.log.debug(message); }
+
+  info(message) { this.log.info(message); }
+
+  warning(message) { this.log.warning(message); }
+
+  error(message) { this.log.error(message); }
+
+  fatal(message) { this.log.fatal(message); }
+
+  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }
+
+  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }
+
+  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
+
   initialise(releaseContexts, dependencyReleaseContexts) {
     const releaseContext = this;  ///
 
@@ -222,19 +248,15 @@ class ReleaseContext {
     this.releaseContexts = releaseContexts;
   }
 
-  static fromLogAndRelease(log, release, ...remainingArguments) {
+  static fromLogReleaseAndCallbacks(log, release, callbacks, ...remainingArguments) {
     const verified = false,
           customGrammar = customGrammarFromRelease(release),
           fileContexts = [],
           florenceLexer = null,
           florenceParser = null,
           releaseContexts = [],
-          releaseContext = new ReleaseContext(log, release, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
+          releaseContext = new ReleaseContext(log, release, callbacks, verified, customGrammar, fileContexts, florenceLexer, florenceParser, releaseContexts, ...remainingArguments);
 
     return releaseContext;
   }
 }
-
-Object.assign(ReleaseContext.prototype, logMixins);
-
-export default ReleaseContext;

package/src/index.js

@@ -1,4 +1,5 @@
 "use strict";
 
+export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";

package/src/mixins/callbacks.js

@@ -0,0 +1,15 @@
+"use strict";
+
+function halt(node) { this.context.halt(node); }
+
+function begin(node) { this.context.begin(node); }
+
+function complete(node) { this.context.complete(node); }
+
+const callbacksMixins = {
+  halt,
+  begin,
+  complete
+};
+
+export default callbacksMixins;

package/src/mixins/file.js

@@ -0,0 +1,12 @@
+"use strict";
+
+function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
+
+function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
+
+const fileMixins = {
+  findRuleByReferenceName,
+  findAxiomByReferenceName
+};
+
+export default fileMixins;

package/src/mixins/logging.js

@@ -0,0 +1,24 @@
+"use strict";
+
+function trace(message) { this.context.trace(message); }
+
+function debug(message) { this.context.debug(message); }
+
+function info(message) { this.context.info(message); }
+
+function warning(message) { this.context.warning(message); }
+
+function error(message) { this.context.error(message); }
+
+function fatal(message) { this.context.fatal(message); }
+
+const loggingMixins = {
+  trace,
+  debug,
+  info,
+  warning,
+  error,
+  fatal
+};
+
+export default loggingMixins;

package/src/rule.js

@@ -23,7 +23,7 @@ export default class Rule {
     return this.conclusion;
   }
 
-  matchMetastatement(metastatementNode, context) {
+  matchMetastatement(metastatementNode, metaproofContext) {
     let metastatementNatches;
 
     const premisesLength = this.premises.length;
@@ -34,7 +34,7 @@ export default class Rule {
 
       metastatementNatches = conclusionMatches; ///
     } else {
-      const metaAssertions = context.getMetaAssertions();
+      const metaAssertions = metaproofContext.getMetaAssertions();
 
       metastatementNatches = someSubArray(metaAssertions, premisesLength, (metaAssertions) => {
         const premisesMatchConclusion = matchPremisesAndConclusion(this.premises, this.conclusion, metaAssertions, metastatementNode);

package/src/verify/IndicativeConditional.js

@@ -1,20 +1,29 @@
 "use strict";
 
-import verifyUnqualifiedStatement from "../verify/metastatement/unqualified";
+import verifyUnqualifiedStatement from "../verify/statement/unqualified";
 
 import { nodesQuery } from "../utilities/query";
 
 const unqualifiedStatementNodesQuery = nodesQuery("/indicativeConditional/unqualifiedStatement");
 
-export default function verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context) {
-  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(indicativeConditionalNode),
-        indicativeConditionalVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
-          const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+export default function verifyIndicativeConditional(indicativeConditionalNode, statementNodes, proofContext) {
+  let indicativeConditionalVerified;
 
-          if (unqualifiedStatementVerified) {
-            return true;
-          }
-        });
+  proofContext.begin(indicativeConditionalNode);
+
+  const unqualifiedStatementNodes = unqualifiedStatementNodesQuery(indicativeConditionalNode);
+
+  indicativeConditionalVerified = unqualifiedStatementNodes.every((unqualifiedStatementNode) => {
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
+
+    if (unqualifiedStatementVerified) {
+      return true;
+    }
+  });
+
+  indicativeConditionalVerified ?
+    proofContext.complete(indicativeConditionalNode) :
+      proofContext.halt(indicativeConditionalNode);
 
   return indicativeConditionalVerified;
 }

package/src/verify/assertion/type.js

@@ -9,17 +9,19 @@ import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
 const termNodeQuery = nodeQuery("/typeAssertion/term"),
       typeNodeQuery = nodeQuery("/typeAssertion/type");
 
-export default function verifyTypeAssertion(typeAssertionNode, context) {
+export default function verifyTypeAssertion(typeAssertionNode, proofContext) {
   let typeAssertionVerified = false;
 
+  proofContext.begin(typeAssertionNode);
+
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
-        typePresent = context.isTypePresentByTypeName(typeName);
+        typePresent = proofContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    context.error(`The ${typeName} type is not present.`, typeAssertionNode);
+    proofContext.error(`The ${typeName} type is not present.`);
   } else {
-    const derived = context.isDerived();
+    const derived = proofContext.isDerived();
 
     if (derived) {
       debugger
@@ -27,6 +29,7 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
       const types = [],
             names = [],
             values = [],
+            context = proofContext, ///
             termNode = termNodeQuery(typeAssertionNode),
             termVerified = verifyTermAsVariable(termNode, types, names, values, context);
 
@@ -37,20 +40,20 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
               value = firstValue;
 
         if (value !== undefined) {
-          context.error(`The value of the ${variableName} variable is not undefined.`, typeAssertionNode);
+          proofContext.error(`The value of the ${variableName} variable is not undefined.`);
         } else {
-          const type = context.findTypeByTypeName(typeName),
+          const type = proofContext.findTypeByTypeName(typeName),
                 firstType = first(types),
                 variableType = firstType, ///
                 typeSubTypeOfVariableType = type.isSubTypeOf(variableType);
 
           if (!typeSubTypeOfVariableType) {
-            context.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`, typeAssertionNode);
+            proofContext.error(`The asserted type of the ${variableName} variable is not a sub-type of its declared type.`);
           } else {
             const name = variableName,  ///
                   variable = Variable.fromTypeAndName(type, name);
 
-            context.addVariable(variable);
+            proofContext.addVariable(variable);
 
             typeAssertionVerified = true;
           }
@@ -59,5 +62,9 @@ export default function verifyTypeAssertion(typeAssertionNode, context) {
     }
   }
 
+  typeAssertionVerified ?
+    proofContext.complete(typeAssertionNode) :
+      proofContext.halt(typeAssertionNode);
+
   return typeAssertionVerified;
 }

package/src/verify/axiom.js

@@ -13,30 +13,28 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
       unqualifiedStatementNodeQuery = nodeQuery("/axiom/unqualifiedStatement!"),
       indicativeConditionalNodeQuery = nodeQuery("/axiom/indicativeConditional!");
 
-export default function verifyAxiom(axiomNode, context) {
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = nodesAsString(labelNodes);
-
-  context.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
-
-  const proofContext = ProofContext.fromContext(context);
+export default function verifyAxiom(axiomNode, fileContext) {
+  let axiomVerified = false;
 
-  context = proofContext; ///
+  fileContext.begin(axiomNode);
 
-  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
+  const labelNodes = labelNodesQuery(axiomNode),
+        labelsString = nodesAsString(labelNodes),
+        proofContext = ProofContext.fromFileContext(fileContext),
+        unqualifiedStatementNode = unqualifiedStatementNodeQuery(axiomNode),
         indicativeConditionalNode = indicativeConditionalNodeQuery(axiomNode);
 
-  let axiomVerified = false;
+  fileContext.debug(`Verifying the '${labelsString}' axiom...`);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, context);
+    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, proofContext);
 
     if (unqualifiedStatementVerified) {
       const statementNode = statementNodeQuery(unqualifiedStatementNode),
             labels = labelsString,  ///
             axiom = Axiom.fromStatementNodeAndLabels(statementNode, labels);
 
-      context.addAxiom(axiom);
+      fileContext.addAxiom(axiom);
 
       axiomVerified = true;
     }
@@ -44,7 +42,7 @@ export default function verifyAxiom(axiomNode, context) {
 
   if (indicativeConditionalNode !== null) {
     const statementNodes = [],
-          indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, statementNodes, context);
+          indicativeConditionalVerified = verifyIndicativeConditional(indicativeConditionalNode, statementNodes, proofContext);
 
     if (indicativeConditionalVerified !== null) {
       const labels = labelsString,  ///
@@ -54,15 +52,15 @@ export default function verifyAxiom(axiomNode, context) {
             consequentStatementNode = secondStatementNode,  ///
             axiom = Axiom.fromSuppositionStatementNodeConsequentStatementNodeAndLabels(suppositionStatementNode, consequentStatementNode, labels);
 
-      context.addAxiom(axiom);
+      fileContext.addAxiom(axiom);
 
       axiomVerified = true;
     }
   }
 
-  if (axiomVerified) {
-    context.info(`Verified the '${labelsString}' axiom.`, axiomNode);
-  }
+  axiomVerified ?
+    fileContext.complete(axiomNode) :
+      fileContext.halt(axiomNode);
 
   return axiomVerified;
 }

package/src/verify/conclusion.js

@@ -8,13 +8,15 @@ import { nodeQuery } from "../utilities/query";
 const metastatementNodeQuery = nodeQuery("/*/metastatement!"),
       unqualifiedMetastatementNodeQuery = nodeQuery("/conclusion/unqualifiedMetastatement!");
 
-export default function verifyConclusion(conclusionNode, conclusions, context) {
+export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
   let conclusionVerified = false;
 
+  metaproofContext.begin(conclusionNode);
+
   const unqualifiedMetastatementNode = unqualifiedMetastatementNodeQuery(conclusionNode);
 
   if (unqualifiedMetastatementNode !== null) {
-    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, context);
+    const unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, metaproofContext);
 
     if (unqualifiedMetastatementVerified) {
       const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
@@ -26,5 +28,9 @@ export default function verifyConclusion(conclusionNode, conclusions, context) {
     }
   }
 
+  conclusionVerified ?
+    metaproofContext.complete(conclusionNode) :
+      metaproofContext.halt(conclusionNode);
+
   return conclusionVerified;
 }

package/src/verify/conditinalInference.js

@@ -8,18 +8,24 @@ import { nodeQuery } from "../utilities/query";
 const conclusionNodeQuery = nodeQuery("/conditionalInference/conclusion!"),
       premiseOrPremisesNodeQuery = nodeQuery("/conditionalInference/premise|premises!");
 
-export default function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, context) {
+export default function verifyConditionalInference(conditionalInferenceNode, premises, conclusions, metaproofContext) {
   let conditionalInferenceVerified = false;
 
+  metaproofContext.begin(conditionalInferenceNode);
+
   const conclusionNode = conclusionNodeQuery(conditionalInferenceNode),
         premiseOrPremisesNode = premiseOrPremisesNodeQuery(conditionalInferenceNode),
-        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, context);
+        premiseOrPremisesVerified = verifyPremiseOrPremises(premiseOrPremisesNode, premises, metaproofContext);
 
   if (premiseOrPremisesVerified) {
-    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, context);
+    const conclusionVerified = verifyConclusion(conclusionNode, conclusions, metaproofContext);
 
-    conditionalInferenceVerified = conclusionVerified;
+    conditionalInferenceVerified = conclusionVerified;  ///
   }
 
+  conditionalInferenceVerified ?
+    metaproofContext.complete(conditionalInferenceNode) :
+      metaproofContext.halt(conditionalInferenceNode);
+
   return conditionalInferenceVerified;
 }

package/src/verify/declaration/combinator.js

@@ -6,10 +6,19 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
-export default function verifyCombinatorDeclaration(combinatorDeclarationNode, context) {
+export default function verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext) {
+  let combinatorDeclarationVerified;
+
+  fileContext.begin(combinatorDeclarationNode);
+
   const statementNode = statementNodeQuery(combinatorDeclarationNode),
-        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, context),
-        combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
+        statementVerifiedAsCombinator = verifyStatementAsCombinator(statementNode, fileContext);
+
+  combinatorDeclarationVerified = statementVerifiedAsCombinator; ///
+
+  combinatorDeclarationVerified ?
+    fileContext.complete(combinatorDeclarationNode) :
+      fileContext.halt(combinatorDeclarationNode);
 
   return combinatorDeclarationVerified;
 }

package/src/verify/declaration/constructor.js

@@ -7,11 +7,20 @@ import { nodeQuery } from "../../utilities/query";
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       typeNodeQuery = nodeQuery("/constructorDeclaration/type");
 
-export default function verifyConstructorDeclaration(constructorDeclarationNode, context) {
+export default function verifyConstructorDeclaration(constructorDeclarationNode, fileContext) {
+  let constructorDeclarationVerified;
+
+  fileContext.begin(constructorDeclarationNode);
+
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
-        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, context),
-        constructorDeclarationVerified = termVerifiedAsConstructor; ///
+        termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
+
+  constructorDeclarationVerified = termVerifiedAsConstructor; ///
+
+  constructorDeclarationVerified ?
+    fileContext.complete(constructorDeclarationNode) :
+      fileContext.halt(constructorDeclarationNode);
 
   return constructorDeclarationVerified;
 }

package/src/verify/declaration/topLevel.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
-
 import verifyRule from "../../verify/rule";
 import verifyAxiom from "../../verify/axiom";
 import verifyTypeDeclaration from "../../verify/declaration/type";
@@ -9,6 +7,8 @@ import verifyVariableDeclaration from "../../verify/declaration/variable";
 import verifyCombinatorDeclaration from "../../verify/declaration/combinator";
 import verifyConstructorDeclaration from "../../verify/declaration/constructor";
 
+import { nodeQuery } from "../../utilities/query";
+
 const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       axiomNodeQuery = nodeQuery("/topLevelDeclaration/axiom!"),
       typeDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/typeDeclaration!"),
@@ -16,9 +16,11 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
       combinatorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/combinatorDeclaration!"),
       constructorDeclarationNodeQuery = nodeQuery("/topLevelDeclaration/constructorDeclaration!");
 
-export default function verifyTopLevelDeclaration(topLevelDeclarationNode, context) {
+export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
 
+  fileContext.begin(topLevelDeclarationNode);
+
   const node = topLevelDeclarationNode, ///
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
@@ -30,30 +32,34 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, conte
   if (false) {
     ///
   } else if (ruleNode !== null) {
-    const ruleVerified = verifyRule(ruleNode, context);
+    const ruleVerified = verifyRule(ruleNode, fileContext);
 
     topLevelDeclarationVerified = ruleVerified;  ///
   } else if (axiomNode !== null) {
-    const axiomVerified = verifyAxiom(axiomNode, context);
+    const axiomVerified = verifyAxiom(axiomNode, fileContext);
 
     topLevelDeclarationVerified = axiomVerified;  ///
   } else if (typeDeclarationNode !== null) {
-    const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, context);
+    const typeDeclarationVerified = verifyTypeDeclaration(typeDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = typeDeclarationVerified;  ///
   } else if (variableDeclarationNode !== null) {
-    const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, context);
+    const variableDeclarationVerified = verifyVariableDeclaration(variableDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = variableDeclarationVerified;  ///
   } else if (combinatorDeclarationNode !== null) {
-    const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, context);
+    const combinatorDeclarationVerified = verifyCombinatorDeclaration(combinatorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = combinatorDeclarationVerified;  ///
   } else if (constructorDeclarationNode !== null) {
-    const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, context);
+    const constructorDeclarationVerified = verifyConstructorDeclaration(constructorDeclarationNode, fileContext);
 
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
   }
 
+  topLevelDeclarationVerified ?
+    fileContext.complete(topLevelDeclarationNode) :
+      fileContext.halt(topLevelDeclarationNode);
+
   return topLevelDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -7,13 +7,23 @@ import { nodeQuery } from "../../utilities/query";
 const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       secondTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
 
-export default function verifyTypeDeclaration(typeDeclarationNode, context) {
+export default function verifyTypeDeclaration(typeDeclarationNode, fileContext) {
+  let typeDeclarationVerified;
+
+  fileContext.begin(typeDeclarationNode);
+
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
-        superTypeNode = secondTypeNode, ///
-        typeVerified = verifyType(typeNode, superTypeNode, context),
-        typeDeclarationVerified = typeVerified; ///
+        superTypeNode = secondTypeNode; ///
+
+  const typeVerified = verifyType(typeNode, superTypeNode, fileContext);
+
+  typeDeclarationVerified = typeVerified; ///
+
+  typeDeclarationVerified ?
+    fileContext.complete(typeDeclarationNode) :
+      fileContext.halt(typeDeclarationNode);
 
   return typeDeclarationVerified;
 }

package/src/verify/declaration/variable.js

@@ -7,11 +7,20 @@ import { nodeQuery } from "../../utilities/query";
 const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable");
 
-export default function verifyVariableDeclaration(variableDeclarationNode, context) {
+export default function verifyVariableDeclaration(variableDeclarationNode, fileContext) {
+  let variableDeclarationVerified;
+
+  fileContext.begin(variableDeclarationNode);
+
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
-        variableVVerified = verifyVariable(variableNode, typeNode, context),
-        variableDeclarationVerified = variableVVerified;  ///
+        variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
+
+  variableDeclarationVerified = variableVVerified;  ///
+
+  variableDeclarationVerified ?
+    fileContext.complete(variableDeclarationNode) :
+      fileContext.halt(variableDeclarationNode);
 
   return variableDeclarationVerified;
 }

package/src/verify/equality.js

@@ -8,11 +8,14 @@ import { first, second } from "../utilities/array";
 const firstTermNodeQuery = nodeQuery("/equality/term[0]"),
       secondTermNodeQuery = nodeQuery("/equality/term[1]");
 
-export default function verifyEquality(equalityNode, context) {
+export default function verifyEquality(equalityNode, proofContext) {
   let equalityVerified = false;
 
+  proofContext.begin(equalityNode);
+
   const types = [],
         values = [],
+        context = proofContext,
         firstTermNode = firstTermNodeQuery(equalityNode),
         secondTermNode = secondTermNodeQuery(equalityNode),
         firstTermVerified = verifyTerm(firstTermNode, types, values, context),
@@ -24,10 +27,10 @@ export default function verifyEquality(equalityNode, context) {
           firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType = firstType.isEqualToSubTypeOfOrSuperTypeOf(secondType);
 
     if (firstTypeEqualToSubTypeOfOrSuperTypeOfSecondType) {
-      const derived = context.isDerived();
+      const derived = proofContext.isDerived();
 
       if (derived) {
-        const termsEqual = equateTerms(firstTermNode, secondTermNode, context);
+        const termsEqual = equateTerms(firstTermNode, secondTermNode, proofContext);
 
         if (termsEqual) {
           equalityVerified = true;
@@ -38,10 +41,14 @@ export default function verifyEquality(equalityNode, context) {
     }
   }
 
+  equalityVerified ?
+    proofContext.complete(equalityNode) :
+      proofContext.halt(equalityNode);
+
   return equalityVerified;
 }
 
-function equateTerms(firstTermNode, secondTermNode, context) {
+function equateTerms(firstTermNode, secondTermNode, proofContext) {
   let termsEqual = true;  ///
 
   debugger