occam-verify-cli 0.0.697 → 0.0.700

package/src/type.js

@@ -58,29 +58,29 @@ export default class Type {
     return superTypeOf;
   }
 
-  isEqualToOrSubTypeOf(type) {
+  isComparableTo(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
-          equalToOrSubTypeOf = (equalTo || subTypeOf);
+          superTypeOf = this.isSuperTypeOf(type),
+          comparableTo = equalTo || subTypeOf || superTypeOf;
 
-    return equalToOrSubTypeOf;
+    return comparableTo;
   }
 
-  isEqualToOrSuperTypeOf(type) {
+  isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSuperTypeOf = (equalTo || superTypeOf);
+          subTypeOf = this.isSubTypeOf(type),
+          equalToOrSubTypeOf = equalTo || subTypeOf;
 
-    return equalToOrSuperTypeOf;
+    return equalToOrSubTypeOf;
   }
 
-  isEqualToSubTypeOfOrSuperTypeOf(type) {
+  isEqualToOrSuperTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
           superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSubTypeOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+          equalToOrSuperTypeOf = equalTo || superTypeOf;
 
-    return equalToOrSubTypeOfSuperTypeOf;
+    return equalToOrSuperTypeOf;
   }
 
   match(type) {
@@ -101,7 +101,7 @@ export default class Type {
     return typeNameMatches;
   }
 
-  asString(tokens, noSuperType) {
+  asString(tokens, noSuperType = false) {
     let string;
 
     if (noSuperType) {
@@ -135,22 +135,6 @@ export default class Type {
     return type;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    let type;
-
-    let { superType } = json;
-
-    const superTypeJSON = superType;  ///
-
-    superType = superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext);
-
-    const { name } = json;
-
-    type = new Type(name, superType);
-
-    return type;
-  }
-
   static fromTypeNameAndSuperType(typeName, superType) {
     const name = typeName,  ///
           type = new Type(name, superType);
@@ -182,19 +166,23 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
-  let superType = null;
+export function typeFromJSONAndFileContext(json, fileContext) {
+  let type;
+
+  const { name } = json,
+        typeName = name;  ///
 
-  if (superTypeJSON !== null) {
-    const json = superTypeJSON, ///
-          { name } = json,
-          typeName = name,  ///
-          type = fileContext.findTypeByTypeName(typeName);
+  type = fileContext.findTypeByTypeName(typeName);
+
+  if (type === null) {
+    let { superType } = json;
 
-      superType = (type !== null) ?
-                    type :  ///
-                      Type.fromJSONAndFileContext(json, fileContext);  ///
+    const superJSON = superType;  ///
+
+    superType = typeFromJSONAndFileContext(superJSON, fileContext);
+
+    type = new Type(name, superType);
   }
 
-  return superType;
+  return type;
 }

package/src/utilities/node.js

@@ -4,19 +4,14 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TYPE_RULE_NAME,
-         LABEL_RULE_NAME,
-         VARIABLE_RULE_NAME,
-         META_TYPE_RULE_NAME,
-         METAVARIABLE_RULE_NAME,
+import { LABEL_RULE_NAME,
+         VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 import { labelTokensFromLabelString,
-         constructorDeclarationTokensFromTermString,
          variableDeclarationTokensFromVariableString,
          unqualifiedStatementTokensFromStatementString,
-         metavariableDeclarationTokensFromMetavariableString,
          unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
@@ -25,20 +20,10 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      typeNodeQuery = nodeQuery("/variableDeclaration/type!"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
-      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, parser),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
-
-  return termNode;
-}
-
 export function labelNodeFromLabelString(labelString, lexer, parser) {
   const labelTokens = labelTokensFromLabelString(labelString, lexer),
         labelNode = labelNodeFromLabelTokens(labelTokens, parser);
@@ -46,13 +31,6 @@ export function labelNodeFromLabelString(labelString, lexer, parser) {
   return labelNode;
 }
 
-export function typeNodeFromVariableString(variableString, lexer, parser) {
-  const variableDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
-        typeNode = typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser);
-
-  return typeNode;
-}
-
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
         variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
@@ -67,20 +45,6 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
-export function metaTypeNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metaTypeNode = metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metavariableNode = metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metavariableNode;
-}
-
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
   const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
         metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
@@ -102,27 +66,6 @@ export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatement
   return statementNode;
 }
 
-export function typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const typeDeclarationNode = typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser),
-        typeNode = typeNodeQuery(typeDeclarationNode);
-
-  return typeNode;
-}
-
-export function metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metaTypeDeclarationNode = metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metaTypeNode = metaTypeNodeQuery(metaTypeDeclarationNode);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metavariableDeclarationNode = metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode);
-
-  return metavariableNode;
-}
-
 export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
   const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser),
         variableNode = variableNodeQuery(variableDeclarationNode);
