occam-verify-cli 0.0.864 → 0.0.866

package/src/metaLemmaMetatheorem.js

@@ -0,0 +1,194 @@
+"use strict";
+
+import Label from "./label";
+import LocalContext from "./context/local";
+import MetaConsequent from "./metaConsequent";
+import MetaSupposition from "./metaSupposition";
+
+import { prune } from "./utilities/array";
+import { someSubArray } from "./utilities/array";
+
+export default class MetaLemmaMetatheorem {
+  constructor(labels, metaSuppositions, metaConsequent, localContext) {
+    this.labels = labels;
+    this.metaSuppositions = metaSuppositions;
+    this.metaConsequent = metaConsequent;
+    this.localContext = localContext;
+  }
+
+  getLabels() {
+    return this.labels;
+  }
+
+  getMetaSuppositions() {
+    return this.metaSuppositions;
+  }
+
+  getMetaConsequent() {
+    return this.metaConsequent;
+  }
+
+  getLocalContext() {
+    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;
+
+    const metaSuppositionsLength = this.metaSuppositions.length;
+
+    if (metaSuppositionsLength === 0) {
+      const substitutions = [],
+            metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.localContext, metastatementLocalContext);
+
+      metastatementNatches = metaConsequentMatches; ///
+    } else {
+      const metaproofSteps = metastatementLocalContext.getProofSteps();
+
+      metastatementNatches = someSubArray(metaproofSteps, metaSuppositionsLength, (metaproofSteps) => {
+        let metaSuppositionsMatchMetaConsequent = false;
+
+        const substitutions = [],
+              metaSuppositionsMatch = matchMetaSuppositions(this.metaSuppositions, metaproofSteps, substitutions, this.localContext, metastatementLocalContext);
+
+        if (metaSuppositionsMatch) {
+          const metaConsequentMatches = matchMetaConsequent(this.metaConsequent, metastatementNode, substitutions, this.localContext, metastatementLocalContext);
+
+          metaSuppositionsMatchMetaConsequent = metaConsequentMatches;  ///
+        }
+
+        if (metaSuppositionsMatchMetaConsequent) {
+          return true;
+        }
+      });
+    }
+
+    return metastatementNatches;
+  }
+
+  toJSON(tokens) {
+    const labelsJSON = this.labels.map((label) => {
+            const labelJSON = label.toJSON(tokens);
+
+            return labelJSON;
+          }),
+          metaSuppositionsJSON = this.metaSuppositions.map((metaSupposition) => {
+            const metaSuppositionJSON = metaSupposition.toJSON(tokens);
+
+            return metaSuppositionJSON;
+          }),
+          metaConsequentJSON = this.metaConsequent.toJSON(tokens),
+          localContextJSON = this.localContext.toJSON(tokens),
+          labels = labelsJSON,  ///
+          metaSuppositions = metaSuppositionsJSON,  ///
+          metaConsequent = metaConsequentJSON,  ///
+          localContext = localContextJSON,  ///
+          json = {
+            labels,
+            metaSuppositions,
+            metaConsequent,
+            localContext
+          };
+
+    return json;
+  }
+
+  static fromJSONAndFileContext(Class, json, fileContext) {
+    let { labels } = json;
+
+    const labelsJSON = labels;  ///
+
+    labels = labelsJSON.map((labelJSON) => {
+      const json = labelJSON, ///
+            label = Label.fromJSONAndFileContext(json, fileContext);
+
+      return label;
+    });
+
+    let { metaSuppositions, metaConsequent, localContext } = json;
+
+    const metaSuppositionsJSON = metaSuppositions;  ///
+
+    metaSuppositions = metaSuppositionsJSON.map((metaSuppositionJSON) => {
+      const json = metaSuppositionJSON, ///
+            metaSupposition = MetaSupposition.fromJSONAndFileContext(json, fileContext);
+
+      return metaSupposition;
+    });
+
+    const metaConsequentJSON = metaConsequent;  ///
+
+    json = metaConsequentJSON;  ///
+
+    metaConsequent = MetaConsequent.fromJSONAndFileContext(json, fileContext);
+
+    const localContextJSON = localContext;  ///
+
+    json = localContextJSON;  ///
+
+    localContext = LocalContext.fromJSONAndFileContext(json, fileContext);
+
+    return new Class(labels, metaSuppositions, metaConsequent, localContext);  ///
+  }
+
+  static fromLabelsMetaSuppositionsMetaConsequentAndLocalContext(Class, labels, metaSuppositions, metaConsequent, localContext) { return new Class(labels, metaSuppositions, metaConsequent, localContext); }
+}
+
+function matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, localContext, metastatementLocalContext) {
+  const metaproofStep = prune(metaproofSteps, (metaproofStep) => {
+    const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
+          metastatementNode = metaproofStep.getMetastatementNode();
+
+    if (metaSubproofNode !== null) {
+      const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, localContext, metastatementLocalContext);
+
+      if (!metaSubProofMatches) {  ///
+        return true;
+      }
+    }
+
+    if (metastatementNode !== null) {
+      const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext);
+
+      if (!metastatementMatches) {  ///
+        return true;
+      }
+    }
+  }) || null;
+
+  const metaSuppositionMatches = (metaproofStep !== null);
+
+  return metaSuppositionMatches;
+}
+
+function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions, localContext, metastatementLocalContext) {
+  const metaSuppositionsMatch = metaSuppositions.every((metaSupposition) => {
+    const metaSuppositionMatches = matchMetaSupposition(metaSupposition, metaproofSteps, substitutions, localContext, metastatementLocalContext);
+
+    if (metaSuppositionMatches) {
+      return true;
+    }
+  });
+
+  return metaSuppositionsMatch;
+}
+
+function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, localContext, metastatementLocalContext) {
+  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext),
+        metaConsequentMatches = nonTerminalNodeMatches; ///
+
+  return metaConsequentMatches;
+}

package/src/metaSupposition.js

@@ -0,0 +1,103 @@
+"use strict";
+
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+
+import { match } from "./utilities/array";
+import { nodeAsString } from "./utilities/string";
+import { nodeQuery, nodesQuery } from "./utilities/query";
+import { metastatementNodeFromMetastatementString } from "./utilities/node";
+
+const metaSubproofAssertionNodeQuery = nodeQuery("/metastatement/metaSubproofAssertion!"),
+      metaSubproofAssertionMetastatementNodesQuery = nodesQuery("/metaSubproofAssertion/metastatement"),
+      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement/metastatement!"),
+      metaSubproofSubDerivationLastMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/qualifiedMetastatement|unqualifiedMetastatement[-1]/metastatement!");
+
+export default class MetaSupposition {
+  constructor(metastatementNode) {
+    this.metastatementNode = metastatementNode;
+  }
+
+  getMetastatementNode() {
+    return this.metastatementNode;
+  }
+
+  matchMetaSubproofNode(metaSubproofNode, substitutions, localContext, metastatementLocalContext) {
+    let metaSubproofNodeMatches = false;
+
+    const metaSubproofAssertionNode = metaSubproofAssertionNodeQuery(this.metastatementNode);
+
+    if (metaSubproofAssertionNode !== null) {
+      const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
+            metaSubproofSubDerivationLastMetastatementNode = metaSubproofSubDerivationLastMetastatementNodeQuery(metaSubproofNode),
+            metaSubproofMetastatementNodes = [
+              ...metaSubproofMetaSuppositionMetastatementNodes,
+              metaSubproofSubDerivationLastMetastatementNode
+            ],
+            metaSubproofAssertionMetastatementNodes = metaSubproofAssertionMetastatementNodesQuery(metaSubproofAssertionNode),
+            metaSubproofMetastatementNodesLength = metaSubproofMetastatementNodes.length,
+            metaSubproofAssertionMetastatementNodesLength = metaSubproofAssertionMetastatementNodes.length;
+
+      if (metaSubproofMetastatementNodesLength === metaSubproofAssertionMetastatementNodesLength) {
+        metaSubproofNodeMatches = match(metaSubproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (metaSubproofAssertionMetastatementNode, metaSubproofMetastatementNode) => {
+          const nonTerminalNodeA = metaSubproofAssertionMetastatementNode,  ///
+                nonTerminalNodeB = metaSubproofMetastatementNode, ///
+                localContextA = localContext, ///
+                localContextB = metastatementLocalContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return metaSubproofNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNode, substitutions, localContext, metastatementLocalContext) {
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = metastatementNode,  ///
+          localContextA = localContext, ///
+          localContextB = metastatementLocalContext,  ///
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+            const verifiedAhead = true;
+
+            return verifiedAhead;
+          }),
+          metastatementNodeMatches = nonTerminalNodeVerified; ///
+
+    return metastatementNodeMatches;
+  }
+
+  toJSON(tokens) {
+    const metastatementString = nodeAsString(this.metastatementNode, tokens),
+          metastatement = metastatementString, ///
+          json = {
+            metastatement
+          };
+
+    return json;
+  }
+
+  static fromMetastatementNode(metastatementNode) {
+    const metaSupposition = new MetaSupposition(metastatementNode);
+
+    return metaSupposition;
+  }
+
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metastatement } = json,
+          metastatementString = metastatement,  ///
+          lexer = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
+          metaSupposition = new MetaSupposition(metastatementNode);
+
+    return metaSupposition;
+  }
+}

