occam-verify-cli 0.0.526 → 0.0.529

package/src/equality.js

@@ -1,7 +1,15 @@
 "use strict";
 
+import matcher from "./matcher";
+import verifyTerm from "./verify/term";
+import equalityCombinator from "./ocmbinator/equality";
+import equalityStatementNode from "./node/statement/equality";
+
 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 +28,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 +36,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 +46,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 +54,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 +94,15 @@ export default class Equality {
     const statementNode = proofStep.getStatementNode();
 
     if (statementNode !== null) {
-      const leftTermNode = leftTermNodeQuery(statementNode),
-            rightTermNode = rightTermNodeQuery(statementNode);
+      const nodeA = statementNode,  ///
+            nodeB = equalityStatementNode,  ///
+            depth = EQUALITY_DEPTH,
+            nodeMatches = matcher.matchNode(nodeA, nodeB, depth);
+
+      if (nodeMatches) {
+        const leftTermNode = leftTermNodeQuery(statementNode),
+              rightTermNode = rightTermNodeQuery(statementNode);
 
-      if ((leftTermNode !== null) && (rightTermNode !== null)) {
         equality = new Equality(leftTermNode, rightTermNode);
       }
     }
@@ -95,22 +110,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 +137,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 +152,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 +161,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 +172,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 +192,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 +202,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 +211,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 +246,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.'`, leftTermNode);
+    }
+  }
+
+  return equality;
+}

package/src/index.js

@@ -1,13 +1,11 @@
 "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 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/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

@@ -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, lexer, parser) { return AxiomLemmaTheoremConjecture.fromJSON(Lemma, json, lexer, parser); }
 
-  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/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,41 +1,47 @@
 "use strict";
 
-export default class Matcher {
-  matchNode(nodeA, nodeB, ...remainingArguments) {
+class Matcher {
+  matchNode(nodeA, nodeB, depth = Infinity) {
     let nodeMatches = false;
 
-    const nodeATerminalNode = nodeA.isTerminalNode(),
-          nodeBTerminalNode = nodeB.isTerminalNode();
-
-    if (nodeATerminalNode === nodeBTerminalNode) {
-      if (nodeATerminalNode) {
-        const terminalNodeA = nodeA,  ///
-              terminalNodeB = nodeB,  ///
-              terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
-
-        nodeMatches = terminalNodeMatches;  ///
-      } else {
-        const nonTerminalNodeA = nodeA,  ///
-              nonTerminalNodeB = nodeB, ///
-              nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
-
-        nodeMatches = nonTerminalNodeMatches; ///
+    if (depth === 0) {
+      nodeMatches = true;
+    } else {
+      const nodeATerminalNode = nodeA.isTerminalNode(),
+            nodeBTerminalNode = nodeB.isTerminalNode();
+
+      if (nodeATerminalNode === nodeBTerminalNode) {
+        if (nodeATerminalNode) {
+          const terminalNodeA = nodeA,  ///
+                terminalNodeB = nodeB,  ///
+                terminalNodeMatches = this.matchTerminalNode(terminalNodeA, terminalNodeB);
+
+          nodeMatches = terminalNodeMatches;  ///
+        } else {
+          const nonTerminalNodeA = nodeA,  ///
+                nonTerminalNodeB = nodeB, ///
+                nonTerminalNodeMatches = this.matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, depth);
+
+          nodeMatches = nonTerminalNodeMatches; ///
+        }
       }
     }
 
     return nodeMatches;
   }
 
-  matchNodes(nodesA, nodesB, ...remainingArguments) {
+  matchNodes(nodesA, nodesB, depth) {
     let nodesMatch = false;
 
     const nodesALength = nodesA.length,
           nodesBLength = nodesB.length;
 
     if (nodesALength === nodesBLength) {
+      depth --;
+
       nodesMatch = nodesA.every((nodeA, index) => {
         const nodeB = nodesB[index],
-              nodeMatches = this.matchNode(nodeA, nodeB, ...remainingArguments);
+              nodeMatches = this.matchNode(nodeA, nodeB, depth);
 
         if (nodeMatches) {
           return true;
@@ -46,14 +52,14 @@ export default class Matcher {
     return nodesMatch;
   }
 
-  matchTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) {
+  matchTerminalNode(terminalNodeA, terminalNodeB, depth) {
     const matches = terminalNodeA.match(terminalNodeB),
           terminalNodeMatches = matches;  ///
 
     return terminalNodeMatches;
   }
 
-  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  matchNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, depth) {
     let nonTerminalNodeMatches = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
@@ -64,7 +70,7 @@ export default class Matcher {
             nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
             nodesA = nonTerminalNodeAChildNodes, ///
             nodesB = nonTerminalNodeBChildNodes, ///
-            nodesMatch = this.matchNodes(nodesA, nodesB, ...remainingArguments);
+            nodesMatch = this.matchNodes(nodesA, nodesB, depth);
 
       nonTerminalNodeMatches = nodesMatch; ///
     }
@@ -73,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/file.js

@@ -1,12 +1,57 @@
 "use strict";
 
+function getAxioms() { return this.context.getAxioms(); }
+
+function getLemmas() { return this.context.getLemmas(); }
+
+function getTheorems() { return this.context.getTheorems(); }
+
+function getConjectures() { return this.context.getConjectures(); }
+
+function getCombinators() { return this.context.getCombinators(); }
+
+function getConstructors() { return this.context.getConstructors(); }
+
+function findTypeByTypeName(typeName) { return this.context.findTypeByTypeName(typeName); }
+
+function findLabelByTypeName(labelName) { return this.context.findLabelByTypeName(labelName); }
+
 function findRuleByReferenceName(referenceName) { return this.context.findRuleByReferenceName(referenceName); }
 
 function findAxiomByReferenceName(referenceName) { return this.context.findAxiomByReferenceName(referenceName); }
 
+function findLemmaByReferenceName(referenceName) { return this.context.findLemmaByReferenceName(referenceName); }
+
+function findTheoremByReferenceName(referenceName) { return this.context.findTheoremByReferenceName(referenceName); }
+
+function findConjectureByReferenceName(referenceName) { return this.context.findConjectureByReferenceName(referenceName); }
+
+function isLabelPresentByLabelName(labelName) { return this.context.isLabelPresentByLabelName(labelName); }
+
+function isTypePresentByTypeName(typeName) { return this.context.isTypePresentByTypeName(typeName); }
+
+function nodeAsString(node) { return this.context.nodeAsString(node); }
+
+function nodesAsString(node) { return this.context.nodesAsString(node); }
+
 const fileMixins = {
+  getAxioms,
+  getLemmas,
+  getTheorems,
+  getConjectures,
+  getCombinators,
+  getConstructors,
+  findTypeByTypeName,
+  findLabelByTypeName,
   findRuleByReferenceName,
-  findAxiomByReferenceName
+  findAxiomByReferenceName,
+  findLemmaByReferenceName,
+  findTheoremByReferenceName,
+  findConjectureByReferenceName,
+  isLabelPresentByLabelName,
+  isTypePresentByTypeName,
+  nodeAsString,
+  nodesAsString
 };
 
 export default fileMixins;

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;