@@ -144,15 +87,8 @@ export function labelNodeFromLabelTokens(labelTokens, parser) {
   return labelNode;
 }
 
-export function typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const ruleName = TYPE_RULE_NAME,
-        typeDeclarationNode = nodeFromTokensRuleNameAndParser(variableDeclarationTokens, ruleName, parser);
-
-  return typeDeclarationNode;
-}
-
 export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  const ruleName = VARIABLE_RULE_NAME,
+  const ruleName = VARIABLE_DECLARATION_RULE_NAME,
         variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
 
   return variableDeclarationNode;
@@ -165,13 +101,6 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifi
   return unqualifiedStatementNode;
 }
 
-export function metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = META_TYPE_RULE_NAME,
-        metaTypeDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metaTypeDeclarationNode;
-}
-
 export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
         constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
@@ -179,13 +108,6 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-export function metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        metavariableDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metavariableDeclarationNode;
-}
-
 export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
   const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
         unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);

package/src/utilities/query.js

@@ -5,9 +5,7 @@ import { Query } from "occam-dom";
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
       labelNameTerminalNodeQuery = nodeQuery("/label/@name"),
-      variableNameTerminalNodeQuery = nodeQuery("/variable/@name"),
-      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name"),
-      metavariableNameTerminalNodeQuery = nodeQuery("/metavariable/@name");
+      referenceNameTerminalNodeQuery = nodeQuery("/reference/@name");
 
 export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
@@ -71,14 +69,6 @@ export function metaTypeNameFromMetaTypeNode(metaTypeNode) {
   return metaTypeName;
 }
 
-export function variableNameFromVariableNode(variableNode) {
-  const variableNameTerminalNode = variableNameTerminalNodeQuery(variableNode),
-        variableNameTerminalNodeContent = variableNameTerminalNode.getContent(),
-        variableName = variableNameTerminalNodeContent; ///
-
-  return variableName;
-}
-
 export function referenceNameFromReferenceNode(referenceNode) {
   const referenceNameTerminalNode = referenceNameTerminalNodeQuery(referenceNode),
         referenceNameTerminalNodeContent = referenceNameTerminalNode.getContent(),
@@ -86,11 +76,3 @@ export function referenceNameFromReferenceNode(referenceNode) {
 
   return referenceName;
 }
-
-export function metavariableNameFromMetavariableNode(metavariableNode) {
-  const metavariableNameTerminalNode = metavariableNameTerminalNodeQuery(metavariableNode),
-        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
-        metavariableName = metavariableNameTerminalNodeContent; ///
-
-  return metavariableName;
-}

package/src/utilities/tokens.js

@@ -40,14 +40,6 @@ export function unqualifiedStatementTokensFromStatementString(statementString, l
   return unqualifiedStatementTokens;
 }
 
-export function metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer) {
-  const metavariableDeclarationContent = `Metavariable ${metavariableString}
-`,
-        metavariableDeclarationTokens = tokensFromContentAndLexer(metavariableDeclarationContent, lexer);
-
-  return metavariableDeclarationTokens;
-}
-
 export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
   const unqualifiedMetastatementContent = `${metastatementString}
 `,

package/src/variable.js

@@ -1,15 +1,17 @@
 "use strict";
 
