occam-verify-cli 0.0.526 → 0.0.527

package/src/context/release/file.js

@@ -9,15 +9,16 @@ import Type from "../../type";
 import Axiom from "../../axiom";
 import Lemma from "../../lemma";
 import Theorem from "../../theorem";
+import Conjecture from "../../conjecture";
 import Combinator from "../../combinator";
 import Constructor from "../../constructor";
 
 import { push } from "../../utilities/array";
 import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
-import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
+import { RULE_KIND, TYPE_KIND, AXIOM_KIND, LEMMA_KIND, THEOREM_KIND, CONJECTURE_KIND, COMBINATOR_KIND, CONSTRUCTOR_KIND } from "../../kinds";
 
 export default class FileReleaseContext extends ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors) {
+  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors) {
     super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
 
     this.types = types;
@@ -25,8 +26,10 @@ export default class FileReleaseContext extends ReleaseContext {
     this.axioms = axioms;
     this.lemmas = lemmas;
     this.theorems = theorems;
+    this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
+
     this.contextJSON = contextJSON;
   }
 
@@ -153,6 +156,25 @@ export default class FileReleaseContext extends ReleaseContext {
     return theorems;
   }
 
+  getConjectures(includeDependencies = true) {
+    const conjectures = [];
+
+    push(conjectures, this.conjectures);
+
+    if (includeDependencies) {
+      const dependencyReleaseContexts = this.getDependencyReleaseContexts();
+
+      dependencyReleaseContexts.forEach((releaseContext) => {
+        const includeDependencies = false,
+              releaseContextConjectures = releaseContext.getConjectures(includeDependencies);
+
+        push(conjectures, releaseContextConjectures);
+      });
+    }
+
+    return conjectures;
+  }
+
   getCombinators(includeDependencies = true) {
     const combinators = [];
 
@@ -252,6 +274,14 @@ export default class FileReleaseContext extends ReleaseContext {
           break;
         }
 
+        case CONJECTURE_KIND: {
+          const conjecture = Conjecture.fromJSON(json, releaseContext);
+
+          this.conjectures.push(conjecture);
+
+          break;
+        }
+
         case COMBINATOR_KIND: {
           const combinator = Combinator.fromJSON(json, releaseContext);
 
@@ -288,9 +318,10 @@ export default class FileReleaseContext extends ReleaseContext {
           axioms = [],
           lemmas = [],
           theorems = [],
+          conjectures = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors);
 
     return releaseContext;
   }

package/src/equality.js

@@ -1,7 +1,14 @@
 "use strict";
 
+import verifyTerm from "./verify/term";
+import equalityCombinator from "./ocmbinator/equality";
+
+import { matcher } from "./matcher";
 import { nodeQuery } from "./utilities/query";
+import { first, second } from "./utilities/array";
+import { EQUALITY_DEPTH } from "./constants";
 import { TERM_RULE_NAME } from "./ruleNames";
+import { verifyStatementAgainstCombinator } from "./verify/statement";
 
 const leftTermNodeQuery = nodeQuery("/statement/argument[0]/term!"),
       rightTermNodeQuery = nodeQuery("/statement/argument[1]/term!");
@@ -20,30 +27,7 @@ export default class Equality {
     return this.rightTermNode;
   }
 
-  match(equality, equalities) {
-    let matches = false;
-
-    const leftTermNode = equality.getLeftTermNode(),
-          rightTermNode = equality.getRightTermNode();
-
-    if (!matches) {
-      const reversed = false,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    if (!matches) {
-      const reversed = true,
-            leftTermNodeAndRightTermNodeMatch = this.matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities);
-
-      matches = leftTermNodeAndRightTermNodeMatch;  ///
-    }
-
-    return matches;
-  }
-
-  matchLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, reversed, equalities) {
+  matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context) {
     let leftTermNodeAndRightTermNodeMatch = true;
 
     if (leftTermNodeAndRightTermNodeMatch) {
@@ -51,7 +35,7 @@ export default class Equality {
                                     this.rightTermNode :
                                       this.leftTermNode,  ///
             rightNonTerminalNode = leftTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities);
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
     }
@@ -61,7 +45,7 @@ export default class Equality {
                                     this.leftTermNode :
                                       this.rightTermNode,  ///
             rightNonTerminalNode = rightTermNode,  ///
-            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities);
+            nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context);
 
       leftTermNodeAndRightTermNodeMatch = nonTerminalNodeEquates; ///
     }
