occam-verify-cli 0.0.869 → 0.0.870

package/src/verifier/node/termAsConstructor.js

@@ -2,45 +2,50 @@
 
 import NodeVerifier from "../../verifier/node";
 
+import { nodeQuery } from "../../utilities/query";
+import { verifyNode } from "../../utilities/verifier";
 import { verifyStandaloneType } from "../../verify/type";
 import { verifyStandaloneTerm } from "../../verify/term";
-import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
+
+const termNodeQuery = nodeQuery("/term!"),
+      typeNodeQuery = nodeQuery("/type!");
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
-    const ruleName = nonTerminalNode.getRuleName();
-
-    switch (ruleName) {
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
-
-        nonTerminalNodeVerified = termNodeVerified; ///
-
-        break;
+    const nodeQueryMaps = [
+      {
+        nodeQuery: termNodeQuery,
+        verifyNode: this.verifyTermNode
+      },
+      {
+        nodeQuery: typeNodeQuery,
+        verifyNode: this.verifyTypeNode
       }
+    ];
 
-      case TYPE_RULE_NAME: {
-        const typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-              typeNodeVerified = standaloneTypeVerified;  ///
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
-        nonTerminalNodeVerified = typeNodeVerified; ///
+    nonTerminalNodeVerified = nodeVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
-        break;
-      }
+    return nonTerminalNodeVerified;
+  }
 
-      default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
+  verifyTermNode(termNode, localContext, verifyAhead) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+          termNodeVerified = standaloneTermVerified;  ///
 
-        break;
-      }
-    }
+    return termNodeVerified;
+  }
 
-    return nonTerminalNodeVerified;
+  verifyTypeNode(typeNode, localContext, verifyAhead) {
+    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+          typeNodeVerified = standaloneTypeVerified;  ///
+
+    return typeNodeVerified;
   }
 }
 

package/src/verifier/nodes/equality.js

@@ -1,59 +1,54 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
+import verifyTermAgainstTerm from "../../verify/termAgainstTerm";
 
-import { TERM_RULE_NAME } from "../../ruleNames";
-import { areTermNodesEqual } from "../../utilities/equivalences";
+import { nodeQuery } from "../../utilities/query";
+import { verifyNodes } from "../../utilities/verifier";
 
-class EqualityNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+const termNodeQuery = nodeQuery("/term!");
 
-    const ruleNameA = nonTerminalNodeA.getRuleName(), ///
-          ruleNameB = nonTerminalNodeB.getRuleName(); ///
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
+    let nonTerminalNodeVerified;
 
-    if (ruleNameA === ruleNameB) {
-      switch (ruleNameA) {
-        case TERM_RULE_NAME: {
-          const termNodeA = nonTerminalNodeA, ///
-                termNodeB = nonTerminalNodeB, ///
-                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead);
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-          nonTerminalNodeVerified = termNodeVerified;  ///
+          const termNodeA = nodeA,  ///
+                termNodeB = nodeB,  ///
+                termNodeVerifiedAgainstTermNode =
 
-          break;
-        }
+                  this.verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead);
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
+          nonTerminalNodeVerified = termNodeVerifiedAgainstTermNode; ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
       }
-    }
+    ];
 
-    return nonTerminalNodeVerified;
-  }
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-  verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead) {
-    let termNodeVerified;
+    nonTerminalNodeVerified = nodesVerified ?
+                                 true :
+                                   super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    const leftTermNode = termNodeA, ///
-          rightTermNode = termNodeB, ///
-          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
+    return nonTerminalNodeVerified;
+  }
 
-    if (termNodesEqual) {
-      const verifiedAhead = verifyAhead();
+  verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead) {
+    let termNodeVerifiedAgainstTermNode;
 
-      termNodeVerified = verifiedAhead;  ///
-    } else {
-      const nonTerminalNodeA = termNodeA, ///
-            nonTerminalNodeB = termNodeB; ///
+    const termVerifiedAgainstTerm = verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead);
 
-      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
-    }
+    termNodeVerifiedAgainstTermNode = termVerifiedAgainstTerm;  ///
 
-    return termNodeVerified;
+    return termNodeVerifiedAgainstTermNode;
   }
 }
 

package/src/verifier/nodes/intrinsicLevel.js

@@ -1,68 +1,60 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
+import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
 
 import { nodeQuery } from "../../utilities/query";
-import { TERM_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const variableNodeQuery = nodeQuery("/term/variable!");
+const termNodeQuery = nodeQuery("/term!"),
+      termVariableNodeQuery = nodeQuery("/term/variable!");
 
 class IntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const ruleName = nonTerminalNodeARuleName;  ///
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                termVariableNodeVerifiedAgainstTermNode =
 
-      switch (ruleName) {
-        case TERM_RULE_NAME: {
-          const termNodeA = nonTerminalNodeA,  ///
-                termNodeB = nonTerminalNodeB,  ///
-                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = termNodeVerified;  ///
+          nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
+      }
+    ];
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          break;
-        }
-      }
-    }
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let termNodeVerified;
+  verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let termVariableNodeVerifiedAgainstTermNode;
 