-import Type from "./type";
+import { nodeAsString } from "./utilities/string";
+import { typeFromJSONAndFileContext } from "./type";
+import { variableNodeFromVariableString } from "./utilities/node";
 
 export default class Variable {
-  constructor(name, type) {
-    this.name = name;
+  constructor(node, type) {
+    this.node = node;
     this.type = type;
   }
 
-  getName() {
-    return this.name;
+  getNode() {
+    return this.node;
   }
 
   getType() {
@@ -17,19 +19,19 @@ export default class Variable {
   }
 
   match(variable) {
-    const name = variable.getName(),
-          type = variable.getType(),
-          nameMatches = this.matchName(name),
+    const type = variable.getType(),
+          node = variable.getNode(),
           typeMatches = this.matchType(type),
-          matches = (nameMatches && typeMatches);
+          nodeMatches = this.matchNode(node),
+          matches = nodeMatches && typeMatches;
 
     return matches;
   }
 
-  matchName(name) {
-    const nameMatches = (this.name === name);
+  matchNode(node) {
+    const nodeMatches = this.node.match(node);
 
-    return nameMatches;
+    return nodeMatches;
   }
 
   matchType(type) {
@@ -38,53 +40,69 @@ export default class Variable {
     return typeMatches;
   }
 
-  matchNameAndType(name, type) {
-    const nameMatches = this.matchName(name),
+  matchNodeAndType(node, type) {
+    const nodeMatches = this.matchNode(node),
           typeMatches = this.matchType(type),
-          nameAndTypeMatch = (nameMatches && typeMatches);
+          nodeAndTypeMatch = nodeMatches && typeMatches;
 
-    return nameAndTypeMatch;
+    return nodeAndTypeMatch;
   }
 
   asString(tokens) {
-    const typeName = this.type.getName(),
-          string = `${this.name}:${typeName}`;
+    const typeName = this.type.getName();
+
+    let string = nodeAsString(this.node, tokens);
+
+    string = `${string}:${typeName}`; ///
 
     return string;
   }
 
   toJSON(tokens) {
     const typeJSON = this.type.toJSON(tokens),
-          name = this.name, ///
+          string = nodeAsString(this.node, tokens),
+          node = string,  //
           type = typeJSON,  ///
           json = {
-            name,
+            node,
             type
           };
 
     return json;
   }
 
-  static fromNameAndType(name, type) {
-    const variable = new Variable(name, type);
+  static fromJSONAndFileContext(json, fileContext) {
+    let { node } = json;
 
-    return variable;
-  }
+    const lexer  = fileContext.getLexer(),
+          parser = fileContext.getParser(),
+          variableString = node,  ///
+          variableNode = variableNodeFromVariableString(variableString, lexer, parser);
 
-  static fromJSONAndFileContext(json, fileContext) {
-    const { name } = json;
+    node = variableNode;  ///
 
     let { type } = json;
 
     json = type;  ///
 
-    type = Type.fromJSONAndFileContext(json, fileContext);
+    type = typeFromJSONAndFileContext(json, fileContext);
 
-    const typeName = type.getName();
+    const variable = new Variable(node, type);
 
-    type = fileContext.findTypeByTypeName(typeName); ///
+    return variable;
+  }
+
+  static fromVariableAndType(variable, type) {
+    const node = variable.getNode();
+
+    variable = new Variable(node, type);  ///
+
+    return variable;
+  }
 
-    const variable = new Variable(name, type);
+  static fromVariableNodeAndType(variableNode, type) {
+    const node = variableNode,  ///
+          variable = new Variable(node, type);
 
     return variable;
   }

package/src/verifier/node/metastatement.js

@@ -3,7 +3,6 @@
 import NodeVerifier from "../../verifier/node";
 
 import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 class MetastatementNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
@@ -44,8 +43,7 @@ function verifyMetavariable(metavariableNode, localMetaContext, verifyAhead) {
 
   localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
 
-  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-        metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableName(metavariableName);
+  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
 
   if (metavariablePresent) {
     const verifiedAhead = verifyAhead();

package/src/verifier/node/statementAsCombinator.js

@@ -3,7 +3,7 @@
 import NodeVerifier from "../../verifier/node";
 import verifyStatement from "../../verify/statement";
 
-import { verifyStandaloneTerm, verifyType } from "./../../verifier/node/termAsConstructor";
+import { verifyType, verifyStandaloneTerm } from "./../../verifier/node/termAsConstructor";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -5,7 +5,6 @@ import MetastatementForMetavariableSubstitution from "../../substitution/metasta
 
 import { nodeQuery } from "../../utilities/query";
 import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
@@ -55,11 +54,10 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
   verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let metavariableNodeVerified;
 
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const metavariableName = substitution.getMetavariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
-            if (metavariableName === metavariableNameA) {
+            if (substitutionMatchesMetavariableNodeA) {
               return true;
             }
           }) || null;
@@ -73,9 +71,9 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const metavariableName = metavariableNameA, ///
+        const metavariableNode = metavariableNodeA, ///
               metastatementNode = metastatementNodeB, ///
-              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNameAndMetastatementNode(metavariableName, metastatementNode),
+              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
               substitution = metastatementForMetavariableSubstitution;  ///
 
         substitutions.push(substitution);

package/src/verifier/nodes/statementForMetavariable.js

@@ -4,7 +4,6 @@ import NodesVerifier from "../../verifier/nodes";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../../utilities/query";
 import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
@@ -71,11 +70,10 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
   verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContext) {
     let metavariableNodeVerified;
 
-    const metavariableNameA = metavariableNameFromMetavariableNode(metavariableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const metavariableName = substitution.getMetavariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
 
-            if (metavariableName === metavariableNameA) {
+            if (substitutionMatchesMetavariableNodeA) {
               return true;
             }
           }) || null;
@@ -89,9 +87,9 @@ export default class StatementForMetavariableNodesVerifier extends NodesVerifier
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const metavariableName = metavariableNameA, ///
+        const metavariableNode = metavariableNodeA, ///
               statementNode = statementNodeB, ///
-              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNameAndStatementNode(metavariableName, statementNode),
+              statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode),
               substitution = statementForMetavariableSubstitution;  ///
 
         substitutions.push(substitution);

package/src/verifier/nodes/termForVariable.js

@@ -7,7 +7,6 @@ import TermForVariableSubstitution from "../../substitution/termForVariable";
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME } from "../../ruleNames";
-import { variableNameFromVariableNode } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
@@ -57,11 +56,10 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
   verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let variableVerified = false;
 
-    const variableNameA = variableNameFromVariableNode(variableNodeA),
-          substitution = substitutions.find((substitution) => {
-            const variableName = substitution.getVariableName();
+    const substitution = substitutions.find((substitution) => {
+            const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
 
-            if (variableName === variableNameA) {
+            if (substitutionMatchesVariableNodeA) {
               return true;
             }
           }) || null;
@@ -79,9 +77,9 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
       const { createSubstitutions } = this.constructor;
 
       if (createSubstitutions) {
-        const variableName = variableNameA, ///
+        const variableNode = variableNodeA, ///
               localContext = localContextA, ///
-              variable = localContext.findVariableByVariableName(variableName);
+              variable = localContext.findVariableByVariableNode(variableNode);
 
         if (variable !== null) {
           const terms = [],
@@ -97,7 +95,7 @@ export default class TermForVariableNodesVerifier extends NodesVerifier {
                         variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
 
                   if (variableTypeEqualToOrSuperTypeOfTermType) {
-                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNameAndTermNode(variableName, termNode),
+                    const termForVariableSubstitution = TermForVariableSubstitution.fromVariableNodeAndTermNode(variableNode, termNode),
                           substitution = termForVariableSubstitution;  ///
 
                     substitutions.push(substitution);

package/src/verify/axiom.js

@@ -4,7 +4,7 @@ import Axiom from "../axiom";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
 import verifyConsequent from "../verify/consequent";
-import verifySupposition from "../verify/supposition";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -28,13 +28,7 @@ export default function verifyAxiom(axiomNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(axiomNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],

package/src/verify/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedMetastatement from "./metastatement/unqualified";
+import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
 import { nodeQuery } from "../utilities/query";
 

package/src/verify/conjecture.js

@@ -4,8 +4,8 @@ import Conjecture from "../conjecture";
 import verifyProof from "../verify/proof";
 import LocalContext from "../context/local";
 import verifyLabels from "../verify/labels";
-import verifyConsequent from "./consequent";
-import verifySupposition from "./supposition";
+import verifyConsequent from "../verify/consequent";
+import verifySuppositions from "../verify/suppositions";
 
 import { first } from "../utilities/array";
 import { nodeQuery, nodesQuery } from "../utilities/query";
@@ -30,13 +30,7 @@ export default function verifyConjecture(conjectureNode, fileContext) {
   if (labelsVerified) {
     const suppositions = [],
           suppositionNodes = suppositionsNodeQuery(conjectureNode),
-          suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-            const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
-
-            if (suppositionVerified) {
-              return true;
-            }
-          });
+          suppositionsVerified = verifySuppositions(suppositionNodes, suppositions, localContext);
 
     if (suppositionsVerified) {
       const consequents = [],