occam-verify-cli 0.0.506 → 0.0.507

package/src/conclusion.js

@@ -1,10 +1,9 @@
 "use strict";
 
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
-import { metavariableNameFromMetavariableNode } from "./utilities/query";
+import { conclusionMatcher } from "./matcher/conclusion";
+import { conclusionMetaMatcher } from "./metaMatcher/conclusion";
 import { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "./ruleNames";
 
 export default class Conclusion {
   constructor(metastatementNode) {
@@ -18,8 +17,8 @@ export default class Conclusion {
   matchStatementNode(statementNode, substitutions) {
     const nonTerminalNode = statementNode,  ///
           conclusionNonTerminalNode = this.metastatementNode,  ///
-          conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = conclusionNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = conclusionMatcher.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -27,8 +26,8 @@ export default class Conclusion {
   matchMetastatementNode(metastatementNode, metaSubstitutions) {
     const nonTerminalNode = metastatementNode,  ///
           conclusionNonTerminalNode = this.metastatementNode,  ///
-          conclusionNonTerminalNodeMatches = metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          metastatementNodeMatches = conclusionNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = conclusionMetaMatcher.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          metastatementNodeMatches = nonTerminalNodeMatches; ///
 
     return metastatementNodeMatches;
   }
@@ -58,273 +57,3 @@ export default class Conclusion {
     return conclusion;
   }
 }
-
-function matchConclusionNode(conclusionNode, node, substitutions) {
-  let conclusionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = conclusionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            conclusionTerminalNode = conclusionNode,  ///
-            conclusionTerminalNodeMatches = matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, substitutions);
-
-      conclusionNodeMatches = conclusionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            conclusionNonTerminalNode = conclusionNode,  ///
-            conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions);
-
-      conclusionNodeMatches = conclusionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return conclusionNodeMatches;
-}
-
-function matchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
-  let conclusionNodesMatch = false;
-
-  const nodesLength = nodes.length,
-        conclusionNodesLength = conclusionNodes.length;
-
-  if (nodesLength === conclusionNodesLength) {
-    conclusionNodesMatch = nodes.every((node, index) => {
-      const conclusionNode = conclusionNodes[index],
-            conclusionNodeMatches = matchConclusionNode(conclusionNode, node, metaSubstitutions);
-
-      if (conclusionNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return conclusionNodesMatch;
-}
-
-function matchConclusionTerminalNode(conclusionTerminalNode, terminalNode, substitutions) {
-  const matches = conclusionTerminalNode.match(terminalNode),
-        conclusionTerminalNodeMatches = matches;  ///
-
-  return conclusionTerminalNodeMatches;
-}
-
-function matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions) {
-  let conclusionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
-        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
-        ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
-        conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameStatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
-    const statementNode = nonTerminalNode,  ///
-          conclusionMetastatementNode = conclusionNonTerminalNode,  ///
-          conclusionMetastatementNodeMatches = matchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, substitutions);
-
-    if (conclusionMetastatementNodeMatches) {
-      conclusionNonTerminalNodeMatches = true; ///
-    } else {
-      const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
-
-      conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === conclusionNonTerminalNodeRuleName) {
-    const conclusionNonTerminalNodeChildNodesMatches = matchConclusionNodes(conclusionNodes, nodes, substitutions);
-
-    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return conclusionNonTerminalNodeMatches;
-}
-
-function matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions) {
-  let conclusionMetavariableNodeMatches = true;
-
-  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
-        substitution = substitutions.find((substitution) => {
-          const metavariableName = substitution.getMetavariableName();
-
-          if (metavariableName === conclusionMetavariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (substitution !== null) {
-    const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
-
-    conclusionMetavariableNodeMatches = substitutionNodesMatch;  ///
-  }
-
-  return conclusionMetavariableNodeMatches;
-}
-
-function matchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, substitutions) {
-  let conclusionMetastatementNodeMatches = false;
-
-  const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
-        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
-        conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
-
-  if (conclusionNonTerminalNodeChildNodesLength === 1) {
-    const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
-          conclusionChildNode = firstConclusionChildNode,  ///
-          conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
-
-    if (conclusionChildNodeNonTerminalNode) {
-      const conclusionNonTerminalChildNode = conclusionChildNode,  ///
-            conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
-            conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
-
-      if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
-        const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
-              conclusionMetavariableNodeMatches = matchConclusionMetavariableNode(conclusionMetavariableNode, statementNode, substitutions);
-
-        conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
-      }
-    }
-  }
-
-  return conclusionMetastatementNodeMatches;
-}
-
-function metaMatchConclusionNode(conclusionNode, node, metaSubstitutions) {
-  let conclusionNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = conclusionNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            conclusionTerminalNode = conclusionNode,  ///
-            conclusionTerminalNodeMatches = metaMatchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions);
-
-      conclusionNodeMatches = conclusionTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            conclusionNonTerminalNode = conclusionNode,  ///
-            conclusionNonTerminalNodeMatches = metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      conclusionNodeMatches = conclusionNonTerminalNodeMatches; ///
-    }
-  }
-
-  return conclusionNodeMatches;
-}
-
-function metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions) {
-  let conclusionNodesMatch = false;
-
-  const nodesLength = nodes.length,
-        conclusionNodesLength = conclusionNodes.length;
-
-  if (nodesLength === conclusionNodesLength) {
-    conclusionNodesMatch = nodes.every((node, index) => {
-      const conclusionNode = conclusionNodes[index],
-            conclusionNodeMatches = metaMatchConclusionNode(conclusionNode, node, metaSubstitutions);
-
-      if (conclusionNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return conclusionNodesMatch;
-}
-
-function metaMatchConclusionTerminalNode(conclusionTerminalNode, terminalNode, metaSubstitutions) {
-  const matches = conclusionTerminalNode.match(terminalNode),
-        conclusionTerminalNodeMatches = matches;  ///
-
-  return conclusionTerminalNodeMatches;
-}
-
-function metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-  let conclusionNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        childNodes = nonTerminalNode.getChildNodes(),
-        conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
-        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
-        nodes = childNodes, ///
-        conclusionNodes = conclusionNonTerminalNodeChildNodes, ///
-        ruleNameMetastatementRuleName = (ruleName === METASTATEMENT_RULE_NAME),
-        conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
-
-  if (ruleNameMetastatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
-    const statementNode = nonTerminalNode,  ///
-          conclusionMetastatementNode = conclusionNonTerminalNode,  ///
-          conclusionMetastatementNodeMatches = metaMatchConclusionMetastatementNode(conclusionMetastatementNode, statementNode, metaSubstitutions);
-
-    if (conclusionMetastatementNodeMatches) {
-      conclusionNonTerminalNodeMatches = true; ///
-    } else {
-      const conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
-
-      conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
-    }
-  } else if (ruleName === conclusionNonTerminalNodeRuleName) {
-    const conclusionNonTerminalNodeChildNodesMatches = metaMatchConclusionNodes(conclusionNodes, nodes, metaSubstitutions);
-
-    conclusionNonTerminalNodeMatches = conclusionNonTerminalNodeChildNodesMatches; ///
-  }
-
-  return conclusionNonTerminalNodeMatches;
-}
-
-function metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions) {
-  let conclusionMetavariableNodeMatches = true;
-
-  const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const metavariableName = metaSubstitution.getMetavariableName();
-
-          if (metavariableName === conclusionMetavariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchMetastatementNode(metastatementNode);
-
-    conclusionMetavariableNodeMatches = metaSubstitutionNodesMatch;  ///
-  }
-
-  return conclusionMetavariableNodeMatches;
-}
-
-function metaMatchConclusionMetastatementNode(conclusionMetastatementNode, metastatementNode, metaSubstitutions) {
-  let conclusionMetastatementNodeMatches = false;
-
-  const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
-        conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
-        conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
-
-  if (conclusionNonTerminalNodeChildNodesLength === 1) {
-    const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
-          conclusionChildNode = firstConclusionChildNode,  ///
-          conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
-
-    if (conclusionChildNodeNonTerminalNode) {
-      const conclusionNonTerminalChildNode = conclusionChildNode,  ///
-            conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
-            conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
-
-      if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
-        const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
-              conclusionMetavariableNodeMatches = metaMatchConclusionMetavariableNode(conclusionMetavariableNode, metastatementNode, metaSubstitutions);
-
-        conclusionMetastatementNodeMatches = conclusionMetavariableNodeMatches; ///
-      }
-    }
-  }
-
-  return conclusionMetastatementNodeMatches;
-}

package/src/consequence.js

@@ -1,10 +1,8 @@
 "use strict";
 
-import { first } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
-import { variableNameFromVariableNode } from "./utilities/query";
+import { consequenceMatcher } from "./matcher/consequence";
 import { statementNodeFromStatementString } from "./utilities/string";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
 
 export default class Consequence {
   constructor(statementNode) {
@@ -18,8 +16,8 @@ export default class Consequence {
   matchStatementNode(statementNode, metaSubstitutions) {
     const nonTerminalNode = statementNode,  ///
           consequenceNonTerminalNode = this.statementNode,  ///
-          consequenceNonTerminalNodeMatches = matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          statementNodeMatches = consequenceNonTerminalNodeMatches; ///
+          nonTerminalNodeMatches = consequenceMatcher.matchNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
@@ -49,139 +47,3 @@ export default class Consequence {
     return consequence;
   }
 }
-
-function matchConsequenceNode(consequenceNode, node, metaSubstitutions) {
-  let consequenceNodeMatches = false;
-
-  const nodeTerminalNode = node.isTerminalNode(),
-        ruleNodeTerminalNode = consequenceNode.isTerminalNode();
-
-  if (nodeTerminalNode === ruleNodeTerminalNode) {
-    if (nodeTerminalNode) {
-      const terminalNode = node,  ///
-            consequenceTerminalNode = consequenceNode,  ///
-            consequenceTerminalNodeMatches = matchConsequenceTerminalNode(consequenceTerminalNode, terminalNode, metaSubstitutions);
-
-      consequenceNodeMatches = consequenceTerminalNodeMatches;  ///
-    } else {
-      const nonTerminalNode = node, ///
-            consequenceNonTerminalNode = consequenceNode,  ///
-            consequenceNonTerminalNodeMatches = matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions);
-
-      consequenceNodeMatches = consequenceNonTerminalNodeMatches; ///
-    }
-  }
-
-  return consequenceNodeMatches;
-}
-
-function matchConsequenceNodes(consequenceNodes, nodes, metaSubstitutions) {
-  let consequenceNodesMatches = false;
-
-  const nodesLength = nodes.length,
-        consequenceNodesLength = consequenceNodes.length;
-
-  if (nodesLength === consequenceNodesLength) {
-    consequenceNodesMatches = nodes.every((node, index) => {
-      const consequenceNode = consequenceNodes[index],
-            consequenceNodeMatches = matchConsequenceNode(consequenceNode, node, metaSubstitutions);
-
-      if (consequenceNodeMatches) {
-        return true;
-      }
-    });
-  }
-
-  return consequenceNodesMatches;
-}
-
-function matchConsequenceVariable(consequenceVariableNode, nodes, metaSubstitutions) {
-  let consequenceVariableMatches = true;
-
-  const consequenceVariableName = variableNameFromVariableNode(consequenceVariableNode),
-        metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
-          const variableName = metaSubstitution.getVariableName();
-
-          if (variableName === consequenceVariableName) {
-            return true;
-          }
-        }) || null;
-
-  if (metaSubstitution !== null) {
-    const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
-
-    consequenceVariableMatches = metaSubstitutionNodesMatch;  ///
-  }
-
-  return consequenceVariableMatches;
-}
-
-function matchConsequenceTerminalNode(consequenceTerminalNode, terminalNode, metaSubstitutions) {
-  const matches = consequenceTerminalNode.match(terminalNode),
-        consequenceTerminalNodeMatches = matches;  ///
-
-  return consequenceTerminalNodeMatches;
-}
-
-function matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions) {
-  let consequenceNonTerminalNodeMatches = false;
-
-  const ruleName = nonTerminalNode.getRuleName(),
-        consequenceRuleName = consequenceNonTerminalNode.getRuleName(); ///
-
-  if (ruleName === consequenceRuleName) {
-    const childNodes = nonTerminalNode.getChildNodes(),
-          consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
-          nodes = childNodes, ///
-          consequenceNodes = consequenceChildNodes, ///
-          consequenceChildNodesMatches = matchConsequenceNodes(consequenceNodes, nodes, metaSubstitutions);
-
-    consequenceNonTerminalNodeMatches = consequenceChildNodesMatches; ///
-
-    if (!consequenceNonTerminalNodeMatches) {
-      const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
-
-      if (ruleNameStatementRuleName) {
-        const statementNode = nonTerminalNode,  ///
-              consequenceStatementNode = consequenceNonTerminalNode,  ///
-              consequenceStatementNodeMatches = matchConsequenceStatementNode(consequenceStatementNode, statementNode, metaSubstitutions);
-
-        consequenceNonTerminalNodeMatches = consequenceStatementNodeMatches; ///
-      }
-    }
-  }
-
-  return consequenceNonTerminalNodeMatches;
-}
-
-function matchConsequenceStatementNode(consequenceStatementNode, statementNode, metaSubstitutions) {
-  let consequenceStatementNodeMatches = false;
-
-  const consequenceNonTerminalNode = consequenceStatementNode,  ///
-        consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
-        consequenceChildNodesLength = consequenceChildNodes.length;
-
-  if (consequenceChildNodesLength === 1) {
-    const firstConsequenceChildNode = first(consequenceChildNodes),
-          consequenceChildNode = firstConsequenceChildNode,  ///
-          consequenceChildNodeNonTerminalNode = consequenceChildNode.isNonTerminalNode();
-
-    if (consequenceChildNodeNonTerminalNode) {
-      const consequenceNonTerminalChildNode = consequenceChildNode,  ///
-            consequenceNonTerminalChildNodeRuleName = consequenceNonTerminalChildNode.getRuleName(),
-            consequenceNonTerminalChildNodeRuleNameVariableRuleName = (consequenceNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
-
-      if (consequenceNonTerminalChildNodeRuleNameVariableRuleName) {
-        const consequenceVariableNode = consequenceNonTerminalChildNode,  ///
-              nonTerminalNode = statementNode,  ///
-              childNodes = nonTerminalNode.getChildNodes(),
-              nodes = childNodes, ///
-              consequenceMetaVariableMatches = matchConsequenceVariable(consequenceVariableNode, nodes, metaSubstitutions);
-
-        consequenceStatementNodeMatches = consequenceMetaVariableMatches; ///
-      }
-    }
-  }
-
-  return consequenceStatementNodeMatches;
-}

package/src/matcher/conclusion.js

@@ -0,0 +1,86 @@
+"use strict";
+
+import Matcher from "../matcher";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+class ConclusionMatcher extends Matcher {
+  matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          conclusionNonTerminalNodeRuleName = conclusionNonTerminalNode.getRuleName(),
+          ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME),
+          conclusionNonTerminalNodeRuleNameMetastatementRuleName = (conclusionNonTerminalNodeRuleName === METASTATEMENT_RULE_NAME);
+
+    if (ruleNameStatementRuleName && conclusionNonTerminalNodeRuleNameMetastatementRuleName) {
+      const statementNode = nonTerminalNode,  ///
+            conclusionMetastatementNode = conclusionNonTerminalNode,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(conclusionMetastatementNode, statementNode, substitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true; ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions);
+      }
+    } else if (ruleName === conclusionNonTerminalNodeRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetavariableNode(conclusionMetavariableNode, statementNode, substitutions) {
+    let metavariableNodeMatches = true;
+
+    const conclusionMetavariableName = metavariableNameFromMetavariableNode(conclusionMetavariableNode),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === conclusionMetavariableName) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const substitutionNodesMatch = substitution.matchStatementNode(statementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    }
+
+    return metavariableNodeMatches;
+  }
+
+  matchMetastatementNode(conclusionMetastatementNode, statementNode, substitutions) {
+    let metastatementNodeMatches = false;
+
+    const conclusionNonTerminalNode = conclusionMetastatementNode,  ///
+          conclusionNonTerminalNodeChildNodes = conclusionNonTerminalNode.getChildNodes(),
+          conclusionNonTerminalNodeChildNodesLength = conclusionNonTerminalNodeChildNodes.length;
+
+    if (conclusionNonTerminalNodeChildNodesLength === 1) {
+      const firstConclusionChildNode = first(conclusionNonTerminalNodeChildNodes),
+            conclusionChildNode = firstConclusionChildNode,  ///
+            conclusionChildNodeNonTerminalNode = conclusionChildNode.isNonTerminalNode();
+
+      if (conclusionChildNodeNonTerminalNode) {
+        const conclusionNonTerminalChildNode = conclusionChildNode,  ///
+              conclusionNonTerminalChildNodeRuleName = conclusionNonTerminalChildNode.getRuleName(),
+              conclusionNonTerminalChildNodeRuleNameMetavariableRuleName = (conclusionNonTerminalChildNodeRuleName === METAVARIABLE_RULE_NAME);
+
+        if (conclusionNonTerminalChildNodeRuleNameMetavariableRuleName) {
+          const conclusionMetavariableNode = conclusionNonTerminalChildNode,  ///
+                metavariableNodeMatches = this.matchMetavariableNode(conclusionMetavariableNode, statementNode, substitutions);
+
+          metastatementNodeMatches = metavariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+}
+
+export const conclusionMatcher = new ConclusionMatcher();

package/src/matcher/consequence.js

@@ -0,0 +1,89 @@
+"use strict";
+
+import Matcher from "../matcher";
+
+import { first } from "../utilities/array";
+import { variableNameFromVariableNode } from "../utilities/query";
+import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+
+class ConsequenceMatcher extends Matcher {
+  matchNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const ruleName = nonTerminalNode.getRuleName(),
+          consequenceRuleName = consequenceNonTerminalNode.getRuleName(); ///
+
+    if (ruleName === consequenceRuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions);
+
+      if (!nonTerminalNodeMatches) {
+        const ruleNameStatementRuleName = (ruleName === STATEMENT_RULE_NAME);
+
+        if (ruleNameStatementRuleName) {
+          const statementNode = nonTerminalNode,  ///
+                consequenceStatementNode = consequenceNonTerminalNode,  ///
+                statementNodeMatches = this.matchStatementNode(consequenceStatementNode, statementNode, metaSubstitutions);
+
+          nonTerminalNodeMatches = statementNodeMatches; ///
+        }
+      }
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchStatementNode(consequenceStatementNode, statementNode, metaSubstitutions) {
+    let statementNodeMatches = false;
+
+    const consequenceNonTerminalNode = consequenceStatementNode,  ///
+          consequenceChildNodes = consequenceNonTerminalNode.getChildNodes(),
+          consequenceChildNodesLength = consequenceChildNodes.length;
+
+    if (consequenceChildNodesLength === 1) {
+      const firstConsequenceChildNode = first(consequenceChildNodes),
+            consequenceChildNode = firstConsequenceChildNode,  ///
+            consequenceChildNodeNonTerminalNode = consequenceChildNode.isNonTerminalNode();
+
+      if (consequenceChildNodeNonTerminalNode) {
+        const consequenceNonTerminalChildNode = consequenceChildNode,  ///
+              consequenceNonTerminalChildNodeRuleName = consequenceNonTerminalChildNode.getRuleName(),
+              consequenceNonTerminalChildNodeRuleNameVariableRuleName = (consequenceNonTerminalChildNodeRuleName === VARIABLE_RULE_NAME);
+
+        if (consequenceNonTerminalChildNodeRuleNameVariableRuleName) {
+          const consequenceVariableNode = consequenceNonTerminalChildNode,  ///
+                nonTerminalNode = statementNode,  ///
+                childNodes = nonTerminalNode.getChildNodes(),
+                nodes = childNodes, ///
+                variableMatches = this.matchVariable(consequenceVariableNode, nodes, metaSubstitutions);
+
+          statementNodeMatches = variableMatches; ///
+        }
+      }
+    }
+
+    return statementNodeMatches;
+  }
+
+  matchVariable(consequenceVariableNode, nodes, metaSubstitutions) {
+    let variableMatches = true;
+
+    const consequenceVariableName = variableNameFromVariableNode(consequenceVariableNode),
+          metaSubstitution = metaSubstitutions.find((metaSubstitution) => {
+            const variableName = metaSubstitution.getVariableName();
+
+            if (variableName === consequenceVariableName) {
+              return true;
+            }
+          }) || null;
+
+    if (metaSubstitution !== null) {
+      const metaSubstitutionNodesMatch = metaSubstitution.matchNodes(nodes);
+
+      variableMatches = metaSubstitutionNodesMatch;  ///
+    }
+
+    return variableMatches;
+  }
+}
+
+export const consequenceMatcher = new ConsequenceMatcher();