occam-verify-cli 0.0.833 → 0.0.835

package/src/consequent.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
+import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
 import { nodeAsString } from "./utilities/string";
 import { statementNodeFromStatementString } from "./utilities/node";
@@ -19,7 +19,7 @@ export default class Consequent {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext, ///
-          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/constants.js

@@ -1,6 +1,7 @@
 "use strict";
 
 export const COMMA = ',';
+export const CONTAINED = "contained";
 export const EMPTY_STRING = "";
 export const MAXIMUM_INDEXES_LENGTH = 10;
 export const BRACKETED_STATEMENT_DEPTH = 2;

package/src/context/localMeta.js

@@ -104,6 +104,27 @@ class LocalMetaContext {
     return metastatementMatches;
   }
 
+  findVariableByVariableNode(variableNode) {
+    const node = variableNode,  ///
+          variables = this.getVariables(),
+          variable = variables.find((variable) => {
+            const matches = variable.matchNode(node);
+
+            if (matches) {
+              return true;
+            }
+          }) || null;
+
+    return variable;
+  }
+
+  isVariablePresentByVariableNode(variableNode) {
+    const variable = this.findVariableByVariableNode(variableNode),
+          variablePresent = (variable !== null);
+
+    return variablePresent;
+  }
+
   findMetavariableByMetavariableNode(metavariableNode) {
     const node = metavariableNode,  ///
           metavariables = this.getMetavariables(),

package/src/premise.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import statementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable";
-import metastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable";
+import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
+import metaLevelToIntrinsicLevelNodesVerifier from "./verifier/nodes/metaLevelToIntrinsicLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
@@ -46,7 +46,7 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+                nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -67,7 +67,7 @@ export default class Premise {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -99,7 +99,7 @@ export default class Premise {
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
                 localMetaContextB = metastatementLocalMetaContext,  ///
-                nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+                nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -120,7 +120,7 @@ export default class Premise {
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
           localMetaContextB = metastatementLocalMetaContext,  ///
-          nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
+          nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/ruleNames.js

@@ -3,6 +3,7 @@
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
+export const VARIABLE_RULE_NAME = "variable";
 export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
 export const STATEMENT_RULE_NAME = "statement";

package/src/supposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
+import intrinsicLevelNodesVerifier from "./verifier/nodes/intrinsicLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
@@ -43,7 +43,7 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = localContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -64,7 +64,7 @@ export default class Supposition {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = intrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/utilities/array.js

@@ -6,7 +6,7 @@ import permutationsMatrix from "../permutationsMatrix";
 
 import { MAXIMUM_INDEXES_LENGTH, MAXIMUM_PERMUTATION_LENGTH } from "../constants";
 
-export const { first, second, last, push, prune, match, filter, compress } = arrayUtilities;
+export const { first, second, third, last, push, prune, match, filter, compress } = arrayUtilities;
 
 export function someSubArray(array, subArrayLength, callback) {
   let found = false;

package/src/verifier/node/metastatement.js

@@ -2,7 +2,7 @@
 
 import NodeVerifier from "../../verifier/node";
 
-import { METAVARIABLE_RULE_NAME } from "../../ruleNames";
+import { VARIABLE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 class MetastatementNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
@@ -21,6 +21,16 @@ class MetastatementNodeVerifier extends NodeVerifier {
         break;
       }
 
+      case VARIABLE_RULE_NAME: {
+        const variableNode = nonTerminalNode, ///
+              variableVerified = verifyVariable(variableNode, localMetaContext, verifyAhead),
+              variableNodeVerified = variableVerified;  ///
+
+        nonTerminalNodeVerified = variableNodeVerified; ///
+
+        break;
+      }
+
       default: {
         nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
 
@@ -57,3 +67,25 @@ function verifyMetavariable(metavariableNode, localMetaContext, verifyAhead) {
 
   return metavariableVerified;
 }
+
+function verifyVariable(variableNode, localMetaContext, verifyAhead) {
+  let variableVerified;
+
+  const variableString = localMetaContext.nodeAsString(variableNode);
+
+  localMetaContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
+
+  const variablePresent = localMetaContext.isVariablePresentByVariableNode(variableNode);
+
+  if (variablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    variableVerified = verifiedAhead; ///
+  }
+
+  if (variableVerified) {
+    localMetaContext.debug(`...verified the '${variableString}' variable.`, variableNode);
+  }
+
+  return variableVerified;
+}

package/src/verifier/nodes/{termForVariable.js → intrinsicLevel.js}

@@ -10,29 +10,36 @@ import { TERM_RULE_NAME } from "../../ruleNames";
 
 const variableNodeQuery = nodeQuery('/term/variable!');
 
-class TermForVariableNodesVerifier extends NodesVerifier {
+class IntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
 
-    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      const nonTerminalNodeARuleNameTermRuleName = (nonTerminalNodeARuleName === TERM_RULE_NAME),
-            nonTerminalNodeBRuleNameTermRuleName = (nonTerminalNodeBRuleName === TERM_RULE_NAME);
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
 
-      if (nonTerminalNodeARuleNameTermRuleName && nonTerminalNodeBRuleNameTermRuleName) {
-        const termNodeA = nonTerminalNodeA,  ///
-              termNodeB = nonTerminalNodeB,  ///
-              termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+      switch (ruleName) {
+        case TERM_RULE_NAME: {
+          const termNodeA = nonTerminalNodeA,  ///
+                termNodeB = nonTerminalNodeB,  ///
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-        if (termNodeVerified) {
-          nonTerminalNodeVerified = true;  ///
-        } else {
+          if (termNodeVerified) {
+            nonTerminalNodeVerified = true;  ///
+          } else {
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+          }
+
+          break;
+        }
+
+        default: {
           nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          break;
         }
-      } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
       }
     }
 
@@ -115,6 +122,6 @@ class TermForVariableNodesVerifier extends NodesVerifier {
   }
 }
 
-const termForVariableNodesVerifier = new TermForVariableNodesVerifier();
+const intrinsicLevelNodesVerifier = new IntrinsicLevelNodesVerifier();
 
-export default termForVariableNodesVerifier;
+export default intrinsicLevelNodesVerifier;

package/src/verifier/nodes/{metastatementForMetavariable.js → metaLevel.js}

@@ -8,29 +8,36 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
+class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
           nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
 
-    if (nonTerminalNodeBRuleName === nonTerminalNodeARuleName) {
-      const nonTerminalNodeARuleNameMetastatementRuleName = (nonTerminalNodeARuleName === METASTATEMENT_RULE_NAME),
-            nonTerminalNodeBRuleNameMetastatementRuleName = (nonTerminalNodeBRuleName === METASTATEMENT_RULE_NAME);
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const ruleName = nonTerminalNodeARuleName;  ///
 
-      if (nonTerminalNodeARuleNameMetastatementRuleName && nonTerminalNodeBRuleNameMetastatementRuleName) {
-        const metastatementNodeA = nonTerminalNodeA,  ///
-              metastatementNodeB = nonTerminalNodeB,  ///
-              metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+      switch (ruleName) {
+        case METASTATEMENT_RULE_NAME: {
+          const metastatementNodeA = nonTerminalNodeA,  ///
+                metastatementNodeB = nonTerminalNodeB,  ///
+                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
 
-        if (metastatementNodeVerified) {
-          nonTerminalNodeVerified = true;  ///
-        } else {
+          if (metastatementNodeVerified) {
+            nonTerminalNodeVerified = true;  ///
+          } else {
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+          }
+
+          break;
+        }
+
+        default: {
           nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
+
+          break;
         }
-      } else {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead);
       }
     }
 
@@ -82,6 +89,6 @@ class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
   }
 }
 
-const metastatementForMetavariableNodesVerifier = new MetastatementForMetavariableNodesVerifier();
+const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
 
-export default metastatementForMetavariableNodesVerifier;
+export default metaLevelNodesVerifier;

package/src/verifier/nodes/{statementForMetavariable.js → metaLevelToIntrinsicLevel.js}

@@ -1,6 +1,7 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
@@ -9,7 +10,7 @@ import { STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME }
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!'),
       metaArgumentChildNodeNodeQuery = nodeQuery('/metaArgument/*!');
 
-class StatementForMetavariableNodesVerifier extends NodesVerifier {
+class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContext) {
     let nonTerminalNodeVerified = false;
 
@@ -98,6 +99,6 @@ class StatementForMetavariableNodesVerifier extends NodesVerifier {
   }
 }
 
-const statementForMetavariableNodesVerifier = new StatementForMetavariableNodesVerifier();
+const metaLevelToIntrinsicLevelNodesVerifier = new MetaLevelToIntrinsicLevelNodesVerifier();
 
-export default statementForMetavariableNodesVerifier;
+export default metaLevelToIntrinsicLevelNodesVerifier;

package/src/verifier/nodes/statement.js

@@ -23,16 +23,6 @@ class StatementNodesVerifier extends NodesVerifier {
 
     if (ruleName === combinatorRuleName) {
       switch (ruleName) {
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
-
-          nonTerminalNodeVerified = argumentNodeVerified; ///
-
-          break;
-        }
-
         case META_ARGUMENT_RULE_NAME: {
           const metaArgumentNode = nonTerminalNode, ///
                 combinatorMetaargumentNode = combinatorNonTerminalNode, ///
@@ -43,6 +33,16 @@ class StatementNodesVerifier extends NodesVerifier {
           break;
         }
 
+        case ARGUMENT_RULE_NAME: {
+          const argumentNode = nonTerminalNode, ///
+                constructorArgumentNode = combinatorNonTerminalNode, ///
+                argumentNodeVerified = termNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, context, verifyAhead);
+
+          nonTerminalNodeVerified = argumentNodeVerified; ///
+
+          break;
+        }
+
         default: {
           nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
 

package/src/verifier/nodes/term.js

@@ -10,9 +10,12 @@ const termNodeQuery = nodeQuery("/argument/term!"),
       typeNodeQuery = nodeQuery("/argument/type!");
 
 class TermNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNode, constructorNonTerminalNode, context, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
+    const nonTerminalNode = nonTerminalNodeA, ///
+          constructorNonTerminalNode = nonTerminalNodeB; ///
+
     const ruleName = nonTerminalNode.getRuleName(), ///
           constructorRuleName = constructorNonTerminalNode.getRuleName(); ///
 

package/src/verify/containment.js

@@ -0,0 +1,40 @@
+"use strict";
+
+import { third } from "../utilities/array";
+import { CONTAINED } from "../constants";
+import { nodeQuery, nodesQuery } from "../utilities/query";
+
+const statementVariableNodesQuery = nodesQuery("/statement//variable");
+
+export const containmentVariableNodeQuery = nodeQuery("/containment/argument/term/variable!");
+
+export default function verifyContainment(containmentNode, statementNode) {
+  let containmentVerified = false;
+
+  const contained = containedFromContainmendNode(containmentNode),
+        statementVariableNodes = statementVariableNodesQuery(statementNode),
+        containmentVariableNode = containmentVariableNodeQuery(containmentNode),
+        containmentVariableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+          const containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
+
+          if (containmentVariableNodeMatchesStatementVariableNode) {
+            return true;
+          }
+        });
+
+  if (contained === containmentVariableNodeMatchesStatementVariableNode) {
+    containmentVerified = true;
+  }
+
+  return containmentVerified;
+}
+
+function containedFromContainmendNode(containmentNode) {
+  const childNodes = containmentNode.getChildNodes(),
+        thirdChildNode = third(childNodes),
+        terminalNode = thirdChildNode,  ///
+        content = terminalNode.getContent(),
+        contained = (content === CONTAINED);
+
+  return contained;
+}

package/src/verify/statement.js

@@ -1,13 +1,16 @@
 "use strict";
 
 import verifyEquality from "../verify/equality";
+import verifyContainment from "../verify/containment";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/typeAssertion";
 import statementNodesVerifier from "../verifier/nodes/statement";
 
 import { nodeQuery } from "../utilities/query";
+import { containmentVariableNodeQuery } from "../verify/containment";
 
 const equalityNodeQuery = nodeQuery("/statement/equality!"),
+      statementNodeQuery = nodeQuery("/statement/statement!"),
       containmentNodeQuery = nodeQuery("/statement/containment!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!");
 
@@ -112,25 +115,46 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
 }
 
 function verifyStatementWithContainment(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAsTypeAssertion = false;
+  let statementVerifiedWithContainment = false;
 
   const containmentNode = containmentNodeQuery(statementNode);
 
   if (containmentNode !== null) {
-    // const statementString = context.nodeAsString(statementNode);
-    //
-    // context.trace(`Verifying the '${statementString}' statement with a containment...`, statementNode);
-    //
-    // const containmentVerified = verifyTypeAssertion(containmentNode, assignments, derived, context, verifyAhead);
-    //
-    // statementVerifiedAsTypeAssertion = containmentVerified; ///
-    //
-    // if (statementVerifiedAsTypeAssertion) {
-    //   context.debug(`...verified the '${statementString}' statement with a containment.`, statementNode);
-    // }
+    statementNode = statementNodeQuery(statementNode);  ///
+
+    const statementString = context.nodeAsString(statementNode),
+          containmentVariableNode = containmentVariableNodeQuery(containmentNode),
+          containmentVariableString = context.nodeAsString(containmentVariableNode);
+
+    context.trace(`Verifying that the '${containmentVariableString}' is either contained in or omitted from the '${statementString}' statement...`, statementNode);
+
+    const containmentVerified = verifyContainment(containmentNode, statementNode);
+
+    if (containmentVerified) {
+      const verifyStatementFunctions = [
+        verifyStatementAsEquality,
+        verifyStatementAgainstCombinators
+      ];
+
+      const statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
+        const derived = false,
+              assignments = [],
+              statementVerified = verifyStatementFunction(statementNode, assignments, derived, context, verifyAhead);
+
+        if (statementVerified) {
+          return true;
+        }
+      });
+
+      statementVerifiedWithContainment = statementVerified; ///
+    }
+
+    if (statementVerifiedWithContainment) {
+      context.debug(`...verified that '${containmentVariableString}' is either contained in or omitted from the '${statementString}' statement.`, statementNode);
+    }
   }
 
-  return statementVerifiedAsTypeAssertion;
+  return statementVerifiedWithContainment;
 }
 
 function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {