occam-verify-cli 0.0.527 → 0.0.529

package/src/context/release/file.js

@@ -2,8 +2,6 @@
 
 import ReleaseContext from "../../context/release";
 
-import { rewriteNodes } from "occam-grammar-utilities";
-
 import Rule from "../../rule";
 import Type from "../../type";
 import Axiom from "../../axiom";
@@ -18,8 +16,8 @@ import { customGrammarFromNameAndEntries } from "../../utilities/customGrammar";
 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, conjectures, combinators, constructors) {
-    super(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts);
+  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, contextJSON) {
+    super(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts);
 
     this.types = types;
     this.rules = rules;
@@ -29,7 +27,6 @@ export default class FileReleaseContext extends ReleaseContext {
     this.conjectures = conjectures;
     this.combinators = combinators;
     this.constructors = constructors;
-
     this.contextJSON = contextJSON;
   }
 
@@ -213,29 +210,17 @@ export default class FileReleaseContext extends ReleaseContext {
     return constructors;
   }
 
-  nodeFromContentAndRuleName(content, ruleName) {
-    const ruleMap = this.florenceParser.getRuleMap(),
-          rule = ruleMap[ruleName],
-          tokens = this.florenceLexer.tokenise(content),
-          node = this.florenceParser.parse(tokens, rule);
-
-    if (node !== null) {
-      rewriteNodes(node);
-    }
-
-    return node;
-  }
-
   fromJSON() {
     const jsonArray = this.contextJSON,
-          releaseContext = this;  ///
+          lexer = this.getLexer(),
+          parser = this.getParser();
 
     jsonArray.forEach((json) => {
       const { kind } = json;
 
       switch (kind) {
         case TYPE_KIND: {
-          const type = Type.fromJSON(json, releaseContext);
+          const type = Type.fromJSON(json, lexer, parser);
 
           this.types.push(type);
 
@@ -243,7 +228,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case RULE_KIND: {
-          const rule = Rule.fromJSON(json, releaseContext);
+          const rule = Rule.fromJSON(json, lexer, parser);
 
           this.rules.push(rule);
 
@@ -251,7 +236,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case AXIOM_KIND: {
-          const axiom = Axiom.fromJSON(json, releaseContext);
+          const axiom = Axiom.fromJSON(json, lexer, parser);
 
           this.axioms.push(axiom);
 
@@ -259,7 +244,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case LEMMA_KIND: {
-          const lemma = Lemma.fromJSON(json, releaseContext);
+          const lemma = Lemma.fromJSON(json, lexer, parser);
 
           this.lemmas.push(lemma);
 
@@ -267,7 +252,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case THEOREM_KIND: {
-          const theorem = Theorem.fromJSON(json, releaseContext);
+          const theorem = Theorem.fromJSON(json, lexer, parser);
 
           this.theorems.push(theorem);
 
@@ -275,7 +260,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case CONJECTURE_KIND: {
-          const conjecture = Conjecture.fromJSON(json, releaseContext);
+          const conjecture = Conjecture.fromJSON(json, lexer, parser);
 
           this.conjectures.push(conjecture);
 
@@ -283,7 +268,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case COMBINATOR_KIND: {
-          const combinator = Combinator.fromJSON(json, releaseContext);
+          const combinator = Combinator.fromJSON(json, lexer, parser);
 
           this.combinators.push(combinator);
 
@@ -291,7 +276,7 @@ export default class FileReleaseContext extends ReleaseContext {
         }
 
         case CONSTRUCTOR_KIND: {
-          const constructor = Constructor.fromJSON(json, releaseContext);
+          const constructor = Constructor.fromJSON(json, lexer, parser);
 
           this.constructors.push(constructor);
 
@@ -307,11 +292,11 @@ export default class FileReleaseContext extends ReleaseContext {
     this.fromJSON();
   }
 
-  static fromLogNameEntriesCallbacksAndContextJSON(log, name, entries, callbacks, contextJSON) {
-    const verified = true,
+  static fromLogNameEntriesAndContextJSON(log, name, entries, contextJSON) {
+    const lexer = null,
+          parser = null,
+          verified = true,
           customGrammar = customGrammarFromNameAndEntries(name, entries),
-          florenceLexer = null,
-          florenceParser = null,
           dependencyReleaseContexts = null,
           types = [],
           rules = [],
@@ -321,7 +306,7 @@ export default class FileReleaseContext extends ReleaseContext {
           conjectures = [],
           combinators = [],
           constructors = [],
-          releaseContext = new FileReleaseContext(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts, contextJSON, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors);
+          releaseContext = new FileReleaseContext(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts, types, rules, axioms, lemmas, theorems, conjectures, combinators, constructors, contextJSON);
 
     return releaseContext;
   }

package/src/context/release.js

@@ -8,20 +8,19 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities,
       { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 export default class ReleaseContext {
-  constructor(log, name, entries, callbacks, verified, customGrammar, florenceLexer, florenceParser, dependencyReleaseContexts) {
+  constructor(log, name, entries, lexer, parser, verified, customGrammar, dependencyReleaseContexts) {
     this.log = log;
     this.name = name;
     this.entries = entries;
-    this.callbacks = callbacks;
+    this.lexer = lexer;
+    this.parser = parser;
     this.verified = verified;
     this.customGrammar = customGrammar;
-    this.florenceLexer = florenceLexer;
-    this.florenceParser = florenceParser;
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }
 
   getLog() {
-    return this.log;
+    return log;
   }
 
   getName() {
@@ -32,8 +31,12 @@ export default class ReleaseContext {
     return this.entries;
   }
 
-  getCallbacks() {
-    return this.callbacks;
+  getLexer() {
+    return this.lexer;
+  }
+
+  getParser() {
+    return this.parser;
   }
 
   isVerified() {
@@ -44,14 +47,6 @@ export default class ReleaseContext {
     return this.customGrammar;
   }
 
-  getFlorenceLexer() {
-    return this.florenceLexer;
-  }
-
-  getFlorenceParser() {
-    return this.florenceParser;
-  }
-
   getDependencyReleaseContexts() {
     return this.dependencyReleaseContexts;
   }
@@ -96,27 +91,21 @@ export default class ReleaseContext {
     this.verified = verified;
   }
 
-  tokenise(content) { return this.florenceLexer.tokenise(content); }
-
-  parse(tokens) { return this.florenceParser.parse(tokens); }
-
-  trace(message) { this.log.trace(message); }
-
-  debug(message) { this.log.debug(message); }
+  tokenise(content) { return this.lexer.tokenise(content); }
 
-  info(message) { this.log.info(message); }
+  parse(tokens) { return this.parser.parse(tokens); }
 
-  warning(message) { this.log.warning(message); }
+  trace(message, node = null, tokens = null, filePath = null) { this.log.trace(message, node, tokens, filePath); }
 
-  error(message) { this.log.error(message); }
+  debug(message, node = null, tokens = null, filePath = null) { this.log.debug(message, node, tokens, filePath); }
 
-  fatal(message) { this.log.fatal(message); }
+  info(message, node = null, tokens = null, filePath = null) { this.log.info(message, node, tokens, filePath); }
 
-  halt(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.halt(filePath, leastLineIndex, greatestLineIndex); }
+  warning(message, node = null, tokens = null, filePath = null) { this.log.warning(message, node, tokens, filePath); }
 
-  begin(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.begin(filePath, leastLineIndex, greatestLineIndex); }
+  error(message, node = null, tokens = null, filePath = null) { this.log.error(message, node, tokens, filePath); }
 
-  complete(filePath, leastLineIndex, greatestLineIndex) { this.callbacks.complete(filePath, leastLineIndex, greatestLineIndex); }
+  fatal(message, node = null, tokens = null, filePath = null) { this.log.fatal(message, node, tokens, filePath); }
 
   initialise(dependencyReleaseContexts) {
     const releaseContext = this,  ///
@@ -124,11 +113,13 @@ export default class ReleaseContext {
             releaseContext,
             ...dependencyReleaseContexts
           ],
-          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts);
+          combinedCustomGrammar = combinedCustomGrammarFromReleaseContexts(releaseContexts),
+          florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar),
+          florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-    this.florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+    this.lexer = florenceLexer; ///
 
-    this.florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
+    this.parser = florenceParser; ///
 
     this.dependencyReleaseContexts = dependencyReleaseContexts;
   }

package/src/equality.js

@@ -1,9 +1,10 @@
 "use strict";
 
+import matcher from "./matcher";
 import verifyTerm from "./verify/term";
 import equalityCombinator from "./ocmbinator/equality";
+import equalityStatementNode from "./node/statement/equality";
 
-import { matcher } from "./matcher";
 import { nodeQuery } from "./utilities/query";
 import { first, second } from "./utilities/array";
 import { EQUALITY_DEPTH } from "./constants";
@@ -93,13 +94,10 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const combinator = equalityCombinator,  ///
-            combinatorStatementNode = combinator.getStatementNode(),  ///
-            substitutions = null,
+      const nodeA = statementNode,  ///
+            nodeB = equalityStatementNode,  ///
             depth = EQUALITY_DEPTH,
-            nodeA = statementNode,  ///
-            nodeB = combinatorStatementNode,  ///
-            nodeMatches = matcher.matchNode(nodeA, nodeB, substitutions, depth);
+            nodeMatches = matcher.matchNode(nodeA, nodeB, depth);
 
       if (nodeMatches) {
         const leftTermNode = leftTermNodeQuery(statementNode),
@@ -271,7 +269,7 @@ function equalityFromLeftTermNodeAndRightTermNode(leftTermNode, rightTermNode, c
             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.'`);
+      context.error(`The left '${leftTermString}' term's '${leftTermTypeName}' type is not equal to the right '${rightTermString}' term's '${rightTermTypeName}' type.'`, leftTermNode);
     }
   }
 

package/src/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
-export { default as Callbacks } from "./callbacks";
+export { default as Log } from "./log";
+
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as FileReleaseContext } from "./context/release/file";

package/src/label.js

@@ -2,7 +2,7 @@
 
 import { nodeAsString } from "./utilities/string";
 import { labelNameFromLabelNode } from "./utilities/query";
-import { labelNodeFromLabelString } from "./utilities/string";
+import { labelNodeFromLabelString } from "./utilities/node";
 
 export default class Label {
   constructor(node) {
@@ -34,9 +34,9 @@ export default class Label {
     return json;
   }
 
-  static fromJSON(json, releaseContext) {
+  static fromJSON(json, lexer, parser) {
     const labelString = json, ///
-          labelNode = labelNodeFromLabelString(labelString, releaseContext),
+          labelNode = labelNodeFromLabelString(labelString, lexer, parser),
           node = labelNode, ///
           label = new Label(node);
 

package/src/lemma.js

@@ -7,7 +7,7 @@ import { LEMMA_KIND } from "./kinds";
 export default class Lemma extends AxiomLemmaTheoremConjecture {
   static kind = LEMMA_KIND;
 
-  static fromJSON(json, releaseContext) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, releaseContext); }
+  static fromJSON(json, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, lexer, parser); }
 
   static fromLabelsSuppositionsAndConsequence(labels, suppositions, consequence) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsAndConsequence(Lemma, labels, suppositions, consequence); }
 }

package/src/log.js

@@ -0,0 +1,116 @@
+"use strict";
+
+import { levels } from "necessary";
+
+import { leastLineIndexFromNodeAndTokens, greatestLineIndexFromNodeAndTokens } from "./utilities/tokens";
+
+const { TRACE_LEVEL, DEBUG_LEVEL, INFO_LEVEL, WARNING_LEVEL, ERROR_LEVEL, FATAL_LEVEL } = levels;
+
+export default class Log {
+  constructor(messages, logLevel, follow) {
+    this.messages = messages;
+    this.logLevel = logLevel;
+    this.follow = follow;
+  }
+
+  getMessages() {
+    return this.messages;
+  }
+
+  getLogLevel() {
+    return this.logLevel;
+  }
+
+  getFollow() {
+    return this.follow;
+  }
+
+  trace(message, node, tokens, filePath) {
+    const level = TRACE_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  debug(message, node, tokens, filePath) {
+    const level = DEBUG_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  info(message, node, tokens, filePath) {
+    const level = INFO_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  warning(message, node, tokens, filePath) {
+    const level = WARNING_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  error(message, node, tokens, filePath) {
+    const level = ERROR_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  fatal(message, node, tokens, filePath) {
+    const level = FATAL_LEVEL;
+
+    this.write(level, message, node, tokens, filePath);
+  }
+
+  write(level, message, node, tokens, filePath) {
+    const levels = [
+            TRACE_LEVEL,
+            DEBUG_LEVEL,
+            INFO_LEVEL,
+            WARNING_LEVEL,
+            ERROR_LEVEL,
+            FATAL_LEVEL,
+          ],
+          levelIndex = levels.indexOf(level),
+          logLevelIndex = levels.indexOf(this.logLevel);
+
+    if (levelIndex < logLevelIndex) {
+      return;
+    }
+
+    message = formatMessage(level, message, node, tokens, filePath);  ///
+
+    this.follow ?
+      console.log(message) :
+        this.messages.push(message);
+  }
+
+  static followAndLogLevel(follow, logLevel) {
+    const messages = follow ?
+                       null :
+                         [],
+          log = new Log(messages, logLevel, follow);
+
+    return log;
+  }
+}
+
+function formatMessage(level, message, node, tokens, filePath) {
+  const upperCaseLevel = level.toUpperCase();
+
+  if (node === null) {
+    message = `${upperCaseLevel}: ${message}`;
+  } else {
+    const leastLineIndex = leastLineIndexFromNodeAndTokens(node, tokens),
+          greatestLineIndex = greatestLineIndexFromNodeAndTokens(node, tokens);
+
+    if (leastLineIndex === greatestLineIndex) {
+      const lineIndex = leastLineIndex; ///
+
+      message = `${upperCaseLevel}: ${filePath} (${lineIndex}) - ${message}`;
+    } else {
+      message = `${upperCaseLevel}: ${filePath} (${leastLineIndex}-${greatestLineIndex}) - ${message}`;
+    }
+  }
+
+  return message;
+}

package/src/matcher.js

@@ -1,7 +1,7 @@
 "use strict";
 
-export default class Matcher {
-  matchNode(nodeA, nodeB, substitutions, depth = Infinity) {
+class Matcher {
+  matchNode(nodeA, nodeB, depth = Infinity) {
     let nodeMatches = false;
 
     if (depth === 0) {
@@ -20,7 +20,7 @@ export default class Matcher {
         } else {
           const nonTerminalNodeA = nodeA,  ///
                 nonTerminalNodeB = nodeB, ///
-                nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, depth);
+                nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, depth);
 
           nodeMatches = nonTerminalNodeMatches; ///
         }
@@ -30,7 +30,7 @@ export default class Matcher {
     return nodeMatches;
   }
 
-  matchNodes(nodesA, nodesB, substitutions, depth = Infinity) {
+  matchNodes(nodesA, nodesB, depth) {
     let nodesMatch = false;
 
     const nodesALength = nodesA.length,
@@ -41,7 +41,7 @@ export default class Matcher {
 
       nodesMatch = nodesA.every((nodeA, index) => {
         const nodeB = nodesB[index],
-              nodeMatches = this.matchNode(nodeA, nodeB, substitutions, depth);
+              nodeMatches = this.matchNode(nodeA, nodeB, depth);
 
         if (nodeMatches) {
           return true;
@@ -52,14 +52,14 @@ export default class Matcher {
     return nodesMatch;
   }
 
-  matchTerminalNode(terminalNodeA, terminalNodeB, substitutions, depth) {
+  matchTerminalNode(terminalNodeA, terminalNodeB, depth) {
     const matches = terminalNodeA.match(terminalNodeB),
           terminalNodeMatches = matches;  ///
 
     return terminalNodeMatches;
   }
 
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, depth = Infinity) {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, depth) {
     let nonTerminalNodeMatches = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
@@ -70,7 +70,7 @@ export default class Matcher {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             nodesA = nonTerminalNodeAChildNodes, ///
             nodesB = nonTerminalNodeBChildNodes, ///
-            nodesMatch = this.matchNodes(nodesA, nodesB, substitutions, depth);
+            nodesMatch = this.matchNodes(nodesA, nodesB, depth);
 
       nonTerminalNodeMatches = nodesMatch; ///
     }
@@ -79,4 +79,6 @@ export default class Matcher {
   }
 }
 
-export const matcher = new Matcher();
+const matcher = new Matcher();
+
+export default matcher;

package/src/metaTypeNames.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export const STATEMENT_META_TYPE_NAME = "Statement";

package/src/mixins/logging.js

@@ -1,16 +1,16 @@
 "use strict";
 
-function trace(message) { this.context.trace(message); }
+function trace(node, message) { this.context.trace(node, message); }
 
-function debug(message) { this.context.debug(message); }
+function debug(node, message) { this.context.debug(node, message); }
 
-function info(message) { this.context.info(message); }
+function info(node, message) { this.context.info(node, message); }
 
-function warning(message) { this.context.warning(message); }
+function warning(node, message) { this.context.warning(node, message); }
 
-function error(message) { this.context.error(message); }
+function error(node, message) { this.context.error(node, message); }
 
-function fatal(message) { this.context.fatal(message); }
+function fatal(node, message) { this.context.fatal(node, message); }
 
 const loggingMixins = {
   trace,

package/src/node/metastatement/bracketed.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { metastatementNodeFromMetastatementString } from "../../utilities/node";
+
+const bracketedMetastatementString = "(A)";
+
+const bracketedMetastatementNode = metastatementNodeFromMetastatementString(bracketedMetastatementString);
+
+export default bracketedMetastatementNode;

package/src/node/statement/bracketed.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { statementNodeFromStatementString } from "../../utilities/node";
+
+const bracketedStatementString = "(n=m)";
+
+const bracketedStatementNode = statementNodeFromStatementString(bracketedStatementString);
+
+export default bracketedStatementNode;

package/src/node/statement/combinator/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { STATEMENT_META_TYPE_NAME } from "../../../metaTypeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
+
+const bracketedCombinatorStatementString = `(${STATEMENT_META_TYPE_NAME})`;
+
+const bracketedCombinatorStatementNode = statementNodeFromStatementString(bracketedCombinatorStatementString);
+
+export default bracketedCombinatorStatementNode;

package/src/node/statement/combinator/equality.js

@@ -0,0 +1,11 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../../typeNames";
+import { statementNodeFromStatementString } from "../../../utilities/node";
+
+const equalityCombinatorStatementString = `${OBJECT_TYPE_NAME} = ${OBJECT_TYPE_NAME}`;
+
+const equalityCombinatorStatementNode = statementNodeFromStatementString(equalityCombinatorStatementString);
+
+export default equalityCombinatorStatementNode;
+

package/src/node/statement/equality.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { statementNodeFromStatementString } from "../../utilities/node";
+
+const equalityStatementString = "n=m";
+
+const equalityStatementNode = statementNodeFromStatementString(equalityStatementString);
+
+export default equalityStatementNode;
+

package/src/ocmbinator/bracketed.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Combinator from "../combinator";
-import combinatorReleaseContext from "../context/release/combinator";
 
-import { statementNodeFromStatementString } from "../utilities/string";
+import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
 
 class BracketedCombinator extends Combinator {
   static fromNothing() {
-    const statementString = "(Statement)",
-          releaseContext = combinatorReleaseContext, ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+    const statementNode = bracketedCombinatorStatementNode,  ///
           bracketedCombinator = new BracketedCombinator(statementNode);
 
     return bracketedCombinator;

package/src/ocmbinator/equality.js

@@ -1,15 +1,12 @@
 "use strict";
 
 import Combinator from "../combinator";
-import CombinatorReleaseContext from "../context/release/combinator";
 
-import { statementNodeFromStatementString } from "../utilities/string";
+import equalityCombinatorStatementNode from "../node/statement/combinator/equality";
 
 class EqualityCombinator extends Combinator {
   static fromNothing() {
-    const statementString = "Object = Object",
-          releaseContext = CombinatorReleaseContext, ///
-          statementNode = statementNodeFromStatementString(statementString, releaseContext),
+    const statementNode = equalityCombinatorStatementNode,  ///
           equalityCombinator = new EqualityCombinator(statementNode);
 
     return equalityCombinator;