@@ -69,10 +53,35 @@ export default class Equality {
     return leftTermNodeAndRightTermNodeMatch;
   }
 
-  equate(equalities) {
+  match(equality, equalities, context) {
+    let matches = false;
+
+    const leftTermNode = equality.getLeftTermNode(),
+          rightTermNode = equality.getRightTermNode();
+
+    equalities = filterEqualities(equalities, equality);  ///
+
+    if (!matches) {
+      const reversed = false,
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
+
+      matches = leftTermNodeAndRightTermNodeMatch;  ///
+    }
+
+    if (!matches) {
+      const reversed = true,
+            leftTermNodeAndRightTermNodeMatch = this.matchTermNodes(leftTermNode, rightTermNode, reversed, equalities, context);
+
+      matches = leftTermNodeAndRightTermNodeMatch;  ///
+    }
+
+    return matches;
+  }
+
+  equate(equalities, context) {
     const leftNonTerminalNode = this.leftTermNode,  ///
           rightNonTerminalNode = this.rightTermNode,  ///
-          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities),
+          nonTerminalNodeEquates = equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context),
           equates = nonTerminalNodeEquates; ///
 
     return equates;
@@ -84,10 +93,18 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode);
+      const combinator = equalityCombinator,  ///
+            combinatorStatementNode = combinator.getStatementNode(),  ///
+            substitutions = null,
+            depth = EQUALITY_DEPTH,
+            nodeA = statementNode,  ///
+            nodeB = combinatorStatementNode,  ///
+            nodeMatches = matcher.matchNode(nodeA, nodeB, substitutions, depth);
+
+      if (nodeMatches) {
+        const leftTermNode = leftTermNodeQuery(statementNode),
+              rightTermNode = rightTermNodeQuery(statementNode);
 
-      if ((leftTermNode !== null) && (rightTermNode !== null)) {
         equality = new Equality(leftTermNode, rightTermNode);
       }
     }
@@ -95,22 +112,24 @@ export default class Equality {
     return equality;
   }
 
-  static fromStatementNode(statementNode) {
-    const leftTermNode = leftTermNodeQuery(statementNode),
-          rightTermNode = rightTermNodeQuery(statementNode),
-          equality = new Equality(leftTermNode, rightTermNode);
+  static fromStatementNode(statementNode, context) {
+    let equality = null;
 
-    return equality;
-  }
+    const combinator = equalityCombinator,  ///
+          statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context);
 
-  static fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode) {
-    const equality = new Equality(leftTermNode, rightTermNode);
+    if (statementVerifiedAgainstCombinator) {
+      const leftTermNode = leftTermNodeQuery(statementNode),
+            rightTermNode = rightTermNodeQuery(statementNode);
+
+      equality = new Equality(leftTermNode, rightTermNode);
+    }
 
     return equality;
   }
 }
 
-function equateNode(nodeA, nodeB, equalities) {
+function equateNode(nodeA, nodeB, equalities, context) {
   let nodeEquates = false;
 
   const nodeATerminalNode = nodeA.isTerminalNode(),
@@ -120,13 +139,13 @@ function equateNode(nodeA, nodeB, equalities) {
     if (nodeATerminalNode) {
       const terminalNodeA = nodeA,  ///
             terminalNodeB = nodeB,  ///
-            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities);
+            terminalNodeEquates = equateTerminalNode(terminalNodeA, terminalNodeB, equalities, context);
 
       nodeEquates = terminalNodeEquates;  ///
     } else {
       const nonTerminalNodeA = nodeA,  ///
             nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities);
+            nonTerminalNodeEquates = equateNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equalities, context);
 
       nodeEquates = nonTerminalNodeEquates; ///
     }
@@ -135,7 +154,7 @@ function equateNode(nodeA, nodeB, equalities) {
   return nodeEquates;
 }
 
