occam-verify-cli 0.0.983 → 0.0.985

package/src/node/term/constructor/bracketed.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import bracketedConstructorDeclarationTokens from "../../../tokens/constructorDeclaration/bracketed";
+import bracketedConstructorTermTokens from "../../../tokens/constructorTerm/bracketed";
 
-import { termNodeFromConstructorDeclarationTokens } from "../../../utilities/node";
+import { termNodeFromTermTokens } from "../../../utilities/node";
 
-const bracketedConstructorTermNode = termNodeFromConstructorDeclarationTokens(bracketedConstructorDeclarationTokens);
+const bracketedConstructorTermNode = termNodeFromTermTokens(bracketedConstructorTermTokens);
 
 export default bracketedConstructorTermNode;

package/src/ocmbinator/bracketed.js

@@ -2,14 +2,14 @@
 
 import Combinator from "../combinator";
 import bracketedCombinatorStatementNode from "../node/statement/combinator/bracketed";
-import bracketedCombinatorUnqualifiedStatementTokens from "../tokens/unqualifiedStatement/combinator/bracketed";
+import bracketedCombinatorStatementTokens from "../tokens/combinatorStatement/bracketed";
 
 import { nodeAsString } from "../utilities/string";
 
 class BracketedCombinator extends Combinator {
   static fromNothing() {
     const node = bracketedCombinatorStatementNode,  ///
-          tokens = bracketedCombinatorUnqualifiedStatementTokens, ///
+          tokens = bracketedCombinatorStatementTokens, ///
           string = nodeAsString(node, tokens),
           statementNode = node, ///
           bracketedCombinator = new BracketedCombinator(statementNode, string);

package/src/ruleNames.js

@@ -1,4 +1,4 @@
 "use strict";
 
-export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
-export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
+export const TERM_RULE_NAME = "term";
+export const STATEMENT_RULE_NAME = "statement";

package/src/substitution/frameForMetavariable.js

@@ -4,10 +4,10 @@ import Substitution from "../substitution";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { nodeQuery } from "../utilities/query";
-import { stripBracketsFromFrame } from "../utilities/brackets";
 
 const frameNodeQuery = nodeQuery("/substitution/frame!"),
-      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      substitutionMetavariableNodeQuery = nodeQuery("/substitution/metavariable!");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
   constructor(frameNode, metavariableNode, substitution) {
@@ -60,8 +60,6 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   matchFrameNode(frameNode) {
-    frameNode = stripBracketsFromFrame(frameNode); ///
-
     const frameNodeMatches = this.frameNode.match(frameNode);
 
     return frameNodeMatches;
@@ -101,13 +99,12 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   static fromSubstitutionNode(substitutionNode) {
     let frameForMetavariableSubstitution = null;
 
-    let frameNode = frameNodeQuery(substitutionNode),
-        metavariableNode = metavariableNodeQuery(substitutionNode);
+    let frameNode = frameNodeQuery(substitutionNode);
 
     if (frameNode !== null) {
-      frameNode = stripBracketsFromFrame(frameNode); ///
-
-      const substitution = null;
+      const substitutionMetavariableNode = substitutionMetavariableNodeQuery(substitutionNode),
+            metavariableNode = substitutionMetavariableNode,  ///
+            substitution = null;
 
       frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
     }
@@ -116,8 +113,6 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   static fromFrameNodeAndMetavariableNode(frameNode, metavariableNode) {
-    frameNode = stripBracketsFromFrame(frameNode); ///
-
     const substitution = null,
           frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
 
@@ -125,8 +120,6 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   static fromFrameNodeMetavariableNodeAndSubstitutionNode(frameNode, metavariableNode, substitutionNode) {
-    frameNode = stripBracketsFromFrame(frameNode); ///
-
     const substitution = substitutionFromSubstitutionNode(substitutionNode),
           frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(frameNode, metavariableNode, substitution);
 
@@ -159,9 +152,11 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 function transformFrameNode(frameNode, substitutions) {
   let transformedFrameNode = null;
 
-  const metavariableNode = metavariableNodeQuery(frameNode);
+  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
+
+  if (frameMetavariableNode !== null) {
+    const metavariableNode = frameMetavariableNode;  ///
 
-  if (metavariableNode !== null) {
     substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
 

package/src/substitution/statementForMetavariable.js

@@ -7,8 +7,7 @@ import FrameForMetavariableSubstitution from "../substitution/frameForMetavariab
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromStatement } from "../utilities/brackets";
 
-const statementNodeQuery = nodeQuery("/substitution/statement!"),
-      metavariableNodeQuery = nodeQuery("/*/metavariable!");
+const statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(statementNode, metavariableNode, substitution) {
@@ -99,23 +98,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return string;
   }
 
-  // static fromSubstitutionNode(substitutionNode) {
-  //   let statementForMetavariableSubstitution = null;
-  //
-  //   let statementNode = statementNodeQuery(substitutionNode),
-  //       metavariableNode = metavariableNodeQuery(substitutionNode);
-  //
-  //   if (statementNode !== null) {
-  //     statementNode = stripBracketsFromStatement(statementNode); ///
-  //
-  //     const substitution = null;
-  //
-  //     statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(statementNode, metavariableNode, substitution);
-  //   }
-  //
-  //   return statementForMetavariableSubstitution;
-  // }
-
   static fromStatementNodeAndMetavariableNode(statementNode, metavariableNode) {
     statementNode = stripBracketsFromStatement(statementNode); ///
 
@@ -160,9 +142,11 @@ function substitutionFromSubstitutionNode(substitutionNode) {
 function transformStatementNode(statementNode, substitutions) {
   let transformedStatementNode = null;
 
-  const metavariableNode = metavariableNodeQuery(statementNode);
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode; ///
 
-  if (metavariableNode !== null) {
     substitutions.someSubstitution((substitution) => {
       const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
 

package/src/tokens/combinatorFrame/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { FRAME_META_TYPE_NAME } from "../../metaTypeNames";
+import { fromTokensFromFrameString } from "../../utilities/tokens";
+
+const bracketedCombinatorFrameString = `(${FRAME_META_TYPE_NAME})`;
+
+const bracketedCombinatorFrameTokens = fromTokensFromFrameString(bracketedCombinatorFrameString)
+
+export default bracketedCombinatorFrameTokens;

package/src/tokens/combinatorStatement/bracketed.js

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

package/src/tokens/constructorTerm/bracketed.js

@@ -0,0 +1,10 @@
+"use strict";
+
+import { OBJECT_TYPE_NAME } from "../../typeNames";
+import { termTokensFromTermString } from "../../utilities/tokens";
+
+const bracketedConstructorTermString = `(${OBJECT_TYPE_NAME})`;
+
+const bracketedConstructorDeclarationTokens = termTokensFromTermString(bracketedConstructorTermString)
+
+export default bracketedConstructorDeclarationTokens;

package/src/unifier/metaLevel.js

@@ -3,16 +3,19 @@
 import shim from "../shim";
 import Unifier from "../unifier";
 import unifyVariableWithTerm from "../unify/variableWithTerm";
+import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
 import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 import unifyMetavariableWithStatementGivenSubstitution from "../unify/metavariableWithStatementGivenSubstitution";
 
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term!"),
+      frameNodeQuery = nodeQuery("/frame!"),
       statementNodeQuery = nodeQuery("/statement!"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
-      substitutionNodeQuery = nodeQuery("/statement/substitution!"),
-      metavariableNodeQuery = nodeQuery("/statement/metavariable!");
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
   unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
@@ -34,17 +37,19 @@ class MetaLevelUnifier extends Unifier {
       unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
         let statementUnifiedWithStatement;
 
-        const metavariableNodeA = metavariableNodeQuery(statementNodeA);
+        const statementMetavariableNodeA = statementMetavariableNodeQuery(statementNodeA);
 
-        if (metavariableNodeA !== null) {
-          const substitutionNodeA = substitutionNodeQuery(statementNodeA);
+        if (statementMetavariableNodeA !== null) {
+          const metavariableNodeA = statementMetavariableNodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA);
 
-          if (substitutionNodeA === null) {
+          if (statementSubstitutionNodeA === null) {
             const metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutions, localContextA, localContextB);
 
             statementUnifiedWithStatement = metavariableUnifiedWithStatement; ///
           } else {
-            const metavariableUnifiedWithStatementGivenSubstitution = unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+            const substitutionNodeA = statementSubstitutionNodeA, ///
+                  metavariableUnifiedWithStatementGivenSubstitution = unifyMetavariableWithStatementGivenSubstitution(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
 
             statementUnifiedWithStatement = metavariableUnifiedWithStatementGivenSubstitution; ///
           }
@@ -63,6 +68,16 @@ class MetaLevelUnifier extends Unifier {
         return statementUnifiedWithStatement;
       }
     },
+    {
+      nodeQueryA: frameMetavariableNodeQuery,
+      nodeQueryB: frameNodeQuery,
+      unify: (frameMetavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) => {
+        const metavariableNodeA = frameMetavariableNodeA, ///
+              metavariableUnifiedWithFrame = unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB);
+
+        return metavariableUnifiedWithFrame;
+      }
+    },
     {
       nodeQueryA: termVariableNodeQuery,
       nodeQueryB: termNodeQuery,

package/src/unify/metavariableWithFrame.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
+
+import { metavariableFromFrameNode } from "../utilities/unify";
+
+export default function unifyMetavariableWithFrame(metavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) {
+  let metavariableUnifiedWithFrame = false;
+
+  const simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNodeA),
+        substitution = simpleSubstitution;  ///
+
+  if (substitution !== null) {
+    const frameNodeMatches = substitution.matchFrameNode(frameNodeB);
+
+    if (frameNodeMatches) {
+      metavariableUnifiedWithFrame = true;
+    }
+  } else {
+    const metavariableA = localContextA.findMetavariableByMetavariableNode(metavariableNodeA),
+          metavariableB = metavariableFromFrameNode(frameNodeB, localContextB);
+
+    if (metavariableA === metavariableB) {
+      metavariableUnifiedWithFrame = true;
+    } else {
+      const frameNode = frameNodeB, ///
+            metavariableNode = metavariableNodeA, ///
+            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode),
+            substitution = frameForMetavariableSubstitution;  ///
+
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
+
+      metavariableUnifiedWithFrame = true;
+    }
+  }
+
+  return metavariableUnifiedWithFrame;
+}

package/src/utilities/node.js

@@ -2,61 +2,45 @@
 
 import { parsersUtilities } from "occam-custom-grammars";
 
-import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { constructorDeclarationTokensFromTermString, unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
+import { termTokensFromTermString, statementTokensFromStatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
-const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
-
 export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, lexer),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
+  const termTokens = termTokensFromTermString(termString, lexer),
+        termNode = termNodeFromTermTokens(termTokens, parser);
 
   return termNode;
 }
 
 export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
-        statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+  const statementTokens = statementTokensFromStatementString(statementString, lexer),
+        statementNode = statementNodeFromStatementTokens(statementTokens, parser);
 
   return statementNode;
 }
 
-export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
-        termNode = termNodeQuery(constructorDeclarationNode);
+export function termNodeFromTermTokens(termTokens, parser) {
+  const tokens = termTokens,  ///
+        ruleName = TERM_RULE_NAME,
+        termNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
   return termNode;
 }
 
-export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+export function statementNodeFromStatementTokens(statementTokens, parser) {
+  const tokens = statementTokens,  ///
+        ruleName = STATEMENT_RULE_NAME,
+        statementNode = nodeFromTokensRuleNameAndParser(tokens, ruleName, parser);
 
   return statementNode;
 }
 
-function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
-  const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
-        unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);
-
-  return unqualifiedStatementNode;
-}
-
-function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
-  const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
-        constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
-
-  return constructorDeclarationNode;
-}
-
 function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = florenceParser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],

package/src/utilities/tokens.js

@@ -9,20 +9,18 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function constructorDeclarationTokensFromTermString(termString, lexer) {
-  const constructorDeclarationContent = `Constructor ${termString}
-`,
-        constructorDeclarationTokens = tokensFromContentAndLexer(constructorDeclarationContent, lexer);
+export function termTokensFromTermString(termString, lexer) {
+  const content = termString, ///
+        termTokens = tokensFromContentAndLexer(content, lexer);
 
-  return constructorDeclarationTokens;
+  return termTokens;
 }
 
-export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
-  const unqualifiedStatementContent = `${statementString}
-`,
-        unqualifiedStatementTokens = tokensFromContentAndLexer(unqualifiedStatementContent, lexer);
+export function statementTokensFromStatementString(statementString, lexer) {
+  const content = statementString,  ///
+        statementTokens = tokensFromContentAndLexer(content, lexer);
 
-  return unqualifiedStatementTokens;
+  return statementTokens;
 }
 
 function tokensFromContentAndLexer(content, lexer = florenceLexer) {

package/src/utilities/unify.js

@@ -2,27 +2,46 @@
 
 import { nodeQuery } from "../utilities/query";
 
-const variableNodeQuery = nodeQuery("/term/variable"),
-      metavariableNodeQuery = nodeQuery("/statement/metavariable");
+const termVariableNodeQuery = nodeQuery("/term/variable"),
+      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
 export function variableFromTermNode(termNode, localContext) {
   let variable = null;
 
-  const variableNode = variableNodeQuery(termNode);
+  const termVariableNode = termVariableNodeQuery(termNode);
+
+  if (termVariableNode !== null) {
+    const variableNode = termVariableNode;  ///
 
-  if (variableNode !== null) {
     variable = localContext.findVariableByVariableNode(variableNode);
   }
 
   return variable;
 }
 
+export function metavariableFromFrameNode(frameNode, localContext) {
+  let metavariable = null;
+
+  const frameMetavariableNode = frameMetavariableNodeQuery(frameNode)
+
+  if (frameMetavariableNode !== null) {
+    const metavariableNode = frameMetavariableNode; ///
+
+    metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
+  }
+
+  return metavariable;
+}
+
 export function metavariableFromStatementNode(statementNode, localContext) {
   let metavariable = null;
 
-  const metavariableNode = metavariableNodeQuery(statementNode)
+  const statementMetavariableNode = statementMetavariableNodeQuery(statementNode)
+
+  if (statementMetavariableNode !== null) {
+    const metavariableNode = statementMetavariableNode; ///
 
-  if (metavariableNode !== null) {
     metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
   }
 

package/src/verify/assertion/contained.js

@@ -6,9 +6,9 @@ import { isAssertionNegated } from "../../utilities/assertion";
 import { nodeQuery, nodesQuery } from "../../utilities/query";
 
 const variableNodeQuery = nodeQuery("/containedAssertion/term/variable!"),
-      metavariableNodeQuery = nodeQuery("/containedAssertion/frame[0]/metavariable"),
-      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//variable"),
-      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement[-1]//metavariable");
+      metavariableNodeQuery = nodeQuery("/containedAssertion/frame/metavariable!"),
+      statementVariableNodesQuery = nodesQuery("/containedAssertion/statement//variable"),
+      statementMetavariableNodesQuery = nodesQuery("/containedAssertion/statement//metavariable");
 
 const verifyContainedAssertionFunctions = [
   verifyDerivedContainedAssertion,
@@ -56,53 +56,56 @@ function verifyDerivedContainedAssertion(containedAssertionNode, assignments, st
 
     localContext.trace(`Verifying the '${containedAssertionString}' derived contained assertion...`, containedAssertionNode);
 
-    const assertionNegated = isAssertionNegated(containedAssertionNode),
-          metavariableNode = metavariableNodeQuery(containedAssertionNode),
-          variableNode = variableNodeQuery(containedAssertionNode),
-          negated = assertionNegated; ///
-
-    if (false) {
-      ///
-    } else if (metavariableNode !== null) {
-      const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
-              const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
-
-              if (variableNodeMatchesStatementMetavariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+    const metavariableNode = metavariableNodeQuery(containedAssertionNode);
+
+    if (metavariableNode !== null) {
+      const assertionNegated = isAssertionNegated(containedAssertionNode),
+            variableNode = variableNodeQuery(containedAssertionNode),
+            negated = assertionNegated; ///
+
+      if (false) {
+        ///
+      } else if (metavariableNode !== null) {
+        const statementMetavariableNodes = statementMetavariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementMetavariableNode = statementMetavariableNodes.some((statementMetavariableNode) => {
+                const variableNodeMatchesStatementMetavariableNode = metavariableNode.match(statementMetavariableNode);
+
+                if (variableNodeMatchesStatementMetavariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementMetavariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementMetavariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
-    } else if (variableNode !== null) {
-      const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
-            variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
-              const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
-
-              if (variableNodeMatchesStatementVariableNode) {
-                return true;
-              }
-            });
-
-      if (!negated) {
-        if (variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+      } else if (variableNode !== null) {
+        const statementVariableNodes = statementVariableNodesQuery(containedAssertionNode),
+              variableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
+                const variableNodeMatchesStatementVariableNode = variableNode.match(statementVariableNode);
+
+                if (variableNodeMatchesStatementVariableNode) {
+                  return true;
+                }
+              });
+
+        if (!negated) {
+          if (variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
-      }
 
-      if (negated) {
-        if (!variableNodeMatchesStatementVariableNode) {
-          derivedContainedAssertionVerified = true;
+        if (negated) {
+          if (!variableNodeMatchesStatementVariableNode) {
+            derivedContainedAssertionVerified = true;
+          }
         }
       }
     }