occam-verify-cli 0.0.316 → 0.0.318

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

package/src/verify/file.js

@@ -1,35 +1,33 @@
 "use strict";
 
 import FileContext from "../context/file";
-import ReleaseContext from "../context/release";
-import verifyTopLevelDeclaration from "../verify/declaration/topLevel";
+import verifyTopLevelDeclaration from "./declaration/topLevel";
 
 import { nodesQuery } from "../utilities/query";
 
 const topLevelDeclarationNodesQuery = nodesQuery("/document/topLevelDeclaration");
 
-export default function verifyFile(filePath, releaseContext = ReleaseContext.fromNothing()) {
-  let fileVerified = false;
+export default function verifyFile(filePath, releaseContext) {
+  let fileVerified;
 
   releaseContext.debug(`Verifying the '${filePath}' file...`);
 
   const fileContext = FileContext.fromReleaseContextAndFilePath(releaseContext, filePath),
-        context = fileContext,  ///
         node = fileContext.getNode(),
         topLevelDeclarationNodes = topLevelDeclarationNodesQuery(node),
         topLevelDeclarationsVerified = topLevelDeclarationNodes.every((topLevelDeclarationNode) => {
-          const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, context);
+          const topLevelDeclarationVerified = verifyTopLevelDeclaration(topLevelDeclarationNode, fileContext);
 
           if (topLevelDeclarationVerified) {
             return true;
           }
         })
 
+  fileVerified = topLevelDeclarationsVerified;  ///
+
   if (topLevelDeclarationsVerified) {
     releaseContext.addFileContext(fileContext);
 
-    fileVerified = true;
-
     releaseContext.info(`Verified the '${filePath}' file.`);
   }
 

package/src/verify/label.js

@@ -2,20 +2,26 @@
 
 import { labelNameFromLabelNode } from "../utilities/query";
 
-export default function verifyLabel(labelNode, labels, context) {
+export default function verifyLabel(labelNode, labels, fileContext) {
   let labelVerified = false;
 
+  fileContext.begin(labelNode);
+
   const labelName = labelNameFromLabelNode(labelNode),
         label = labelName,  ///
-        labelPresent = context.isLabelPresent(label);
+        labelPresent = fileContext.isLabelPresent(label);
 
   if (labelPresent) {
-    context.error(`The label ${label} is already present`, labelNode);
+    fileContext.error(`The label ${label} is already present`, labelNode);
   } else {
     labels.push(label);
 
     labelVerified = true;
   }
 
+  labelVerified ?
+    fileContext.complete(labelNode) :
+      fileContext.halt(labelNode);
+
   return labelVerified;
 }

package/src/verify/labels.js

@@ -2,9 +2,11 @@
 
 import verifyLabel from "../verify/label";
 
-export default function verifyLabels(labelNodes, labels, context) {
-  const labelsVerified = labelNodes.every((labelNode) => {
-    const labelVerified = verifyLabel(labelNode, labels, context);
+export default function verifyLabels(labelNodes, labels, fileContext) {
+  let labelsVerified;
+
+  labelsVerified = labelNodes.every((labelNode) => {
+    const labelVerified = verifyLabel(labelNode, labels, fileContext);
 
     if (labelVerified) {
       return true;