package/src/metaType.js

@@ -1,6 +1,7 @@
 "use strict";
 
-import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+import { metaTypeNameFromMetaTypeNode } from "./utilities/name";
+import { CONTEXT_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 
 export default class MetaType {
   constructor(name) {
@@ -36,6 +37,14 @@ export default class MetaType {
     return metaTypeNameMatches;
   }
 
+  matchMetaTypeNode(metaTypeNode) {
+    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+          metaTypeNameMatches = this.matchMetaTypeName(metaTypeName),
+          metaTypeNodeMatches = metaTypeNameMatches;  ///
+
+    return metaTypeNodeMatches;
+  }
+
   asString(tokens) {
     const string = `${this.name}`;
 
@@ -59,15 +68,26 @@ export default class MetaType {
   }
 }
 
+class ContextMetaType extends MetaType {
+  static fromNothing() {
+    const name = CONTEXT_META_TYPE_NAME,
+          contextMetaType = new ContextMetaType(name);
+
+    return contextMetaType;
+  }
+}
+
 class StatementMetaType extends MetaType {
   static fromNothing() {
     const name = STATEMENT_META_TYPE_NAME,
-          objectMetaType = new StatementMetaType(name);
+          statementMetaType = new StatementMetaType(name);
 
-    return objectMetaType;
+    return statementMetaType;
   }
 }
 
+export const contextMetaType = ContextMetaType.fromNothing();
+
 export const statementMetaType = StatementMetaType.fromNothing();
 
 export function metaTypeFromJSONAndFileContext(json, fileContext) {

package/src/metaTypeNames.js

@@ -1,3 +1,4 @@
 "use strict";
 
+export const CONTEXT_META_TYPE_NAME = "Context";
 export const STATEMENT_META_TYPE_NAME = "Statement";

package/src/metaTypes.js

@@ -1,3 +1,10 @@
 "use strict";
 
-export const STATEMENT_META_TYPE = "Statement";
+import { contextMetaType, statementMetaType } from "./metaType";
+
+const metaTypes = [
+  contextMetaType,
+  statementMetaType
+];
+
+export default metaTypes;

package/src/metatheorem.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetaLemmaMetatheorem from "./metaLemmaMetatheorem";
+
+export default class Metatheorem extends MetaLemmaMetatheorem {
+  static fromJSONAndFileContext(json, fileContext) { return MetaLemmaMetatheorem.fromJSONAndFileContext(Metatheorem, json, fileContext); }
+
+  static fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(labels, suppositions, consequent, localMetaContext) { return MetaLemmaMetatheorem.fromLabelsMetaSuppositionsMetaConsequentAndLocalMetaContext(Metatheorem, labels, suppositions, consequent, localMetaContext); }
+}

package/src/mixins/context.js

@@ -26,22 +26,26 @@ function getConstructors() { return this.context.getConstructors(); }
 
 function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
 
-function findLabelByTypeName(labelName) { return this.context.findLabelByTypeName(labelName); }
+function findTypeByTypeNode(labelNode) { return this.context.findTypeByTypeNode(labelNode); }
 
-function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
+function findLabelByLabelNode(labelNode) { return this.context.findLabelByLabelNode(labelNode); }
 
-function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
+function findRuleByReferenceNode(referenceNode) { return this.context.findRuleByReferenceNode(referenceNode); }
 
-function findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
+function findAxiomByReferenceNode(referenceNode) { return this.context.findAxiomByReferenceNode(referenceNode); }
 
-function findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
+function findLemmaByReferenceNode(referenceNode) { return this.context.findLemmaByReferenceNode(referenceNode); }
 
-function findConjectureByReferenceName(referenceName) { return this.context.findConjectureByReferenceName(referenceName); }
+function findTheoremByReferenceNode(referenceNode) { return this.context.findTheoremByReferenceNode(referenceNode); }
 
-function isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
+function findConjectureByReferenceNode(referenceNode) { return this.context.findConjectureByReferenceNode(referenceNode); }
 
 function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
 
+function isTypePresentByTypeNode(typeNode) { return this.context.isTypePresentByTypeNode(typeNode); }
+
+function isLabelPresentByLabelNode(labelNode) { return this.context.isLabelPresentByLabelNode(labelNode); }
+
 function nodeAsString(node) { return this.context.nodeAsString(node); }
 
 function nodesAsString(node) { return this.context.nodesAsString(node); }
@@ -60,14 +64,16 @@ const contextMixins = {
   getCombinators,
   getConstructors,
   findTypeByTypeName,
-  findLabelByTypeName,
-  findRuleByReferenceName,
-  findAxiomByReferenceName,
-  findLemmaByReferenceName,
-  findTheoremByReferenceName,
-  findConjectureByReferenceName,
-  isLabelPresentByLabelName,
+  findTypeByTypeNode,
+  findLabelByLabelNode,
+  findRuleByReferenceNode,
+  findAxiomByReferenceNode,
+  findLemmaByReferenceNode,
+  findTheoremByReferenceNode,
+  findConjectureByReferenceNode,
   isTypePresentByTypeName,
+  isTypePresentByTypeNode,
+  isLabelPresentByLabelNode,
   nodeAsString,
   nodesAsString
 };

package/src/rule.js

@@ -31,17 +31,17 @@ export default class Rule {
     return this.fileContext;
   }
 
-  matchLabelName(labelName) {
-    const labelNameMatches = this.labels.some((label) => {
-      const name = labelName, ///
-            labelMatchesName = label.matchName(name);
+  matchLabelNode(labelNode) {
+    const labelNodeMatches = this.labels.some((label) => {
+      const node = labelNode, ///
+            labelMatchesNode = label.matchNode(node);
 
-      if (labelMatchesName) {
+      if (labelMatchesNode) {
         return true;
       }
     });
 
-    return labelNameMatches;
+    return labelNodeMatches;
   }
 
   matchStatement(statementNode, statementLocalContext) {

package/src/ruleNames.js

@@ -10,6 +10,7 @@ export const STATEMENT_RULE_NAME = "statement";
 export const METAVARIABLE_RULE_NAME = "metavariable";
 export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
+export const META_SUBPROOF_RULE_NAME = "metaSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";

package/src/step/metaproof.js

@@ -9,8 +9,9 @@ const metastatementNodesQuery = nodesQuery("/ruleSubproofAssertion/metastatement
       qualifiedOrUnqualifiedMetastatementMetastatementNodesQuery = nodesQuery("/ruleSubproof/qualifiedMetastatement|unqualifiedMetastatement/metastatement!");
 
 export default class MetaproofStep {
-  constructor(ruleSubproofNode, metastatementNode) {
+  constructor(ruleSubproofNode, metaSubproofNode, metastatementNode) {
     this.ruleSubproofNode = ruleSubproofNode;
+    this.metaSubproofNode = metaSubproofNode;
     this.metastatementNode = metastatementNode;
   }
 
@@ -18,6 +19,10 @@ export default class MetaproofStep {
     return this.ruleSubproofNode;
   }
 
+  getMetaSubproofNode() {
+    return this.metaSubproofNode;
+  }
+
   getMetastatementNode() {
     return this.metastatementNode;
   }
@@ -87,15 +92,26 @@ export default class MetaproofStep {
   }
 
   static fromRuleSubproofNode(ruleSubproofNode) {
-    const metastatementNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metastatementNode);
+    const metaSubproofNode = null,
+          metastatementNode = null,
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
+
+    return metaProofStep;
+  }
+
+  static fromMetaSubproofNode(metaSubproofNode) {
+    const ruleSubproofNode = null,
+          metastatementNode = null,
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
+
   }
 
   static fromMetastatementNode(metastatementNode) {
     const ruleSubproofNode = null,
-          metaProofStep = new MetaproofStep(ruleSubproofNode, metastatementNode);
+          metaSubproofNode = null,
+          metaProofStep = new MetaproofStep(ruleSubproofNode, metaSubproofNode, metastatementNode);
 
     return metaProofStep;
   }

package/src/type.js

@@ -2,6 +2,8 @@
 
 import { OBJECT_TYPE_NAME } from "./typeNames";
 
+import { typeNameFromTypeNode } from "./utilities/name";
+
 export default class Type {
   constructor(name, superType) {
     this.name = name;
@@ -101,6 +103,14 @@ export default class Type {
     return typeNameMatches;
   }
 
+  matchTypeNode(typeNode) {
+    const typeName = typeNameFromTypeNode(typeNode),
+          typeNameMatches = this.matchTypeName(typeName),
+          typeNodeMatches = typeNameMatches;  ///
+
+    return typeNodeMatches;
+  }
+
   asString(tokens, noSuperType = false) {
     let string;
 

package/src/utilities/name.js

@@ -0,0 +1,50 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const typeTerminalNodeQuery = nodeQuery("/type/@type"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
+      labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
+      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
+
+export function typeNameFromTypeNode(typeNode) {
+  let typeName = null;
+
+  if (typeNode !== null) {
+    const typeTerminalNode = typeTerminalNodeQuery(typeNode),
+          typeTerminalNodeContent = typeTerminalNode.getContent();
+
+    typeName = typeTerminalNodeContent; ///
+  }
+
+  return typeName;
+}
+
+export function labelNameFromLabelNode(labelNode) {
+  const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
+        labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
+        labelName = labelNameTerminalNodeContent; ///
+
+  return labelName;
+}
+
+export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
+  let metaTypeName = null;
+
+  if (metaTypeNode !== null) {
+    const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+          metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent();
+
+    metaTypeName = metaTypeTerminalNodeContent; ///
+  }
+
+  return metaTypeName;
+}
+
+export function referenceNameFromReferenceNode(referenceNode) {
+  const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
+        referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
+        referenceName = referenceNameTerminalNodeContent; ///
+
+  return referenceName;
+}

package/src/utilities/query.js

@@ -2,11 +2,6 @@
 
 import { Query } from "occam-query";
 
-const typeTerminalNodeQuery = nodeQuery("/type/@type"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
-      labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
-      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
-
 export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
 
@@ -34,45 +29,3 @@ export function nodesQuery(expression) {
     return nodes;
   };
 }
-
-export function typeNameFromTypeNode(typeNode) {
-  let typeName = null;
-
-  if (typeNode !== null) {
-    const typeTerminalNode = typeTerminalNodeQuery(typeNode),
-          typeTerminalNodeContent = typeTerminalNode.getContent();
-
-    typeName = typeTerminalNodeContent; ///
-  }
-
-  return typeName;
-}
-
-export function labelNameFromLabelNode(labelNode) {
-  const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
-        labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
-        labelName = labelNameTerminalNodeContent; ///
-
-  return labelName;
-}
-
-export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
-  let metaTypeName = null;
-
-  if (metaTypeNode !== null) {
-    const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
-          metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent();
-
-    metaTypeName = metaTypeTerminalNodeContent; ///
-  }
-
-  return metaTypeName;
-}
-
-export function referenceNameFromReferenceNode(referenceNode) {
-  const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
-        referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
-        referenceName = referenceNameTerminalNodeContent; ///
-
-  return referenceName;
-}

package/src/verifier/node/metastatement.js

@@ -27,7 +27,8 @@ class MetastatementNodeVerifier extends NodeVerifier {
 
       case VARIABLE_RULE_NAME: {
         const variableNode = nonTerminalNode, ///
-              standaloneVariableVerified = verifyStandaloneVariable(variableNode, localMetaContext, verifyAhead),
+              localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+              standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
               variableNodeVerified = standaloneVariableVerified;  ///
 
         nonTerminalNodeVerified = variableNodeVerified; ///