occam-verify-cli 0.0.870 → 0.0.872

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/metavariable.js

@@ -3,9 +3,12 @@
 import Metavariable from "../metavariable";
 import MetavariableAssignment from "../assignment/metavariable";
 
+import { first } from "../utilities/array";
 import { nodeQuery } from "../utilities/query";
+import { nameFromMetavariableNode } from "../utilities/name";
 
-const typeNodeQuery = nodeQuery("/argument/type"),
+const termNodeQuery = nodeQuery("/argument/term"),
+      typeNodeQuery = nodeQuery("/argument/type"),
       argumentNodeQuery = nodeQuery("/metavariable/argument!");
 
 export default function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
@@ -15,17 +18,38 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 
   fileContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariablePresent = fileContext.isMetavariablePresentByMetavariableNode(metavariableNode);
+  const name = nameFromMetavariableNode(metavariableNode),
+        metavariablePresent = fileContext.isMetavariablePresentByName(name);
 
   if (metavariablePresent) {
     fileContext.debug(`The metavariable '${metavariableString}' is already present.`, metavariableNode);
   } else {
-    const argumentNode = argumentNodeQuery(metavariableNode),
-          argumentVerified = verifyArgument(metavariableNode, argumentNode, fileContext);
+    const termTypes = [],
+          metaTypes = [],
+          argumentNode = argumentNodeQuery(metavariableNode),
+          argumentVerified = verifyArgument(argumentNode, termTypes, fileContext),
+          metaTypeVerified = verifyMetaType(metaTypeNode, metaTypes, fileContext);
 
-    if (argumentVerified) {
-      const metaType = fileContext.findMetaTypeByMetaTypeNode(metaTypeNode),
-            metavariable = Metavariable.fromMetavariableNodeAndMetaType(metavariableNode, metaType),
+    if (argumentVerified && metaTypeVerified) {
+      let termType,
+          metaType;
+
+      const firstMetaType = first(metaTypes);
+
+      metaType = firstMetaType; ///
+
+      const termTypesLength = termTypes.length;
+
+      if (termTypesLength === 0) {
+        termType = null;
+      } else {
+        const firstTermType = first(termTypes);
+
+        termType = firstTermType; ///
+      }
+
+      const node = metavariableNode,  ///
+            metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);
 
@@ -64,27 +88,51 @@ export function verifyStandaloneMetavariable(metavariableNode, localMetaContext,
   return standaloneMetavariableVerified;
 }
 
-function verifyArgument(metavariableNode, argumentNode, fileContext) {
+function verifyArgument(argumentNode, termTypes, fileContext) {
   let argumentVerified = false;
 
   if (argumentNode === null) {
     argumentVerified = true;
   } else {
+    const termNode = termNodeQuery(argumentNode);
+
+    if (termNode === null) {
+
+    } else {
+      const termString = fileContext.nodeAsString(termNode);
+
+      fileContext.debug(`The '${termString}' term was found when a type should have been present.`, termNode);
+    }
     const typeNode = typeNodeQuery(argumentNode);
 
     if (typeNode !== null) {
       const type = fileContext.findTypeByTypeNode(typeNode);
 
       if (type !== null) {
+        const termType = type;  ///
+
+        termTypes.push(termType);
+
         argumentVerified = true;
       } else {
-        const typeString = fileContext.nodeAsString(typeNode),
-              metavariableString = fileContext.nodeAsString(metavariableNode);
+        const typeString = fileContext.nodeAsString(typeNode);
 
-        fileContext.debug(`The '${metavariableString}' metavariable's '${typeString}' type is not present.`, metavariableNode);
+        fileContext.debug(`The '${typeString}' type is not present.`, typeNode);
       }
     }
   }
 
   return argumentVerified;
+}
+
+function verifyMetaType(metaTypeNode, metaTypes, fileContext) {
+  let metaTypeVerified;
+
+  const metaType = fileContext.findMetaTypeByMetaTypeNode(metaTypeNode);
+
+  metaTypes.push(metaType);
+
+  metaTypeVerified = true;
+
+  return metaTypeVerified;
 }

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 = [],