occam-verify-cli 1.0.781 → 1.0.787

package/src/element/assumption.js

@@ -3,8 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { descend, instantiate } from "../utilities/context";
+import { unifyAssumption } from "../process/unify";
 import { instantiateAssumption } from "../process/instantiate";
+import { assumptionFromAssumptionNode } from "../utilities/element";
+import { join, descend, reconcile, instantiate } from "../utilities/context";
+import { assumptionStringFromStatementAndReference } from "../utilities/string";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -33,34 +36,31 @@ export default define(class Assumption extends Element {
 
   getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
 
-  matchAssumptionNode(assumptionNode) {
-    const node = assumptionNode, ///
-          nodeMatches = this.matchNode(node),
-          assumptionNodeMatches = nodeMatches; ///
+  isEqualTo(assumption) {
+    const assumptionNode = assumption.getNode(),
+          assumptionNodeMatches = this.matchAssumptionNode(assumptionNode),
+          equalTo = assumptionNodeMatches;  ///
 
-    return assumptionNodeMatches;
+    return equalTo;
   }
 
-  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution = false;
+  isMetaLevel() {
+    const metaLevel = (this.context !== null);
 
-    const assumptionString = this.getString(),  ///
-          metaLevelSubstitutionString = metaLevelSubstitution.getString();
-
-    context.trace(`Comparing the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution...`);
-
-    debugger
+    return metaLevel;
+  }
 
-    if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution.`);
-    }
+  matchAssumptionNode(assumptionNode) {
+    const node = assumptionNode, ///
+          nodeMatches = this.matchNode(node),
+          assumptionNodeMatches = nodeMatches; ///
 
-    return comparesToMetaLevelSubstitution;
+    return assumptionNodeMatches;
   }
 
-  findValidAssumption(context) {
+  findValidAssumption(context, metaLevel = false) {
     const assumptionNode = this.getAssumptionNode(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel),
           validAssumption = assumption;  ///
 
     return validAssumption;
@@ -69,11 +69,17 @@ export default define(class Assumption extends Element {
   validate(context) {
     let assumption = null;
 
+    const metaLevel = this.isMetaLevel();
+
+    if (metaLevel) {
+      context = this.getContext();
+    }
+
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const validAssumption = this.findValidAssumption(context);
+    const validAssumption = this.findValidAssumption(context, metaLevel);
 
     if (validAssumption) {
       assumption = validAssumption; ///
@@ -108,7 +114,7 @@ export default define(class Assumption extends Element {
       if (validates) {
         assumption = this;  ///
 
-        context.addAssumption(assumption);
+        context.addAssumption(assumption, metaLevel);
 
         context.debug(`...validated the '${assumptionString}' assumption.`);
       }
@@ -125,7 +131,7 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
 
-    const reference = this.reference.validate(context);
+    const reference = this.reference.validate();
 
     if (reference !== null) {
       const metavariable = this.reference.getMetavariable(),
@@ -147,6 +153,10 @@ export default define(class Assumption extends Element {
           referenceValidates = true;
         }
       }
+
+      if (referenceValidates) {
+        context.addReference(reference);
+      }
     }
 
     if (referenceValidates) {
@@ -216,6 +226,39 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
+  unifyAssumption(assumption, generalContext, specificContext) {
+    let assumptionUnifies;
+
+    const context = specificContext,  ///
+          generalAssumption = this, ///
+          specificAssumption = assumption,  ///
+          generalAssumptionString = generalAssumption.getString(),
+          specificAssumptionString = specificAssumption.getString();
+
+    context.trace(`Unifying the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption...`);
+
+    const assumptionContext = assumption.getContext();
+
+    specificContext = assumptionContext;  ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        assumptionUnifies = unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext);
+
+        if (assumptionUnifies) {
+          specificContext.commit(context);
+        }
+
+      }, specificContext);
+    }, specificContext, context);
+
+    if (assumptionUnifies) {
+      context.debug(`...unified the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption.`);
+    }
+
+    return assumptionUnifies;
+  }
+
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
     let topLevelMetaAssertionUnifies;
 
@@ -265,6 +308,22 @@ export default define(class Assumption extends Element {
 
     return assumption;
   }
+
+  static fromStatementAndReference(statement, reference, context) {
+    let assumption;
+
+    instantiate((context) => {
+      const assumptionString = assumptionStringFromStatementAndReference(statement, reference),
+            string = assumptionString,  ///
+            assumptionNode = instantiateAssumption(string, context);
+
+      assumption = assumptionFromAssumptionNode(assumptionNode, context);
+
+      assumption.setContext(context);
+    }, context);
+
+    return assumption;
+  }
 });
 
 function referenceFromAssumptionNode(assumptionNode, context) {

package/src/element/frame.js

@@ -7,7 +7,7 @@ import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
 import { descend, reconcile, instantiate } from "../utilities/context";
-import { assumptionsStringFromAssumptions, metaLevelSubstitutionsStringFromMetaLevelSubstitutions } from "../utilities/string";
+import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -119,56 +119,6 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
-  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutionString = metaLevelSubstitution.getString();
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution...`);
-
-    const metavariableNode = this.metavariable.getNode(),
-          judgements = context.findJudgementsByMetavariableNode(metavariableNode),
-          assumptions = assumptionsFromJudgements(judgements);
-
-    comparesToMetaLevelSubstitution = assumptions.some((assumption) => {
-      const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-      if (assumptionComparesToSubstitution) {
-        return true;
-      }
-    });
-
-    if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionString}' meta-level substitution.`);
-    }
-
-    return comparesToMetaLevelSubstitution;
-  }
-
-  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
-    let comparesToMetaLevelSubstitutions;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitution...`);
-
-    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
-      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-      if (compaaresToMetaLevelSubstitution) {
-        return true;
-      }
-    });
-
-    if (comparesToMetaLevelSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
-    }
-
-    return comparesToMetaLevelSubstitutions;
-  }
-
   findValidFrame(context) {
     const frameNode = this.getFrameNode(),
           frame = context.findFrameByFrameNode(frameNode),
@@ -391,13 +341,3 @@ function assumptionsFromFrameNode(frameNode, context) {
 
   return assumptions;
 }
-
-function assumptionsFromJudgements(judgements) {
-  const assumptions = judgements.map((judgement) => {
-    const assumption = judgement.getAssumption();
-
-    return assumption;
-  });
-
-  return assumptions;
-}

package/src/element/judgement.js

@@ -40,6 +40,8 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
+  getMetavariableNode() { return this.frame.getMetavariableNode(); }
+
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -185,12 +187,40 @@ export default define(class Judgement extends Element {
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
     const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
-          metaLevelSubstitutions = topLevelMetaAssertion.getMetaLevelSubstitutions(),
-          frameComparesToSubstitutions = this.frame.compareMetaLevelSubstitutions(metaLevelSubstitutions, context);
+          metavariableNode = this.getMetavariableNode(),
+          judgements = context.findJudgementsByMetavariableNode(metavariableNode);
 
-    if (frameComparesToSubstitutions) {
-      validatesWhenDerived = true;
-    }
+    let assumptions;
+
+    assumptions = topLevelMetaAssertion.getAssumptions();
+
+    const specificAssumptions = assumptions; ///
+
+    assumptions = assumptionsFromJudgements(judgements);
+
+    const generalAssumptions = assumptions;  ///
+
+    reconcile((context) => {
+      const specificAssumptionsUnify = specificAssumptions.every((specificAssumption) => {
+        const specificAssumptionUnifies = generalAssumptions.some((generalAssumption) => {
+          const generalContext = context, ///
+                specificContext = context,  ///
+                specificAssumptionUnifies = generalAssumption.unifyAssumption(specificAssumption, generalContext, specificContext);
+
+          if (specificAssumptionUnifies) {
+            return true;
+          }
+        });
+
+        if (specificAssumptionUnifies) {
+          return true;
+        }
+      });
+
+      if (specificAssumptionsUnify) {
+        validatesWhenDerived = true;
+      }
+    }, context);
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${judgementString}' derived judgement.`);
@@ -254,6 +284,16 @@ function frameFromJudgementNode(judgementNode, context) {
   return frame;
 }
 