-function equateNodes(leftNodes, rightNodes, equalities) {
+function equateNodes(leftNodes, rightNodes, equalities, context) {
   let nodesEquate = false;
 
   const leftNodesLength = leftNodes.length,
@@ -144,7 +163,7 @@ function equateNodes(leftNodes, rightNodes, equalities) {
   if (leftNodesLength === rightNodesLength) {
     nodesEquate = leftNodes.every((LeftNode, index) => {
       const rightNode = rightNodes[index],
-            nodeEquates = equateNode(LeftNode, rightNode, equalities);
+            nodeEquates = equateNode(LeftNode, rightNode, equalities, context);
 
       if (nodeEquates) {
         return true;
@@ -155,14 +174,14 @@ function equateNodes(leftNodes, rightNodes, equalities) {
   return nodesEquate;
 }
 
-function equateTerminalNode(terminalNodeA, terminalNodeB, equalities) {
+function equateTerminalNode(terminalNodeA, terminalNodeB, equalities, context) {
   const matches = terminalNodeA.match(terminalNodeB),
         terminalNodeEquates = matches;  ///
 
   return terminalNodeEquates;
 }
 
-function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities) {
+function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equalities, context) {
   let nonTerminalNodeEquates = false;
 
   const leftNonTerminalNodeRuleName = leftNonTerminalNode.getRuleName(),
@@ -175,7 +194,7 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
     if (ruleNameTermRuleName) {
       const leftTermNode = leftNonTerminalNode, ///
             rightTermNode = rightNonTerminalNode, ///
-            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities);
+            termNodeEquates = equateTermNode(leftTermNode, rightTermNode, equalities, context);
 
       nonTerminalNodeEquates = termNodeEquates;  ///
     }
@@ -185,7 +204,7 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
             rightNonTerminalNodeChildNodes = rightNonTerminalNode.getChildNodes(),
             leftNodes = leftNonTerminalNodeChildNodes, ///
             rightNodes = rightNonTerminalNodeChildNodes, ///
-            nodesEquate = equateNodes(leftNodes, rightNodes, equalities);
+            nodesEquate = equateNodes(leftNodes, rightNodes, equalities, context);
 
       nonTerminalNodeEquates = nodesEquate; ///
     }
@@ -194,23 +213,24 @@ function equateNonTerminalNode(leftNonTerminalNode, rightNonTerminalNode, equali
   return nonTerminalNodeEquates;
 }
 
-function equateTermNode(leftTermNode, rightTermNode, equalities) {
-  const equality = Equality.fromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode),
-        equalityA = equality, ///
-        equalityMatches = equalities.some((equality) => { ///
-          let equalitiesB = equalities; ///
+function equateTermNode(leftTermNode, rightTermNode, equalities, context) {
+  let termNodeEquates = false;
 
-          const equalityB = equality; ///
+  const equality = equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context);
 
-          equalitiesB = filterEqualities(equalitiesB, equalityB);  ///
+  if (equality !== null) {
+    const equalityA = equality, ///
+          equalitiesB = equalities, ///
+          equalityMatches = equalitiesB.some((equalityB) => { ///
+            const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB, context);
 
-          const equalityAMatchesEqualityB = equalityA.match(equalityB, equalitiesB);
+            if (equalityAMatchesEqualityB) {
+              return true;
+            }
+          });
 
-          if (equalityAMatchesEqualityB) {
-            return true;
-          }
-        }),
-        termNodeEquates = equalityMatches;  ///
+    termNodeEquates = equalityMatches;  ///
+  }
 
   return termNodeEquates;
 }
@@ -228,3 +248,32 @@ function filterEqualities(equalities, equality) {
 
   return equalities;
 }
+
+function equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, context) {
+  let equality = null;
+
+  const types = [],
+        leftTermVerified = verifyTerm(leftTermNode, types, context),
+        rightTermVerified = verifyTerm(rightTermNode, types, context);
+
+  if (leftTermVerified && rightTermVerified) {
+    const firstType = first(types),
+          secondType = second(types),
+          leftTermType = firstType, ///
+          rightTermType = secondType, ///
+          leftTermTypeEqualToRightTermType = leftTermType.isEqualTo(rightTermType);
+
+    if (leftTermTypeEqualToRightTermType) {
+      equality = new Equality(leftTermNode, rightTermNode);
+    } else {
+      const leftTermString = context.nodeAsString(leftTermNode),
+            rightTermString = context.nodeAsString(rightTermNode),
+            leftTermTypeName = leftTermType.getName(),
+            rightTermTypeName = rightTermType.getName();
+
+      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type.'`);
+    }
+  }
+
+  return equality;
+}

package/src/index.js

@@ -3,11 +3,8 @@
 export { default as Callbacks } from "./callbacks";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
-export { default as versionChanges } from "./versionChanges";
 export { default as FileReleaseContext } from "./context/release/file";
 export { default as DirectoryReleaseContext } from "./context/release/directory";
 
-export { default as jsonUtilities } from "./utilities/json";
-export { default as versionUtilities } from "./utilities/version";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
 export { default as releaseContextUtilities } from "./utilities/releaseContext";

package/src/kinds.js

@@ -5,5 +5,6 @@ export const RULE_KIND = "rule";
 export const AXIOM_KIND = "axiom";
 export const LEMMA_KIND = "lemma";
 export const THEOREM_KIND = "theorem";
+export const CONJECTURE_KIND = "conjecture";
 export const COMBINATOR_KIND = "combinator";
 export const CONSTRUCTOR_KIND = "constructor";

package/src/lemma.js

@@ -1,13 +1,13 @@
 "use strict";
 
-import AxiomLemmaTheorem from "./axiomLemmaTheorem";
+import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
 import { LEMMA_KIND } from "./kinds";
 
-export default class Lemma extends AxiomLemmaTheorem {
+export default class Lemma extends AxiomLemmaTheoremConjecture {
   static kind = LEMMA_KIND;
 
-  static fromJSON(json, releaseContext) { return AxiomLemmaTheorem.fromJSON(Lemma, json, releaseContext); }
+  static fromJSON(json, releaseContext) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, releaseContext); }
 
-  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheorem.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
+  static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
 }

package/src/matcher/metastatementForMetavariable.js

@@ -3,31 +3,36 @@
 import Matcher from "../matcher";
 import MetastatementForMetavariableSubstitution from "../substitution/metastatementForMetavariable";
 
-import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
+import { METASTATEMENT_RULE_NAME } from "../ruleNames";
 import { metavariableNameFromMetavariableNode } from "../utilities/query";
-import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+
+const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
 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);
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+
+    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
+      const 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 (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
+        const metastatementNodeA = nonTerminalNodeA,  ///
+              metastatementNodeB = nonTerminalNodeB,  ///
+              metastatementNodeMatches = this.matchMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions);
 
-      if (metastatementNodeMatches) {
-        nonTerminalNodeMatches = true;  ///
+        if (metastatementNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+        }
       } else {
         nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
-    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
     }
 
     return nonTerminalNodeMatches;
@@ -36,27 +41,12 @@ export default class MetastatementForMetavariableMatcher extends Matcher {
   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();
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
-      if (cChildNodeANonTerminalNode) {
-        const nonTerminalNodeA = cChildNodeA,  ///
-              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
+    if (metavariableNodeA !== null) {
+      const metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
 
-        if (nonTerminalNodeARuleNameMetavariableRuleName) {
-          const metavariableNodeA = nonTerminalNodeA,  ///
-                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions);
-
-          metastatementNodeMatches = metaVariableNodeMatches; ///
-        }
-      }
+      metastatementNodeMatches = metaVariableNodeMatches; ///
     }
 
     return metastatementNodeMatches;

package/src/matcher/statementForMetavariable.js

@@ -3,31 +3,52 @@
 import Matcher from "../matcher";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-import { first } from "../utilities/array";
+import { nodeQuery } from "../utilities/query";
 import { metavariableNameFromMetavariableNode } from "../utilities/query";
-import { METAVARIABLE_RULE_NAME, METASTATEMENT_RULE_NAME } from "../ruleNames";
+import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../ruleNames";
+
+const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
+      metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
 export default class StatementForMetavariableMatcher extends Matcher {
   matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions) {
     let nonTerminalNodeMatches = false;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
-          nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
-          nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+    const nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+          nonTerminalNodeBRuleNameMetaArgumentRuleName = (nonTerminalNodeBRuleName === META_ARGUMENT_RULE_NAME);
+
+    if (nonTerminalNodeBRuleNameMetaArgumentRuleName) {
+      const metaArgumentNodeB = nonTerminalNodeB, ///
+            metaArgumentChildNodeB = metaArgumentChildNodeNodeQuery(metaArgumentNodeB);
 
-    if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
-      const metastatementNodeA = nonTerminalNodeA,  ///
-            statementNodeB = nonTerminalNodeB,  ///
-            statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+      nonTerminalNodeB = metaArgumentChildNodeB;  ///
 
-      if (statementNodeMatches) {
-        nonTerminalNodeMatches = true;  ///
-      } else {
+      nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
+    } else {
+      const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
+            nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(),
+            nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
+            nonTerminalNodeBRuleNameStatementRuleName = (nonTerminalNodeBRuleName === STATEMENT_RULE_NAME);
+
+      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameStatementRuleName) {
+        const metastatementNodeA = nonTerminalNodeA,  ///
+              statementNodeB = nonTerminalNodeB,  ///
+              statementNodeMatches = this.matchStatementNode(metastatementNodeA, statementNodeB, substitutions);
+
+        if (statementNodeMatches) {
+          nonTerminalNodeMatches = true;  ///
+        } else {
+          const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+                nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+                nodesA = nonTerminalNodeAChildNodes, ///
+                nodesB = nonTerminalNodeBChildNodes, ///
+                nodesMatch = this.matchNodes(nodesA, nodesB, substitutions);
+
+          nonTerminalNodeMatches = nodesMatch;  ///
+        }
+      } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
         nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
       }
-    } else if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      nonTerminalNodeMatches = super.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions);
     }
 
     return nonTerminalNodeMatches;
