occam-verify-cli 0.0.967 → 0.0.971

package/src/verify/assertion/defined.js

@@ -1,33 +1,40 @@
 "use strict";
 
 import verifyTerm from "../../verify/term";
+import metaLevelVerifier from "../../verifier/metaLevel";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { isAssertionNegated } from "../../utilities/verify";
+import { isAssertionNegated } from "../../utilities/assertion";
 
-const termNodeQuery = nodeQuery("/statement/term!"),
-      variableNodeQuery = nodeQuery("/statement/term/variable!");
+const variableNodeQuery = nodeQuery("/definedAssertion/variable!"),
+      metavariableNodeQuery = nodeQuery("/definedAssertion/metavariable!");
 
-export default function verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+const verifyDefinedAssertionFunctions = [
+  verifyDerivedDefinedAssertion,
+  verifyStatedDefinedAssertion
+];
+
+export default function verifyDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let definedAssertionVerified;
 
   const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
   localContext.trace(`Verifying the '${definedAssertionString}' defined assertion...`, definedAssertionNode);
 
-  const verifyDefinedAssertionFunctions = [
-    verifyDerivedDefinedAssertion,
-    verifyStatedDefinedAssertion
-  ];
+  assignments = []; ///
 
-  definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
-    const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, derived, localContext);
+  const verified = metaLevelVerifier.verify(definedAssertionNode, assignments, stated, localContext);
 
