occam-verify-cli 0.0.1036 → 0.0.1038

package/src/substitution/statement.js

@@ -0,0 +1,52 @@
+"use strict";
+
+import Substitution from "../substitution";
+
+import { nodeQuery } from "../utilities/query";
+import { substitutionNodeFromSubstitutionString } from "../utilities/node";
+
+const substitutionNodeQuery = nodeQuery("/statement/substitution");
+
+export default class StatementSubstitution extends Substitution {
+  constructor(string, node) {
+    super(string);
+
+    this.node = node;
+  }
+
+  getNode() {
+    return this.node;
+  }
+
+  static fromJSON(json, fileContext) {
+    let statementSubstitution = null;
+
+    if (json !== null) {
+      const { string } = json,
+            lexer = fileContext.getLexer(),
+            parser = fileContext.getParser(),
+            substitutionString = string,  ///
+            substitutionNode = substitutionNodeFromSubstitutionString(substitutionString, lexer, parser),
+            node = substitutionNode;
+
+      statementSubstitution = new Substitution(string, node);
+    }
+
+    return statementSubstitution;
+  }
+
+  static fromStatementNode(statementNode, fileContext) {
+    let statementSubstitution = null;
+
+    const substitutionNode = substitutionNodeQuery(statementNode);
+
+    if (substitutionNode) {
+      const node = substitutionNode,
+            string = fileContext.nodeAsString(substitutionNode);
+
+      statementSubstitution = new Substitution(string, node);
+    }
+
+    return statementSubstitution;
+  }
+}

package/src/substitution/statementForMetavariable.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
@@ -53,50 +54,77 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNodeMatches;
   }
 
-  static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode, localContextA, localContextB) {
+  static fromStatementAndMetavariable(statement, metavariable, localContext) {
+    let statementNode = statement.getNode();
+
     statementNode = stripBracketsFromStatement(statementNode); ///
 
-    const substitution = null,
-          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext); ///
+
+    const string = stringFromStatementAndMetavariable(statement, metavariable),
+          substitution = null,
+          metavariableNode = metavariable.getNode(),
           statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 
-  static fromStatementNodeMetavariableNodeAndSubstitutionNode(statementNode, metavariableNode, substitutionNode, localContextA, localContextB) {
+  static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
+    let statementNode = statement.getNode();
+
     statementNode = stripBracketsFromStatement(statementNode); ///
 
-    const substitution = substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB),
-          string = stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB),
-          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext); ///
+
+    const metavariableNode = metavariable.getNode(),
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext);
+
+    substitution = substitutionFromSubstitution(substitution, localContext);
+
+    const statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statementNode, metavariableNode, substitution);
 
     return statementForMetavariableSubstitution;
   }
 }
 
