occam-verify-cli 0.0.1074 → 0.0.1077

package/src/assertion/contained.js

@@ -45,13 +45,13 @@ export default class ContainedAssertion {
 
     localContext.trace(`Verifying the '${containedAssertionString}' contained assertion...`);
 
-    stated = true;
+    stated = true;  ///
 
     assignments = null; ///
 
-    let termVerified = true,  ///
-        frameVerified = true, ///
-        statementVerified;
+    let termVerified = true,
+        frameVerified = true,
+        statementVerified = true;
 
     if (this.term !== null) {
       termVerified = this.term.verify(localContext, () => {
@@ -65,7 +65,9 @@ export default class ContainedAssertion {
       frameVerified = this.frame.verify(assignments, stated, localContext);
     }
 
-    statementVerified = this.statement.verify(assignments, stated, localContext);
+    if (this.statement !== null) {
+      statementVerified = this.statement.verify(assignments, stated, localContext);
+    }
 
     if (termVerified && frameVerified && statementVerified) {
       let verifiedWhenStated = false,

package/src/assertion/defined.js

@@ -44,8 +44,8 @@ export default class DefinedAssertion {
 
     assignments = null; ///
 
-    let termVerified = true,  ///
-        frameVerified = true; ///
+    let termVerified = true,
+        frameVerified = true;
 
     if (this.term !== null) {
       termVerified = this.term.verify(localContext, () => {

package/src/assertion/subproof.js

@@ -5,7 +5,6 @@ import { arrayUtilities } from "necessary";
 import shim from "../shim";
 import LocalContext from "../context/local";
 import metaLevelUnifier from "../unifier/metaLevel";
-import metaLevelVerifier from "../verifier/metaLevel";
 
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
@@ -33,6 +32,39 @@ export default class SubproofAssertion {
     return this.statements;
   }
 
+  unifySubproof(subproof, substitutions, fileContext, localContext) {
+    let subproofUnified;
+
+    const subproofString = subproof.getString(),
+          subproofAssertionString = this.string;  ///
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+
+    const subproofStatements = subproof.getStatements(),
+          subproofAssertionStatements = this.statements;  ///
+
+    subproofUnified = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
+      const subproofAssertionStatementNode = subproofAssertionStatement.getNode(),
+            subproofStatementNode = subproofStatement.getNode(),
+            nodeA = subproofAssertionStatementNode,  ///
+            nodeB = subproofStatementNode,  ///
+            fileContextA = fileContext,  ///
+            localContextA = LocalContext.fromFileContext(fileContextA),
+            localContextB = localContext, ///
+            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+      if (unifiedAtMetaLevel) {
+        return true;
+      }
+    });
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return subproofUnified;
+  }
+
   verify(assignments, stated, localContext) {
     let verified;
 
@@ -40,24 +72,31 @@ export default class SubproofAssertion {
 
     localContext.trace(`Verifying the '${subproofAssertionString}' subproof assertion...`);
 
-    let verifiedWhenStated = false,
-        verifiedWhenDerived = false;
+    stated = true;  ///
 
-    if (stated) {
-      verifiedWhenStated = this.verifyWhenStated(localContext);
-    } else {
-      verifiedWhenDerived = this.verifyWhenDerived(localContext);
-    }
+    assignments = null; ///
 
-    if (verifiedWhenStated || verifiedWhenDerived) {
-      assignments = null; ///
+    const statementsVerified = this.statements.map((statement) => {
+      const statementVerified = statement.verify(assignments, stated, localContext);
 
-      stated = true;  ///
+      if (statementVerified) {
+        return true;
+      }
+    });
+
+    if (statementsVerified) {
+      let verifiedWhenStated = false,
+          verifiedWhenDerived = false;
 
-      const subproofAssertionNode = this.node,  ///
-            verifiedAtMetaLevel = metaLevelVerifier.verify(subproofAssertionNode, assignments, stated, localContext);
+      if (stated) {
+        verifiedWhenStated = this.verifyWhenStated(localContext);
+      } else {
+        verifiedWhenDerived = this.verifyWhenDerived(localContext);
+      }
 
-      verified = verifiedAtMetaLevel; ///
+      if (verifiedWhenStated || verifiedWhenDerived) {
+        verified = true; ///
+      }
     }
 
     if (verified) {
@@ -90,42 +129,22 @@ export default class SubproofAssertion {
 
     localContext.trace(`Verifying the '${subproofAssertionString}' derived subproof assertion...`);
 
-    derivedSubproofAssertionVerified = false;
+    const proofSteps = localContext.getProofSteps();
 
-    localContext.debug(`The '${subproofAssertionString}' derived subproof assertion cannot be verified.`);
-
-    return derivedSubproofAssertionVerified;
-  }
-
-  unifySubproof(subproof, substitutions, fileContext, localContext) {
-    let subproofUnified;
-
-    const subproofString = subproof.getString(),
-          subproofStatements = subproof.getStatements(),
-          subproofAssertionString = this.string;  ///
+    derivedSubproofAssertionVerified = proofSteps.some((proofStep) => {
+      const subproofAssertion = this,
+            subproofAssertionUnified = proofStep.unifySubproofAssertion(subproofAssertion, localContext);
 
-    localContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
-
-    subproofUnified = match(this.statements, subproofStatements, (statement, subproofStatement) => {
-      const statementNode = statement.getNode(),
-            subproofStatementNode = subproofStatement.getNode(),
-            nodeA = statementNode,  ///
-            nodeB = subproofStatementNode,  ///
-            fileContextA = fileContext,  ///
-            localContextA = LocalContext.fromFileContext(fileContextA),
-            localContextB = localContext, ///
-            unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-      if (unifiedAtMetaLevel) {
+      if (subproofAssertionUnified) {
         return true;
       }
     });
 
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+    if (derivedSubproofAssertionVerified) {
+      localContext.debug(`...verified the '${subproofAssertionString}' derived subproof assertion.`);
     }
 
-    return subproofUnified;
+    return derivedSubproofAssertionVerified;
   }
 
   static fromStatementNode(statementNode, localContext) {

package/src/assertion/type.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import shim from "../shim";
-import Variable from "../variable";
 import VariableAssignment from "../assignment/variable";
 
 import { nodeQuery } from "../utilities/query";
@@ -111,7 +110,8 @@ export default class TypeAssertion {
 
     if (termVerified) {
       if (assignments !== null) {
-        const termNode = this.term.getNode(),
+        const { Variable } = shim,
+              termNode = this.term.getNode(),
               variableNode = variableNodeQuery(termNode),
               variable = Variable.fromVariableNodeAndType(variableNode, this.type, localContext);
 

package/src/assignment/variable.js

@@ -10,7 +10,8 @@ export default class VariableAssignment {
   }
 
   assign(localContext) {
-    const variableAdded = localContext.addVariable(this.variable),
+    const nested = false,
+          variableAdded = localContext.addVariable(this.variable, nested),
           variableType = this.variable.getType(),
           variableString = this.variable.getString(),
           variableTypeName = variableType.getName(),

package/src/axiom.js

@@ -1,9 +1,6 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
@@ -22,15 +19,15 @@ class Axiom extends TopLevelAssertion {
 
     this.fileContext.trace(`Verifying the '${axiomString}' axiom...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -63,7 +60,8 @@ class Axiom extends TopLevelAssertion {
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Axiom, json, fileContext); }
 
   static fromAxiomNode(axiomNode, fileContext) {
-    const labelNodes = labelNodesQuery(axiomNode),
+    const { Label, Supposition, Consequent } = shim,
+          labelNodes = labelNodesQuery(axiomNode),
           consequentNode = consequentNodeQuery(axiomNode),
           suppositionNodes = suppositionNodesQuery(axiomNode),
           labels = labelNodes.map((labelNode) => {

package/src/combinator/bracketed.js

@@ -4,15 +4,18 @@ import shim from "../shim";
 import Combinator from "../combinator";
 
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+import { nominalLexer, nominalParser } from "../utilities/nominal";
 import { statementTokensFromUnqualifiedStatementTokens, unqualifiedStatementTokensFromUnqualifiedStatementString } from "../utilities/tokens";
 import { statementNodeFromUnqualifiedStatementNode,
          unqualifiedStatementStringFromStatementString,
          unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
 
-const statementString = `(${STATEMENT_META_TYPE_NAME})`,
+const lexer = nominalLexer, ///
+      parser = nominalParser, ///
+      statementString = `(${STATEMENT_META_TYPE_NAME})`,
       unqualifiedStatementString = unqualifiedStatementStringFromStatementString(statementString),
-      unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString),
-      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens),
+      unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+      unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
       statementTokens = statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens),
       statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode),
       nodeAsTokens = (node) => {

package/src/combinator.js

@@ -25,19 +25,19 @@ class Combinator {
     return statementNode;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const combinatorString = this.getString(); ///
 
-    fileContext.trace(`Verifying the '${combinatorString}' combinator at top level...`);
+    fileContext.trace(`Verifying the '${combinatorString}' combinator when declared...`);
 
-    const statementVerifiedAtTopLevel = this.statement.verifyAtTopLevel(fileContext);
+    const statementVerifiedAtTopLevel = this.statement.verifyWhenDeclared(fileContext);
 
     verifiedAtTopLevel = statementVerifiedAtTopLevel; ///
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${combinatorString}' combinator at top level.`);
+      fileContext.debug(`...verified the '${combinatorString}' combinator when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/conclusion.js

@@ -2,7 +2,6 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
@@ -90,7 +89,8 @@ class Conclusion {
   }
 
   static fromConclusionNode(conclusionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(conclusionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           conclusion = new Conclusion(fileContext, unqualifiedStatement);
 

package/src/conjecture.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { stringFromLabels } from "./topLevelAssertion";
@@ -25,15 +20,15 @@ class Conjecture extends TopLevelAssertion {
 
     this.fileContext.trace(`Verifying the '${conjectureString}' conjecture...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -48,7 +43,8 @@ class Conjecture extends TopLevelAssertion {
 
         if (consequentVerified) {
           if (this.proof !== null) {
-            const substitutions = Substitutions.fromNothing();
+            const { Substitutions } = shim,
+                  substitutions = Substitutions.fromNothing();
 
             this.proof.verify(substitutions, this.consequent, localContext);
           }
@@ -72,7 +68,8 @@ class Conjecture extends TopLevelAssertion {
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Conjecture, json, fileContext); }
 
   static fromConjectureNode(conjectureNode, fileContext) {
-    const proofNode = proofNodeQuery(conjectureNode),
+    const { Label, Proof, Supposition, Consequent } = shim,
+          proofNode = proofNodeQuery(conjectureNode),
           labelNodes = labelNodesQuery(conjectureNode),
           consequentNode = consequentNodeQuery(conjectureNode),
           suppositionNodes = suppositionNodesQuery(conjectureNode),

package/src/consequent.js

@@ -2,7 +2,6 @@
 
 import shim from "./shim";
 import LocalContext from "./context/local";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
@@ -90,7 +89,8 @@ class Consequent {
   }
 
   static fromConsequentNode(consequentNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(consequentNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           consequent = new Consequent(fileContext, unqualifiedStatement);
 

package/src/constructor/bracketed.js

@@ -5,15 +5,18 @@ import Constructor from "../constructor";
 
 import { OBJECT_TYPE_NAME } from "../typeNames";
 import { stringFromTermAndType } from "../constructor";
+import { nominalLexer, nominalParser } from "../utilities/nominal";
 import { termTokensFromConstructorDeclarationTokens, constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 import { termNodeFromConstructorDeclarationNode,
          constructorDeclarationStringFromTermString,
          constructorDeclarationNodeFromConstructorDeclarationTokens } from "../utilities/node";
 
-const termString = `(${OBJECT_TYPE_NAME})`,  ///
+const lexer = nominalLexer, ///
+      parser = nominalParser, ///
+      termString = `(${OBJECT_TYPE_NAME})`,  ///
       constructorDeclarationString = constructorDeclarationStringFromTermString(termString),
-      constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString),
-      constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens),
+      constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer),
+      constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
       termNode = termNodeFromConstructorDeclarationNode(constructorDeclarationNode),
       termTokens = termTokensFromConstructorDeclarationTokens(constructorDeclarationTokens),
       nodeAsTokens = (node) => {

package/src/constructor.js

@@ -25,21 +25,21 @@ class Constructor {
 
   getType() { return this.term.getType(); }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const constructorString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${constructorString}' constructor at top level...`);
+    fileContext.trace(`Verifying the '${constructorString}' constructor when declared...`);
 
-    const termVerifiedAtTopLevel = this.term.verifyAtTopLevel(fileContext);
+    const termVerifiedAtTopLevel = this.term.verifyWhenDeclared(fileContext);
 
     if (termVerifiedAtTopLevel) {
       verifiedAtTopLevel = true; ///
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${constructorString}' constructor at top level.`);
+      fileContext.debug(`...verified the '${constructorString}' constructor when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/context/file.js

@@ -2,6 +2,8 @@
 
 import { arrayUtilities } from "necessary";
 
+import metavariableUnifier from "../unifier/metavariable";
+
 import { objectType } from "../type";
 import { frameMetaType, referenceMetaType, statementMetaType } from "../metaType";
 import { nodeAsTokens, nodeAsString, nodesAsString, tokensAsString } from "../utilities/string";
@@ -302,6 +304,16 @@ export default class FileContext {
     return this.metavariables;
   }
 
+  getMetavariableNames(includeRelease = true) {
+    const metavariableNames = this.metavariables.map((metavariable) => {
+      const metavariableName = metavariable.getName();
+
+      return metavariableName;
+    });
+
+    return metavariableNames;
+  }
+
   setReleaseContext(releaseContext) {
     this.releaseContext = releaseContext;
   }
@@ -314,58 +326,6 @@ export default class FileContext {
     this.tokens = tokens;
   }
 
-  setNode(node) {
-    this.node = node;
-  }
-
-  setTypes(types) {
-    this.types = types;
-  }
-
-  setRules(rules) {
-    this.rules = rules;
-  }
-
-  setAxioms(axioms) {
-    this.axioms = axioms;
-  }
-
-  setLemmas(lemmas) {
-    this.lemmas = lemmas;
-  }
-
-  setTheorems(theorems) {
-    this.theorems = theorems;
-  }
-
-  setVariables(variables) {
-    this.variables = variables;
-  }
-
-  setMetaLemmas(metaLemmas) {
-    this.metaLemmas = metaLemmas;
-  }
-
-  setConjectures(conjectures) {
-    this.conjectures = conjectures;
-  }
-
-  setCombinators(combinators) {
-    this.combinators = combinators;
-  }
-
-  setConstructors(constructors) {
-    this.constructors = constructors;
-  }
-
-  setMetatheorems(metatheorems) {
-    this.metatheorems = metatheorems;
-  }
-
-  setMetavariables(metavariables) {
-    this.metavariables = metavariables;
-  }
-
   findTypeByTypeName(typeName) {
     let types = this.getTypes();
 
@@ -436,6 +396,13 @@ export default class FileContext {
     return metavariablePresent;
   }
 
+  isMetavariablePresentByMetavariableNode(metavariableNode, localContext) {
+    const metavariable = this.findMetavariableByMetavariableNode(metavariableNode, localContext),
+          metavariablePresent = (metavariable !== null);
+
+    return metavariablePresent;
+  }
+
   findRuleByReference(reference) {
     const rules = this.getRules(),
           metavariableNode = reference.getMetavariableNode(),
@@ -537,9 +504,9 @@ export default class FileContext {
   findVariableByVariableName(variableName) {
     const variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const nameMatches = variable.matchVariableName(variableName);
+            const variableNameMatches = variable.matchVariableName(variableName);
 
-            if (nameMatches) {
+            if (variableNameMatches) {
               return true;
             }
           }) || null;
@@ -547,12 +514,12 @@ export default class FileContext {
     return variable;
   }
 
-  findJudgementByMetavariableName(metavariableName) {
+  findJudgementByMetavariableNode(metavariableNode) {
     const judgements = this.getJudgements(),
           judgement = judgements.find((judgement) => {
-            const judgementMatchesMetavariableName = judgement.matchMetavariableName(metavariableName);
+            const judgementMatchesMetavariableNode = judgement.matchMetavariableNode(metavariableNode);
 
-            if (judgementMatchesMetavariableName) {
+            if (judgementMatchesMetavariableNode) {
               return true;
             }
           }) || null;
@@ -561,11 +528,28 @@ export default class FileContext {
   }
 
   findMetavariableByMetavariableName(metavariableName) {
-    const metavariables = this.getMetavariables(),
+    const metavariableNameB = metavariableName, ///
+          metavariableNames = this.getMetavariableNames(),
+          metavariable = metavariableNames.find((metavariableName) => {
+            const metavariableNameA = metavariableName; ///
+
+            if (metavariableNameA === metavariableNameB) {
+              return true;
+            }
+          }) || null;
+
+    return metavariable;
+  }
+
+  findMetavariableByMetavariableNode(metavariableNode, localContext) {
+    const metavariableNodeB = metavariableNode, ///
+          metavariables = this.getMetavariables(),
           metavariable = metavariables.find((metavariable) => {
-            const nameMatches = metavariable.matchMetavariableName(metavariableName);
+            const metavariableA = metavariable, ///
+                  metavariableNodeA = metavariableA.getNode(), ///
+                  metavariableUnified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-            if (nameMatches) {
+            if (metavariableUnified) {
               return true;
             }
           }) || null;
@@ -636,18 +620,7 @@ export default class FileContext {
   }
 
   addVariable(variable) {
-    let variableAdded = false;
-
-    const variableName = variable.getName(),
-          variablePresent = this.isVariablePresentByVariableName(variableName);
-
-    if (!variablePresent) {
-      this.variables.push(variable);
-
-      variableAdded = true;
-    }
-
-    return variableAdded;
+    this.variables.push(variable);
   }
 
   addMetaLemma(metaLemma) {
@@ -671,18 +644,7 @@ export default class FileContext {
   }
 
   addMetavariable(metavariable) {
-    let metavariableAdded = false;
-
-    const metavariableName = metavariable.getName(),
-          metavariablePresent = this.isMetavariablePresentByMetavariableName(metavariableName);
-
-    if (!metavariablePresent) {
-      this.metavariables.push(metavariable);
-
-      metavariableAdded = true;
-    }
-
-    return metavariableAdded;
+    this.metavariables.push(metavariable);
   }
 
   trace(message) { this.releaseContext.trace(message, this.filePath); }