occam-verify-cli 0.0.506 → 0.0.508

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 { metastatementNodeFromMetastatementString } from "./utilities/string";
-import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "./ruleNames";
+import { conclusionStatementForMetavariableMatcher } from "./matcher/statementForMetavariable/conclusion";
+import { conclusionMetastatementForMetavariableMatcher } from "./matcher/metastatementForMetavariable/conclusion";
 
 export default class Conclusion {
   constructor(metastatementNode) {
@@ -16,19 +15,19 @@ export default class Conclusion {
   }
 
   matchStatementNode(statementNode, substitutions) {
-    const nonTerminalNode = statementNode,  ///
-          conclusionNonTerminalNode = this.metastatementNode,  ///
-          conclusionNonTerminalNodeMatches = matchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, substitutions),
-          statementNodeMatches = conclusionNonTerminalNodeMatches; ///
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = statementNode,  ///
+          nonTerminalNodeMatches = conclusionStatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          statementNodeMatches = nonTerminalNodeMatches; ///
 
     return statementNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, metaSubstitutions) {
-    const nonTerminalNode = metastatementNode,  ///
-          conclusionNonTerminalNode = this.metastatementNode,  ///
-          conclusionNonTerminalNodeMatches = metaMatchConclusionNonTerminalNode(conclusionNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          metastatementNodeMatches = conclusionNonTerminalNodeMatches; ///
+  matchMetastatementNode(metastatementNode, substitutions) {
+    const nonTerminalNodeA = this.metastatementNode,  ///
+          nonTerminalNodeB = metastatementNode,  ///
+          nonTerminalNodeMatches = conclusionMetastatementForMetavariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          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 { statementNodeFromStatementString } from "./utilities/string";
-import { VARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "./ruleNames";
+import { consequenceStatementForVariableMatcher } from "./matcher/statementForVariable/consequence";
 
 export default class Consequence {
   constructor(statementNode) {
@@ -15,11 +13,11 @@ export default class Consequence {
     return this.statementNode;
   }
 
-  matchStatementNode(statementNode, metaSubstitutions) {
-    const nonTerminalNode = statementNode,  ///
-          consequenceNonTerminalNode = this.statementNode,  ///
-          consequenceNonTerminalNodeMatches = matchConsequenceNonTerminalNode(consequenceNonTerminalNode, nonTerminalNode, metaSubstitutions),
-          statementNodeMatches = consequenceNonTerminalNodeMatches; ///
+  matchStatementNode(statementNode, substitutions) {
+    const nonTerminalNodeA = this.statementNode,  ///
+          nonTerminalNodeB = statementNode,  ///
+          nonTerminalNodeMatches = consequenceStatementForVariableMatcher.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions),
+          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/metastatementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableMatcher from "../../matcher/metastatementForMetavariable";
+
+class ConclusionMetastatementForMetavariableMatcher extends MetastatementForMetavariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const conclusionMetastatementForMetavariableMatcher = new ConclusionMetastatementForMetavariableMatcher();

package/src/matcher/metastatementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import MetastatementForMetavariableMatcher from "../../matcher/metastatementForMetavariable";
+
+class PremiseMetastatementForMetavariableMatcher extends MetastatementForMetavariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const premiseMetastatementForMetavariableMatcher = new PremiseMetastatementForMetavariableMatcher();

package/src/matcher/metastatementForMetavariable.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import Matcher from "../matcher";
+import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
+
+import { first } from "../utilities/array";
+import { metavariableNameFromMetavariableNode } from "../utilities/query";
+import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+export default class MetastatementForMetavariableMatcher extends Matcher {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
+    let nonTerminalNodeMatches = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+          nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === METASTATEMENT_RULE_NAME);
+
+    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+      const metastatementNodeA = nonTerminalNodeA,  ///
+            metastatementNodeB = nonTerminalNodeB,  ///
+            metastatementNodeMatches = this.matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
+
+      if (metastatementNodeMatches) {
+        nonTerminalNodeMatches = true;  ///
+      } else {
+        nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+      }
+    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    }
+
+    return nonTerminalNodeMatches;
+  }
+
+  matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions) {
+    let metastatementNodeMatches = false;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+
+    if (nonTerminalNodeAChildNodesLength === 1) {
+      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
+            cChildNodeA = firstNonTerminalNodeAChildNode,  ///
+            cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
+
+      if (cChildNodeANonTerminalNode) {
+        const nonTerminalNodeA = cChildNodeA,  ///
+              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
+
+        if (nonTerminalNodeARuleNameMetavariableRuleName) {
+          const metavariableNodeA = nonTerminalNodeA,  ///
+                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
+
+          metastatementNodeMatches = metaVariableNodeMatches; ///
+        }
+      }
+    }
+
+    return metastatementNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions) {
+    let metavariableNodeMatches;
+
+    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
+          substitution = substitutions.find((substitution) => {
+            const metavariableName = substitution.getMetavariableName();
+
+            if (metavariableName === metavariableNameA) {
+              return true;
+            }
+          }) || null;
+
+    if (substitution !== null) {
+      const metastatementNode = metastatementNodeB, ///
+            substitutionNodesMatch = substitution.matchMetastatementNode(metastatementNode);
+
+      metavariableNodeMatches = substitutionNodesMatch;  ///
+    } else {
+      const { createSubstitutions } = this.constructor;
+
+      if (createSubstitutions) {
+        const metavariableName = metavariableNameA, ///
+              metastatementNode = metastatementNodeB, ///
+              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode),
+              substitution = metastatementForMetavariableSubstitution;  ///
+
+        substitutions.push(substitution);
+      }
+
+      metavariableNodeMatches = true;
+    }
+
+    return metavariableNodeMatches;
+  }
+}

package/src/matcher/statementForMetavariable/conclusion.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableMatcher from "../../matcher/statementForMetavariable";
+
+class ConclusionStatementForMetavariableMatcher extends StatementForMetavariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const conclusionStatementForMetavariableMatcher = new ConclusionStatementForMetavariableMatcher();

package/src/matcher/statementForMetavariable/premise.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import StatementForMetavariableMatcher from "../../matcher/statementForMetavariable";
+
+class PremiseStatementForMetavariableMatcher extends StatementForMetavariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const premiseStatementForMetavariableMatcher = new PremiseStatementForMetavariableMatcher();