-function substitutionFromSubstitutionNode(substitutionNode, localContextA, localContextB) {
-  let substitution = null;
+function stringFromStatementAndMetavariable(statement, metavariable) {
+  const statementString = statement.getString(),
+        metavariableString = metavariable.getString(),
+        string = `[${statementString} for ${metavariableString}]`;
 
-  if (substitution === null) {
-    const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
+  return string;
+}
 
-    if (termForVariableSubstitution !== null) {
-      substitution = termForVariableSubstitution; ///
-    }
-  }
 
-  if (substitution === null) {
-    const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitutionNode(substitutionNode, localContextA, localContextB);
+function substitutionFromSubstitution(substitution, localContextA, localContextB) {
+  // let substitution = null;
 
-    if (frameForMetavariableSubstitution !== null) {
-      substitution = frameForMetavariableSubstitution;  ///
-    }
-  }
+  debugger
+
+  // if (substitution === null) {
+  //   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
+  //
+  //   if (termForVariableSubstitution !== null) {
+  //     substitution = termForVariableSubstitution; ///
+  //   }
+  // }
+  //
+  // if (substitution === null) {
+  //   const frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromSubstitution(substitutionNode, localContextA, localContextB);
+  //
+  //   if (frameForMetavariableSubstitution !== null) {
+  //     substitution = frameForMetavariableSubstitution;  ///
+  //   }
+  // }
 
   return substitution;
 }
 
-function stringFromStatementNodeMetavariableNodeAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
+function stringFromStatementMetavariableAndSubstitution(statementNode, metavariableNode, substitution, localContextA, localContextB) {
   let string;
 
   const statementNodeB = statementNode,  ///

package/src/substitution/termForVariable.js

@@ -7,7 +7,7 @@ import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
 
 const termVariableNodeQuery = nodeQuery("/term/variable!"),
-      substitutionTermmNodeQuery = nodeQuery("/substitution/term!"),
+      substitutionTermNodeQuery = nodeQuery("/substitution/term!"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
@@ -83,26 +83,12 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromTernAndVariable(term, variable, localContext) {
-    let termNode = term.getNode();
-
-    termNode = stripBracketsFromTerm(termNode); ///
-
-    const { Term } = shim;
-
-    term = Term.fromTermNode(termNode, localContext)
-
-    const string = stringFromTermAndVariable(term, variable),
-          variableNode = variable.getNode(),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
-
-    return termForVariableSubstitution;
-  }
-
-  static fromSubstitutionNode(substitutionNode) {
+  static fromSubstitution(substitution) {
     let termForVariableSubstitution = null;
 
-    let substitutionTermNode = substitutionTermmNodeQuery(substitutionNode);
+    const substitutionNode = substitution.getNode();
+
+    let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
     if (substitutionTermNode !== null) {
       let termNode = substitutionTermNode;  ///
@@ -117,6 +103,22 @@ export default class TermForVariableSubstitution extends Substitution {
 
     return termForVariableSubstitution;
   }
+
+  static fromTernAndVariable(term, variable, localContext) {
+    let termNode = term.getNode();
+
+    termNode = stripBracketsFromTerm(termNode); ///
+
+    const { Term } = shim;
+
+    term = Term.fromTermNode(termNode, localContext); ///
+
+    const string = stringFromTermAndVariable(term, variable),
+          variableNode = variable.getNode(),
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+
+    return termForVariableSubstitution;
+  }
 }
 
 function transformTermNode(termNode, substitutions) {

package/src/supposition.js

@@ -12,9 +12,8 @@ import { assignAssignments } from "./utilities/assignments";
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
 export default class Supposition {
-  constructor(fileContext, subproofAssertion, unqualifiedStatement) {
+  constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
-    this.subproofAssertion = subproofAssertion;
     this.unqualifiedStatement = unqualifiedStatement;
   }
 
@@ -22,10 +21,6 @@ export default class Supposition {
     return this.fileContext;
   }
 
-  getSubproofAssertion() {
-    return this.subproofAssertion;
-  }
-
   getUnqualifiedStatement() {
     return this.unqualifiedStatement;
   }
@@ -34,6 +29,65 @@ export default class Supposition {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
+  verify(localContext) {
+    let verified = false;
+
+    const suppositionString = this.getString(); ///
+
+    if (this.unqualifiedStatement !== null) {
+      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
+
+      const stated = true,
+            assignments = [],
+            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+
+      if (unqualifiedStatementVerified) {
+        const assignmentsAssigned = assignAssignments(assignments, localContext);
+
+        if (assignmentsAssigned) {
+          const { ProofStep } = shim,
+                proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
+
+          localContext.addProofStep(proofStep);
+
+          verified = true;
+        }
+      }
+
+      if (verified) {
+        localContext.debug(`...verified the '${suppositionString}' supposition.`);
+      }
+    } else {
+      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
+    }
+
+    return verified;
+  }
+
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          subproofAssertion = SubproofAssertion.fromStatement(statement, this.fileContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -85,91 +139,24 @@ export default class Supposition {
     return statementUnified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
-
-    if (this.subproofAssertion !== null) {
-      subproofUnified = this.subproofAssertion.unifySubproof(subproof, substitutions, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
-  verify(localContext) {
-    let verified = false;
-
-    const suppositionString = this.getString(); ///
-
-    if (this.unqualifiedStatement !== null) {
-      localContext.trace(`Verifying the '${suppositionString}' supposition...`);
-
-      const stated = true,
-            assignments = [],
-            unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
-
-      if (unqualifiedStatementVerified) {
-        const assignmentsAssigned = assignAssignments(assignments, localContext);
-
-        if (assignmentsAssigned) {
-          const { ProofStep } = shim,
-                proofStep = ProofStep.fromUnqualifiedStatement(this.unqualifiedStatement);
-
-          localContext.addProofStep(proofStep);
-
-          verified = true;
-        }
-      }
-
-      if (verified) {
-        localContext.debug(`...verified the '${suppositionString}' supposition.`);
-      }
-    } else {
-      localContext.debug(`The '${suppositionString}' supposition cannot be verified because it is nonsense.`);
-    }
-
-    return verified;
-  }
-
   toJSON() {
     const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
-          subproofAssertionJSON = (this.subproofAssertion !== null) ?
-                                     this.subproofAssertion.toJSON() :
-                                       null,
           unqualifiedStatement = unqualifiedStatementJSON,  ///
-          subproofAssertion = subproofAssertionJSON,  ///
           json = {
-            unqualifiedStatement,
-            subproofAssertion
+            unqualifiedStatement
           };
 
     return json;
   }
 
   static fromJSON(json, fileContext) {
-    let { subproofAssertion, unqualifiedStatement } = json;
+    let { unqualifiedStatement } = json;
 
     json = unqualifiedStatement;  ///
 
     unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
 
-    json = subproofAssertion; ///
-
-    subproofAssertion = (json !== null) ?
-                          SubproofAssertion.fromJSON(json, fileContext) :
-                            null;
-
-    const supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
+    const supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }
@@ -177,8 +164,7 @@ export default class Supposition {
   static fromSuppositionNode(suppositionNode, fileContext) {
     const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          subproofAssertion = SubproofAssertion.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
-          supposition = new Supposition(fileContext, subproofAssertion, unqualifiedStatement);
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition
   }

package/src/unifier/intrinsicLevel.js

@@ -29,16 +29,15 @@ class IntrinsicLevelUnifier extends Unifier {
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         let termUnified = false;
 
-        const variableNodeA = termVariableNodeA, ///
-              variableNameA = variableNameFromVariableNode(variableNodeA),
-              variableA = localContextA.findVariableByVariableName(variableNameA);
+        const variableNode = termVariableNodeA, ///
+              variableName = variableNameFromVariableNode(variableNode),
+              variable = localContextA.findVariableByVariableName(variableName);
 
-        if (variableA !== null) {
+        if (variable !== null) {
           const { Term } = shim,
-                termB = Term.fromTermNode(termNodeB, localContextB),
                 localContext = localContextB, ///
-                variable = variableA, ///
-                term = termB; ///
+                termNode = termNodeB, ///
+                term = Term.fromTermNode(termNode, localContextB);
 
           termUnified = variable.unifyTerm(term, substitutions, localContext);
         }

package/src/unifier/metaLevel.js

@@ -3,18 +3,15 @@
 import shim from "../shim";
 import Unifier from "../unifier";
 import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
-import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
-import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
-import { variableNameFromVariableNode } from "../utilities/name";
+import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const termNodeQuery = nodeQuery("/term!"),
       frameNodeQuery = nodeQuery("/frame!"),
       statementNodeQuery = nodeQuery("/statement!"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
@@ -35,35 +32,46 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: statementNodeQuery,
       unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
-        let statementUnifiedWithStatement;
+        let statementUnified;
 
         const matches = statementNodeA.match(statementNodeB);
 
         if (matches) {
-          statementUnifiedWithStatement = true;
+          statementUnified = true;
         } else {
-          const statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
+          const { Statement } = shim,
+                statementB = Statement.fromStatementNode(statementNodeB, localContextB),
+                statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
 
           if (statementMetavariableNodeA !== null) {
-            const metavariableNodeA = statementMetavariableNodeA, ///
-                  statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA);
+            let statement;
 
-            if (statementSubstitutionNodeA === null) {
-              const metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB);
+            const statementA = Statement.fromStatementNode(statementNodeA, localContextA);
 
-              statementUnifiedWithStatement = metavariableUnifiedWithStatement; ///
+            statement = statementA; ///
+
+            const substitution = statement.getSubstitution();
+
+            statement = statementB; ///
+
+            const localContext = localContextB, ///
+                  metavariableNode = statementMetavariableNodeA,  ///
+                  metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+
+            if (substitution === null) {
+              statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
             } else {
-              const substitutionNodeA = statementSubstitutionNodeA, ///
-                    metavariableUnifiedWithStatementGivenSubstitution = unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+              const statementUnifiedGivenSubstitution = metavariableNode.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
 
-              statementUnifiedWithStatement = metavariableUnifiedWithStatementGivenSubstitution; ///
+              statementUnified = statementUnifiedGivenSubstitution; ///
             }
           } else {
-            statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
+            statementUnified = unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
           }
         }
 
-        return statementUnifiedWithStatement;
+        return statementUnified;
       }
     },
     {
@@ -84,16 +92,15 @@ class MetaLevelUnifier extends Unifier {
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         let termUnified = false;
 
-        const variableNodeA = termVariableNodeA, ///
-              variableNameA = variableNameFromVariableNode(variableNodeA),
-              variableA = localContextA.findVariableByVariableName(variableNameA);
+        const variableNode = termVariableNodeA, ///
+              variableName = variableNameFromVariableNode(variableNode),
+              variable = localContextA.findVariableByVariableName(variableName);
 
-        if (variableA !== null) {
+        if (variable !== null) {
           const { Term } = shim,
-                termB = Term.fromTermNode(termNodeB, localContextB),
                 localContext = localContextB, ///
-                variable = variableA, ///
-                term = termB; ///
+                termNode = termNodeB, ///
+                term = Term.fromTermNode(termNode, localContextB);
 
           termUnified = variable.unifyTerm(term, substitutions, localContext);
         }
@@ -116,7 +123,7 @@ function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutio
         childNodesA = nonTerminalNodeAChildNodes, ///
         childNodesB = nonTerminalNodeBChildNodes, ///
         childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB),
-        statementUnifiedWithStatement = childNodesVerified; ///
+        statementUnified = childNodesVerified; ///
 
-  return statementUnifiedWithStatement;
+  return statementUnified;
 }

package/src/unifier/statementWithCombinator.js

@@ -5,7 +5,6 @@ import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
-import local from "../context/local";
 
 const termNodeQuery = nodeQuery("/term!"),
       typeNodeQuery = nodeQuery("/type!"),

package/src/utilities/node.js

@@ -6,10 +6,12 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         SUBSTITUTION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
+         substitutionTokensFromSubstitutionString,
          unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
@@ -55,6 +57,13 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
+export function substitutionNodeFromSubstitutionString(substitutionString, lexer, parser) {
+  const substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString, lexer),
+        substitutionNode = substitutionNodeFromSubstitutionTokens(substitutionTokens, parser);
+
+  return substitutionNode;
+}
+
 export function variableNodeFromVariableTokens(variableTokens, parser) {
   const ruleName = VARIABLE_RULE_NAME,
         variableNode = nodeFromTokensRuleNameAndParser(variableTokens, ruleName, parser);
@@ -69,6 +78,13 @@ export function metavariableNodeFromMetavariableTokens(metavariableTokens, parse
   return metavariableNode;
 }
 
+export function substitutionNodeFromSubstitutionTokens(substitutionTokens, parser) {
+  const ruleName = SUBSTITUTION_RULE_NAME,
+        substitutionNode = nodeFromTokensRuleNameAndParser(substitutionTokens, ruleName, parser);
+
+  return substitutionNode;
+}
+
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const tokens = unqualifiedStatementTokens,  ///
         ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,

package/src/utilities/tokens.js

@@ -23,6 +23,13 @@ export function metavariableTokensFromMetavariableString(metavariableString, lex
   return metavariableTokens;
 }
 
+export function substitutionTokensFromSubstitutionString(substitutionString, lexer) {
+  const substitutionContent = `${substitutionString}`,
+        substitutionTokens = tokensFromContentAndLexer(substitutionContent, lexer);
+
+  return substitutionTokens;
+}
+
 export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
   const content = unqualifiedStatementString,  ///
         unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);