occam-verify-cli 0.0.922 → 0.0.923

package/src/premise.js

@@ -7,27 +7,18 @@ import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrin
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { statementNodeFromStatementString, metastatementNodeFromMetastatementString } from "./utilities/node";
+import { statementNodeFromStatementString } from "./utilities/node";
 
-const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
-      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement!/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!"),
-      subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
-      ruleSubproofPremiseMetastatementNodesQuery = nodesQuery("/ruleSubproof/premise/unqualifiedMetastatement!/metastatement!"),
-      metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement!/metastatement!"),
-      ruleSubproofLastRuleProofStepMetastatementNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation/lastRuleProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetaproofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaproofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofPremiseStatementNodesQuery = nodesQuery("/subproof/premise/unqualifiedStatement!/statement!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Premise {
-  constructor(metastatementNode, statementNode) {
-    this.metastatementNode = metastatementNode;
+  constructor(statementNode) {
     this.statementnode = statementNode;
   }
 
-  getMetastatementNode() {
-    return this.metastatementNode;
-  }
-
   getStatementNode() {
     return this.statementnode;
   }
@@ -35,9 +26,9 @@ export default class Premise {
   matchStatementNode(statementNode, substitutions, fileContext, localContext) {
     let matchesStatementNode = false;
 
-    if (this.metastatementNode !== null) {
+    if (this.statementNode !== null) {
       const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
+            nonTerminalNodeA = this.statementNode,  ///
             nonTerminalNodeB = statementNode,  ///
             localContextA = LocalContext.fromFileContext(fileContextA),
             localContextB = localContext,  ///
@@ -56,98 +47,24 @@ export default class Premise {
   matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
     let matchesSubproofNode = false;
 
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
 
       if (subproofAssertionNode !== null) {
-        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+        const subproofPremiseStatementNodes = subproofPremiseStatementNodesQuery(subproofNode),
               subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
               subproofStatementNodes = [
-                ...subproofSuppositionStatementNodes,
+                ...subproofPremiseStatementNodes,
                 subproofLastProofStepStatementNode
               ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
 
-        matchesSubproofNode = match(subproofAssertionMetastatementNodes, subproofStatementNodes, (subproofAssertionMetastatementNode, subproofStatementNode) => {
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, subproofStatementNode) => {
           const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = localContext,  ///
-                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesSubproofNode;
-  }
-
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext) {
-    let matchesRuleSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const ruleSubproofPremiseMetastatementNodes = ruleSubproofPremiseMetastatementNodesQuery(ruleSubproofNode),
-              ruleSubproofLastRuleProofStepMetastatementNode = ruleSubproofLastRuleProofStepMetastatementNodeQuery(ruleSubproofNode),
-              ruleSubproofMetastatementNodes = [
-                ...ruleSubproofPremiseMetastatementNodes,
-                ruleSubproofLastRuleProofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesRuleSubproofNode = match(subproofAssertionMetastatementNodes, ruleSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = localContext,  ///
-                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-                  const verifiedAhead = true;
-
-                  return verifiedAhead;
-                });
-
-          if (nonTerminalNodeVerified) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return matchesRuleSubproofNode;
-  }
-
-  matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext) {
-    let matchesMetaSubproofNode = false;
-
-    if (this.metastatementNode !== null) {
-      const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
-
-      if (subproofAssertionNode !== null) {
-        const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetaproofStepMetastatementNode = metaSubproofLastMetaproofStepMetastatementNodeQuery(metaSubproofNode),
-              metaSubproofMetastatementNodes = [
-                ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetaproofStepMetastatementNode
-              ],
-              subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
-
-        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
-          const fileContextA = fileContext, ///
-                nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
-                nonTerminalNodeB = ruleSubproofMetastatementNode, ///
-                localContextA = LocalContext.fromFileContext(fileContextA),
-                localContextB = localContext,  ///
                 nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
@@ -161,37 +78,13 @@ export default class Premise {
       }
     }
 
-    return matchesMetaSubproofNode;
-  }
-
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext) {
-    let matchesMetastatementNode = false;
-
-    if (this.metastatementNode !== null) {
-      const fileContextA = fileContext, ///
-            nonTerminalNodeA = this.metastatementNode,  ///
-            nonTerminalNodeB = metastatementNode,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext,  ///
-            nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      matchesMetastatementNode = nonTerminalNodeVerified; ///
-    }
-
-    return matchesMetastatementNode;
+    return matchesSubproofNode;
   }
 
   toJSON(tokens) {
-    const metastatementString = nodeAsString(this.metastatementNode, tokens),
-          statementString = nodeAsString(this.statementnode, tokens),
-          metastatement = metastatementString, ///
+    const statementString = nodeAsString(this.statementnode, tokens),
           statement = statementString,  ///
           json = {
-            metastatement,
             statement
           };
 
@@ -199,28 +92,18 @@ export default class Premise {
   }
 
   static fromStatementNode(statementNode) {
-    const metastatementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
-
-    return premise;
-  }
-
-  static fromMetastatementNode(metastatementNode) {
-    const statementNode = null,
-          premise = new Premise(metastatementNode, statementNode);
+    const premise = new Premise(statementNode);
 
     return premise;
   }
 
   static fromJSONAndFileContext(json, fileContext) {
-    const { metastatement, statement } = json,
-          metastatementString = metastatement,  ///
+    const { statement } = json,
           statementString = statement, ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
-          metastatementNode = metastatementNodeFromMetastatementString(metastatementString, lexer, parser),
           statementNode = statementNodeFromStatementString(statementString, lexer, parser),
-          premise = new Premise(metastatementNode, statementNode);
+          premise = new Premise(statementNode, statementNode);
 
     return premise;
   }

package/src/rule.js

@@ -46,22 +46,6 @@ export default class Rule {
     return matchesStatement;
   }
 
-  matchMetastatement(metastatementNode, localContext) {
-    let matchesMetastatement = false;
-
-    const metaproofSteps = localContext.getMetaproofSteps(),
-          substitutions = [],
-          premisesMatch = metaMatchPremises(this.premises, metaproofSteps, substitutions, this.fileContext, localContext);
-
-    if (premisesMatch) {
-      const conclusionMatches = metaMatchConclusion(this.conclusion, metastatementNode, substitutions, this.fileContext, localContext);
-
-      matchesMetastatement = conclusionMatches;  ///
-    }
-
-    return matchesMetastatement;
-  }
-
   matchMetavariableNode(metavariableNode) {
     const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
@@ -186,54 +170,3 @@ function matchConclusion(conclusion, statementNode, substitutions, fileContext,
 
   return conclusionMatches;
 }
-
-function metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext) {
-  let premiseMatches = false;
-
-  const ruleSubproofNode = metaproofStep.getRuleSubproofNode(),
-        metaSubproofNode = metaproofStep.getMetaSubproofNode(),
-        metastatementNode = metaproofStep.getMetastatementNode()
-
-  if (ruleSubproofNode !== null) {
-    const premiseMatchesRuleSubproofNode = premise.matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesRuleSubproofNode; ///
-  }
-
-  if (metaSubproofNode !== null) {
-    const premiseMatchesMetaSubproofNode = premise.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetaSubproofNode; ///
-  }
-
-  if (metastatementNode !== null) {
-    const premiseMatchesMetastatementNode = premise.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext);
-
-    premiseMatches = premiseMatchesMetastatementNode;  ///
-  }
-
-  return premiseMatches;
-}
-
-function metaMatchPremises(premises, metaproofSteps, substitutions, fileContext, localContext) {
-  premises = reverse(premises); ///
-
-  metaproofSteps = reverse(metaproofSteps); ///
-
-  const premisesMatch = correlate(premises, metaproofSteps, (premise, metaproofStep) => {
-    const premiseMatches = metaMatchPremise(premise, metaproofStep, substitutions, fileContext, localContext);
-
-    if (premiseMatches) {
-      return true;
-    }
-  });
-
-  return premisesMatch;
-}
-
-function metaMatchConclusion(conclusion, metastatementNode, substitutions, fileContext, localContext) {
-  const conclusionMatchesMetastatementNode = conclusion.matchMetastatementNode(metastatementNode, substitutions, fileContext, localContext),
-        conclusionMatches = conclusionMatchesMetastatementNode; ///
-
-  return conclusionMatches;
-}

package/src/ruleNames.js

@@ -1,8 +1,6 @@
 "use strict";
 
 export const METAVARIABLE_RULE_NAME = "metavariable";
-export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
-export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/substitution/statementForMetavariable.js

@@ -5,6 +5,7 @@ import TermForVariableSubstitution from "./termForVariable";
 import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
+import { statementNodeFromStatementString, metavariableNodeFromMetavariableString } from "../utilities/node";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(metavariableNode, statementNode, substitution) {
@@ -55,6 +56,19 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return matchesMetavariableNode;
   }
 
+  static fromJSONAndFileContext(json, fileContext) {
+    const { metavariable, statement } = json,
+            metavariableString = metavariable,  ///
+            statementString = statement,  ///
+            lexer = fileContext.getLexer(),
+            parser = fileContext.getParser(),
+            statementNode = statementNodeFromStatementString(statementString, lexer, parser),
+            metavariableNode = metavariableNodeFromMetavariableString(metavariableString, lexer, parser),
+            statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode);
+
+    return statementForMetavariableSubstitution;
+  }
+
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
     let statementForMetavariableSubstitution;
 

package/src/substitution.js

@@ -24,10 +24,4 @@ export default class Substitution {
 
     return matchesMetavariableNode;
   }
-
-  matchMetastatementNode(metastatementNode) {
-    const matchesMetastatementNode = false;
-
-    return matchesMetastatementNode;
-  }
 }

package/src/supposition.js

@@ -1,9 +1,18 @@
 "use strict";
 
+import LocalContext from "./context/local";
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
 import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
+import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
+import {nodeQuery, nodesQuery} from "./utilities/query";
+
+const subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
+      subproofAssertionStatementNodesQuery = nodesQuery("/subproofAssertion/statement"),
+      subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
 
 export default class Supposition {
   constructor(statementNode) {
@@ -29,6 +38,43 @@ export default class Supposition {
     return matchesStatementNode;
   }
 
+  matchSubproofNode(subproofNode, substitutions, fileContext, localContext) {
+    let matchesSubproofNode = false;
+
+    if (this.statementNode !== null) {
+      const subproofAssertionNode = subproofAssertionNodeQuery(this.statementNode);
+
+      if (subproofAssertionNode !== null) {
+        const subproofSuppositionStatementNodes = subproofSuppositionStatementNodesQuery(subproofNode),
+              subproofLastProofStepStatementNode = subproofLastProofStepStatementNodeQuery(subproofNode),
+              subproofStatementNodes = [
+                ...subproofSuppositionStatementNodes,
+                subproofLastProofStepStatementNode
+              ],
+              subproofAssertionStatementNodes = subproofAssertionStatementNodesQuery(subproofAssertionNode);
+
+        matchesSubproofNode = match(subproofAssertionStatementNodes, subproofStatementNodes, (subproofAssertionStatementNode, ruleSubproofStatementNode) => {
+          const fileContextA = fileContext, ///
+                nonTerminalNodeA = subproofAssertionStatementNode,  ///
+                nonTerminalNodeB = ruleSubproofStatementNode, ///
+                localContextA = LocalContext.fromFileContext(fileContextA),  ///
+                localContextB = localContext,  ///
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                  const verifiedAhead = true;
+
+                  return verifiedAhead;
+                });
+
+          if (nonTerminalNodeVerified) {
+            return true;
+          }
+        });
+      }
+    }
+
+    return matchesSubproofNode;
+  }
+
   toJSON(tokens) {
     const statementString = nodeAsString(this.statementNode, tokens),
           statement = statementString, ///

package/src/utilities/customGrammar.js

@@ -5,11 +5,10 @@ import { CustomGrammar, CombinedCustomGrammar } from "occam-custom-grammars";
 export function customGrammarFromNameAndEntries(name, entries) {
   const termBNF = entries.getTermBNF(),
         statementBNF = entries.getStatementBNF(),
-        metastatementBNF = entries.getMetastatementBNF(),
         typePattern = entries.getTypePattern(),
         symbolPattern = entries.getSymbolPattern(),
         operatorPattern = entries.getOperatorPattern(),
-        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFMetastatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, metastatementBNF, typePattern, symbolPattern, operatorPattern);
+        customGrammar = CustomGrammar.fromNameTermBNFStatementBNFTypePatternSymbolPatternAndOperatorPattern(name, termBNF, statementBNF, typePattern, symbolPattern, operatorPattern);
 
   return customGrammar;
 }

package/src/utilities/match.js

@@ -1,76 +1,42 @@
 "use strict";
 
 import bracketedStatementNode from "../node/statement/bracketed";
-import bracketedMetastatementNode from "../node/metastatement/bracketed";
 
 import { nodeQuery } from "../utilities/query";
-import { BRACKETED_STATEMENT_DEPTH, BRACKETED_METASTATEMENT_DEPTH } from "../constants";
+import { BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument!/statement!"),
-      bracketedMetastatementChildNodeQuery = nodeQuery("/metastatement/metastatement!");
+const bracketedStatementChildNodeQuery = nodeQuery("/statement/statement!");
 
 export function matchStatementModuloBrackets(statementNodeA, statementNodeB) {
-  let statementMatchesModuloBrackets = false;
+  let statementMatches = false;
 
-  if (!statementMatchesModuloBrackets) {
-    const statementNodeAMatchesStatementNodeB = statementNodeA.match(statementNodeB);
+  if (!statementMatches) {
+    const statementNodeMatches = statementNodeA.match(statementNodeB);
 
-    statementMatchesModuloBrackets = statementNodeAMatchesStatementNodeB;  ///
+    statementMatches = statementNodeMatches;  ///
   }
 
-  if (!statementMatchesModuloBrackets) {
+  if (!statementMatches) {
     const bracketedStatementChildNodeA = bracketedStatementChildNodeFromStatementNode(statementNodeA);
 
     if (bracketedStatementChildNodeA !== null) {
-      const bracketedStatementChildNodeAMatchStatementNodeB = bracketedStatementChildNodeA.match(statementNodeB);
+      const bracketedStatementChildNodeAMatchesStatementNodeB = bracketedStatementChildNodeA.match(statementNodeB);
 
-      statementMatchesModuloBrackets = bracketedStatementChildNodeAMatchStatementNodeB; ///
+      statementMatches = bracketedStatementChildNodeAMatchesStatementNodeB; ///
     }
   }
 
-  if (!statementMatchesModuloBrackets) {
+  if (!statementMatches) {
     const bracketedStatementChildNodeB = bracketedStatementChildNodeFromStatementNode(statementNodeB);
 
     if (bracketedStatementChildNodeB !== null) {
-      const statementNodeAMatchBracketedStatementChildNodeB = statementNodeA.match(bracketedStatementChildNodeB);
+      const statementNodeAMatchesBracketedStatementChildNodeB = statementNodeA.match(bracketedStatementChildNodeB);
 
-      statementMatchesModuloBrackets = statementNodeAMatchBracketedStatementChildNodeB; ///
+      statementMatches = statementNodeAMatchesBracketedStatementChildNodeB; ///
     }
   }
 
-  return statementMatchesModuloBrackets;
-}
-
-export function matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB) {
-  let metastatementMatches = false;
-
-  if (!metastatementMatches) {
-    const metastatementNodeMatches = metastatementNodeA.match(metastatementNodeB);
-
-    metastatementMatches = metastatementNodeMatches;  ///
-  }
-
-  if (!metastatementMatches) {
-    const bracketedMetastatementChildNodeA = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeA);
-
-    if (bracketedMetastatementChildNodeA !== null) {
-      const bracketedMetastatementChildNodeAMatchesMetastatementNodeB = bracketedMetastatementChildNodeA.match(metastatementNodeB);
-
-      metastatementMatches = bracketedMetastatementChildNodeAMatchesMetastatementNodeB; ///
-    }
-  }
-
-  if (!metastatementMatches) {
-    const bracketedMetastatementChildNodeB = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNodeB);
-
-    if (bracketedMetastatementChildNodeB !== null) {
-      const metastatementNodeAMatchesBracketedMetastatementChildNodeB = metastatementNodeA.match(bracketedMetastatementChildNodeB);
-
-      metastatementMatches = metastatementNodeAMatchesBracketedMetastatementChildNodeB; ///
-    }
-  }
-
-  return metastatementMatches;
+  return statementMatches;
 }
 
 export function bracketedStatementChildNodeFromStatementNode(statementNode) {
@@ -85,16 +51,3 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
 
   return bracketedStatementChildNode;
 }
-
-export function bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode) {
-  let bracketedMetastatementChildNode = null;
-
-  const depth = BRACKETED_METASTATEMENT_DEPTH,
-        metastatementNodeMatchesBracketedMetastatementNode = metastatementNode.match(bracketedMetastatementNode, depth);
-
-  if (metastatementNodeMatchesBracketedMetastatementNode) {
-    bracketedMetastatementChildNode = bracketedMetastatementChildNodeQuery(metastatementNode);
-  }
-
-  return bracketedMetastatementChildNode;
-}

package/src/utilities/node.js

@@ -7,12 +7,10 @@ import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { METAVARIABLE_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONSTRUCTOR_DECLARATION_RULE_NAME,
-         UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
+         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { metavariableTokensFromMetavariableString,
          variableDeclarationTokensFromVariableString,
-         unqualifiedStatementTokensFromStatementString,
-         unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
+         unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -21,8 +19,7 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
+      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
@@ -45,13 +42,6 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
-  const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
-        metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
-
-  return metastatementNode;
-}
-
 export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   let termNode = null;
 
@@ -88,18 +78,6 @@ export function variableNodeFromVariableVariableTDeclarationTokens(variableTDecl
   return variableNode;
 }
 
-export function metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
-  let metastatementNode = null;
-
-  const unqualifiedMetastatementNode = unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
-
-  if (unqualifiedMetastatementNode !== null) {
-    metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode);
-  }
-
-  return metastatementNode;
-}
-
 export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
   const ruleName = METAVARIABLE_RULE_NAME,
         metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
@@ -128,13 +106,6 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
-  const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
-        unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);
-
-  return unqualifiedMetastatementNode;
-}
-
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],

package/src/utilities/tokens.js

@@ -40,14 +40,6 @@ export function unqualifiedStatementTokensFromStatementString(statementString, l
   return unqualifiedStatementTokens;
 }
 
-export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
-  const unqualifiedMetastatementContent = `${metastatementString}
-`,
-        unqualifiedMetastatementTokens = tokensFromContentAndLexer(unqualifiedMetastatementContent, lexer);
-
-  return unqualifiedMetastatementTokens;
-}
-
 function tokensFromContentAndLexer(content, lexer = florenceLexer) {
   const tokens = lexer.tokenise(content);
 

package/src/utilities/verify.js

@@ -5,26 +5,10 @@ import { nodeQuery } from "../utilities/query";
 
 const secondOperatorTerminalNodeQuery = nodeQuery("/*/@operator[1]");
 
-export function isStatementNegated(statementNode) {
-  const node = statementNode, ///
-        negated = isNegated(node),
-        statementNegated = negated; ///
-
-  return statementNegated;
-}
-
-export function isMetastatementNegated(metastatementNode) {
-  const node = metastatementNode, ///
-        negated = isNegated(node),
-        statementNegated = negated; ///
-
-  return statementNegated;
-}
-
-function isNegated(node) {
-  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(node),
+export function isAssertionNegated(assertionNode) {
+  const secondOperatorTerminalNode = secondOperatorTerminalNodeQuery(assertionNode),
         content = secondOperatorTerminalNode.getContent(),
-        negated = (content === NOT);
+        assertionNegated = (content === NOT);
 
-  return negated;
+  return assertionNegated;
 }