occam-verify-cli 0.0.527 → 0.0.529

package/src/utilities/proof.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import matcher from "../matcher";
+import bracketedStatementNode from "../node/statement/bracketed";
+
+import { nodeQuery } from "../utilities/query";
+import { BRACKETED_STATEMENT_DEPTH } from "../constants";
+
+const bracketedStatementChildNodeQuery = nodeQuery('/statement/metaArgument!/statement!');
+
+export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
+  let statementMatchesModuloBrackets = false;
+
+  if (!statementMatchesModuloBrackets) {
+    const nodeA = statementNodeA,  ///
+          nodeB = statementNodeB,  ///
+          nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB);
+
+    statementMatchesModuloBrackets = nonTerminalNodeMatches;  ///
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeA = bracketedStatementChildNodeFromStatementNode(statementNodeA);
+
+    if (bracketedStatementChildNodeA !== null) {
+      const nodeA = bracketedStatementChildNodeA,  ///
+            nodeB = statementNodeB, ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      statementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  if (!statementMatchesModuloBrackets) {
+    const bracketedStatementChildNodeB = bracketedStatementChildNodeFromStatementNode(statementNodeB);
+
+    if (bracketedStatementChildNodeB !== null) {
+      const nodeA = statementNodeA, ///
+            nodeB = bracketedStatementChildNodeB,  ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB);
+
+      statementMatchesModuloBrackets = nodeMatches; ///
+    }
+  }
+
+  return statementMatchesModuloBrackets;
+}
+
+export function bracketedStatementChildNodeFromStatementNode(statementNode) {
+  let bracketedStatementChildNode = null;
+
+  const nodeA = statementNode,  ///
+        nodeB = bracketedStatementNode,  ///
+        depth = BRACKETED_STATEMENT_DEPTH,
+        nonTerminalNodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+  if (nonTerminalNodeMatches) {
+    bracketedStatementChildNode = bracketedStatementChildNodeQuery(statementNode);
+  }
+
+  return bracketedStatementChildNode;
+}

package/src/utilities/releaseContext.js