@@ -36,27 +57,12 @@ export default class StatementForMetavariableMatcher extends Matcher {
   matchStatementNode(metastatementNodeA, statementNodeB, substitutions) {
     let statementNodeMatches = false;
 
-    const nonTerminalNodeA = metastatementNodeA,  ///
-          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          nonTerminalNodeAChildNodesLength = nonTerminalNodeAChildNodes.length;
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
-    if (nonTerminalNodeAChildNodesLength === 1) {
-      const firstNonTerminalNodeAChildNode = first(nonTerminalNodeAChildNodes),
-        cChildNodeA = firstNonTerminalNodeAChildNode,  ///
-        cChildNodeANonTerminalNode = cChildNodeA.isNonTerminalNode();
+    if (metavariableNodeA !== null) {
+      const metavariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
 
-      if (cChildNodeANonTerminalNode) {
-        const nonTerminalNodeA = cChildNodeA,  ///
-              nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-              nonTerminalNodeARuleNameMetavariableRuleName = (nonTerminalNodeARuleName === METAVARIABLE_RULE_NAME);
-
-        if (nonTerminalNodeARuleNameMetavariableRuleName) {
-          const metavariableNodeA = nonTerminalNodeA,  ///
-                metaVariableNodeMatches = this.matchMetavariableNode(metavariableNodeA, statementNodeB, substitutions);
-
-          statementNodeMatches = metaVariableNodeMatches; ///
-        }
-      }
+      statementNodeMatches = metavariableNodeMatches; ///
     }
 
     return statementNodeMatches;

package/src/matcher/termForVariable/consequence.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableMatcher from "../../matcher/termForVariable";
+
+class ConsequenceTermForVariableMatcher extends TermForVariableMatcher {
+  static createSubstitutions = false;
+}
+
+export const consequenceTermForVariableMatcher = new ConsequenceTermForVariableMatcher();

package/src/matcher/termForVariable/supposition.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import TermForVariableMatcher from "../../matcher/termForVariable";
+
+class SuppositionTermForVariableMatcher extends TermForVariableMatcher {
+  static createSubstitutions = true;
+}
+
+export const suppositionTermForVariableMatcher = new SuppositionTermForVariableMatcher();