occam-verify-cli 0.0.1089 → 0.0.1091

package/src/assertion/type.js

@@ -29,23 +29,23 @@ export default class TypeAssertion {
     return this.type;
   }
 
-  verify(assignments, stated, localContext) {
+  verify(assignments, stated, context) {
     let verified = false;
 
     let typeAssertionString = this.string;  ///
 
-    localContext.trace(`Verifying the '${typeAssertionString}' type assertion...`);
+    context.trace(`Verifying the '${typeAssertionString}' type assertion...`);
 
-    const typeVerified = this.verifyType(localContext);
+    const typeVerified = this.verifyType(context);
 
     if (typeVerified) {
       let verifiedWhenStated = false,
           verifiedWhenDerived = false;
 
       if (stated) {
-        verifiedWhenStated = this.verifyWhenStated(assignments, localContext);
+        verifiedWhenStated = this.verifyWhenStated(assignments, context);
       } else {
-        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+        verifiedWhenDerived = this.verifyWhenDerived(context);
       }
 
       if (verifiedWhenStated || verifiedWhenDerived) {
@@ -54,13 +54,13 @@ export default class TypeAssertion {
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${typeAssertionString}' type assertion.`);
+      context.debug(`...verified the '${typeAssertionString}' type assertion.`);
     }
 
     return verified;
   }
 
-  verifyType(localContext) {
+  verifyType(context) {
     let typeVerified;
 
     if (this.type === objectType) {
@@ -68,34 +68,34 @@ export default class TypeAssertion {
     } else {
       const typeName = this.type.getName();
 
-      localContext.trace(`Verifying the '${typeName}' type...`);
+      context.trace(`Verifying the '${typeName}' type...`);
 
-      const type = localContext.findTypeByTypeName(typeName);
+      const type = context.findTypeByTypeName(typeName);
 
       if (type !== null) {
         this.type = type;
 
         typeVerified = true;
       } else {
-        localContext.debug(`The '${typeName}' type is missing.`);
+        context.debug(`The '${typeName}' type is missing.`);
       }
 
       if (typeVerified) {
-        localContext.debug(`...verified the '${typeName}' type.`);
+        context.debug(`...verified the '${typeName}' type.`);
       }
     }
 
     return typeVerified;
   }
 
-  verifyWhenStated(assignments, localContext) {
+  verifyWhenStated(assignments, context) {
     let verifiedWhenStated = false;
 
     const typeAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
+    context.trace(`Verifying the '${typeAssertionString}' stated type assertion...`);
 
-    const termVerified = this.term.verify(localContext, () => {
+    const termVerified = this.term.verify(context, () => {
       let verifiedAhead;
 
       const termType = this.term.getType(),
@@ -113,7 +113,7 @@ export default class TypeAssertion {
         const { Variable } = shim,
               termNode = this.term.getNode(),
               variableNode = variableNodeQuery(termNode),
-              variable = Variable.fromVariableNodeAndType(variableNode, this.type, localContext);
+              variable = Variable.fromVariableNodeAndType(variableNode, this.type, context);
 
         if (variable !== null) {
           const variableAssignment = VariableAssignment.fromVariable(variable),
@@ -127,20 +127,20 @@ export default class TypeAssertion {
     }
 
     if (verifiedWhenStated) {
-      localContext.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
+      context.debug(`...verified the '${typeAssertionString}' stated type assertion.`);
     }
 
     return verifiedWhenStated;
   }
 
-  verifyWhenDerived(localContext) {
+  verifyWhenDerived(context) {
     let verifiedWhenDerived;
 
     const typeAssertionString = this.string; ///
 
-    localContext.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
+    context.trace(`Verifying the '${typeAssertionString}' derived type assertion...`);
 
-    const termVerified = this.term.verify(localContext, () => {
+    const termVerified = this.term.verify(context, () => {
       let verifiedAhead;
 
       const termType = this.term.getType(),
@@ -154,21 +154,21 @@ export default class TypeAssertion {
     verifiedWhenDerived = termVerified; ///
 
     if (verifiedWhenDerived) {
-      localContext.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
+      context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
     }
 
     return verifiedWhenDerived;
   }
 
-  static fromTypeAssertionNode(typeAssertionNode, localContext) {
+  static fromTypeAssertionNode(typeAssertionNode, context) {
     let typeAssertion = null;
 
     if (typeAssertionNode !== null) {
       const { Term, Type } = shim,
             termNode = termNodeQuery(typeAssertionNode),
             typeNode = typeNodeQuery(typeAssertionNode),
-            term = Term.fromTermNode(termNode, localContext),
-            type = Type.fromTypeNode(typeNode, localContext),
+            term = Term.fromTermNode(termNode, context),
+            type = Type.fromTypeNode(typeNode, context),
             string = stringFromTermAndType(term, type);
 
       typeAssertion = new TypeAssertion(string, term, type);

package/src/assignment/equality.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import local from "../context/local";
-
 export default class EqualityAssignment {
   constructor(equality) {
     this.equality = equality;
@@ -11,14 +9,14 @@ export default class EqualityAssignment {
     return this.equality;
   }
 
-  assign(localContext) {
-    const equalityAdded = localContext.addEquality(this.equality, localContext),
+  assign(context) {
+    const equalityAdded = context.addEquality(this.equality, context),
           equalityString = this.equality.getString(),
           equalityAssigned = equalityAdded; ///
 
     equalityAssigned ?
-      localContext.trace(`Assigned the '${equalityString}' equality.`) :
-        localContext.debug(`Unable to assign the '${equalityString}' equality.`);
+      context.trace(`Assigned the '${equalityString}' equality.`) :
+        context.debug(`Unable to assign the '${equalityString}' equality.`);
 
     return equalityAssigned;
   }

package/src/assignment/judgement.js

@@ -9,14 +9,14 @@ export default class JudgementAssignment {
     return this.judgement;
   }
 
-  assign(localContext) {
-    const judgementAdded = localContext.addJudgement(this.judgement),
+  assign(context) {
+    const judgementAdded = context.addJudgement(this.judgement),
           judgementString = this.judgement.getString(),
           judgementAssigned = judgementAdded; ///
 
     judgementAssigned ?
-      localContext.trace(`Assigned the '${judgementString}' judgement.`) :
-        localContext.debug(`Unable to assign the '${judgementString}' judgement.`);
+      context.trace(`Assigned the '${judgementString}' judgement.`) :
+        context.debug(`Unable to assign the '${judgementString}' judgement.`);
 
     return judgementAssigned;
   }

package/src/assignment/variable.js

@@ -9,17 +9,17 @@ export default class VariableAssignment {
     return this.variable;
   }
 
-  assign(localContext) {
+  assign(context) {
     const nested = false,
-          variableAdded = localContext.addVariable(this.variable, nested),
+          variableAdded = context.addVariable(this.variable, nested),
           variableType = this.variable.getType(),
           variableString = this.variable.getString(),
           variableTypeName = variableType.getName(),
           variableAssigned = variableAdded; ///
 
     variableAssigned ?
-      localContext.trace(`Assigned the '${variableString}' variable with type '${variableTypeName}'.`) :
-        localContext.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeName}'.`);
+      context.trace(`Assigned the '${variableString}' variable with type '${variableTypeName}'.`) :
+        context.debug(`Unable to assign the '${variableString}' variable with type '${variableTypeName}'.`);
 
     return variableAssigned;
   }

package/src/combinator/bracketed.js

@@ -33,7 +33,7 @@ const lexer = nominalLexer, ///
 
         return string;
       },
-      localContext = {
+      context = {
         nodeAsTokens,
         nodeAsString,
         tokensAsString
@@ -44,7 +44,7 @@ export const bracketedStatementNode = statementNode;  ///
 export default class BracketedCombinator extends Combinator {
   static fromNothing() {
     const { Statement } = shim,
-          statement = Statement.fromStatementNode(statementNode, localContext),
+          statement = Statement.fromStatementNode(statementNode, context),
           bracketedCombinator = new BracketedCombinator(statement);
 
     return bracketedCombinator;

package/src/conclusion.js

@@ -26,46 +26,45 @@ class Conclusion {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  unifyStatement(statement, substitutions, localContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnified;
 
-    const statementString = statement.getString(),
-          conclusionString = this.getString();
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext, ///
+          specificContext = context; ///
 
-    const localContextB = localContext; ///
+    const conclusion = this,  ///
+          statementString = statement.getString(),
+          conclusionString = conclusion.getString();
 
-    localContext = LocalContext.fromFileContext(this.fileContext);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
 
-    const localContextA = localContext; ///
-
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${conclusionString}' conclusion...`);
-
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${conclusionString}' conclusion.`);
     }
 
     return statementUnified;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified = false;
 
     const conclusionString = this.getString();  ///
 
-    localContext.trace(`Verifying the '${conclusionString}' conclusion...`);
+    context.trace(`Verifying the '${conclusionString}' conclusion...`);
 
     const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
 
     if (unqualifiedStatementVerified) {
       verified = true;
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${conclusionString}' conclusion.`);
+      context.debug(`...verified the '${conclusionString}' conclusion.`);
     }
 
     return verified;

package/src/consequent.js

@@ -26,46 +26,45 @@ class Consequent {
 
   getStatement() { return this.unqualifiedStatement.getStatement(); }
 
-  unifyStatement(statement, substitutions, localContext) {
+  unifyStatement(statement, substitutions, context) {
     let statementUnified;
 
-    const statementString = statement.getString(),
-          consequentString = this.getString();
+    const localContext = LocalContext.fromFileContext(this.fileContext),
+          generalContext = localContext, ///
+          specificContext = context; ///
 
-    const localContextB = localContext; ///
+    const consequent = this,  ///
+          statementString = statement.getString(),
+          consequentString = consequent.getString();
 
-    localContext = LocalContext.fromFileContext(this.fileContext);
+    specificContext.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
 
-    const localContextA = localContext; ///
-
-    localContextB.trace(`Unifying the '${statementString}' statement with the '${consequentString}' consequent...`);
-
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, generalContext, specificContext);
 
     if (statementUnified) {
-      localContextB.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
+      specificContext.debug(`...unified the '${statementString}' statement with the '${consequentString}' consequent.`);
     }
 
     return statementUnified;
   }
 
-  verify(localContext) {
+  verify(context) {
     let verified = false;
 
     const consequentString = this.getString();  ///
 
-    localContext.trace(`Verifying the '${consequentString}' consequent...`);
+    context.trace(`Verifying the '${consequentString}' consequent...`);
 
     const stated = true,
           assignments = [],
-          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, localContext);
+          unqualifiedStatementVerified = this.unqualifiedStatement.verify(assignments, stated, context);
 
     if (unqualifiedStatementVerified) {
       verified = true;
     }
 
     if (verified) {
-      localContext.debug(`...verified the '${consequentString}' consequent.`);
+      context.debug(`...verified the '${consequentString}' consequent.`);
     }
 
     return verified;

package/src/constructor/bracketed.js

@@ -34,7 +34,7 @@ const lexer = nominalLexer, ///
 
         return string;
       },
-      localContext = {
+      context = {
         nodeAsTokens,
         nodeAsString,
         tokensAsString
@@ -45,7 +45,7 @@ export const bracketedTermNode = termNode;  ///
 export default class BracketedConstructor extends Constructor {
   static fromNothing() {
     const { Term } = shim,
-          term = Term.fromTermNode(termNode, localContext),
+          term = Term.fromTermNode(termNode, context),
           type = null,
           string = stringFromTermAndType(term, type),
           bracketedConstructor = new BracketedConstructor(string, term);

package/src/constructor.js

@@ -68,9 +68,10 @@ class Constructor {
     const { Term, Type } = shim,
           termNode = termNodeQuery(constructorDeclarationNode),
           typeNode = typeNodeQuery(constructorDeclarationNode),
-          type = Type.fromTypeNode(typeNode),
           localContext = LocalContext.fromFileContext(fileContext),
-          term = Term.fromTermNodeAndType(termNode, type, localContext),
+          context = localContext, ///
+          type = Type.fromTypeNode(typeNode),
+          term = Term.fromTermNodeAndType(termNode, type, context),
           string = stringFromTermAndType(term, type),
           constructor = new Constructor(string, term);
 

package/src/context/file.js

@@ -2,6 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
+import LocalContext from "./local";
 import metavariableUnifier from "../unifier/metavariable";
 
 import { objectType } from "../type";
@@ -29,6 +30,7 @@ import { typesFromJSON,
          constructorsToConstructorsJSON,
          metatheoremsToMetatheoremsJSON,
          metavariablesToMetavariablesJSON } from "../utilities/json";
+import local from "./local";
 
 const { push } = arrayUtilities;
 
@@ -396,8 +398,8 @@ export default class FileContext {
     return metavariablePresent;
   }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
-    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+  isMetavariablePresentByMetavariableNode(metavariableNode, specificContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, specificContext),
           metavariablePresent = (metavariable !== null);
 
     return metavariablePresent;
@@ -459,41 +461,39 @@ export default class FileContext {
     return theorem;
   }
 
-  findMetaLemmaByReference(reference) {
-    const metaLemmas = this.getMetaLemmas(),
+  findConjectureByReference(reference) {
+    const conjectures = this.getConjectures(),
           metavariableNode = reference.getMetavariableNode(),
-          metaLemma = metaLemmas.find((metaLemma) => {
-            const metavariableNodeMatches = metaLemma.matchMetavariableNode(metavariableNode);
+          conjecture = conjectures.find((conjecture) => {
+            const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
 
             if (metavariableNodeMatches) {
               return true;
             }
           }) || null;
 
-    return metaLemma;
+    return conjecture;
   }
 
-  findConjectureByReference(reference) {
-    const conjectures = this.getConjectures(),
-          metavariableNode = reference.getMetavariableNode(),
-          conjecture = conjectures.find((conjecture) => {
-            const metavariableNodeMatches = conjecture.matchMetavariableNode(metavariableNode);
+  findMetaLemmaByReference(reference, specificContext) {
+    const metaLemmas = this.getMetaLemmas(),
+          metaLemma = metaLemmas.find((metaLemma) => {
+            const referenceUnified = metaLemma.unifyReference(reference, specificContext);
 
-            if (metavariableNodeMatches) {
+            if (referenceUnified) {
               return true;
             }
           }) || null;
 
-    return conjecture;
+    return metaLemma;
   }
 
-  findMetatheoremByReference(reference) {
+  findMetatheoremByReference(reference, specificContext) {
     const metatheorems = this.getMetatheorems(),
-          metavariableNode = reference.getMetavariableNode(),
           metatheorem = metatheorems.find((metatheorem) => {
-            const metavariableNodeMatches = metatheorem.matchMetavariableNode(metavariableNode);
+            const referenceUnified = metatheorem.unifyReference(reference, specificContext);
 
-            if (metavariableNodeMatches) {
+            if (referenceUnified) {
               return true;
             }
           }) || null;
@@ -541,13 +541,14 @@ export default class FileContext {
     return metavariable;
   }
 
-  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+  findMetavariableByMetavariableNode(metavariableNode, specificContext) {
     const metavariableNodeB = metavariableNode, ///
+          generalContext = this,  ///
           metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
             const metavariableA = metavariable, ///
                   metavariableNodeA = metavariableA.getNode(), ///
-                  metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
+                  metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, generalContext, specificContext);
 
             if (metavariableUnified) {
               return true;
@@ -585,15 +586,15 @@ export default class FileContext {
     return conjecturePresent;
   }
 
-  isMetaLemmaPresentByReference(reference) {
-    const metaLemma = this.findMetaLemmaByReference(reference),
+  isMetaLemmaPresentByReference(reference, specificContext) {
+    const metaLemma = this.findMetaLemmaByReference(reference, specificContext),
           metaLemmaPresent = (metaLemma !== null);
 
     return metaLemmaPresent;
   }
 
-  isMetatheoremPresentByReference(reference) {
-    const metatheorem = this.findMetatheoremByReference(reference),
+  isMetatheoremPresentByReference(reference, specificContext) {
+    const metatheorem = this.findMetatheoremByReference(reference, specificContext),
           metatheoremPresent = (metatheorem !== null);
 
     return metatheoremPresent;
@@ -729,7 +730,7 @@ export default class FileContext {
     this.metavariables = metavariablesFromJSON(json, fileContext);
   }
 
-  reset() {
+  clear() {
     this.types = [];
     this.rules = [];
     this.axioms = [];

package/src/context/local.js

@@ -105,7 +105,7 @@ class LocalContext {
 
   getConstructors() { return this.context.getConstructors(); }
 
-  addEquality(equality, localContext) {
+  addEquality(equality, context) {
     let equalityAdded;
 
     const equalityReflexive = equality.isReflexive();
@@ -123,15 +123,15 @@ class LocalContext {
       } else if ((leftEquivalence === null) && (rightEquivalence === null)) {
         const equivalence = Equivalence.fromLeftTermAndRightTerm(leftTerm, rightTerm);
 
-        this.addEquivalence(equivalence, localContext);
+        this.addEquivalence(equivalence, context);
 
         equalityAdded = true;
       } else if ((leftEquivalence !== null) && (rightEquivalence === null)) {
-        leftEquivalence.addTerm(rightTerm, localContext);
+        leftEquivalence.addTerm(rightTerm, context);
 
         equalityAdded = true;
       } else if ((leftEquivalence === null) && (rightEquivalence !== null)) {
-        rightEquivalence.addTerm(leftTerm, localContext);
+        rightEquivalence.addTerm(leftTerm, context);
 
         equalityAdded = true;
       } else if ((leftEquivalence !== null) && (rightEquivalence !== null)) {
@@ -149,9 +149,9 @@ class LocalContext {
           this.addEquivalence(equivalence);
         }
 
-        equivalence.addTerm(leftTerm, localContext);
+        equivalence.addTerm(leftTerm, context);
 
-        equivalence.addTerm(rightTerm, localContext);
+        equivalence.addTerm(rightTerm, context);
 
         equalityAdded = true;
       }
@@ -179,10 +179,10 @@ class LocalContext {
     this.proofSteps.push(proofStep);
   }
 
-  addEquivalence(equivalence, localContext) {
+  addEquivalence(equivalence, context) {
     const equivalenceString = equivalence.asString();
 
-    localContext.trace(`Added the '${equivalenceString}' equivalence.`);
+    context.trace(`Added the '${equivalenceString}' equivalence.`);
 
     this.equivalences.push(equivalence);
   }
@@ -273,7 +273,7 @@ class LocalContext {
 
   isLabelPresentByMetavariableNode(metavariableNode) { return this.context.isLabelPresentByMetavariableNode(metavariableNode); }
 
-  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode, localContext); }
+  isMetavariablePresentByMetavariableNode(metavariableNode, specificContext) { return this.context.isMetavariablePresentByMetavariableNode(metavariableNode, specificContext); }
 
   isVariablePresentByVariableName(variableName, nested = true) {
     const variable = this.findVariableByVariableName(variableName, nested),
@@ -300,7 +300,7 @@ class LocalContext {
 
   findLabelByMetavariableNode(metavariableNode) { return this.context.findLabelByMetavariableNode(metavariableNode); }
 
-  findMetavariableByMetavariableNode(metavariableNode, localContext) { return this.context.findMetavariableByMetavariableNode(metavariableNode, localContext); }
+  findMetavariableByMetavariableNode(metavariableNode, specificContext) { return this.context.findMetavariableByMetavariableNode(metavariableNode, specificContext); }
 
   findVariableByVariableName(variableName, nested = true) {
     const variables = this.getVariables(nested),
@@ -338,11 +338,11 @@ class LocalContext {
 
   findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
 
-  findMetaLemmaByReference(reference) { return this.context.findMetaLemmaByReference(reference); }
-
   findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
 
-  findMetatheoremByReference(reference) { return this.context.findMetatheoremByReference(reference); }
+  findMetaLemmaByReference(reference, specificContext) { return this.context.findMetaLemmaByReference(reference, specificContext); }
+
+  findMetatheoremByReference(reference, specificContext) { return this.context.findMetatheoremByReference(reference, specificContext); }
 
   isAxiomPresentByReference(reference) { return this.context.isAxiomPresentByReference(reference); }
 
@@ -352,9 +352,9 @@ class LocalContext {
 
   isConjecturePresentByReference(reference) { return this.context.isConjecturePresentByReference(reference); }
 
-  isMetaLemmaPresentByReference(reference) { return this.context.isMetaLemmaPresentByReference(reference); }
+  isMetaLemmaPresentByReference(reference, specificContext) { return this.context.isMetaLemmaPresentByReference(reference, specificContext); }
 
-  isMetatheoremPresentByReference(reference) { return this.context.isMetatheoremPresentByReference(reference); }
+  isMetatheoremPresentByReference(reference, specificContext) { return this.context.isMetatheoremPresentByReference(reference, specificContext); }
 
   nodeAsString(node, tokens = null) {
     if (tokens === null) {
@@ -408,9 +408,8 @@ class LocalContext {
 
   error(message, node) { this.context.error(message, node); }
 
-  static fromFileContext(fileContext) {
-    const context = fileContext,  ///
-          tokens = null,
+  static fromContext(context) {
+    const tokens = null,
           variables = [],
           proofSteps = [],
           judgements = [],
@@ -420,15 +419,14 @@ class LocalContext {
     return localContext;
   }
 
-  static fromLocalContext(localContext) {
-    const context = localContext,  ///
+  static fromFileContext(fileContext) {
+    const context = fileContext,  ///
           tokens = null,
           variables = [],
           proofSteps = [],
           judgements = [],
-          equivalences = [];
-
-    localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);  ///
+          equivalences = [],
+          localContext = new LocalContext(context, tokens, variables, proofSteps, judgements, equivalences);
 
     return localContext;
   }

package/src/context/release.js

@@ -510,11 +510,13 @@ function verifyFileContext(fileContext) {
   if (node !== null) {
     fileContext.debug(`Verifying the '${filePath}' file...`);
 
-    fileContext.reset();
-
     const verifiedAtTopLevel = topLevelVerifier.verify(node, fileContext);
 
-    fileContextVerified = verifiedAtTopLevel; ///
+    if (verifiedAtTopLevel) {
+      fileContextVerified = true;
+    } else {
+      fileContext.clear();
+    }
 
     if (fileContextVerified) {
       fileContext.info(`...verified the '${filePath}' file.`);