+function assumptionsFromJudgements(judgements) {
+  const assumptions = judgements.map((judgement) => {
+    const assumption = judgement.getAssumption();
+
+    return assumption;
+  });
+
+  return assumptions;
+}
+
 function assumptionFromJudgementNode(judgementNode, context) {
   const assumptionNode = judgementNode.getAssumptionNode(),
         assumption = context.findAssumptionByAssumptionNode(assumptionNode);

package/src/element/label.js

@@ -4,6 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
+import { labelFromLabelNode } from "../utilities/element";
 import { metavariableFromLabelNode } from "../utilities/element";
 import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
@@ -157,4 +158,17 @@ export default define(class Label extends Element {
 
     return label;
   }
+
+  static fromLabelString(labelString, context) {
+    let label;
+
+    instantiate((context) => {
+      const string = labelString,  ///
+            labelNode = instantiateLabel(string, context);
+
+      label = labelFromLabelNode(labelNode, context);
+    }, context);
+
+    return label;
+  }
 });

package/src/element/metavariable.js

@@ -290,11 +290,10 @@ export default define(class Metavariable extends Element {
       frameUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+            substitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitution !== null) {
-        const substitution = simpleSubstitution,  ///
-              substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
+      if (substitution !== null) {
+        const substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
         if (substitutionFrameComparesToFrame) {
           const frameSubstitution = substitution, ///
@@ -402,12 +401,10 @@ export default define(class Metavariable extends Element {
       referenceUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+            substitution = context.findSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
-              substitution = simpleSubstitution,  ///
-              substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
+      if (substitution !== null) {
+        const substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
         if (substitutionReferenceComparesToReference) {
           const referenceSubstitution = substitution, ///

package/src/element/proofAssertion/step.js

@@ -137,7 +137,7 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${referenceString}' reference... `);
 
-      const reference = this.reference.validate(context);
+      const reference = this.reference.validate();
 
       if (reference === null) {
         referenceValidates = false;
@@ -169,7 +169,7 @@ export default define(class Step extends ProofAssertion {
     }
 
     if (statementValidates) {
-      context.debug(`...validated the '${stepString}' step statement. `);
+      context.debug(`...validated the '${stepString}' step's statement. `);
     }
 
     return statementValidates;

package/src/element/reference.js

@@ -5,7 +5,8 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
-import { serialise, reconcile, unserialise, instantiate } from "../utilities/context";
+import { referenceFromReferenceNode } from "../utilities/element";
+import { attempt, serialise, reconcile, unserialise, instantiate } from "../utilities/context";
 import { metavariableFromReferenceNode, topLevelMetaAssertionFromReferenceNode } from "../utilities/element";
 
 export default define(class Reference extends Element {
@@ -122,30 +123,17 @@ export default define(class Reference extends Element {
     return topLevelMetaAssertionCompares;
   }
 
-  findValidRefernece(context) {
-    const metavariableNode = this.getMetavariableNode(),
-          reference = context.findReferenceByMetavariableNode(metavariableNode),
-          validReference = reference;  ///
+  validate() {
+    let referennce = null;
 
-    return validReference;
-  }
-
-  validate(context) {
-    let reference = null;
-
-    const referenceString = this.getString(); ///
+    const context = this.getContext(),
+          referenceString = this.getString(); ///
 
     context.trace(`Validating the '${referenceString}' reference...`);
 
-    const validReference = this.findValidRefernece(context);
-
-    if (validReference !== null) {
-      reference = validReference; ///
-
-      context.debug(`...the '${referenceString}' reference is already valid.`);
-    } else {
-      let validates = false;
+    let validates;
 
+    attempt((context) => {
       const metavariableValidates = this.validateMetavariable(context);
 
       if (metavariableValidates) {
@@ -170,23 +158,25 @@ export default define(class Reference extends Element {
           } else {
             const metaTypeString = metaType.getString(),
                   metavariableString = this.metavariable.getString(),
-                  reerenceMetaTypeString = referenceMetaType.getString();
+                  referenceMetaTypeString = referenceMetaType.getString();
 
-            context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${reerenceMetaTypeString}' meta-type.`);
+            context.debug(`The '${referenceString}' reference's '${metavariableString}' metavariable's '${metaTypeString}' meta-type should be the '${referenceMetaTypeString}' meta-type.`);
           }
         }
       }
 
       if (validates) {
-        reference = this; ///
+        context.commit(this);
+      }
+    }, context);
 
-        context.addReference(reference);
+    if (validates) {
+      referennce = this;  ///
 
-        context.debug(`...validated the '${referenceString}' reference.`);
-      }
+      context.debug(`...validated the '${referenceString}' reference.`);
     }
 
-    return reference;
+    return referennce;
   }
 
   validateMetavariable(context) {
@@ -195,8 +185,6 @@ export default define(class Reference extends Element {
     const referenceString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
-    context = this.getContext();
-
     context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
     const metavariable = this.metavariable.validate(context);
@@ -336,4 +324,19 @@ export default define(class Reference extends Element {
 
     return reference;
   }
+
+  static fromReferenceString(referenceString, context) {
+    let reference;
+
+    instantiate((context) => {
+      const string = referenceString,  ///
+            referenceNode = instantiateReference(string, context);
+
+      reference = referenceFromReferenceNode(referenceNode, context);
+    }, context);
+
+    return reference;
+  }
 });
+
+let counter = 0;

package/src/element/substitution/frame.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { descend, instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
-import { descend, simplify, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -203,14 +203,12 @@ export default define(class FrameSubstitution extends Substitution {
   static fromFrameAndMetavariable(frame, metavariable, context) {
     let frameSubstitution
 
-    simplify((context) => {
-      instantiate((context) => {
-        const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
-              string = frameSubstitutionString,  ///
-              frameSubstitutionNode = instantiateFrameSubstitution(string, context);
+    instantiate((context) => {
+      const frameSubstitutionString = frameSubstitutionStringFromFrameAndMetavariable(frame, metavariable),
+            string = frameSubstitutionString,  ///
+            frameSubstitutionNode = instantiateFrameSubstitution(string, context);
 
-        frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
-      }, context);
+      frameSubstitution = frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode, context);
     }, context);
 
     return frameSubstitution;

package/src/element/substitution/reference.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { simplify, instantiate } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
@@ -114,15 +114,17 @@ export default define(class ReferenceSubstitution extends Substitution {
   validateTargetReference(generalContext, specificContext) {
     let targetReferenceValidates = false;
 
-    const context = generalContext, ///
+    const context = specificContext, ///
           targetReferenceString = this.targetReference.getString(),
           referenceSubstitutionString = this.getString();  ///
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${targetReferenceString}' target reference...`);
 
-    const targetReference = this.targetReference.validate(context);
+    const targetReference = this.targetReference.validate();
 
     if (targetReference !== null) {
+      context.addReference(targetReference);
+
       targetReferenceValidates = true;
     }
 
@@ -142,9 +144,11 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's '${replacementReferenceString}' replacement reference...`);
 
-    const replacementReference = this.replacementReference.validate(context);
+    const replacementReference = this.replacementReference.validate();
 
     if (replacementReference !== null) {
+      context.addReference(replacementReference);
+
       replacementReferenceValidates = true;
     }
 
@@ -182,14 +186,12 @@ export default define(class ReferenceSubstitution extends Substitution {
   static fromReferenceAndMetavariable(reference, metavariable, context) {
     let referenceSubstitution;
 
-    simplify((context) => {
-      instantiate((context) => {
-        const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
-              string = referenceSubstitutionString,  ///
-              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
+    instantiate((context) => {
+      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+            string = referenceSubstitutionString,  ///
+            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
 
-        referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
-      }, context);
+      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
     }, context);
 
     return referenceSubstitution;

package/src/element/substitution/statement.js

@@ -6,7 +6,7 @@ import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
-import { join, simplify, descend, reconcile, instantiate } from "../../utilities/context";
+import { join, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
@@ -367,14 +367,12 @@ export default define(class StatementSubstitution extends Substitution {
 
     let statementSubstitution;
 
-    simplify((context) => {
-      instantiate((context) => {
-        const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
-              string = statementSubstitutionString, ///
-              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    instantiate((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-      }, context);
+      statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
     }, context);
 
     return statementSubstitution;
@@ -385,14 +383,12 @@ export default define(class StatementSubstitution extends Substitution {
 
     let statementSubstitution;
 
-    simplify((context) => {
-      instantiate((context) => {
-        const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
-              string = statementSubstitutionString, ///
-              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
+    instantiate((context) => {
+      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+            string = statementSubstitutionString, ///
+            statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
-      }, context);
+      statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
     }, context);
 
     return statementSubstitution;