-    const variableNodeA = variableNodeQuery(termNodeA);
+    const termNode = termNodeB, ///
+          variableNode = termVariableNodeA, ///
+          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
 
-    if (variableNodeA !== null) {
-      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
 
-      termNodeVerified = variableNodeVerified; ///
-    } else {
-      const nonTerminalNodeA = termNodeA, ///
-            nonTerminalNodeB = termNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-      termNodeVerified = nonTerminalNodeVerified; ///
-    }
-
-    return termNodeVerified;
+    return termVariableNodeVerifiedAgainstTermNode;
   }
 }
 
-Object.assign(IntrinsicLevelNodesVerifier.prototype, intrinsicLevelNodesVerifierMixins);
-
 const intrinsicLevelNodesVerifier = new IntrinsicLevelNodesVerifier();
 
 export default intrinsicLevelNodesVerifier;

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -0,0 +1,222 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
+import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
+
+import { nodeQuery } from "../../utilities/query";
+import { verifyNodes } from "../../utilities/verifier";
+
+const termNodeQuery = nodeQuery("/term!"),
+      statementNodeQuery = nodeQuery("/statement!"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
+      metastatementNodeQuery = nodeQuery("/metastatement!"),
+      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      metastatementStatementNodeQuery = nodeQuery("/metastatement/statement!"),
+      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
+      metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
+
+class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metastatementStatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const metastatementStatementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metaArgumentStatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const metaArgumentStatementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementStatementNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB, ///
+                metastatementStatementNodeA = nodeA,  ///
+                metastatementStatementNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementStatementNodeVerifiedAgainstStatementNode; ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB,  ///
+                metastatementNodeA = nodeA, ///
+                metastatementNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementNodeVerifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                variableNodeVerifiedAgainstTermNode =
+
+                  this.verifyVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = variableNodeVerifiedAgainstTermNode; ///
+
+          return nonTerminalNodeVerified;
+        }
+      }
+    ];
+
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
+
+    const statementNode = metastatementStatementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+
+    const statementNode = metaArgumentStatementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstStatementNode;
+
+    const statementNode = statementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementStatementNodeVerifiedAgainstStatementNode;
+
+    const nonTerminalNodeA = metastatementStatementNodeA, ///
+          nonTerminalNodeB = statementNodeB,  ///
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    metastatementStatementNodeVerifiedAgainstStatementNode = nonTerminalNodeVerified; ///
+
+    return metastatementStatementNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementNodeVerifiedAgainstStatementNode;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeB = statementNodeB,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          childNodesA = nonTerminalNodeAChildNodes, ///
+          childNodesB = nonTerminalNodeBChildNodes, ///
+          childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, verifyAhead);
+
+    metastatementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
+
+    return metastatementNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let variableNodeVerifiedAgainstTermNode;
+
+    const termNode = termNodeB, ///
+          variableNode = termVariableNodeA, ///
+          variableVerifiedAgainstTerm = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
+
+    variableNodeVerifiedAgainstTermNode = variableVerifiedAgainstTerm;  ///
+
+    return variableNodeVerifiedAgainstTermNode;
+  }
+}
+
+const intrinsicLevelAgainstMetaLevelNodesVerifier = new IntrinsicLevelAgainstMetaLevelNodesVerifier();
+
+export default intrinsicLevelAgainstMetaLevelNodesVerifier;

package/src/verifier/nodes/metaLevel.js

@@ -1,68 +1,60 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import metaLevelNodesVerifierMixins from "../../mixins/nodesVerifier/metaLevel";
+import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+const metastatementNodeQuery = nodeQuery("/metastatement!"),
+      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metastatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const ruleName = nonTerminalNodeARuleName;  ///
+          const metastatementNodeB = nodeB, ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementMetavariableNodeVerifiedAgainstMetastatementNode =
 
-      switch (ruleName) {
-        case METASTATEMENT_RULE_NAME: {
-          const metastatementNodeA = nonTerminalNodeA,  ///
-                metastatementNodeB = nonTerminalNodeB,  ///
-                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementNodeVerified;  ///
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
+      }
+    ];
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-          break;
-        }
-      }
-    }
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
-    let metastatementNodeVerified;
+  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
 
-    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+    const metavariableNode = metastatementMetavariableNodeA, ///
+          metastatementNode = metastatementNodeB, ///
+          metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-    if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+    metastatementMetavariableNodeVerifiedAgainstMetastatementNode = metavariableVerifiedAgainstMetastatement;  ///
 
-      metastatementNodeVerified = metaVariableNodeVerified; ///
-    } else {
-      const nonTerminalNodeA = metastatementNodeA,  ///
-            nonTerminalNodeB = metastatementNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
-
-      metastatementNodeVerified = nonTerminalNodeVerified;  ///
-    }
-
-    return metastatementNodeVerified;
+    return metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
   }
 }
 
-Object.assign(MetaLevelNodesVerifier.prototype, metaLevelNodesVerifierMixins);
-
 const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
 
 export default metaLevelNodesVerifier;