occam-verify-cli 0.0.1067 → 0.0.1068

package/src/substitution/frameForMetavariable.js

@@ -4,19 +4,23 @@ import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
+import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
+import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
 
-const substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      substitutionFrameNodeQuery = nodeQuery("/substitution/frame!"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
+const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
+      metavariableNodeQuery = nodeQuery("/substitution/frame[1]/metavariable!"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frameNode, metavariableNode, substitutionNode) {
+  constructor(string, frameNode, metavariableNode, substitutionNode, substitutionTokens) {
     super(string);
 
     this.frameNode = frameNode;
     this.metavariableNode = metavariableNode;
     this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
   getFrameNode() {
@@ -31,36 +35,40 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return this.substitutionNode;
   }
 
-  transformed(substitutions) {
-    let transformedSubstitution = null;
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
+  }
 
-    const transformedFrameNode = transformFrameNode(this.frameNode, substitutions),
-          transformedMetavariableNode = transformMetavariableNode(this.metavariableNode, substitutions);
+  getMetavariableName() {
+    const metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
 
-    if ((transformedFrameNode !== null) && (transformedMetavariableNode !== null)) {
-      const string = null,  ///
-            frameNode = transformedFrameNode, ///
-            metavariableNode = transformedMetavariableNode, ///
-            substitutionNode = null,
-            frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+    return metavariableName;
+  }
 
-      transformedSubstitution = frameForMetavariableSubstitution;  ///
-    }
+  setSubstitutionNode() {
+    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
+  }
 
-    return transformedSubstitution;
+  setSubstitutionTokens() {
+    const frameMetavariableNode = frameMetavariableNodeQuery(this.frameNode),
+        frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode),
+        metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode),
+        substitutionString = `[[${frameMetavariableName}] for [${metavariableName}]]`;
+
+    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
   }
 
   isEqualTo(substitution) {
     let equalTo = false;
 
     const frameNode = substitution.getFrameNode(),
-          metavariableNode = substitution.getMetavariableNode();
+          metavariableName = substitution.getMetavariableName();
 
-    if ((frameNode !== null) && (metavariableNode !== null)) {
+    if ((frameNode !== null) && (metavariableName !== null)) {
       const frameNodeMatches = this.matchFrameNode(frameNode),
-            metavariableNodeMatches = this.matchMetavariableNode(metavariableNode);
+            metavariableNameMatches = this.matchMetavariableName(metavariableName);
 
-      equalTo = (frameNodeMatches && metavariableNodeMatches);
+      equalTo = (frameNodeMatches && metavariableNameMatches);
     }
 
     return equalTo;
@@ -72,24 +80,42 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return frameNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+  matchMetavariableName(metavariableName) {
+    let metavariableNameMatches;
+
+    const metavariableNameA = metavariableName; ///
+
+    metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
+
+    const metavariableNameB = metavariableName; ///
 
-    return metavariableNodeMatches;
+    metavariableNameMatches = (metavariableNameA === metavariableNameB);
+
+    return metavariableNameMatches;
   }
 
   matchSubstitutionNode(substitutionNode) {
-    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    let substitutionNodeMatches;
+
+    if ((substitutionNode === null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitutionNode !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    }
 
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   static fromStatementNode(statementNode, localContext) {
@@ -98,18 +124,17 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      let substitutionFrameNode = substitutionFrameNodeQuery(substitutionNode);
+      const frameNode = frameNodeQuery(substitutionNode),
+            metavariableNode = metavariableNodeQuery(substitutionNode);
 
-      if (substitutionFrameNode !== null) {
+      if ((frameNode !== null) && (metavariableNode !== null)) {
         const { Frame, Metavariable } = shim,
-              substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
-              metavariableNode = substitutionMetavariableNode,  ///
-              frameNode = substitutionFrameNode,  ///
-              frame = Frame.fromTermNode(frameNode, localContext),
+              frame = Frame.fromFrameNode(frameNode, localContext),
               variable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-              string = stringFromFrameAndMetavariable(frame, variable, localContext);
+              string = stringFromFrameAndMetavariable(frame, variable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
       }
     }
 
@@ -121,57 +146,13 @@ export default class FrameForMetavariableSubstitution extends Substitution {
           frameNode = frame.getNode(),
           metavariableNode = metavariable.getNode(),
           substitutionNode = null,
-          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode);
+          substitutionTokens = null,
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function transformFrameNode(frameNode, substitutions) {
-  let transformedFrameNode = null;
-
-  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-  if (frameMetavariableNode !== null) {
-    const metavariableNode = frameMetavariableNode;  ///
-
-    substitutions.someSubstitution((substitution) => {
-      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-      if (metavariableNodeMatches) {
-        const frameNode = substitution.getFrameNode();
-
-        transformedFrameNode = frameNode; ////
-
-        return true;
-      }
-    });
-  }
-
-  return transformedFrameNode;
-}
-
-function transformMetavariableNode(metavariableNode, substitutions) {
-  let transformedMetavariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
-
-    if (metavariableNodeMatches) {
-      const frameNode = substitution.getFrameNode(),
-            frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
-
-      if (frameMetavariableNode !== null) {
-        transformedMetavariableNode = frameMetavariableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedMetavariableNode;
-}
-
 function stringFromFrameAndMetavariable(frame, metavariable, localContext) {
   const frameNode = frame.getNode(),
         frameString = localContext.nodeAsString(frameNode),

package/src/substitution/statementForMetavariable.js

@@ -2,7 +2,9 @@
 
 import shim from "../shim";
 import Substitution from "../substitution";
+import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
+import metaLevelUnifier from "../unifier/metaLevel";
 
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
@@ -39,76 +41,105 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNode;
   }
 
+  getMetavariableName() {
+    const metavariableName = this.metavariable.getName();
+
+    return metavariableName;
+  }
+
   isSimple() {
     const simple = (this.substitution === null);
 
     return simple;
   }
 
-  resolve(substitutions, localContext) {
+  resolve(substitutions, localContextA, localContextB) {
     let resolved = false;
 
     const substitutionString = this.string;
 
-    localContext.trace(`Resolving the ${substitutionString} substitution...`);
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const metavariableNode = this.getMetavariableNode(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
+    const metavariableName = this.getMetavariableName(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
 
     if (simpleSubstitution !== null) {
       const substitution = simpleSubstitution,  ///
-            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContext);
+            substitutionResolved = substitution.resolveSubstitution(this.substitution, this.statement, substitutions, localContextA, localContextB);
 
       resolved = substitutionResolved; ///
     }
 
     if (resolved) {
-      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
     }
 
     return resolved;
   }
 
-  resolveSubstitution(substitution, statement, substitutions, localContext) {
+  resolveSubstitution(substitution, statement, substitutions, localContextA, localContextB) {
     let substitutionResolved = false;
 
     const substitutionString = substitution.getString();
 
-    localContext.trace(`Resolving the ${substitutionString} substitution...`);
+    localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const transformedSubstitution = substitution.transformed(substitutions, localContext);
+    const substitutionA = substitution; ///
 
-    if (transformedSubstitution !== null) {
-      const transformedSubstitutionString = transformedSubstitution.getString();
+    substitution = this.unifyStatement(statement, localContextA, localContextB);
 
-      localContext.trace(`Transformed the substitution to ${transformedSubstitutionString}...`);
+    if (substitution !== null) {
+      substitutions.snapshot();
 
-      substitutions = Substitutions.fromNothing();  ///
+      const substitutionTokens = substitution.getSubstitutionTokens(),
+            tokens = substitutionTokens;  ///
 
-      const localContextA = localContext, ///
-            localContextB = localContext, ///
-            statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+      localContextB = LocalContext.fromLocalContextAndTokens(localContextB, tokens);  ///
 
-      if (statementUnified) {
-        const substitutionsLength = substitutions.getLength();
+      const substitutionB = substitution, ///
+            nodeA = substitutionA.getSubstitutionNode(),  ///
+            nodeB = substitutionB.getSubstitutionNode(),  ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-        if (substitutionsLength === 1) {
-          const firstSubstitution = substitutions.getFirstSubstitution(),
-                substitution = firstSubstitution, ///
-                substitutionEqualToTransformedSubstitution = substitution.isEqualTo(transformedSubstitution);
+      unifiedAtMetaLevel ?
+        substitutions.continue() :
+          substitutions.rollback(localContextB);
 
-          substitutionResolved = substitutionEqualToTransformedSubstitution;  ///
-        }
-      }
+      substitutionResolved = unifiedAtMetaLevel;  ///
     }
 
     if (substitutionResolved) {
-      localContext.debug(`...resolved the ${substitutionString} substitution.`);
+      localContextB.debug(`...resolved the ${substitutionString} substitution.`);
     }
 
     return substitutionResolved;
   }
 
+  unifyStatement(statement, localContextA, localContextB) {
+    let substitution = null;
+
+    localContextA = localContextB;  ///
+
+    const substitutions = Substitutions.fromNothing(),
+          statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
+
+    if (statementUnified) {
+      const substitutionsLength = substitutions.getLength();
+
+      if (substitutionsLength === 1) {
+        const firstSubstitution = substitutions.getFirstSubstitution();
+
+        substitution = firstSubstitution; ///
+
+        substitution.setSubstitutionTokens();
+
+        substitution.setSubstitutionNode();
+      }
+    }
+
+    return substitution;
+  }
+
   matchStatementNode(statementNode) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
@@ -117,7 +148,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
+  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
 
   matchSubstitutionNode(substitutionNode) {
     let substitutionNodeMatches;
@@ -135,12 +166,12 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
+          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
@@ -175,4 +206,4 @@ function stringFromStatementMetavariableAndSubstitution(statement, metavariable,
   }
 
   return string;
-}
+}

package/src/substitution/termForVariable.js

@@ -5,19 +5,23 @@ import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
+import { variableNameFromVariableNode } from "../utilities/name";
+import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
+import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
 
-const substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      termVariableNodeQuery = nodeQuery("/term/variable!"),
-      substitutionTermNodeQuery = nodeQuery("/substitution/term!"),
-      substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
+const termNodeQuery = nodeQuery("/substitution/term[0]"),
+      variableNodeQuery = nodeQuery("/substitution/term[1]/variable!"),
+      termVariableNodeQuery = nodeQuery("/term/variable"),
+      substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode, substitutionNode) {
+  constructor(string, termNode, variableNode, substitutionNode, substitutionTokens) {
     super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
     this.substitutionNode = substitutionNode;
+    this.substitutionTokens = substitutionTokens;
   }
 
   getTermNode() {
@@ -32,25 +36,27 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.substitutionNode;
   }
 
-  transformed(substitutions, localContext) {
-    let transformedSubstitution = null;
+  getSubstitutionTokens() {
+    return this.substitutionTokens;
+  }
 
-    const transformedTermNode = transformTermNode(this.termNode, substitutions),
-          transformedVariableNode = transformVariableNode(this.variableNode, substitutions);
+  getVariableName() {
+    const variableName = variableNameFromVariableNode(this.variableNode);
 
-    if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
-      const termNode = transformedTermNode, ///
-            variableNode = transformedVariableNode, ///
-            termString = localContext.nodeAsString(termNode),
-            variableString = localContext.nodeAsString(variableNode),
-            string = `[${termString} for ${variableString}]`,
-            substitutionNode = null,
-            termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+    return variableName;
+  }
 
-      transformedSubstitution = termForVariableSubstitution;  ///
-    }
+  setSubstitutionNode() {
+    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
+  }
 
-    return transformedSubstitution;
+  setSubstitutionTokens() {
+    const termVariableNode = termVariableNodeQuery(this.termNode),
+          termVariableName = variableNameFromVariableNode(termVariableNode),
+          variableName = variableNameFromVariableNode(this.variableNode),
+          substitutionString = `[${termVariableName} for ${variableName}]`;
+
+    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
   }
 
   isEqualTo(substitution) {
@@ -77,14 +83,32 @@ export default class TermForVariableSubstitution extends Substitution {
     return termNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = this.variableNode.match(variableNode);
+  matchVariableName(variableName) {
+    let variableNameMatches;
+
+    const variableNameA = variableName; ///
+
+    variableName = variableNameFromVariableNode(this.variableNode);
+
+    const variableNameB = variableName; ///
 
-    return variableNodeMatches;
+    variableNameMatches = (variableNameA === variableNameB);
+
+    return variableNameMatches;
   }
 
   matchSubstitutionNode(substitutionNode) {
-    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    let substitutionNodeMatches;
+
+    if ((substitutionNode === null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = true;
+    } else if ((substitutionNode === null) && (this.substitutionNode !== null)) {
+      substitutionNodeMatches = false;
+    } else if ((substitutionNode !== null) && (this.substitutionNode === null)) {
+      substitutionNodeMatches = false;
+    } else {
+      substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+    }
 
     return substitutionNodeMatches;
   }
@@ -111,18 +135,17 @@ export default class TermForVariableSubstitution extends Substitution {
     const substitutionNode = substitutionNodeQuery(statementNode);
 
     if (substitutionNode !== null) {
-      let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
+      const termNode = termNodeQuery(substitutionNode),
+            variableNode = variableNodeQuery(substitutionNode);
 
-      if (substitutionTermNode !== null) {
+      if ((termNode !== null) && (variableNode !== null)) {
         const { Term, Variable } = shim,
-              substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-              variableNode = substitutionVariableNode,  ///
-              termNode = substitutionTermNode,  ///
               term = Term.fromTermNode(termNode, localContext),
               variable = Variable.fromVariableNode(variableNode, localContext),
-              string = stringFromTermAndVariable(term, variable, localContext);
+              string = stringFromTermAndVariable(term, variable, localContext),
+              substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
       }
     }
 
@@ -137,57 +160,13 @@ export default class TermForVariableSubstitution extends Substitution {
     const string = stringFromTermAndVariable(term, variable, localContext),
           variableNode = variable.getNode(),
           substitutionNode = null,
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+          substitutionTokens = null,
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
 
     return termForVariableSubstitution;
   }
 }
 
-function transformTermNode(termNode, substitutions) {
-  let transformedTermNode = null;
-
-  const termVariableNode = termVariableNodeQuery(termNode);
-
-  if (termVariableNode !== null) {
-    const variableNode = termVariableNode;  ///
-
-    substitutions.someSubstitution((substitution) => {
-      const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
-
-      if (substitutionMatchesVariableNode) {
-        const termNode = substitution.getTermNode();
-
-        transformedTermNode = termNode; ////
-
-        return true;
-      }
-    });
-  }
-
-  return transformedTermNode;
-}
-
-function transformVariableNode(variableNode, substitutions) {
-  let transformedVariableNode = null;
-
-  substitutions.someSubstitution((substitution) => {
-    const variableNodeMatches = substitution.matchVariableNode(variableNode);
-
-    if (variableNodeMatches) {
-      const termNode = substitution.getTermNode(),
-            termVariableNode = termVariableNodeQuery(termNode);
-
-      if (termVariableNode !== null) {
-        transformedVariableNode = termVariableNode;  ///
-
-        return true;
-      }
-    }
-  });
-
-  return transformedVariableNode;
-}
-
 function stringFromTermAndVariable(term, variable, localContext) {
   const termNode = term.getNode(),
         termString = localContext.nodeAsString(termNode),

package/src/substitution.js

@@ -27,22 +27,22 @@ export default class Substitution {
     return statementNode;
   }
 
-  getVariableNode() {
-    const variableNode = null;
+  getSubstitutionNode() {
+    const substitutionNode = null;
 
-    return variableNode;
+    return substitutionNode;
   }
 
-  getMetavariableNode() {
-    const metavariableNode = null;
+  getVariableName() {
+    const variableName = null;
 
-    return metavariableNode;
+    return variableName;
   }
 
-  getSubstitutionNode() {
-    const substitutionNode = null;
+  getMetavariableName() {
+    const metavariableName = null;
 
-    return substitutionNode;
+    return metavariableName;
   }
 
   isSimple() {
@@ -82,28 +82,28 @@ export default class Substitution {
     return frameNodeMatches;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeMatches = false;
-
-    return variableNodeMatches;
-  }
-
   matchStatementNode(statementNode) {
     const statementNodeMatches = false;
 
     return statementNodeMatches;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = false;
+  matchVariableName(variableName) {
+    const variableNameMatches = false;
+
+    return variableNameMatches;
+  }
+
+  matchMetavariableName(metavariableName) {
+    const metavariableNameMatches = false;
 
-    return metavariableNodeMatches;
+    return metavariableNameMatches;
   }
 
-  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const metavariableNodeAndSubstitutionNodeMatches = false;
+  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+    const metavariableNameAndSubstitutionNodeMatches = false;
 
-    return metavariableNodeAndSubstitutionNodeMatches;
+    return metavariableNameAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {