occam-verify-cli 1.0.444 → 1.0.457

package/src/context/file.js

@@ -5,6 +5,7 @@ import { arrayUtilities } from "necessary";
 import elements from "../elements";
 
 import { verifyFile } from "../process/verify";
+import { chainContext } from "../utilities/context";
 import { baseTypeFromNothing } from "../types";
 import { nodeAsString, nodesAsString } from "../utilities/node";
 import { typesFromJSON,
@@ -35,8 +36,8 @@ import { typesFromJSON,
 const { push, filter } = arrayUtilities;
 
 export default class FileContext {
-  constructor(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables) {
-    this.releaseContext = releaseContext;
+  constructor(context, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables) {
+    this.context = context;
     this.filePath = filePath;
     this.lineIndex = lineIndex;
     this.tokens = tokens;
@@ -54,10 +55,12 @@ export default class FileContext {
     this.constructors = constructors;
     this.metatheorems = metatheorems;
     this.metavariables = metavariables;
+
+    return chainContext(this);
   }
 
-  getReleaseContext() {
-    return this.releaseContext;
+  getContext() {
+    return this.context;
   }
 
   getFilePath() {
@@ -76,14 +79,6 @@ export default class FileContext {
     return this.node;
   }
 
-  getLexer() { return this.releaseContext.getLexer(); }
-
-  getParser() { return this.releaseContext.getParser(); }
-
-  getMetaTypes() { return this.releaseContext.getMetaTypes(); }
-
-  getTypePrefix() { return this.releaseContext.getTypePrefix(); }
-
   getJudgements() {
     const judgements = [];
 
@@ -97,17 +92,17 @@ export default class FileContext {
     return equivalences;
   }
 
-  getStepsOrSubproofs() {
-    const stepsOrSubproofs = [];
+  getSubproofOrProofAssertions() {
+    const subproofOrProofAssertions = [];
 
-    return stepsOrSubproofs;
+    return subproofOrProofAssertions;
   }
 
   getLabels(includeRelease = true) {
     const labels = [];
 
     if (includeRelease) {
-      const releaseContextLabels = this.releaseContext.getLabels();
+      const releaseContextLabels = this.context.getLabels();
 
       push(labels, releaseContextLabels);
     } else {
@@ -153,7 +148,7 @@ export default class FileContext {
 
   getTypes(includeRelease = true, includeDependencies = true) {
     const types = includeRelease ?
-                    this.releaseContext.getTypes(includeDependencies) :
+                    this.context.getTypes(includeDependencies) :
                       this.types;
 
     return types;
@@ -161,7 +156,7 @@ export default class FileContext {
 
   getRules(includeRelease = true) {
     const rules = includeRelease ?
-                    this.releaseContext.getRules() :
+                    this.context.getRules() :
                       this.rules;
 
     return rules;
@@ -169,7 +164,7 @@ export default class FileContext {
 
   getAxioms(includeRelease = true) {
     const axioms = includeRelease ?
-                     this.releaseContext.getAxioms() :
+                     this.context.getAxioms() :
                        this.axioms;
 
     return axioms;
@@ -177,7 +172,7 @@ export default class FileContext {
 
   getLemmas(includeRelease = true) {
     const lemmas = includeRelease ?
-                     this.releaseContext.getLemmas() :
+                     this.context.getLemmas() :
                        this.lemmas;
 
     return lemmas;
@@ -185,7 +180,7 @@ export default class FileContext {
 
   getTheorems(includeRelease = true) {
     const theorems = includeRelease ?
-                       this.releaseContext.getTheorems() :
+                       this.context.getTheorems() :
                          this.theorems;
 
     return theorems;
@@ -197,7 +192,7 @@ export default class FileContext {
 
   getProcedures(includeRelease = true) {
     const procedures = includeRelease ?
-                         this.releaseContext.getProcedures() :
+                         this.context.getProcedures() :
                            null;  ///
 
     return procedures;
@@ -205,7 +200,7 @@ export default class FileContext {
 
   getMetaLemmas(includeRelease = true) {
     const metaLemmas = includeRelease ?
-                         this.releaseContext.getMetaLemmas() :
+                         this.context.getMetaLemmas() :
                            this.metaLemmas;
 
     return metaLemmas;
@@ -213,7 +208,7 @@ export default class FileContext {
 
   getConjectures(includeRelease = true) {
     const conjectures = includeRelease ?
-                          this.releaseContext.getConjectures() :
+                          this.context.getConjectures() :
                             this.conjectures;
 
     return conjectures;
@@ -221,7 +216,7 @@ export default class FileContext {
 
   getCombinators(includeRelease = true) {
     const combinators = includeRelease ?
-                          this.releaseContext.getCombinators() :
+                          this.context.getCombinators() :
                             this.combinators;
 
     return combinators;
@@ -229,7 +224,7 @@ export default class FileContext {
 
   getTypePrefixes(includeRelease = true) {
     const typePrefixes = includeRelease ?
-                           this.releaseContext.getTypePrefixes() :
+                           this.context.getTypePrefixes() :
                              this.typePrefixes;
 
     return typePrefixes;
@@ -237,7 +232,7 @@ export default class FileContext {
 
   getConstructors(includeRelease = true) {
     const constructors = includeRelease ?
-                           this.releaseContext.getConstructors() :
+                           this.context.getConstructors() :
                              this.constructors;
 
     return constructors;
@@ -245,7 +240,7 @@ export default class FileContext {
 
   getMetatheorems(includeRelease = true) {
     const metatheorems = includeRelease ?
-                           this.releaseContext.getMetatheorems() :
+                           this.context.getMetatheorems() :
                              this.metatheorems;
 
     return metatheorems;
@@ -440,10 +435,10 @@ export default class FileContext {
 
     filter(metaLemmas, (metaLemma) => {
       const context = this, ///
-            metaLemmaMetaTheorem = metaLemma, ///
-            metaLemmaMetatheoremUnifies = reference.unifyMetaLemmaMetatheorem(metaLemmaMetaTheorem, context);
+            topLevelMetaAssertion = metaLemma, ///
+            topLevelMetaAssertionUnifies = reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-      if (metaLemmaMetatheoremUnifies) {
+      if (topLevelMetaAssertionUnifies) {
         return true;
       }
     });
@@ -456,10 +451,10 @@ export default class FileContext {
 
     filter(metatheorems, (metatheorem) => {
       const context = this, ///
-            metaLemmaMetaTheorem = metatheorem, ///
-            metaLemmaMetatheoremUnifies = reference.unifyMetaLemmaMetatheorem(metaLemmaMetaTheorem, context);
+            topLevelMetaAssertion = metatheorem, ///
+            topLevelMetaAssertionUnifies = reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-      if (metaLemmaMetatheoremUnifies) {
+      if (topLevelMetaAssertionUnifies) {
         return true;
       }
     });
@@ -467,33 +462,33 @@ export default class FileContext {
     return metatheorems;
   }
 
-  findMetaLemmaMetatheoremByReference(reference) {
+  findTopLevelMetaAssertionByReference(reference) {
     const metaLemma = this.findMetaLemmaByReference(reference),
           metatheorem = this.findMetatheoremByReference(reference),
-          metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
+          topLevelMetaAssertion = (metaLemma || metatheorem);  ///
 
-    return metaLemmaMetatheorem;
+    return topLevelMetaAssertion;
   }
 
-  findMetaLemmaMetatheoremsByReference(reference) {
+  findTopLevelMetaAssertionsByReference(reference) {
     const metaLemmas = this.findMetaLemmasByReference(reference),
           metatheorems = this.findMetatheoremsByReference(reference),
-          metaLemmaMetatheorems = [
+          topLevelMetaAssertions = [
             ...metaLemmas,
             ...metatheorems
           ];
 
-    return metaLemmaMetatheorems;
+    return topLevelMetaAssertions;
   }
 
-  findAxiomLemmaTheoremOrConjectureByReference(reference) {
+  findTopLevelAssertionByReference(reference) {
     const axiom = this.findAxiomByReference(reference),
           lemma = this.findLemmaByReference(reference),
           theorem = this.findTheoremByReference(reference),
           conjecture = this.findConjectureByReference(reference),
-          axiomLemmaTheoremOrConjecture = (axiom || lemma || theorem || conjecture);
+          topLevelAssertion = (axiom || lemma || theorem || conjecture);
 
-    return axiomLemmaTheoremOrConjecture;
+    return topLevelAssertion;
   }
 
   findMetavariable(metavariable) {
@@ -776,11 +771,11 @@ export default class FileContext {
     return metavariablePresent;
   }
 
-  isMetaLemmaMetatheoremPresentByReference(reference) {
-    const metaLemmaMetatheorem = this.findMetaLemmaMetatheoremByReference(reference),
-          metaLemmaMetatheoremPresent = (metaLemmaMetatheorem !== null);
+  isTopLevelMetaAssertionPresentByReference(reference) {
+    const topLevelMetaAssertion = this.findTopLevelMetaAssertionByReference(reference),
+          topLevelMetaAssertionPresent = (topLevelMetaAssertion !== null);
 
-    return metaLemmaMetatheoremPresent;
+    return topLevelMetaAssertionPresent;
   }
 
   nodeAsString(node) {
@@ -795,36 +790,34 @@ export default class FileContext {
     return string;
   }
 
-  findFile(filePath) { return this.releaseContext.findFile(filePath); }
-
   trace(message, node = null) {
     this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
 
-    this.releaseContext.trace(message, this.filePath, this.lineIndex);
+    this.context.trace(message, this.filePath, this.lineIndex);
   }
 
   debug(message, node = null) {
     this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
 
-    this.releaseContext.debug(message, this.filePath, this.lineIndex);
+    this.context.debug(message, this.filePath, this.lineIndex);
   }
 
   info(message, node = null) {
     this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
 
-    this.releaseContext.info(message, this.filePath, this.lineIndex);
+    this.context.info(message, this.filePath, this.lineIndex);
   }
 
   warning(message, node = null) {
     this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
 
-    this.releaseContext.warning(message, this.filePath, this.lineIndex);
+    this.context.warning(message, this.filePath, this.lineIndex);
   }
 
   error(message, node = null) {
     this.lineIndex = lineIndexFromNodeAndTokens(node, this.tokens, this.lineIndex);
 
-    this.releaseContext.error(message, this.filePath, this.lineIndex);
+    this.context.error(message, this.filePath, this.lineIndex);
   }
 
   verify() {
@@ -961,7 +954,7 @@ export default class FileContext {
     return json;
   }
 
-  static fromFile(file, releaseContext) {
+  static fromFile(file, context) {
     const filePath = file.getPath(),
           lineIndex = null,
           tokens = null,
@@ -979,12 +972,12 @@ export default class FileContext {
           constructors = [],
           metatheorems = [],
           metavariables = [],
-          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(context, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
 
     return fileContext;
   }
 
-  static fromFilePath(filePath, releaseContext) {
+  static fromFilePath(filePath, context) {
     const lineIndex = null,
           tokens = null,
           node = null,
@@ -1001,7 +994,7 @@ export default class FileContext {
           constructors = null,
           metatheorems = null,
           metavariables = null,
-          fileContext = new FileContext(releaseContext, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
+          fileContext = new FileContext(context, filePath, lineIndex, tokens, node, types, rules, axioms, lemmas, theorems, variables, metaLemmas, conjectures, combinators, typePrefixes, constructors, metatheorems, metavariables);
 
     return fileContext;
   }

package/src/context/fragment.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import { nodeAsString } from "../utilities/node";
+import { chainContext } from "../utilities/context";
+
+export default class FragmentContext {
+  constructor(context, tokens) {
+    this.context = context;
+    this.tokens = tokens;
+
+    return chainContext(this);
+  }
+
+  getContext() {
+    return this.context;
+  }
+
+  getTokens() {
+    return this.tokens;
+  }
+
+  setTokens(tokens) {
+    this.tokens = tokens;
+  }
+
+  nodeAsString(node) {
+    const string = nodeAsString(node, this.tokens);
+
+    return string;
+  }
+
+  static fromNothing(context) {
+    const tokens = null,
+          fragmentContext = new FragmentContext(context, tokens);
+
+    return fragmentContext;
+  }
+}

package/src/context/release.js

@@ -10,8 +10,8 @@ import FileContext from "../context/file";
 import NominalLexer from "../nominal/lexer";
 import NominalParser from "../nominal/parser";
 
+import { getMetaTypes } from "../metaTypes";
 import { customGrammarFromNameAndEntries, combinedCustomGrammarFromReleaseContexts } from "../utilities/customGrammar";
-import { frameMetaTypeFromNothing, referenceMetaTypeFromNothing, statementMetaTypeFromNothing } from "../metaTypes";
 
 const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
       { nominalParserFromCombinedCustomGrammar } = parsersUtilities,
@@ -58,14 +58,7 @@ export default class ReleaseContext {
   }
 
   getMetaTypes() {
-    const frameMetaType = frameMetaTypeFromNothing(),
-          referenceMetaType = referenceMetaTypeFromNothing(),
-          statementMetaType = statementMetaTypeFromNothing(),
-          metaTypes = [
-            frameMetaType,
-            referenceMetaType,
-            statementMetaType
-          ];
+    const metaTypes = getMetaTypes();
 
     return metaTypes;
   }
@@ -589,7 +582,8 @@ function fileContextsFromJSON(json,fileContexts, releaseContext) {
     }
 
     if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFilePath(filePath, releaseContext);
+      const context = releaseContext, ///
+            fileContext = FileContext.fromFilePath(filePath, context);
 
       fileContexts.push(fileContext);
 
@@ -612,7 +606,8 @@ function fileContextsFromEntries(entries, fileContexts, releaseContext) {
     }
 
     if (filePathNominalFilePath) {
-      const fileContext = FileContext.fromFile(file, releaseContext);
+      const context = releaseContext, ///
+            fileContext = FileContext.fromFile(file, context);
 
       fileContexts.push(fileContext);
     }

package/src/context/{local.js → scoped.js}

@@ -4,15 +4,19 @@ import { arrayUtilities } from "necessary";
 
 import elements from "../elements";
 
+import { chainContext } from "../utilities/context";
+
 const { last } = arrayUtilities;
 
-class LocalContext {
-  constructor(context, variables, judgements, equivalences, stepsOrSubproofs) {
+class ScopedContext {
+  constructor(context, variables, judgements, equivalences, subproofOrProofAssertions) {
     this.context = context;
     this.variables = variables;
     this.judgements = judgements;
     this.equivalences = equivalences;
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
+
+    return chainContext(this);
   }
 
   getContext() {
@@ -55,69 +59,43 @@ class LocalContext {
     return equivalences;
   }
 
-  getSteps() {
-    const stepsOrSubproofs = this.getStepsOrSubproofs(),
-          steps = stepsOrSubproofs.filter((stepOrSubproof) => {
-            const stepOrSubproofStep = stepOrSubproof.isStep();
+  getProofAssertions() {
+    const subproofOrProofAssertions = this.getSubproofOrProofAssertions(),
+          proofAssertions = subproofOrProofAssertions.filter((subproofOrProofAssertion) => {
+            const subproofOrProofAssertionproofAssertion = subproofOrProofAssertion.isProofAssertion();
 
-            if (stepOrSubproofStep) {
+            if (subproofOrProofAssertionproofAssertion) {
               return true;
             }
           });
 
-    return steps;
+    return proofAssertions;
   }
 
-  getLastStep() {
-    let lastStep = null;
+  getLastProofAssertion() {
+    let lastProofAssertion = null;
 
-    const steps = this.getSteps(),
-          stepsLength = steps.length;
+    const proofAssertions = this.getProofAssertions(),
+          proofAssertionsLength = proofAssertions.length;
 
-    if (stepsLength > 0) {
-      lastStep = last(steps);
+    if (proofAssertionsLength > 0) {
+      lastProofAssertion = last(proofAssertions);
     }
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
-  getStepsOrSubproofs() {
-    let stepsOrSubproofs = this.context.getStepsOrSubproofs();
+  getSubproofOrProofAssertions() {
+    let subproofOrProofAssertions = this.context.getSubproofOrProofAssertions();
 
-    stepsOrSubproofs = [  ///
-      ...stepsOrSubproofs,
-      ...this.stepsOrSubproofs
+    subproofOrProofAssertions = [  ///
+      ...subproofOrProofAssertions,
+      ...this.subproofOrProofAssertions
     ];
 
-    return stepsOrSubproofs;
+    return subproofOrProofAssertions;
   }
 
-  getFilePath() { return this.context.getFilePath(); }
-
-  getLexer() { return this.context.getLexer(); }
-
-  getParser() { return this.context.getParser(); }
-
-  getAxioms() { return this.context.getAxioms(); }
-
-  getLemmas() { return this.context.getLemmas(); }
-
-  getTheorems() { return this.context.getTheorems(); }
-
-  getConjectures() { return this.context.getConjectures(); }
-
-  getCombinators() { return this.context.getCombinators(); }
-
-  getConstructors() { return this.context.getConstructors(); }
-
-  getTypePrefix() { return this.context.getTypePrefix(); }
-
-  addAxiom(axiom) { this.context.addAxiom(axiom); }
-
-  addLemma(lemma) { this.context.addLemma(lemma); }
-
-  addTheorem(theorem) { this.context.addTheorem(theorem); }
-
   addEquality(equality) {
     let equalityAdded;
 
@@ -187,32 +165,10 @@ class LocalContext {
     return judgementAdded;
   }
 
-  addStepOrSubproof(stepOrSubproof) {
-    this.stepsOrSubproofs.push(stepOrSubproof);
+  addSubproofOrProofAssertion(subproofOrProofAssertion) {
+    this.subproofOrProofAssertions.push(subproofOrProofAssertion);
   }
 
-  findProcedureByName(name) { return this.context.findProcedureByName(name); }
-
-  findLabelByReference(reference, context) { return this.context.findLabelByReference(reference, context); }
-
-  findRuleByReference(reference) { return this.context.findRuleByReference(reference); }
-
-  findAxiomByReference(reference) { return this.context.findAxiomByReference(reference); }
-
-  findLemmaByReference(reference) { return this.context.findLemmaByReference(reference); }
-
-  findTheoremByReference(reference) { return this.context.findTheoremByReference(reference); }
-
-  findConjectureByReference(reference) { return this.context.findConjectureByReference(reference); }
-
-  findMetaLemmasByReference(reference) { return this.context.findMetaLemmasByReference(reference); }
-
-  findMetatheoremsByReference(reference) { return this.context.findMetatheoremsByReference(reference); }
-
-  findMetaLemmaMetatheoremByReference(reference) { return this.context.findMetaLemmaMetatheoremByReference(reference); }
-
-  findMetaLemmaMetatheoremsByReference(reference) { return this.context.findMetaLemmaMetatheoremsByReference(reference); }
-
   findVariableByVariableIdentifier(variableIdentifier, nested = true) {
     const variables = this.getVariables(nested),
           variable = variables.find((variable) => {
@@ -246,36 +202,8 @@ class LocalContext {
 
   findEquivalenceByTerm(term) { return this.equivalences.findEquivalenceByTerm(term); }
 
-  findMetavariable(metavariable) { return this.context.findMetavariable(metavariable); }
-
-  findLabelByMetavariable(metavariable) { return this.context.findLabelByMetavariable(metavariable); }
-
-  findTypeByNominalTypeName(nominalTypeName) { return this.context.findTypeByNominalTypeName(nominalTypeName); }
-
-  findMetaTypeByMetaTypeName(metaTypeName) { return this.context.findMetaTypeByMetaTypeName(metaTypeName); }
-
-  findMetavariableByMetavariableName(metavariableName) { return this.context.findMetavariableByMetavariableName(metavariableName); }
-
-  isProcedurePresentByName(name) { return this.context.isProcedurePresentByName(name); }
-
-  isLabelPresentByReference(reference) { return this.context.isLabelPresentByReference(reference); }
-
-  isMetavariablePresentByReference(reference) { return this.context.isMetavariablePresentByReference(reference); }
-
-  isMetaLemmaMetatheoremPresentByReference(reference) { return this.context.isMetaLemmaMetatheoremPresentByReference(reference); }
-
-  findAxiomLemmaTheoremOrConjectureByReference(reference) { return this.context.findAxiomLemmaTheoremOrConjectureByReference(reference); }
-
-  isMetavariablePresent(metavariable) { return this.context.isMetavariablePresent(metavariable); }
-
   isTypePresentByTypeName(typeName, includeRelease = true, includeDependencies = true) { return this.context.isTypePresentByTypeName(typeName, includeRelease, includeDependencies); }
 
-  isTypePresentByNominalTypeName(nominalTypeName) { return this.context.isTypePresentByNominalTypeName(nominalTypeName); }
-
-  isTypePresentByPrefixedTypeName(prefixedTypeName) { return this.context.isTypePresentByPrefixedTypeName(prefixedTypeName); }
-
-  isTypePrefixPresentByTypePrefixName(typePrefixName) { return this.context.isTypePrefixPresentByTypePrefixName(typePrefixName); }
-
   isVariablePresentByVariableIdentifier(variableIdentifier, nested = true) {
     const variable = this.findVariableByVariableIdentifier(variableIdentifier, nested),
           variablePresent = (variable !== null);
@@ -283,12 +211,6 @@ class LocalContext {
     return variablePresent;
   }
 
-  isLabelPresentByMetavariableName(metavariableName) { return this.context.isLabelPresentByMetavariableName(metavariableName); }
-
-  isLabelPresentByMetavariable(metavariable) { return this.context.isLabelPresentByMetavariable(metavariable); }
-
-  isMetavariablePresentByMetavariableName(metavariableNode) { return this.context.isMetavariablePresentByMetavariableName(metavariableNode); }
-
   isJudgementPresentByMetavariable(metavariable) {
     const judgement = this.findJudgementByMetavariable(metavariable),
           judgementPresent = (judgement !== null);
@@ -346,9 +268,9 @@ class LocalContext {
 
   compareTermAndPropertyRelation(term, propertyRelation) {
     const context = this, ///
-          steps = this.getSteps(),
-          comparesToTermAndPropertyRelation = steps.some((step) => {
-            const comparesToTermAndPropertyRelation = step.compareTermAndPropertyRelation(term, propertyRelation, context);
+          proofAssertions = this.getProofAssertions(),
+          comparesToTermAndPropertyRelation = proofAssertions.some((proofAssertion) => {
+            const comparesToTermAndPropertyRelation = proofAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);
 
             if (comparesToTermAndPropertyRelation) {
               return true;
@@ -358,30 +280,16 @@ class LocalContext {
     return comparesToTermAndPropertyRelation;
   }
 
-  nodeAsString(node) { return this.context.nodeAsString(node); }
-
-  nodesAsString(node) { return this.context.nodesAsString(node); }
-
-  trace(message, node = null) { this.context.trace(message, node); }
-
-  debug(message, node = null) { this.context.debug(message, node); }
-
-  info(message, node = null) { this.context.info(message, node); }
-
-  warning(message, node = null) { this.context.warning(message, node); }
-
-  error(message, node = null) { this.context.error(message, node); }
-
   static fromNothing(context) {
     const { Equivalences } = elements,
           variables = [],
           judgements = [],
           equivalences = Equivalences.fromNothing(),
-          stepsOrSubproofs = [],
-          localContext = new LocalContext(context, variables, judgements, equivalences, stepsOrSubproofs);
+          subproofOrProofAssertions = [],
+          scopedContext = new ScopedContext(context, variables, judgements, equivalences, subproofOrProofAssertions);
 
-    return localContext;
+    return scopedContext;
   }
 }
 
-export default LocalContext;
+export default ScopedContext;