@@ -35,7 +35,7 @@ export function createReleaseContext(dependency, dependentNames, context, callba
 
     error = checkReleaseMatchesDependency(dependency, dependentNames, releaseContext);
 
-    if (error !== null)  {
+    if (error) {
       callback(error);
 
       return;
@@ -47,19 +47,25 @@ export function createReleaseContext(dependency, dependentNames, context, callba
   }, context);
 }
 
-export function initialiseReleaseContext(dependency, dependentName, verified, context) {
+export function initialiseReleaseContext(dependency, dependentName, verified, context, callback) {
+  let error = null;
+
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
         releaseName = dependencyName, ///
         releaseContext = releaseContextMap[releaseName] || null;
 
   if (releaseContext === null) {
+    callback(error);
+
     return;
   }
 
   const initialised = releaseContext.isInitialised();
 
   if (initialised) {
+    callback(error);
+
     return;
   }
 
@@ -67,27 +73,39 @@ export function initialiseReleaseContext(dependency, dependentName, verified, co
 
   if (verified) {
     if (!releaseContextVerified) {
-      const { log } = context;
+      error = `Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`;
 
-      log.error(`Unable to initialise the '${releaseName}' dependency's context because its '${dependentName}' dependent is a package.`);
+      callback(error);
 
       return;
     }
   }
 
-  verified = releaseContextVerified;  ///
-
   dependentName = releaseName;  ///
 
+  verified = releaseContextVerified;  ///
+
   const dependencies = releaseContext.getDependencies();
 
-  dependencies.forEachDependency((dependency) => {
-    initialiseReleaseContext(dependency, dependentName, verified, context);
-  });
+  dependencies.asynchronousForEachDependency((dependency, next, done) => {
+    initialiseReleaseContext(dependency, dependentName, verified, context, (error) => {
+      if (error) {
+        callback(error);
 
-  const dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependency, context);
+        return;
+      }
 
-  releaseContext.initialise(dependencyReleaseContexts);
+      next();
+    });
+  }, done);
+
+  function done() {
+    const dependencyReleaseContexts = retrieveDependencyReleaseContexts(dependency, context);
+
+    releaseContext.initialise(dependencyReleaseContexts);
+
+    callback(error);
+  }
 }
 
 export default {
@@ -153,7 +171,7 @@ function createDependencyReleaseContexts(dependency, dependentNames, context, ca
   dependencies.asynchronousForEachDependency((dependency, next, done) => {
     const error = checkCyclicDependencyExists(dependency, dependentNames);
 
-    if (error !== null) {
+    if (error) {
       callback(error);
 
       return;

package/src/utilities/string.js

@@ -1,12 +1,6 @@
 "use strict";
 
-import { nodeQuery } from "../utilities/query";
 import { COMMA, EMPTY_STRING } from "../constants";
-import { LABEL_RULE_NAME, UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATIONRULE_NAME, UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
-
-const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
 export function nodeAsString(node, tokens) {
   let string = null;
@@ -61,44 +55,3 @@ export function nodesAsString(nodes, tokens) {
   return string;
 }
 
-export function termNodeFromTermString(termString, releaseContext) {
-  const ruleName = CONSTRUCTOR_DECLARATIONRULE_NAME,
-        content = `Constructor ${termString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        constructorDeclarationNode = node, ///
-        termNode = termNodeQuery(constructorDeclarationNode);
-
-  return termNode;
-}
-
-export function labelNodeFromLabelString(labelString, releaseContext) {
-  const content = labelString, ///
-        ruleName = LABEL_RULE_NAME,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        labelNode = node; ///
-
-  return labelNode;
-}
-
-export function statementNodeFromStatementString(statementString, releaseContext) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        content = `${statementString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        unqualifiedStatementNode = node,  ///
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
-
-  return statementNode;
-}
-
-export function metastatementNodeFromMetastatementString(metastatementString, releaseContext) {
-  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
-        content = `${metastatementString}
-`,
-        node = releaseContext.nodeFromContentAndRuleName(content, ruleName),
-        unqualifiedMetastatementNode = node,  ///
-        metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-
-  return metastatementNode;
-}

package/src/verifier/metastatementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableVerifier from "../../verifier/metastatementForMetavariable";
+
+class ConclusionMetastatementForMetavariableVerifier extends MetastatementForMetavariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const conclusionMetastatementForMetavariableVerifier = new ConclusionMetastatementForMetavariableVerifier();

package/src/verifier/metastatementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableVerifier from "../../verifier/metastatementForMetavariable";
+
+class PremiseMetastatementForMetavariableVerifier extends MetastatementForMetavariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const premiseMetastatementForMetavariableVerifier = new PremiseMetastatementForMetavariableVerifier();

package/src/{matcher → verifier}/metastatementForMetavariable.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import Matcher from "../matcher";
+import Verifier from "../verifier";
 import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
@@ -9,7 +9,7 @@ import { metavariableNameFromMetavariableNode } from "../utilities/query";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-export default class MetastatementForMetavariableMatcher extends Matcher {
+export default class MetastatementForMetavariableVerifier extends Verifier {
   matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
     let nonTerminalNodeMatches = false;
 

package/src/verifier/statementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableVerifier from "../../verifier/statementForMetavariable";
+
+class ConclusionStatementForMetavariableVerifier extends StatementForMetavariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const conclusionStatementForMetavariableVerifier = new ConclusionStatementForMetavariableVerifier();

package/src/verifier/statementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableVerifier from "../../verifier/statementForMetavariable";
+
+class PremiseStatementForMetavariableVerifier extends StatementForMetavariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const premiseStatementForMetavariableVerifier = new PremiseStatementForMetavariableVerifier();

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

@@ -1,6 +1,6 @@
 "use strict";
 
-import Matcher from "../matcher";
+import Verifier from "../verifier";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
@@ -10,7 +10,7 @@ import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME }
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-export default class StatementForMetavariableMatcher extends Matcher {
+export default class StatementForMetavariableVerifier extends Verifier {
   matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
     let nonTerminalNodeMatches = false;
 

package/src/verifier/termForVariable/consequence.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableVerifier from "../../verifier/termForVariable";
+
+class ConsequenceTermForVariableVerifier extends TermForVariableVerifier {
+  static createSubstitutions = false;
+}
+
+export const consequenceTermForVariableVerifier = new ConsequenceTermForVariableVerifier();

package/src/verifier/termForVariable/supposition.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableVerifier from "../../verifier/termForVariable";
+
+class SuppositionTermForVariableVerifier extends TermForVariableVerifier {
+  static createSubstitutions = true;
+}
+
+export const suppositionTermForVariableVerifier = new SuppositionTermForVariableVerifier();

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

@@ -1,6 +1,6 @@
 "use strict";
 
-import Matcher from "../matcher";
+import Verifier from "../verifier";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { nodeQuery } from "../utilities/query";
@@ -9,7 +9,7 @@ import { variableNameFromVariableNode } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-export default class TermForVariableMatcher extends Matcher {
+export default class TermForVariableVerifier extends Verifier {
   matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
     let nonTerminalNodeMatches = false;
 

package/src/verifier.js

@@ -0,0 +1,74 @@
+"use strict";
+
+export default class Verifier {
+  matchNode(nodeA, nodeB, substitutions) {
+    let nodeMatches = false;
+
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode();
+
+    if (nodeATerminalNode === nodeBTerminalNode) {
+      if (nodeATerminalNode) {
+        const terminalNodeA = nodeA,  ///
+              terminalNodeB = nodeB,  ///
+              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB);
+
+        nodeMatches = terminalNodeMatches;  ///
+      } else {
+        const nonTerminalNodeA = nodeA,  ///
+              nonTerminalNodeB = nodeB, ///
+              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+
+        nodeMatches = nonTerminalNodeMatches; ///
+      }
+    }
+
+    return nodeMatches;
+  }
+
+  matchNodes(nodesA, nodesB, substitutions) {
+    let nodesMatch = false;
+
+    const nodesALength = nodesA.length,
+          nodesBLength = nodesB.length;
+
+    if (nodesALength === nodesBLength) {
+      nodesMatch = nodesA.every((nodeA, index) => {
+        const nodeB = nodesB[index],
+              nodeMatches = this.matchNode(nodeA, nodeB, substitutions);
+
+        if (nodeMatches) {
+          return true;
+        }
+      })
+    }
+
+    return nodesMatch;
+  }
+
+  matchTerminalNode(terminalNodeA, terminalNodeB, substitutions) {
+    const matches = terminalNodeA.match(terminalNodeB),
+          terminalNodeMatches = matches;  ///
+
+    return terminalNodeMatches;
+  }
+
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            nodesA = nonTerminalNodeAChildNodes, ///
+            nodesB = nonTerminalNodeBChildNodes, ///
+            nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+
+      nonTerminalNodeMatches = nodesMatch; ///
+    }
+
+    return nonTerminalNodeMatches;
+  }
+}

package/src/verify/assertion/type.js

@@ -13,18 +13,16 @@ const termNodeQuery = nodeQuery("/typeAssertion/term"),
 export default function verifyTypeAssertion(typeAssertionNode, assertions, derived, proofContext) {
   let typeAssertionVerified = false;
 
-  proofContext.begin(typeAssertionNode);
-
   const typeAssertionString = proofContext.nodeAsString(typeAssertionNode);
 
-  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`);
+  proofContext.debug(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
   const typeNode = typeNodeQuery(typeAssertionNode),
         typeName = typeNameFromTypeNode(typeNode),
         typePresent = proofContext.isTypePresentByTypeName(typeName);
 
   if (!typePresent) {
-    proofContext.error(`The ${typeName} type is not present.`);
+    proofContext.error(`The ${typeName} type is not present.`, typeAssertionNode);
   } else {
     if (!typeAssertionVerified) {
       const variableTypeAssertionVerified = verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, proofContext);
@@ -40,13 +38,9 @@ export default function verifyTypeAssertion(typeAssertionNode, assertions, deriv
   }
 
   if (typeAssertionVerified) {
-    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`);
+    proofContext.info(`Verified the '${typeAssertionString}' statement type assertion.`, typeAssertionNode);
   }
 
-  typeAssertionVerified ?
-    proofContext.complete(typeAssertionNode) :
-      proofContext.halt(typeAssertionNode);
-
   return typeAssertionVerified;
 }
 
@@ -75,7 +69,7 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
         const assertedTypeName = assertedType.getName(),
               variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`);
+        proofContext.error(`The '${variableName}' variable's '${variableTypeName}' type is not equal to or a sub-type of the '${assertedTypeName}' asserted type.`, typeAssertionNode);
       } else {
         variableTypeAssertionVerified = true;
       }
@@ -86,7 +80,7 @@ function verifyVariableTypeAssertion(typeAssertionNode, assertions, derived, pro
         const assertedTypeName = assertedType.getName(),
               variableTypeName = variableType.getName();
 
-        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`);
+        proofContext.error(`The '${assertedTypeName}' asserted type is not equal to or a sub-type of the '${variableName}' variable's '${variableTypeName}' type.`, typeAssertionNode);
       } else {
         const type = assertedType,  ///
               name = variableName,  ///

package/src/verify/axiom.js

@@ -16,13 +16,11 @@ const labelNodesQuery = nodesQuery("/axiom/label"),
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  fileContext.begin(axiomNode);
-
   const labelNodes = labelNodesQuery(axiomNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' axiom...`);
+  fileContext.debug(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -56,12 +54,8 @@ export default function verifyAxiom(axiomNode, fileContext) {
   }
 
   if (axiomVerified) {
-    fileContext.info(`Verified the '${labelsString}' axiom.`);
+    fileContext.info(`Verified the '${labelsString}' axiom.`, axiomNode);
   }
 
-  axiomVerified ?
-    fileContext.complete(axiomNode) :
-      fileContext.complete(axiomNode);
-
   return axiomVerified;
 }

package/src/verify/conclusion.js

@@ -11,11 +11,9 @@ const metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatemen
 export default function verifyConclusion(conclusionNode, conclusions, metaproofContext) {
   let conclusionVerified = false;
 
-  metaproofContext.begin(conclusionNode);
-
   const conclusionString = metaproofContext.nodeAsString(conclusionNode);
 
-  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`);
+  metaproofContext.debug(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
   const derived = false,
         assertions = [],
@@ -31,9 +29,5 @@ export default function verifyConclusion(conclusionNode, conclusions, metaproofC
     conclusionVerified = true;
   }
 
-  conclusionVerified ?
-    metaproofContext.complete(conclusionNode) :
-      metaproofContext.halt(conclusionNode);
-
   return conclusionVerified;
 }

package/src/verify/conjecture.js

@@ -18,13 +18,11 @@ const proofNodeQuery = nodeQuery("/conjecture/proof!"),
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  fileContext.begin(conjectureNode);
-
   const labelNodes = labelNodesQuery(conjectureNode),
         labelsString = fileContext.nodesAsString(labelNodes),
         proofContext = ProofContext.fromFileContext(fileContext);
 
-  fileContext.debug(`Verifying the '${labelsString}' conjecture...`);
+  fileContext.debug(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
   const labels = [],
         labelsVerified = verifyLabels(labelNodes, labels, fileContext);
@@ -62,12 +60,8 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   }
 
   if (conjectureVerified) {
-    fileContext.info(`Verified the '${labelsString}' conjecture.`);
+    fileContext.info(`Verified the '${labelsString}' conjecture.`, conjectureNode);
   }
 
-  conjectureVerified ?
-    fileContext.complete(conjectureNode) :
-      fileContext.complete(conjectureNode);
-
   return conjectureVerified;
 }

package/src/verify/consequence.js

@@ -11,11 +11,9 @@ const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
 export default function verifyConsequence(consequenceNode, consequences, proofContext) {
   let consequenceVerified = false;
 
-  proofContext.begin(consequenceNode);
-
   const consequenceString = proofContext.nodeAsString(consequenceNode);
 
-  proofContext.debug(`Verifying the '${consequenceString}' consequence...`);
+  proofContext.debug(`Verifying the '${consequenceString}' consequence...`, consequenceNode);
 
   const derived = false,
         assertions = [],
@@ -31,9 +29,5 @@ export default function verifyConsequence(consequenceNode, consequences, proofCo
     consequenceVerified = true;
   }
 
-  consequenceVerified ?
-    proofContext.complete(consequenceNode) :
-      proofContext.halt(consequenceNode);
-
   return consequenceVerified;
 }

package/src/verify/declaration/combinator.js

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

package/src/verify/declaration/constructor.js

@@ -10,17 +10,11 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
 export default function verifyConstructorDeclaration(constructorDeclarationNode, fileContext) {
   let constructorDeclarationVerified;
 
-  fileContext.begin(constructorDeclarationNode);
-
   const termNode = termNodeQuery(constructorDeclarationNode),
         typeNode = typeNodeQuery(constructorDeclarationNode),
         termVerifiedAsConstructor = verifyTermAsConstructor(termNode, typeNode, fileContext);
 
   constructorDeclarationVerified = termVerifiedAsConstructor; ///
 
-  constructorDeclarationVerified ?
-    fileContext.complete(constructorDeclarationNode) :
-      fileContext.halt(constructorDeclarationNode);
-
   return constructorDeclarationVerified;
 }

package/src/verify/declaration/topLevel.js

@@ -25,8 +25,6 @@ const ruleNodeQuery = nodeQuery("/topLevelDeclaration/rule!"),
 export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext) {
   let topLevelDeclarationVerified = false;
 
-  fileContext.begin(topLevelDeclarationNode);
-
   const node = topLevelDeclarationNode, ///
         ruleNode = ruleNodeQuery(node),
         axiomNode = axiomNodeQuery(node),
@@ -78,9 +76,5 @@ export default function verifyTopLevelDeclaration(topLevelDeclarationNode, fileC
     topLevelDeclarationVerified = constructorDeclarationVerified;  ///
   }
 
-  topLevelDeclarationVerified ?
-    fileContext.complete(topLevelDeclarationNode) :
-      fileContext.halt(topLevelDeclarationNode);
-
   return topLevelDeclarationVerified;
 }

package/src/verify/declaration/type.js

@@ -10,8 +10,6 @@ const firstTypeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
 export default function verifyTypeDeclaration(typeDeclarationNode, fileContext) {
   let typeDeclarationVerified;
 
-  fileContext.begin(typeDeclarationNode);
-
   const firstTypeNode = firstTypeNodeQuery(typeDeclarationNode),
         secondTypeNode = secondTypeNodeQuery(typeDeclarationNode),
         typeNode = firstTypeNode, ///
@@ -21,9 +19,5 @@ export default function verifyTypeDeclaration(typeDeclarationNode, fileContext)
 
   typeDeclarationVerified = typeVerified; ///
 
-  typeDeclarationVerified ?
-    fileContext.complete(typeDeclarationNode) :
-      fileContext.halt(typeDeclarationNode);
-
   return typeDeclarationVerified;
 }

package/src/verify/declaration/variable.js

@@ -10,17 +10,11 @@ const typeNodeQuery = nodeQuery("/variableDeclaration/type"),
 export default function verifyVariableDeclaration(variableDeclarationNode, fileContext) {
   let variableDeclarationVerified;
 
-  fileContext.begin(variableDeclarationNode);
-
   const typeNode = typeNodeQuery(variableDeclarationNode),
         variableNode = variableNodeQuery(variableDeclarationNode),
         variableVVerified = verifyVariable(variableNode, typeNode, fileContext);
 
   variableDeclarationVerified = variableVVerified;  ///
 
-  variableDeclarationVerified ?
-    fileContext.complete(variableDeclarationNode) :
-      fileContext.halt(variableDeclarationNode);
-
   return variableDeclarationVerified;
 }