-    if (definedAssertionVerified) {
-      return true;
-    }
-  });
+  if (verified) {
+    definedAssertionVerified = verifyDefinedAssertionFunctions.some((verifyDefinedAssertionFunction) => {
+      const definedAssertionVerified = verifyDefinedAssertionFunction(definedAssertionNode, assignments, stated, localContext);
+
+      if (definedAssertionVerified) {
+        return true;
+      }
+    });
+  }
 
   if (definedAssertionVerified) {
     localContext.debug(`...verified the '${definedAssertionString}' defined assertion.`, definedAssertionNode);
@@ -36,61 +43,48 @@ export default function verifyDefinedAssertion(definedAssertionNode, assignments
   return definedAssertionVerified;
 }
 
-function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
+function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
   let derivedDefinedAssertionVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
     localContext.trace(`Verifying the '${definedAssertionString}' derived defined assertion...`, definedAssertionNode);
 
-    const statementNegated = isAssertionNegated(definedAssertionNode),
-          variableNode = variableNodeQuery(definedAssertionNode),
-          termNode = termNodeQuery(definedAssertionNode);
+    const assertionNegated = isAssertionNegated(definedAssertionNode),
+          metavariableNode = metavariableNodeQuery(definedAssertionNode),
+          variableNode = variableNodeQuery(definedAssertionNode);
 
     if (false) {
       ///
-    } else if (variableNode !== null) {
-      const variable = localContext.findVariableByVariableNode(variableNode);
-
-      if (variable !== null) {
-        const variableDefined = localContext.isVariableDefined(variable);
+    } else if (metavariableNode !== null) {
+      const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode),
+            metavariableDefined = localContext.isMetavariableDefined(metavariable);
 
-        if (!statementNegated) {
-          if (variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (!assertionNegated) {
+        if (metavariableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (statementNegated) {
-          if (!variableDefined) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!metavariableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
       }
-    } else if (termNode !== null) {
-      const terms = [],
-            termVerified = verifyTerm(termNode, terms, localContext, () => {
-              const verifiedAhead = true;
-
-              return verifiedAhead;
-            });
-
-      if (termVerified) {
-        const firstTerm = first(terms),
-              term = firstTerm, ///
-              termGrounded = localContext.isTermGrounded(term);
-
-        if (!statementNegated) {
-          if (termGrounded) {
-            derivedDefinedAssertionVerified = true;
-          }
+    } else if (variableNode !== null) {
+      const variable = localContext.findVariableByVariableNode(variableNode),
+            variableDefined = localContext.isVariableDefined(variable);
+
+      if (!assertionNegated) {
+        if (variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
+      }
 
-        if (statementNegated) {
-          if (!termGrounded) {
-            derivedDefinedAssertionVerified = true;
-          }
+      if (assertionNegated) {
+        if (!variableDefined) {
+          derivedDefinedAssertionVerified = true;
         }
       }
     }
@@ -103,15 +97,15 @@ function verifyDerivedDefinedAssertion(definedAssertionNode, assignments, derive
   return derivedDefinedAssertionVerified;
 }
 
-function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived, localContext) {
-  let statedDefinedAssertionVerified = false;
+function verifyStatedDefinedAssertion(definedAssertionNode, assignments, stated, localContext) {
+  let statedDefinedAssertionVerified;
 
-  if (!derived) {
+  if (stated) {
     const definedAssertionString = localContext.nodeAsString(definedAssertionNode);
 
     localContext.trace(`Verifying the '${definedAssertionString}' stated defined assertion...`, definedAssertionNode);
 
-    debugger
+    statedDefinedAssertionVerified = true;
 
     if (statedDefinedAssertionVerified) {
       localContext.debug(`...verified the '${definedAssertionString}' stated defined assertion.`, definedAssertionNode);
@@ -120,3 +114,18 @@ function verifyStatedDefinedAssertion(definedAssertionNode, assignments, derived
 
   return statedDefinedAssertionVerified;
 }
+
+function termFromTermNode(termNode, localContext) {
+  const terms = [];
+
+  verifyTerm(termNode, terms, localContext, () => {
+    const verifiedAhead = true;
+
+    return verifiedAhead;
+  });
+
+  const firstTerm = first(terms),
+        term = firstTerm; ///
+
+  return term;
+}

package/src/verify/assertion/subproof.js

@@ -7,18 +7,18 @@ const verifySubproofAssertionFunctions = [
   verifyStatedSubproofAssertion
 ];
 
-export default function verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
-  let subproofAssertionVerified;
+export default function verifySubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
+  let subproofAssertionVerified = false;
 
   const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
   localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`, subproofAssertionNode);
 
-  const verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, derived, localContext);
+  const verified = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
 
   if (verified) {
     subproofAssertionVerified = verifySubproofAssertionFunctions.some((verifySubproofAssertionFunction) => {
-      const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, derived, localContext);
+      const subproofAssertionVerified = verifySubproofAssertionFunction(subproofAssertionNode, assignments, stated, localContext);
 
       if (subproofAssertionVerified) {
         return true;
@@ -33,10 +33,10 @@ export default function verifySubproofAssertion(subproofAssertionNode, assignmen
   return subproofAssertionVerified;
 }
 
-function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
   let derivedSubproofAssertionVerified;
 
-  if (derived) {
+  if (!stated) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
     localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`, subproofAssertionNode);
@@ -49,10 +49,10 @@ function verifyDerivedSubproofAssertion(subproofAssertionNode, assignments, deri
   return derivedSubproofAssertionVerified;
 }
 
-function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, derived, localContext) {
+function verifyStatedSubproofAssertion(subproofAssertionNode, assignments, stated, localContext) {
   let statedSubproofAssertionVerified;
 
-  if (!derived) {
+  if (stated) {
     const subproofAssertionString = localContext.nodeAsString(subproofAssertionNode);
 
     localContext.trace(`Verifying the '${subproofAssertionString}' stated subproof assertion...`, subproofAssertionNode);

package/src/verify/assertion/type.js

@@ -11,20 +11,20 @@ const termNodeQuery = nodeQuery("/typeAssertion/term!"),
       typeNodeQuery = nodeQuery("/typeAssertion/type!"),
       variableNodeQuery = nodeQuery("/term/variable!");
 
-export default function verifyTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+const verifyTypeAssertionFunctions = [
+  verifyDerivedTypeAssertion,
+  verifyStatedTypeAssertion
+];
+
+export default function verifyTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let typeAssertionVerified;
 
   const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
   localContext.trace(`Verifying the '${typeAssertionString}' type assertion...`, typeAssertionNode);
 
-  const verifyTypeAssertionFunctions = [
-    verifyDerivedTypeAssertion,
-    verifyStatedTypeAssertion
-  ];
-
   typeAssertionVerified = verifyTypeAssertionFunctions.some((verifyTypeAssertionFunction) => {
-    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, derived, localContext);
+    const typeAssertionVerified = verifyTypeAssertionFunction(typeAssertionNode, assignments, stated, localContext);
 
     if (typeAssertionVerified) {
       return true;
@@ -38,10 +38,10 @@ export default function verifyTypeAssertion(typeAssertionNode, assignments, deri
   return typeAssertionVerified;
 }
 
-function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+function verifyDerivedTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let derivedTypeAssertionVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
     localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`, typeAssertionNode);
@@ -82,10 +82,10 @@ function verifyDerivedTypeAssertion(typeAssertionNode, assignments, derived, loc
   return derivedTypeAssertionVerified;
 }
 
-function verifyStatedTypeAssertion(typeAssertionNode, assignments, derived, localContext) {
+function verifyStatedTypeAssertion(typeAssertionNode, assignments, stated, localContext) {
   let statedTypeAssertionVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const typeAssertionString = localContext.nodeAsString(typeAssertionNode);
 
     localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`, typeAssertionNode);

package/src/verify/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Conclusion from "../conclusion";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -15,16 +15,16 @@ export default function verifyConclusion(conclusionNode, conclusions, localConte
 
   localContext.trace(`Verifying the '${conclusionString}' conclusion...`, conclusionNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            conclusion = Conclusion.fromStatementNode(statementNode);
+    if (statementVerified) {
+      const conclusion = Conclusion.fromStatementNode(statementNode);
 
       conclusions.push(conclusion);
 

package/src/verify/consequent.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Consequent from "../consequent";
-import verifyUnqualifiedStatement from "../verify/statement/unqualified";
+import verifyStatement from "../verify/statement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -15,16 +15,16 @@ export default function verifyConsequent(consequentNode, consequents, localConte
 
   localContext.trace(`Verifying the '${consequentString}' consequent...`, consequentNode);
 
-  const derived = false,
-        assignments = [],
-        unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
+  const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode);
 
   if (unqualifiedStatementNode !== null) {
-    const unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
+    const stated = true,
+          assignments = [],
+          statementNode = statementNodeQuery(unqualifiedStatementNode),
+          statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-    if (unqualifiedStatementVerified) {
-      const statementNode = statementNodeQuery(unqualifiedStatementNode),
-            consequent = Consequent.fromStatementNode(statementNode);
+    if (statementVerified) {
+      const consequent = Consequent.fromStatementNode(statementNode);
 
       consequents.push(consequent);
 

package/src/verify/declaration/metavariable.js

@@ -5,7 +5,7 @@ import MetavariableAssignment from "../../assignment/metavariable";
 
 import { first } from "../../utilities/array";
 import { nodeQuery } from "../../utilities/query";
-import { nameFromMetavariableNode } from "../../utilities/name";
+import { metavariableNameFromMetavariableNode } from "../../utilities/name";
 
 const termNodeQuery = nodeQuery("/argument/term"),
       typeNodeQuery = nodeQuery("/argument/type"),
@@ -70,8 +70,9 @@ function verifyMetavariable(metavariableNode, metaTypeNode, fileContext) {
         termType = firstTermType; ///
       }
 
-      const node = metavariableNode,  ///
-            name = nameFromMetavariableNode(metavariableNode),
+      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+            node = metavariableNode,  ///
+            name = metavariableName,  ///
             metavariable = Metavariable.fromNodeNameTermTypeAndMetaType(node, name, termType, metaType),
             metavariableAssignment = MetavariableAssignment.fromMetavariable(metavariable),
             metavariableAssigned = metavariableAssignment.assign(fileContext);

package/src/verify/declaration.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "../shim";
 import Declaration from "../declaration"
 import referenceMetaType from "../metaType/reference";
 
@@ -8,20 +9,20 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/declaration/statement!"),
       metavariableNodeQuery = nodeQuery("/declaration/metavariable!");
 
-export default function verifyDeclaration(declarationNode, assignments, derived, localContext) {
+const verifyDeclarationFunctions = [
+  verifyDerivedDeclaration,
+  verifyStatedDeclaration
+];
+
+export default function verifyDeclaration(declarationNode, declarations, stated, localContext) {
   let declarationVerified;
 
   const declarationString = localContext.nodeAsString(declarationNode);
 
   localContext.trace(`Verifying the '${declarationString}' declaration...`, declarationNode);
 
-  const verifyDeclarationFunctions = [
-    verifyDerivedDeclaration,
-    verifyStatedDeclaration
-  ];
-
   declarationVerified = verifyDeclarationFunctions.some((verifyDeclarationFunction) => {
-    const declarationVerified = verifyDeclarationFunction(declarationNode, assignments, derived, localContext);
+    const declarationVerified = verifyDeclarationFunction(declarationNode, declarations, stated, localContext);
 
     if (declarationVerified) {
       return true;
@@ -35,32 +36,54 @@ export default function verifyDeclaration(declarationNode, assignments, derived,
   return declarationVerified;
 }
 
-function verifyStatedDeclaration(declarationNode, declarations, localContext) {
-  let statedDeclarationVerified = false;
+function verifyDerivedDeclaration(declarationNode, declarations, stated, localContext) {
+  let derivedDeclarationVerified;
 
-  const declarationString = localContext.nodeAsString(declarationNode);
+  if (!stated) {
+    const declarationString = localContext.nodeAsString(declarationNode);
 
-  localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
+    localContext.trace(`Verifying the '${declarationString}' derived declaration...`, declarationNode);
 
-  const metavariableNode = metavariableNodeQuery(declarationNode),
-        metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    debugger
 
-  if (metavariableVerified) {
-    const statementNode = statementNodeQuery(declarationNode);
+    if (derivedDeclarationVerified) {
+      localContext.debug(`...verified the '${declarationString}' derived declaration.`, declarationNode);
+    }
+  }
 
-    debugger
+  return derivedDeclarationVerified;
+}
+
+function verifyStatedDeclaration(declarationNode, declarations, stated, localContext) {
+  let statedDeclarationVerified = false;
+
+  if (stated) {
+    const declarationString = localContext.nodeAsString(declarationNode);
+
+    localContext.trace(`Verifying the '${declarationString}' stated declaration...`, declarationNode);
 
-    if (statementVerified) {
-      const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+    const metavariableNode = metavariableNodeQuery(declarationNode),
+          metavariableVerified = verifyMetavariable(metavariableNode, localContext);
 
-      declarations.push(declaration);
+    if (metavariableVerified) {
+      const { verifyStatement } = shim,
+            stated = true,
+            assignments = [],
+            statementNode = statementNodeQuery(declarationNode),
+            statementVerified = verifyStatement(statementNode, assignments, stated, localContext);
 
-      statedDeclarationVerified = true;
+      if (statementVerified) {
+        const declaration = Declaration.fromMetavariableNodeAndStatementNode(metavariableNode, statementNode);
+
+        declarations.push(declaration);
+
+        statedDeclarationVerified = true;
+      }
     }
-  }
 
-  if (statedDeclarationVerified) {
-    localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
+    if (statedDeclarationVerified) {
+      localContext.debug(`...verified the '${declarationString}' stated declaration.`, declarationNode);
+    }
   }
 
   return statedDeclarationVerified;

package/src/verify/equality.js

@@ -8,20 +8,20 @@ import { nodesQuery } from "../utilities/query";
 
 const termNodesQuery = nodesQuery("/equality/term");
 
-export default function verifyEquality(equalityNode, assignments, derived, localContext) {
+const verifyEqualityFunctions = [
+  verifyDerivedEquality,
+  verifyStatedEquality
+];
+
+export default function verifyEquality(equalityNode, assignments, stated, localContext) {
   let equalityVerified;
 
   const equalityString = localContext.nodeAsString(equalityNode);
 
   localContext.trace(`Verifying the '${equalityString}' equality...`, equalityNode);
 
-  const verifyEqualityFunctions = [
-    verifyDerivedEquality,
-    verifyStatedEquality
-  ];
-
   equalityVerified = verifyEqualityFunctions.some((verifyEqualityFunction) => {
-    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, derived, localContext);
+    const equalityVerified = verifyEqualityFunction(equalityNode, assignments, stated, localContext);
 
     if (equalityVerified) {
       return true;
@@ -35,13 +35,13 @@ export default function verifyEquality(equalityNode, assignments, derived, local
   return equalityVerified;
 }
 
-function verifyDerivedEquality(equalityNode, assignments, derived, localContext) {
+function verifyDerivedEquality(equalityNode, assignments, stated, localContext) {
   let derivedEqualityVerified = false;
 
-  if (derived) {
+  if (!stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
-    localContext.trace(`Verifying the '${equalityString}' derived equality...`, equalityNode);
+    localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);
 
     const terms = [],
           termNodes = termNodesQuery(equalityNode),
@@ -69,17 +69,17 @@ function verifyDerivedEquality(equalityNode, assignments, derived, localContext)
     derivedEqualityVerified = termsVerified; ///
 
     if (derivedEqualityVerified) {
-      localContext.debug(`...verified the '${equalityString}' derived equality.`, equalityNode);
+      localContext.debug(`...verified the '${equalityString}' stated equality.`, equalityNode);
     }
   }
 
   return derivedEqualityVerified;
 }
 
-function verifyStatedEquality(equalityNode, assignments, derived, localContext) {
+function verifyStatedEquality(equalityNode, assignments, stated, localContext) {
   let statedEqualityVerified = false;
 
-  if (!derived) {
+  if (stated) {
     const equalityString = localContext.nodeAsString(equalityNode);
 
     localContext.trace(`Verifying the '${equalityString}' stated equality...`, equalityNode);

package/src/verify/frame.js

@@ -10,20 +10,20 @@ import { nodesQuery } from "../utilities/query";
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable");
 
-export default function verifyFrame(frameNode, assignments, derived, localContext) {
+const verifyFrameFunctions = [
+  verifyDerivedFrame,
+  verifyStatedFrame
+];
+
+export default function verifyFrame(frameNode, frames, stated, localContext) {
   let frameVerified;
 
   const frameString = localContext.nodeAsString(frameNode);
 
   localContext.trace(`Verifying the '${frameString}' frame...`, frameNode);
 
-  const verifyFrameFunctions = [
-    verifyDerivedFrame,
-    verifyStatedFrame
-  ];
-
   frameVerified = verifyFrameFunctions.some((verifyFrameFunction) => {
-    const frameVerified = verifyFrameFunction(frameNode, assignments, derived, localContext);
+    const frameVerified = verifyFrameFunction(frameNode, frames, stated, localContext);
 
     if (frameVerified) {
       return true;
@@ -37,37 +37,57 @@ export default function verifyFrame(frameNode, assignments, derived, localContex
   return frameVerified;
 }
 
-function verifyStatedFrame(frameNode, frames, assignments, derived, localContext) {
+function verifyDerivedFrame(frameNode, frames, stated, localContext) {
+  let derivedFrameVerified;
+
+  if (!stated) {
+    const frameString = localContext.nodeAsString(frameNode);
+
+    localContext.trace(`Verifying the '${frameString}' derived frame...`, frameNode);
+
+    debugger
+
+    if (derivedFrameVerified) {
+      localContext.debug(`...verified the '${frameString}' derived frame.`, frameNode);
+    }
+  }
+
+  return derivedFrameVerified;
+}
+
+function verifyStatedFrame(frameNode, frames, stated, localContext) {
   let statedFrameVerified;
 
-  const frameString = localContext.nodeAsString(frameNode);
+  if (stated) {
+    const frameString = localContext.nodeAsString(frameNode);
 
-  localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
+    localContext.trace(`Verifying the '${frameString}' stated frame...`, frameNode);
 
-  const declarations = [],
-        declarationNodes = declarationNodesQuery(frameNode),
-        metavariableNodes = metavariableNodesQuery(frameNode),
-        declarationsVerified = declarationNodes.every((declarationNode) => {
-          const declarationVerified = verifyDeclaration(declarationNode, declarations, localContext);
+    const declarations = [],
+          declarationNodes = declarationNodesQuery(frameNode),
+          metavariableNodes = metavariableNodesQuery(frameNode),
+          declarationsVerified = declarationNodes.every((declarationNode) => {
+            const declarationVerified = verifyDeclaration(declarationNode, declarations, stated, localContext);
 
-          return declarationVerified;
-        }),
-        metavariablesVerified = metavariableNodes.every((metavariableNode) => {
-          const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
+            return declarationVerified;
+          }),
+          metavariablesVerified = metavariableNodes.every((metavariableNode) => {
+            const metavariableVerified = verifyMetavariable(metavariableNode, declarations, localContext);
 
-          return metavariableVerified;
-        });
+            return metavariableVerified;
+          });
 
-  if (declarationsVerified && metavariablesVerified) {
-    const frame = Frame.fromDeclarations(declarations);
+    if (declarationsVerified && metavariablesVerified) {
+      const frame = Frame.fromDeclarations(declarations);
 
-    frames.push(frame);
+      frames.push(frame);
 
-    statedFrameVerified = true;
-  }
+      statedFrameVerified = true;
+    }
 
-  if (statedFrameVerified) {
-    localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
+    if (statedFrameVerified) {
+      localContext.debug(`...verified the '${frameString}' stated frame.`, frameNode);
+    }
   }
 
   return statedFrameVerified;