occam-verify-cli 1.0.806 → 1.0.814

package/src/element/topLevelAssertion/axiom.js

@@ -38,9 +38,12 @@ export default define(class Axiom extends TopLevelAssertion {
 
       context = this.getContext();
 
-      const generalContext = context;  ///
+      const generalContext = context,  ///
+            signatureAComparesToSignatureB = signatureA.compareSignature(signatureB, generalContext, specificContext);
 
-      comparesToSignature = signatureA.compare(signatureB, generalContext, specificContext);
+      if (signatureAComparesToSignatureB) {
+        comparesToSignature = true;
+      }
     }
 
     return comparesToSignature;

package/src/element/topLevelAssertion.js

@@ -3,7 +3,7 @@
 import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { asyncRestrict } from "../utilities/context";
+import { enclose } from "../utilities/context";
 import { topLevelAssertionStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
 import { labelsFromJSON,
          deductionFromJSON,
@@ -16,8 +16,8 @@ import { labelsFromJSON,
          hypothesesToHypothesesJSON,
          suppositionsToSuppositionsJSON } from "../utilities/json";
 
-const { extract, reverse, correlate } = arrayUtilities,
-      { asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
+const { reverse, correlate } = arrayUtilities,
+      { asyncExtract, asyncForwardsEvery, asyncBackwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelAssertion extends Element {
   constructor(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses) {
@@ -59,6 +59,12 @@ export default class TopLevelAssertion extends Element {
     this.hypotheses = hypotheses;
   }
 
+  getSupposition(index) {
+    const supposition = this.suppositions[index] || null;
+
+    return supposition;
+  }
+
   isHypothetical() {
     const hypothesesLength = this.hypotheses.length,
           hypothetical = (hypothesesLength > 0);
@@ -73,22 +79,16 @@ export default class TopLevelAssertion extends Element {
     return unconditional;
   }
 
-  getSupposition(index) {
-    const supposition = this.suppositions[index] || null;
-
-    return supposition;
-  }
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = this.labels.some((label) => {
+      const metavariableNodeMatches = label.matchMetavariableNode(metavariableNode);
 
-  compareMetavariableName(metavariableName) {
-    const comparesToMetavariableName = this.labels.some((label) => {
-      const labelComparesToMetavariableName = label.compareMetavariableName(metavariableName);
-
-      if (labelComparesToMetavariableName) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
 
-    return comparesToMetavariableName;
+    return metavariableNodeMatches;
   }
 
   correlateHypotheses(context) {
@@ -120,28 +120,6 @@ export default class TopLevelAssertion extends Element {
     return correlatesToHypotheses;
   }
 
-  unifyStatementWithDeduction(statement, context) {
-    let statementUnifiesWithDeduction = false;
-
-    const statementString = statement.getString(),
-          deductionString = this.deduction.getString(),
-          topLevelAssertionString = this.getString(); ///
-
-    context.trace(`Unifying the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
-
-    const statementUnifies = this.deduction.unifyStatement(statement, context);
-
-    if (statementUnifies) {
-      statementUnifiesWithDeduction = true;
-    }
-
-    if (statementUnifiesWithDeduction) {
-      context.debug(`...unified the '${statementString}' statement with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
-    }
-
-    return statementUnifiesWithDeduction;
-  }
-
   async verify() {
     let verifies = false;
 
@@ -150,7 +128,7 @@ export default class TopLevelAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelAssertionString}' top level assertion...`);
 
-    await asyncRestrict(async (context) => {
+    await enclose(async (context) => {
       const labelsVerify = this.verifyLabels();
 
       if (labelsVerify) {
@@ -304,47 +282,65 @@ export default class TopLevelAssertion extends Element {
     return suppositionsVerify;
   }
 
-  async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
-    let statementAndSubproofOrProofAssertionsUnify = false;
+  async unifyStepWithDeduction(step, context) {
+    let stepUnifiesWithDeduction = false;
+
+    await this.break(context);
+
+    const stepString = step.getString(),
+          deductionString = this.deduction.getString(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Unifying the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction...`);
+
+    const stepUnifies = await this.deduction.unifyStep(step, context);
+
+    if (stepUnifies) {
+      stepUnifiesWithDeduction = true;
+    }
+
+    if (stepUnifiesWithDeduction) {
+      context.debug(`...unified the '${stepString}' step with the '${topLevelAssertionString}' top level assertion's '${deductionString}' deduction.`);
+    }
+
+    return stepUnifiesWithDeduction;
+  }
+
+  async unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context) {
+    let stepAndSubproofOrProofAssertionsUnify = false;
 
     const correlatesToHypotheses = this.correlateHypotheses(context);
 
     if (correlatesToHypotheses) {
-      const statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
+      const stepUnifiesWithDeduction = await this.unifyStepWithDeduction(step, context);
 
-      if (statementUnifiesWithDeduction) {
+      if (stepUnifiesWithDeduction) {
         const subproofOrProofAssertionsUnifiesWithSuppositions = await this.unifySubproofOrProofAssertionsWithSuppositions(subproofOrProofAssertions, context);
 
         if (subproofOrProofAssertionsUnifiesWithSuppositions) {
           const substitutionsResolved = context.areSubstitutionsResolved();
 
           if (substitutionsResolved) {
-            statementAndSubproofOrProofAssertionsUnify = true;
+            stepAndSubproofOrProofAssertionsUnify = true;
           }
         }
       }
     }
 
-    return statementAndSubproofOrProofAssertionsUnify;
+    return stepAndSubproofOrProofAssertionsUnify;
   }
 
   async unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context) {
     let subproofOrProofAssertionsUnifiesWithSupposition = false;
 
+    await this.break(context);
+
     if (!subproofOrProofAssertionsUnifiesWithSupposition) {
-      const subproofOrProofAssertion = extract(subproofOrProofAssertions, (subproofOrProofAssertion) => {
-        const subproofOrProofAssertionUnifies = supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
+      const subproofOrProofAssertion = await asyncExtract(subproofOrProofAssertions, async (subproofOrProofAssertion) => {
+        const subproofOrProofAssertionUnifies = await supposition.unifySubproofOrProofAssertion(subproofOrProofAssertion, context);
 
         if (subproofOrProofAssertionUnifies) {
-          const specificContext = context;  ///
-
-          context = this.getContext();
-
-          const generalContext = context; ///
-
-          context = specificContext;  ///
-
-          context.resolveSubstitutions(generalContext, specificContext);
+          context.resolveSubstitutions();
 
           return true;
         }
@@ -371,7 +367,7 @@ export default class TopLevelAssertion extends Element {
 
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    subproofOrProofAssertionsUnifiesWithSuppositions = asyncBackwardsEvery(this.suppositions, async (supposition) => {
+    subproofOrProofAssertionsUnifiesWithSuppositions = await asyncBackwardsEvery(this.suppositions, async (supposition) => {
       const stepUnifiesWithSupposition = await this.unifySubproofOrProofAssertionsWithSupposition(subproofOrProofAssertions, supposition, context);
 
       if (stepUnifiesWithSupposition) {

package/src/element/topLevelMetaAssertion.js

@@ -2,7 +2,7 @@
 
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { asyncRestrict } from "../utilities/context";
+import { enclose } from "../utilities/context";
 import { topLevelMetaAssertionStringFromLabelSuppositionsDeductionAndMetaLevelAssumptions } from "../utilities/string";
 import { labelFromJSON,
          labelToLabelJSON,
@@ -103,7 +103,7 @@ export default class TopLevelMetaAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion...`);
 
-    await asyncRestrict(async (context) => {
+    await enclose(async (context) => {
       const labelVerifies = this.verifyLabel();
 
       if (labelVerifies) {

package/src/element/variable.js

@@ -45,11 +45,11 @@ export default define(class Variable extends Element {
     return identifierEqualTo;
   }
 
-  compare(variable) {
+  compareVariable(variable) {
     const variableIdentifier = variable.getIdentifier(),
-          comparesTo = (this.identifier === variableIdentifier);
+          comparesToVariable = (this.identifier === variableIdentifier);
 
-    return comparesTo;
+    return comparesToVariable;
   }
 
   compareParamter(parameter) {
@@ -117,9 +117,9 @@ export default define(class Variable extends Element {
 
     variable = this; ///
 
-    const variableIdentifier = variable.getIdentifier();
+    const variableNode = variable.getNode();
 
-    substitution = context.findSubstitutionByVariableIdentifier(variableIdentifier);
+    substitution = context.findSubstitutionByVariableNode(variableNode);
 
     if (substitution !== null) {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);

package/src/node/frame.js

@@ -22,18 +22,6 @@ export default class FrameNode extends NonTerminalNode {
     return singular;
   }
 
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const metavariableNode = this.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      metavariableName = metavariableNode.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
   getAssumptionNodes() {
     const ruleName = ASSUMPTION_RULE_NAME,
           declarationNodes = this.getNodesByRuleName(ruleName);

package/src/node/statement.js

@@ -31,18 +31,6 @@ export default class StatementNode extends NonTerminalNode {
     return singular;
   }
 
-  getMetavariableName() {
-    let metavariableName = null;
-
-    const metavariableNode = this.getMetavariableNode();
-
-    if (metavariableNode !== null) {
-      metavariableName = metavariableNode.getMetavariableName();
-    }
-
-    return metavariableName;
-  }
-
   getMetavariableNode() {
     const singularMetavariableNode = this.getSingularMetavariableNode(),
           metavariableNode = singularMetavariableNode;  ///

package/src/node/term.js

@@ -36,34 +36,6 @@ export default class TermNode extends NonTerminalNode {
     return singularTermNode;
   }
 
-  getVariableIdentifier() {
-    let variableIdentifier = null;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const singularVariableNode = this.getSingularVariableNode();
-
-      variableIdentifier = singularVariableNode.getVariableIdentifier();
-    }
-
-    return variableIdentifier;
-  }
-
-  getSingularVariableIdentifier() {
-    let singularVariableIdentifier = null;
-
-    const singularVariableNode = this.getSingularVariableNode();
-
-    if (singularVariableNode !== null) {
-      const variableIdentifier = singularVariableNode.getVariableIdentifier();
-
-      singularVariableIdentifier = variableIdentifier;  ///
-    }
-
-    return singularVariableIdentifier;
-  }
-
   getVariableNodes() {
     const ruleName = VARIABLE_RULE_NAME,
           variableNodes = this.getNodesByRuleName(ruleName);

package/src/process/assign.js

@@ -24,37 +24,17 @@ export function judgementAssignmentFromJudgement(judgement, context) {
 }
 
 export function leftVariableAssignmentFromEquality(equality, context) {
-  let leftVariableAssignment = (contxt) => {
-    ///
-  };
-
   const type = equality.getType(),
-        leftTermNode = equality.getLeftTermNode(),
-        singularVariableNode = leftTermNode.getSingularVariableNode();
-
-  if (singularVariableNode !== null) {
-    const leftVariableNode = singularVariableNode;  ///
-
-    leftVariableAssignment = variableAssignmentFromVariableNodeAndType(leftVariableNode, type, context);
-  }
+        leftTerm = equality.getLeftTerm(),
+        leftVariableAssignment = variableAssignmentFromTermAndType(leftTerm, type, context);
 
   return leftVariableAssignment;
 }
 
 export function rightVariableAssignmentFromEquality(equality, context) {
-  let rightVariableAssignment = (context) => {
-    ///
-  };
-
   const type = equality.getType(),
-        rightTermNode = equality.getRightTermNode(),
-        singularVariableNode = rightTermNode.getSingularVariableNode();
-
-  if (singularVariableNode !== null) {
-    const rightVariableNode = singularVariableNode;  ///
-
-    rightVariableAssignment = variableAssignmentFromVariableNodeAndType(rightVariableNode, type, context);
-  }
+        rightTerm = equality.getRightTerm(),
+        rightVariableAssignment = variableAssignmentFromTermAndType(rightTerm, type, context);
 
   return rightVariableAssignment;
 }
@@ -68,15 +48,10 @@ export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
         termSingular = term.isSingular();
 
   if (termSingular) {
-    const variableIdentifier = term.getVariableIdentifier(),
-          variable = context.findVariableByVariableIdentifier(variableIdentifier);
+    const type = typeAssertion.getType(),
+          variableNode = term.getVariableNode();
 
-    if (variable !== null) {
-      const type = typeAssertion.getType(),
-            variableNode = variable.getNode();
-
-      variableAssignment = variableAssignmentFromVariableNodeAndType(variableNode, type, context);
-    }
+    variableAssignment = variableAssignmentFromTermAndType(variableNode, type, context);
   }
 
   return variableAssignment;
@@ -104,26 +79,40 @@ export function variableAssignmentFromPrepertyAssertion(propertyAssertion, conte
 
   }
 
-function variableAssignmentFromVariableNodeAndType(variableNode, type, context) {
-  const variable = variableFromVariableNode(variableNode, context);
+function variableAssignmentFromTermAndType(term, type, context) {
+  let variableAssignment = (context) => {
+    ///
+  };
+
+  const termSingular = term.isSingular();
 
-  variable.setType(type);
+  if (termSingular) {
+    const termType = term.getType(),
+          termTypeEqualToType = termType.isEqualTo(type);
 
-  const variableAssignment = (context) => {
-    const declaredVariable = variable;  ///
+    if (!termTypeEqualToType) {
+      const variableNode = term.getVariableNode(),
+            variable = variableFromVariableNode(variableNode, context);
 
-    context.addDeclaredVariable(declaredVariable);
+      variable.setType(type);
 
-    const declaredVariableTypeString = declaredVariable.getTypeString(),
-          declaredVariableString = declaredVariable.getString(),
-          assigned = true;  ///
+      variableAssignment = (context) => {
+        const declaredVariable = variable;  ///
 
-    assigned ?
-      context.trace(`Assigned the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`) :
-        context.debug(`Unable to assign the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`);
+        context.addDeclaredVariable(declaredVariable);
 
-    return assigned;
-  };
+        const declaredVariableTypeString = declaredVariable.getTypeString(),
+              declaredVariableString = declaredVariable.getString(),
+              assigned = true;  ///
+
+        assigned ?
+          context.trace(`Assigned the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`) :
+             context.debug(`Unable to assign the '${declaredVariableString}' declared variable with type '${declaredVariableTypeString}'.`);
+
+        return assigned;
+      };
+    }
+  }
 
   return variableAssignment;
 }

package/src/utilities/context.js

@@ -1,22 +1,36 @@
 "use strict";
 
-import ProofContext from "../context/proof";
 import NestedContext from "../context/nested";
 import TheticContext from "../context/thetic";
+import BoundedContext from "../context/bounded";
 import NominalContext from "../context/nominal";
 import LiteralContext from "../context/literal";
 import LiminalContext from "../context/liminal";
+import SynopticContext from "../context/synoptic";
 import IllativeContext from "../context/illative";
 import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
-import SyntheticContext from "../context/synthetic";
 import NominalFileContext from "../context/file/nominal";
 
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
 export function join(innerFunction, ...contexts) {
-  const syntheticContext = SyntheticContext.fromContexts(...contexts),
-        context = syntheticContext;  ///
+  const synopticContext = SynopticContext.fromContexts(...contexts),
+        context = synopticContext;  ///
+
+  return innerFunction(context);
+}
+
+export function ground(innerFunction) {
+  let context;
+
+  const nominalContext = NominalContext.fromNothing();
+
+  context = nominalContext; ///
+
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
 
   return innerFunction(context);
 }
@@ -57,14 +71,6 @@ export function declare(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function descend(innerFunction, context) {
-  const nestedContext = NestedContext.fromNothing(context);
-
-  context = nestedContext;  ///
-
-  return innerFunction(context);
-}
-
 export function attempt(innerFunction, context) {
   const ephemeralContext = EphemeralContext.fromNothing(context);
 
@@ -73,32 +79,38 @@ export function attempt(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function reconcile(innerFunction, context) {
-  const liminalContext = LiminalContext.fromNothing(context);
+export function descend(innerFunction, context) {
+  const nestedContext = NestedContext.fromNothing(context);
 
-  context = liminalContext;  ///
+  context = nestedContext;  ///
 
   return innerFunction(context);
 }
 
-export function instantiate(innerFunction, context) {
-  const literalContext = LiteralContext.fromNothing(context);
+export function enclose(innerFunction, metaLevelAssumptions, context) {
+  if (context === undefined) {
+    context = metaLevelAssumptions;  ///
 
-  context = literalContext;  ///
+    metaLevelAssumptions = null;
+  }
+
+  const boundedContext = BoundedContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
+
+  context = boundedContext;  ///
 
   return innerFunction(context);
 }
 
-export function nominally(innerFunction) {
-  let context;
-
-  const nominalContext = NominalContext.fromNothing();
+export function evaluate(procedure, terms) {
+  const context = procedure.getContext();
 
-  context = nominalContext; ///
+  return procedure.call(terms, context);
+}
 
-  const literalContext = LiteralContext.fromNothing(context);
+export function reconcile(innerFunction, context) {
+  const liminalContext = LiminalContext.fromNothing(context);
 
-  context = literalContext;  ///
+  context = liminalContext;  ///
 
   return innerFunction(context);
 }
@@ -121,24 +133,10 @@ export function unserialise(innerFunction, json, context) {
   return innerFunction(json, context);
 }
 
-export async function asyncRestrict(innerFunction, metaLevelAssumptions, context) {
-  if (context === undefined) {
-    context = metaLevelAssumptions;  ///
-
-    metaLevelAssumptions = null;
-  }
-
-  const proofContext = ProofContext.fromMetaLevelAssumptions(metaLevelAssumptions, context);
-
-  context = proofContext;  ///
-
-  return await innerFunction(context);
-}
-
-export async function asyncReconcile(innerFunction, context) {
-  const liminalContext = LiminalContext.fromNothing(context);
+export function instantiate(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
 
-  context = liminalContext;  ///
+  context = literalContext;  ///
 
-  return await innerFunction(context);
+  return innerFunction(context);
 }

package/src/utilities/element.js

@@ -618,9 +618,10 @@ export function termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, c
   const { TermSubstitution } = elements,
         node = termSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromTermSubstitutionNode(termSubstitutionNode, context),
         targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
         replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context),
-        termSubstitution = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
+        termSubstitution = new TermSubstitution(context, string, node, generalContext, targetTerm, replacementTerm);
 
   return termSubstitution;
 }
@@ -629,9 +630,10 @@ export function frameSubstitutionFromFrameSubstitutionNode(frameSubstitutionNode
   const { FrameSubstitution } = elements,
         node = frameSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context),
         targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
         replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-        frameSubstitution = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
+        frameSubstitution = new FrameSubstitution(context, string, node, generalContext, targetFrame, replacementFrame);
 
   return frameSubstitution;
 }
@@ -767,9 +769,10 @@ export function referenceSubstitutionFromReferenceSubstitutionNode(referenceSubs
   const { ReferenceSubstitution } = elements,
         node = referenceSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
         targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
         replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-        referenceSubstitution = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
+        referenceSubstitution = new ReferenceSubstitution(context, string, node, generalContext, targetReference, replacementReference);
 
   return referenceSubstitution;
 }
@@ -779,11 +782,12 @@ export function statementSubstitutionFromStatementSubstitutionNode(statementSubs
   const { StatementSubstitution } = elements,
         node = statementSubstitutionNode,  ///
         string = context.nodeAsString(node),
+        generalContext = generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context),
         resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context),
         substitution = substitutionFromStatementSubstitutionNode(statementSubstitutionNode, context),
         targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
         replacementStatement = replacementStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
-        statementSubstitution = new StatementSubstitution(context, string, node, resolved, substitution, targetStatement, replacementStatement);
+        statementSubstitution = new StatementSubstitution(context, string, node, generalContext, resolved, substitution, targetStatement, replacementStatement);
 
   return statementSubstitution;
 }
@@ -1757,6 +1761,12 @@ export function topLevelMetaAssertionFromReferenceNode(referenceNode, context) {
   return topLevelMetaAssertion;
 }
 
+export function generalContextFromTermSubstitutionNode(termSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function deductionFromTopLevelMetaAssertionNode(metaLemmaMetathoremNode, context) {
   const deductionNode = metaLemmaMetathoremNode.getDeductionNode(),
         deduction = deductionFromDeductionNode(deductionNode, context);
@@ -1778,6 +1788,12 @@ export function replacementTermFromTermSubstitutionNode(termSubstitutionNode, co
   return replacementTerm;
 }
 
+export function generalContextFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function superTypesFromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
   let superTypes = [];
 
@@ -1881,6 +1897,18 @@ export function provisionalFromComplexTypeDeclarationNode(complexTypeDeclaration
   return provisional;
 }
 
+export function generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
+export function generalContextFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+  const generalContext = null;
+
+  return generalContext;
+}
+
 export function metavariableFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   const metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
         metavariable = metavariableFromMetavariableNode(metavariableNode, context);