occam-verify-cli 1.0.792 → 1.0.799

package/src/element/reference.js

@@ -224,20 +224,30 @@ export default define(class Reference extends Element {
   unifyLabel(label) {
     let labelUnifies = false;
 
-    const context = label.getContext(),
-          labelString = label.getString(),
+    let context;
+
+    const labelString = label.getString(),
+          labelContext = label.getContext(),
           referenceString = this.getString(); ///
 
+    context = labelContext; ///
+
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    reconcile((context) => {
+    const specificContext = labelContext;  ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    reconcile((specificContext) => {
       const metavariable = label.getMetavariable(),
-            metavariableUnifies = this.unifyMetavariable(metavariable, context);
+            metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
 
       if (metavariableUnifies) {
         labelUnifies = true;
       }
-    }, context);
+    }, specificContext);
 
     if (labelUnifies) {
       context.debug(`...unified the '${labelString}' label with the '${referenceString}' reference.`);
@@ -246,22 +256,15 @@ export default define(class Reference extends Element {
     return labelUnifies;
   }
 
-  unifyMetavariable(metavariable, context) {
+  unifyMetavariable(metavariable, generalContext, specificContext) {
     let metavariableUnifies = false;
 
-    const referenceString = this.getString(), ///
+    const context = specificContext,  ///
+          referenceString = this.getString(), ///
           metavariableString = metavariable.getString();
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const metavariableUnifiesIntrinsically = this.metavariable.unifyMetavariableIntrinsically(metavariable, generalContext, specificContext);
 
     if (metavariableUnifiesIntrinsically) {
@@ -279,29 +282,33 @@ export default define(class Reference extends Element {
     let topLevelMetaAssertionUUnifies = false;
 
     const label = topLevelMetaAssertion.getLabel(),
+          labelContext = label.getContext(),
           referenceString = this.getString(), ///
+          temporaryContext = context, ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
 
-    const specificContext = context;  ///
+    const specificContext = labelContext; ///
 
-    context = label.getContext();
+    context = this.getContext();
 
-    reconcile((context) => {
+    const generalContext = context; ///
+
+    context = temporaryContext; ///
+
+    reconcile((specificContext) => {
       const metavariable = label.getMetavariable(),
-            metavariableUnifies = this.unifyMetavariable(metavariable, context);
+            metavariableUnifies = this.unifyMetavariable(metavariable, generalContext, specificContext);
 
       if (metavariableUnifies) {
         this.topLevelMetaAssertion = topLevelMetaAssertion;
 
-        context.commit(specificContext);
+        specificContext.commit(context);
 
         topLevelMetaAssertionUUnifies = true;
       }
-    }, context);
-
-    context = specificContext;  ///
+    }, specificContext);
 
     if (topLevelMetaAssertionUUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);

package/src/element/substitution/frame.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { attempt, instantiate } from "../../utilities/context";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
-import { attempt, descend, instantiate } from "../../utilities/context";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 
@@ -132,15 +132,13 @@ export default define(class FrameSubstitution extends Substitution {
     const targetFrameSingular = this.targetFrame.isSingular();
 
     if (targetFrameSingular) {
-      descend((context) => {
-        const tragetFrame = this.targetFrame.validate(context);
+      const tragetFrame = this.targetFrame.validate(context);
 
-        if (tragetFrame !== null) {
-          this.targetFrame = tragetFrame;
+      if (tragetFrame !== null) {
+        this.targetFrame = tragetFrame;
 
-          targetFrameValidates = true;
-        }
-      }, context);
+        targetFrameValidates = true;
+      }
     } else {
       context.debug(`The '${frameSubstitutionString}' frame substitution's '${targetFrameString}' target frame is not singular.`);
     }
@@ -161,15 +159,13 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame...`);
 
-    descend((context) => {
-      const replacementFrame = this.replacementFrame.validate(context);
+    const replacementFrame = this.replacementFrame.validate(context);
 
-      if (replacementFrame !== null) {
-        this.replacementFrame = replacementFrame;
+    if (replacementFrame !== null) {
+      this.replacementFrame = replacementFrame;
 
-        replacementFrameValidates = true;
-      }
-    }, context);
+      replacementFrameValidates = true;
+    }
 
     if (replacementFrameValidates) {
       context.debug(`...validated the '${frameSubstitutionString}' frame substitution's '${replacementFrameString}' replacement frame.`);

package/src/element/substitution/reference.js

@@ -70,6 +70,23 @@ export default define(class ReferenceSubstitution extends Substitution {
     return comparesToParameter;
   }
 
+  compareSubstitution(substitution) {
+    let substitutionCompares = false;
+
+    const substitutionReferenceSubstitution = (substitution instanceof ReferenceSubstitution);
+
+    if (substitutionReferenceSubstitution) {
+      const substitutionNode = substitution.getNode(),
+            substitutionNodeMatches = this.matchNode(substitutionNode);
+
+      if (substitutionNodeMatches) {
+        substitutionCompares = true;
+      }
+    }
+
+    return substitutionCompares;
+  }
+
   validate(generalContext, specificContext) {
     let referenceSubstitution = null;
 
@@ -199,6 +216,22 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     return referenceSubstitution;
   }
+
+  static fromAssumptionAndMetaLevelAssumption(assumption, metaLevelAssumption, context) {
+    let referenceSubstitution;
+
+    instantiate((context) => {
+      const reference = metaLevelAssumption.getReference(),
+            metavariable = assumption.getMetavariable(),
+            referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+            string = referenceSubstitutionString,  ///
+            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
+
+      referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    }, context);
+
+    return referenceSubstitution;
+  }
 });
 
 function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {

package/src/element/substitution/statement.js

@@ -132,7 +132,11 @@ export default define(class StatementSubstitution extends Substitution {
           const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
 
           if (replacementStatementValidates) {
-            validates = true;
+            const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
+
+            if (substitutionValidates) {
+              validates = true;
+            }
           }
         }
 
@@ -155,6 +159,34 @@ export default define(class StatementSubstitution extends Substitution {
     return statementSubstitution;
   }
 
+  validateSubstitution(generalContext, specificContext) {
+    let substitutionValidates = true;
+
+    if (this.substitution !== null) {
+      const context = specificContext,  ///
+            substitutionString = this.substitution.getString(),
+            statementSubstitutionString = this.getString();
+
+      context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
+
+      specificContext = generalContext; ///
+
+      const substitution = this.substitution.validate(generalContext, specificContext);
+
+      if (substitution !== null) {
+        this.substitution = substitution;
+
+        substitutionValidates = true;
+      }
+
+      if (substitutionValidates) {
+        context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
+      }
+    }
+
+    return substitutionValidates;
+  }
+
   validateTargetStatement(generalContext, specificContext) {
     let targetStatementValidates = false;
 

package/src/element/topLevelMetaAssertion.js

@@ -3,27 +3,27 @@
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { asyncRestrict } from "../utilities/context";
-import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
+import { topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
-         assumptionsFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
-         assumptionsToAssumptionsJSON,
-         suppositionsToSuppositionsJSON } from "../utilities/json";
+         metaLevelAssumptionsFromJSON,
+         suppositionsToSuppositionsJSON,
+         metaLevelAssumptionsToMetaLevelAssumptionsJSON } from "../utilities/json";
 
 const { asyncForwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelMetaAssertion extends Element {
-  constructor(context, string, node, label, suppositions, deduction, proof, assumptions) {
+  constructor(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions) {
     super(context, string, node);
 
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
-    this.assumptions = assumptions;
+    this.metaLevelAssumptions = metaLevelAssumptions;
   }
 
   getLabel() {
@@ -42,8 +42,8 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getAssumptions() {
-    return this.assumptions;
+  getMetaLevelAssumptions() {
+    return this.metaLevelAssumptions;
   }
 
   getStatement() {
@@ -121,7 +121,7 @@ export default class TopLevelMetaAssertion extends Element {
           }
         }
       }
-    }, this.assumptions, context);
+    }, this.metaLevelAssumptions, context);
 
     if (verifies) {
       context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
@@ -234,16 +234,16 @@ export default class TopLevelMetaAssertion extends Element {
     const labelJSON = labelToLabelJSON(this.label),
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
-          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
+          metaLevelAssumptionsJSON = metaLevelAssumptionsToMetaLevelAssumptionsJSON(this.metaLevelAssumptions),
           label = labelJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          assumptions = assumptionsJSON,  ///
+          metaLevelAssumptions = metaLevelAssumptionsJSON,  ///
           json = {
             label,
             deduction,
             suppositions,
-            assumptions
+            metaLevelAssumptions
           };
 
     return json;
@@ -253,11 +253,11 @@ export default class TopLevelMetaAssertion extends Element {
     const label = labelFromJSON(json, context),
           deduction = deductionFromJSON(json, context),
           suppositions = suppositionsFromJSON(json, context),
-          assumptions = assumptionsFromJSON(json, context),
+          metaLevelAssumptions = metaLevelAssumptionsFromJSON(json, context),
           node = null,
           proof = null,
-          string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, assumptions);
+          string = topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions(label, suppositions, deduction, metaLevelAssumptions),
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, metaLevelAssumptions);
 
     return topLevelMetaAssertion;
   }

package/src/node/assumption/metaLevel.js

@@ -0,0 +1,23 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { REFERENCE_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
+
+export default class MetaLevelAssumptionpNode extends NonTerminalNode {
+  getReferenceNode() {
+    const ruleName = REFERENCE_RULE_NAME,
+          referenceNode = this.getNodeByRuleName(ruleName);
+
+    return referenceNode;
+  }
+
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLevelAssumptionpNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/assumption.js

@@ -2,16 +2,9 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { STATEMENT_RULE_NAME, METAVARIABLE_RULE_NAME } from "../ruleNames";
+import { METAVARIABLE_RULE_NAME, STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class AssumptionpNode extends NonTerminalNode {
-  getStatementNode() {
-    const ruleName = STATEMENT_RULE_NAME,
-          statementNode = this.getNodeByRuleName(ruleName);
-
-    return statementNode;
-  }
-
   getMetavariableNode() {
     const ruleName = METAVARIABLE_RULE_NAME,
           metavariableNode = this.getNodeByRuleName(ruleName);
@@ -19,5 +12,12 @@ export default class AssumptionpNode extends NonTerminalNode {
     return metavariableNode;
   }
 
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(AssumptionpNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/declaration/metavariable.js

@@ -5,11 +5,11 @@ import DeclarationNode from "../../node/declaration";
 import { META_TYPE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 export default class MetavariableDeclarationNode extends DeclarationNode {
-  getTypeNode() {
-    const metavariableNode = this.getMetavariableNode(),
-          typeNode = metavariableNode.getTypeNode();
+  getMetaTypeName() {
+    const metaTypeNode = this.getMetaTypeNode(),
+          metaTypeName = metaTypeNode.getMetaTypeName();
 
-    return typeNode;
+    return metaTypeName;
   }
 
   getMetaTypeNode() {

package/src/node/frame.js

@@ -11,7 +11,12 @@ export default class FrameNode extends NonTerminalNode {
     const metavariableNode = this.getMetavariableNode();
 
     if (metavariableNode !== null) {
-      singular = true;
+      const assumptionNodes = this.getAssumptionNodes(),
+            assumptionNodesLength = assumptionNodes.length;
+
+      if (assumptionNodesLength === 0) {
+        singular = true;
+      }
     }
 
     return singular;

package/src/nonTerminalNodeMap.js

@@ -75,6 +75,7 @@ import SatisfiesAssertionNode from "./node/assertion/satisfies";
 import ParenthesisedLabelsNode from "./node/parenthesisedLabels"
 import PropertyDeclarationNode from "./node/declaration/property";
 import VariableDeclarationNode from "./node/declaration/variable";
+import MetaLevelAssumptionpNode from "./node/assumption/metaLevel";
 import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
 import ReferenceSubstitutionNode from "./node/substitution/reference";
@@ -160,6 +161,7 @@ import {
   PARENTHESISED_LABELS_RULE_NAME,
   PROPERTY_DECLARATION_RULE_NAME,
   VARIABLE_DECLARATION_RULE_NAME,
+  META_LEVEL_ASSUMPTION_RULE_NAME,
   COMBINATOR_DECLARATION_RULE_NAME,
   REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
@@ -245,6 +247,7 @@ const NonTerminalNodeMap = {
   [PARENTHESISED_LABELS_RULE_NAME]: ParenthesisedLabelsNode,
   [VARIABLE_DECLARATION_RULE_NAME]: VariableDeclarationNode,
   [PROPERTY_DECLARATION_RULE_NAME]: PropertyDeclarationNode,
+  [META_LEVEL_ASSUMPTION_RULE_NAME]: MetaLevelAssumptionpNode,
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
   [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,

package/src/preamble.js

@@ -50,6 +50,7 @@ import PropertyAssertion from "./element/assertion/property";
 import ProcedureReference from "./element/procedureReference";
 import ContainedAssertion from "./element/assertion/contained";
 import SatisfiesAssertion from "./element/assertion/satisfies";
+import MetaLevelAssumption from "./element/assumption/metaLevel";
 import VariableDeclaration from "./element/declaration/variable";
 import BracketedCombinator from "./element/combinator/bracketed";
 import BracketedConstructor from "./element/constructor/bracketed";

package/src/process/instantiate.js

@@ -33,6 +33,7 @@ import { TERM_RULE_NAME,
          PROCEDURE_REFERENCE_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
+         META_LEVEL_ASSUMPTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
          REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
@@ -68,6 +69,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
+      metaLevelAssumptionPlaceholderRule = ruleFromRuleName(META_LEVEL_ASSUMPTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
       referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
@@ -155,6 +157,8 @@ export function instantiateContainedAssertion(string, context) { return instanti
 
 export function instantiateSatisfiesAssertion(string, context) { return instantiate(satisfiesAssertionPlaceholderRule, string, context); }
 
+export function instantiateMetaLevelAssumption(string, context) { return instantiate(metaLevelAssumptionPlaceholderRule, string, context); }
+
 export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }

package/src/process/unify.js

@@ -17,6 +17,7 @@ const typeNodeQuery = nodeQuery("/type"),
       metavariableNodeQuery = nodeQuery("/metavariable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+      referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
@@ -29,21 +30,24 @@ class MetaLevelPass extends ZipPassBase {
         let success = false;
 
         let context,
+            reference,
             metavariableNode;
 
         context = generalContext; ///
 
         metavariableNode = generalAssumptionMetavariableNode;  ///
 
-        const metavariableName = metavariableNode.getMetavariableName(),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+        const metavariable = reference.getMetavariable();
 
         context = specificContext;  ///
 
         metavariableNode = specificAssumptionMetavariableNode; ///
 
-        const reference = context.findReferenceByMetavariableNode(metavariableNode),
-              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+        const referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
 
         if (referenceUnifies) {
           success = true;
@@ -64,8 +68,7 @@ class MetaLevelPass extends ZipPassBase {
         context = generalContext; ///
 
         const metavariableNode = generalStatementMetavariableNode,  ///
-              metavariableName = metavariableNode.getMetavariableName(),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName),
+              metavariable = context.findMetavariableByMetavariableNode(metavariableNode),
               metavariableNodeParentNode = metavariableNode.getParentNode();
 
         statementNode = metavariableNodeParentNode; ///
@@ -96,14 +99,13 @@ class MetaLevelPass extends ZipPassBase {
         let success = false;
 
         const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameMetavariableNode,  ///
-              metavariableName = metavariableNode.getMetavariableName();
+              metavariableNode = generalFrameMetavariableNode;
 
         let context;
 
         context = generalContext; ///
 
-        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        const metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
 
         context = specificContext;  ///
 
@@ -157,14 +159,13 @@ class AssumptionPass extends ZipPass {
         let success = false;
 
         const statementNode = specificStatementNode, ///
-              metavariableNode = generalStatementMetavariableNode,  ///
-              metavariableName = metavariableNode.getMetavariableName();
+              metavariableNode = generalStatementMetavariableNode;  ///
 
         let context;
 
         context = generalContext; ///
 
-        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        const metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
 
         context = specificContext;  ///
 
@@ -181,56 +182,31 @@ class AssumptionPass extends ZipPass {
     },
     {
       generalNodeQuery: metavariableNodeQuery,
-      specificNodeQuery: metavariableNodeQuery,
-      run: (generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) => {
+      specificNodeQuery: referenceMetavariableNodeQuery,
+      run: (generalMetavariableNode, specificReferenceMetavariableNode, generalContext, specificContext) => {
         let success = false;
 
         let context,
+            reference,
             metavariableNode;
 
         context = generalContext; ///
 
         metavariableNode = generalMetavariableNode;  ///
 
-        const metavariableName = metavariableNode.getMetavariableName(),
-              metavariable = context.findMetavariableByMetavariableName(metavariableName);
-
-        context = specificContext;  ///
-
-        metavariableNode = specificMetavariableNode; ///
-
-        const reference = context.findReferenceByMetavariableNode(metavariableNode),
-              referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
-
-        if (referenceUnifies) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      generalNodeQuery: termVariableNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
-        let success = false;
-
-        const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode, ///
-              variableIdentifier = variableNode.getVariableIdentifier();
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
 
-        let context;
+        const metavariable = reference.getMetavariable();
 
-        context = generalContext; ///
+        context = specificContext;  ///
 
-        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+        metavariableNode = specificReferenceMetavariableNode; ///
 
-        context = specificContext;  ///
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
 
-        const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+        const referenceUnifies = metavariable.unifyReference(reference, generalContext, specificContext);
 
-        if (termUnifies) {
+        if (referenceUnifies) {
           success = true;
         }
 
@@ -406,14 +382,13 @@ class SubstitutionPass extends ZipPass {
         let success = false;
 
         const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameMetavariableNode,  ///
-              metavariableName = metavariableNode.getMetavariableName();
+              metavariableNode = generalFrameMetavariableNode;  ///
 
         let context;
 
         context = generalContext; ///
 
-        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+        const metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
 
         context = specificContext;  ///
 

package/src/ruleNames.js

@@ -75,6 +75,7 @@ export const SATISFIES_ASSERTION_RULE_NAME = "satisfiesAssertion";
 export const PARENTHESISED_LABELS_RULE_NAME = "parenthesisedLabels";
 export const PROPERTY_DECLARATION_RULE_NAME = "propertyDeclaration";
 export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
+export const META_LEVEL_ASSUMPTION_RULE_NAME = "metaLevelAssumption";
 export const COMBINATOR_DECLARATION_RULE_NAME = "combinatorDeclaration";
 export const STATEMENT_SUBSTITUTION_RULE_NAME = "statementSubstitution";
 export const REFERENCE_SUBSTITUTION_RULE_NAME = "referenceSubstitution";