occam-verify-cli 0.0.870 → 0.0.871

package/src/metaLemmaMetatheorem.js

@@ -32,19 +32,6 @@ export default class MetaLemmaMetatheorem {
     return this.localContext;
   }
 
-  matchLabelNode(labelNode) {
-    const labelNodeMatches = this.labels.some((label) => {
-      const node = labelNode, ///
-            labelMatchesNode = label.matchNode(node);
-
-      if (labelMatchesNode) {
-        return true;
-      }
-    });
-
-    return labelNodeMatches;
-  }
-
   matchMetastatement(metastatementNode, metastatementLocalContext) {
     let metastatementNatches;
 
@@ -79,6 +66,19 @@ export default class MetaLemmaMetatheorem {
     return metastatementNatches;
   }
 
+  matchLabelMetavariableNode(labelMetavariableNode) {
+    const labelMetavariableNodeMatches = this.labels.some((label) => {
+      const node = labelMetavariableNode, ///
+            labelMatchesNode = label.matchNode(node);
+
+      if (labelMatchesNode) {
+        return true;
+      }
+    });
+
+    return labelMetavariableNodeMatches;
+  }
+
   toJSON(tokens) {
     const labelsJSON = this.labels.map((label) => {
             const labelJSON = label.toJSON(tokens);

package/src/mixins/context.js

@@ -26,25 +26,25 @@ function getConstructors() { return this.context.getConstructors(); }
 
 function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-function findTypeByTypeNode(labelNode) { return this.context.findTypeByTypeNode(labelNode); }
+function findTypeByTypeNode(labelMetavariableNode) { return this.context.findTypeByTypeNode(labelMetavariableNode); }
 
-function findLabelByLabelNode(labelNode) { return this.context.findLabelByLabelNode(labelNode); }
+function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
-function findRuleByLabelNode(labelNode) { return this.context.findRuleByLabelNode(labelNode); }
+function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
 
-function findAxiomByLabelNode(labelNode) { return this.context.findAxiomByLabelNode(labelNode); }
+function findLabelByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLabelByLabelMetavariableNode(labelMetavariableNode); }
 
-function findLemmaByLabelNode(labelNode) { return this.context.findLemmaByLabelNode(labelNode); }
+function findRuleByLabelMetavariableNode(labelMetavariableNode) { return this.context.findRuleByLabelMetavariableNode(labelMetavariableNode); }
 
-function findTheoremByLabelNode(labelNode) { return this.context.findTheoremByLabelNode(labelNode); }
+function findAxiomByLabelMetavariableNode(labelMetavariableNode) { return this.context.findAxiomByLabelMetavariableNode(labelMetavariableNode); }
 
-function findConjectureByLabelNode(labelNode) { return this.context.findConjectureByLabelNode(labelNode); }
+function findLemmaByLabelMetavariableNode(labelMetavariableNode) { return this.context.findLemmaByLabelMetavariableNode(labelMetavariableNode); }
 
-function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+function findTheoremByLabelMetavariableNode(labelMetavariableNode) { return this.context.findTheoremByLabelMetavariableNode(labelMetavariableNode); }
 
-function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
+function findConjectureByLabelMetavariableNode(labelMetavariableNode) { return this.context.findConjectureByLabelMetavariableNode(labelMetavariableNode); }
 
-function isLabelPresentByLabelNode(labelNode) { return this.context.isLabelPresentByLabelNode(labelNode); }
+function isLabelPresentByLabelMetavariableNode(labelMetavariableNode) { return this.context.isLabelPresentByLabelMetavariableNode(labelMetavariableNode); }
 
 function nodeAsString(node) { return this.context.nodeAsString(node); }
 
@@ -65,15 +65,15 @@ const contextMixins = {
   getConstructors,
   findTypeByTypeName,
   findTypeByTypeNode,
-  findLabelByLabelNode,
-  findRuleByLabelNode,
-  findAxiomByLabelNode,
-  findLemmaByLabelNode,
-  findTheoremByLabelNode,
-  findConjectureByLabelNode,
   isTypePresentByTypeName,
   isTypePresentByTypeNode,
-  isLabelPresentByLabelNode,
+  findLabelByLabelMetavariableNode,
+  findRuleByLabelMetavariableNode,
+  findAxiomByLabelMetavariableNode,
+  findLemmaByLabelMetavariableNode,
+  findTheoremByLabelMetavariableNode,
+  findConjectureByLabelMetavariableNode,
+  isLabelPresentByLabelMetavariableNode,
   nodeAsString,
   nodesAsString
 };

package/src/rule.js

@@ -31,19 +31,6 @@ export default class Rule {
     return this.fileContext;
   }
 
-  matchLabelNode(labelNode) {
-    const labelNodeMatches = this.labels.some((label) => {
-      const node = labelNode, ///
-            labelMatchesNode = label.matchNode(node);
-
-      if (labelMatchesNode) {
-        return true;
-      }
-    });
-
-    return labelNodeMatches;
-  }
-
   matchStatement(statementNode, statementLocalContext) {
     let statementNatches;
 
@@ -112,6 +99,19 @@ export default class Rule {
     return metastatementNatches;
   }
 
+  matchLabelMetavariableNode(labelMetavariableNode) {
+    const labelMetavariableNodeMatches = this.labels.some((label) => {
+      const node = labelMetavariableNode, ///
+            labelMatchesNode = label.matchNode(node);
+
+      if (labelMatchesNode) {
+        return true;
+      }
+    });
+
+    return labelMetavariableNodeMatches;
+  }
+
   toJSON(tokens) {
     const labelsJSON = this.labels.map((label) => {
             const labelJSON = label.toJSON(tokens);

package/src/ruleNames.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export const LABEL_RULE_NAME = "label";
 export const SUBPROOF_RULE_NAME = "subproof";
+export const METAVARIABLE_RULE_NAME = "metavariable";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";

package/src/utilities/name.js

@@ -3,8 +3,8 @@
 import { nodeQuery } from "../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
-      labelNameTerminalNodeQuery = nodeQuery("/label/@name");
+      nameTerminalNodeQuery = nodeQuery("/metavariable/@name"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export function typeNameFromTypeNode(typeNode) {
   let typeName = null;
@@ -19,12 +19,12 @@ export function typeNameFromTypeNode(typeNode) {
   return typeName;
 }
 
-export function labelNameFromLabelNode(labelNode) {
-  const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
-        labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
-        labelName = labelNameTerminalNodeContent; ///
+export function nameFromMetavariableNode(metavariableNode) {
+  const nameTerminalNode = nameTerminalNodeQuery(metavariableNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
 
-  return labelName;
+  return name;
 }
 
 export function metaTypeNameFromMetaTypeNode(metaTypeNode) {

package/src/utilities/node.js

@@ -4,12 +4,12 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { LABEL_RULE_NAME,
+import { METAVARIABLE_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { labelTokensFromLabelString,
+import { metavariableTokensFromMetavariableString,
          variableDeclarationTokensFromVariableString,
          unqualifiedStatementTokensFromStatementString,
          unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
@@ -24,13 +24,6 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function labelNodeFromLabelString(labelString, lexer, parser) {
-  const labelTokens = labelTokensFromLabelString(labelString, lexer),
-        labelNode = labelNodeFromLabelTokens(labelTokens, parser);
-
-  return labelNode;
-}
-
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
         variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
@@ -45,6 +38,13 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
+export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
+  const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
+        metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
+
+  return metavariableNode;
+}
+
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
   const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
         metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
@@ -80,11 +80,11 @@ export function metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedM
   return metastatementNode;
 }
 
-export function labelNodeFromLabelTokens(labelTokens, parser) {
-  const ruleName = LABEL_RULE_NAME,
-        labelNode = nodeFromTokensRuleNameAndParser(labelTokens, ruleName, parser);
+export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
+  const ruleName = METAVARIABLE_RULE_NAME,
+        metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
 
-  return labelNode;
+  return metavariableNode;
 }
 
 export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {

package/src/utilities/query.js

@@ -6,11 +6,9 @@ export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
-    if (node !== null) {
-      const nodes = query.execute(node);
+    const nodes = query.execute(node);
 
-      node = nodes.shift() || null; ///
-    }
+    node = nodes.shift() || null; ///
 
     return node;
   };
@@ -20,11 +18,7 @@ export function nodesQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
-    let nodes = null;
-
-    if (node !== null) {
-      nodes = query.execute(node);
-    }
+    const nodes = query.execute(node);
 
     return nodes;
   };

package/src/utilities/tokens.js

@@ -9,11 +9,11 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function labelTokensFromLabelString(labelString, lexer) {
-  const labelContent = `${labelString}`,
-        labelTokens = tokensFromContentAndLexer(labelContent, lexer);
+export function metavariableTokensFromMetavariableString(metavariableString, lexer) {
+  const metavariableContent = `${metavariableString}`,
+        metavariableTokens = tokensFromContentAndLexer(metavariableContent, lexer);
 
-  return labelTokens;
+  return metavariableTokens;
 }
 
 export function constructorDeclarationTokensFromTermString(termString, lexer) {

package/src/verify/axiom.js

@@ -9,21 +9,21 @@ import verifySuppositions from "../verify/suppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/axiom//reference/label"),
+const labelsNodeQuery = nodeQuery("/axiom/labels!"),
       consequentNodeQuery = nodeQuery("/axiom/consequent!"),
       suppositionsNodeQuery = nodesQuery("/axiom/supposition");
 
 export default function verifyAxiom(axiomNode, fileContext) {
   let axiomVerified = false;
 
-  const labelNodes = labelNodesQuery(axiomNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(axiomNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' axiom...`, axiomNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

package/src/verify/conjecture.js

@@ -11,21 +11,21 @@ import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/conjecture/proof!"),
-      labelNodesQuery = nodesQuery("/conjecture//reference/label"),
+      labelsNodeQuery = nodeQuery("/conjecture/labels!"),
       consequentNodeQuery = nodeQuery("/conjecture/consequent!"),
       suppositionsNodeQuery = nodesQuery("/conjecture/supposition");
 
 export default function verifyConjecture(conjectureNode, fileContext) {
   let conjectureVerified = false;
 
-  const labelNodes = labelNodesQuery(conjectureNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(conjectureNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' conjecture...`, conjectureNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

package/src/verify/label.js

@@ -2,21 +2,20 @@
 
 import Label from "../label";
 
-export default function verifyLabel(labelNode, labels, fileContext) {
+export default function verifyLabel(labelsMetavariableNode, labels, fileContext) {
   let labelVerified = false;
 
-  const labelString = fileContext.nodeAsString(labelNode);
+  const labelMetavariableString = fileContext.nodeAsString(labelsMetavariableNode);
 
-  fileContext.trace(`Verifying the '${labelString}' label...`, labelNode);
+  fileContext.trace(`Verifying the '${labelMetavariableString}' label...`, labelsMetavariableNode);
 
-  const labelPresent = fileContext.isLabelPresentByLabelNode(labelNode);
+  const labelPresent = fileContext.isLabelPresentByLabelMetavariableNode(labelsMetavariableNode);
 
   if (labelPresent) {
-    const labelString = fileContext.nodeAsString(labelNode);
-
-    fileContext.debug(`The '${labelString}' label is already present.`, labelNode);
+    fileContext.debug(`The '${labelMetavariableString}' label is already present.`, labelsMetavariableNode);
   } else {
-    const label = Label.fromLabelNode(labelNode);
+    const metavariableNode = labelsMetavariableNode,  ///
+          label = Label.fromMetavariableNode(metavariableNode);
 
     labels.push(label);
 
@@ -24,7 +23,7 @@ export default function verifyLabel(labelNode, labels, fileContext) {
   }
 
   if (labelVerified) {
-    fileContext.debug(`...verified the '${labelString}' label.`, labelNode);
+    fileContext.debug(`...verified the '${labelMetavariableString}' label.`, labelsMetavariableNode);
   }
 
   return labelVerified;

package/src/verify/labels.js

@@ -2,16 +2,26 @@
 
 import verifyLabel from "../verify/label";
 
-export default function verifyLabels(labelNodes, labels, fileContext) {
+import { nodesQuery } from "../utilities/query";
+
+const labelsMetavariableNodesQuery = nodesQuery("/labels/metavariable");
+
+export default function verifyLabels(labelsNode, labels, fileContext) {
   let labelsVerified;
 
-  labelsVerified = labelNodes.every((labelNode) => {
-    const labelVerified = verifyLabel(labelNode, labels, fileContext);
+  if (labelsNode === null) {
+    labelsVerified = true;
+  } else {
+    const labelsMetavariableNodes = labelsMetavariableNodesQuery(labelsNode);
+
+    labelsVerified = labelsMetavariableNodes.every((labelsMetavariableNode) => {
+      const labelVerified = verifyLabel(labelsMetavariableNode, labels, fileContext);
 
-    if (labelVerified) {
-      return true;
-    }
-  });
+      if (labelVerified) {
+        return true;
+      }
+    });
+  }
 
   return labelsVerified;
 }

package/src/verify/lemma.js

@@ -12,15 +12,15 @@ import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const proofNodeQuery = nodeQuery("/lemma/proof!"),
-      labelNodesQuery = nodesQuery("/lemma//reference/label"),
+      labelsNodeQuery = nodeQuery("/lemma/labels!"),
       consequentNodeQuery = nodeQuery("/lemma/consequent!"),
       suppositionsNodeQuery = nodesQuery("/lemma/supposition");
 
 export default function verifyLemma(lemmaNode, fileContext) {
   let lemmaVerified = false;
 
-  const labelNodes = labelNodesQuery(lemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(lemmaNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localContext = LocalContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
@@ -28,7 +28,7 @@ export default function verifyLemma(lemmaNode, fileContext) {
       fileContext.trace(`Verifying the '${labelsString}' lemma...`, lemmaNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const suppositions = [],

package/src/verify/metaLemma.js

@@ -11,7 +11,7 @@ import { first } from "../utilities/array";
 import { EMPTY_STRING } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metaLemma//reference/label"),
+const labelsNodeQuery = nodeQuery("/metaLemma/labels!"),
       metaproofNodeQuery = nodeQuery("/metaLemma/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metaLemma/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metaLemma/metaSupposition");
@@ -19,8 +19,8 @@ const labelNodesQuery = nodesQuery("/metaLemma//reference/label"),
 export default function verifyMetaLemma(metaLemmaNode, fileContext) {
   let metaLemmaVerified = false;
 
-  const labelNodes = labelNodesQuery(metaLemmaNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(metaLemmaNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   (labelsString === EMPTY_STRING) ?
@@ -28,7 +28,7 @@ export default function verifyMetaLemma(metaLemmaNode, fileContext) {
       fileContext.trace(`Verifying the '${labelsString}' meta-lLemma...`, metaLemmaNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const metaSuppositions = [],

package/src/verify/metastatement/qualified.js

@@ -2,8 +2,8 @@
 
 import { nodeQuery } from "../../utilities/query";
 
-const labelNodeQuery = nodeQuery("/qualifiedMetastatement/qualification!/label!"),
-      metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!");
+const metastatementNodeQuery = nodeQuery("/qualifiedMetastatement/metastatement!"),
+      referenceMetavariableNodeQuery = nodeQuery("/qualifiedMetastatement/reference!/metavariable!");
 
 export default function verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext) {
   let qualifiedMetastatementVerified = false;
@@ -16,8 +16,9 @@ export default function verifyQualifiedMetastatement(qualifiedMetastatementNode,
 
     localMetaContext.trace(`Verifying the '${metastatementString}' qualified metastatement...`, qualifiedMetastatementNode);
 
-    const labelNode = labelNodeQuery(qualifiedMetastatementNode),
-          rule = localMetaContext.findRuleByLabelNode(labelNode);
+    const referenceMetavariableNode = referenceMetavariableNodeQuery(qualifiedMetastatementNode),
+          labelMetavariableNode = referenceMetavariableNode,  ///
+          rule = localMetaContext.findRuleByLabelMetavariableNode(labelMetavariableNode);
 
     if (rule !== null) {
       const ruleMatchesMetastatement = rule.matchMetastatement(metastatementNode, metastatementLocalMetaContext);

package/src/verify/metatheorem.js

@@ -10,7 +10,7 @@ import verifyMetaSuppositions from "../verify/metaSuppositions";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/metatheorem//reference/label"),
+const labelsNodeQuery = nodeQuery("/metatheorem/labels!"),
       metaproofNodeQuery = nodeQuery("/metatheorem/metaproof!"),
       metaConsequentNodeQuery = nodeQuery("/metatheorem/metaConsequent!"),
       metaSuppositionsNodeQuery = nodesQuery("/metatheorem/metaSupposition");
@@ -18,14 +18,14 @@ const labelNodesQuery = nodesQuery("/metatheorem//reference/label"),
 export default function verifyMetatheorem(metatheoremNode, fileContext) {
   let metatheoremVerified = false;
 
-  const labelNodes = labelNodesQuery(metatheoremNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(metatheoremNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' metatheorem...`, metatheoremNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const metaSuppositions = [],

package/src/verify/rule.js

@@ -10,7 +10,7 @@ import verifyConclusion from "../verify/conclusion";
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const labelNodesQuery = nodesQuery("/rule//reference/label"),
+const labelsNodeQuery = nodeQuery("/rule/labels!"),
       premisesNodeQuery = nodesQuery("/rule/premise"),
       ruleProofNodeQuery = nodeQuery("/rule/ruleProof!"),
       conclusionNodeQuery = nodeQuery("/rule/conclusion!");
@@ -18,14 +18,14 @@ const labelNodesQuery = nodesQuery("/rule//reference/label"),
 export default function verifyRule(ruleNode, fileContext) {
   let ruleVerified = false;
 
-  const labelNodes = labelNodesQuery(ruleNode),
-        labelsString = fileContext.nodesAsString(labelNodes),
+  const labelsNode = labelsNodeQuery(ruleNode),
+        labelsString = fileContext.nodeAsString(labelsNode),
         localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
 
   const labels = [],
-        labelsVerified = verifyLabels(labelNodes, labels, fileContext);
+        labelsVerified = verifyLabels(labelsNode, labels, fileContext);
 
   if (labelsVerified) {
     const premises = [],