occam-verify-cli 1.0.230 → 1.0.233

package/src/dom/label.js

@@ -1,23 +1,22 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 
 import { domAssigned } from "../dom";
 import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default domAssigned(class Label {
-  constructor(metavariable, fileContext) {
+  constructor(context, metavariable) {
+    this.context = context;
     this.metavariable = metavariable;
-    this.fileContext = fileContext;
   }
 
-  getMetavariable() {
-    return this.metavariable;
+  getContext() {
+    return this.context;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getString() { return this.metavariable.getString(); }
@@ -56,28 +55,28 @@ export default domAssigned(class Label {
 
     const labelString = this.getString(); ///
 
-    this.fileContext.trace(`Verifying the '${labelString}' label...`);
+    this.context.trace(`Verifying the '${labelString}' label...`);
 
     let labelPresent;
 
     if (nameOnly) {
       const metavariableName = this.getMetavariableName();
 
-      labelPresent = this.fileContext.isLabelPresentByMetavariableName(metavariableName);
+      labelPresent = this.context.isLabelPresentByMetavariableName(metavariableName);
     } else {
       const metavariable = this.getMetavariable();
 
-      labelPresent = this.fileContext.isLabelPresentByMetavariable(metavariable);
+      labelPresent = this.context.isLabelPresentByMetavariable(metavariable);
     }
 
     if (labelPresent) {
-      this.fileContext.debug(`The '${labelString}' label is already present.`);
+      this.context.debug(`The '${labelString}' label is already present.`);
     } else {
       verifies = true;
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${labelString}' label.`);
+      this.context.debug(`...verified the '${labelString}' label.`);
     }
 
     return verifies;
@@ -95,18 +94,17 @@ export default domAssigned(class Label {
 
   static name = "Label";
 
-  static fromJSON(json, fileContext) {
-    const metavariable = metavariableFromJSON(json, fileContext),
-          label = new Label(metavariable, fileContext);
+  static fromJSON(json, context) {
+    const metavariable = metavariableFromJSON(json, context),
+          label = new Label(context, metavariable);
 
     return label;
   }
 
-  static fromLabelNode(labelNode, fileContext) {
+  static fromLabelNode(labelNode, context) {
     const { Metavariable } = dom,
-          localContext = LocalContext.fromFileContext(fileContext),
-          metavariable = Metavariable.fromLabelNode(labelNode, localContext),
-          label = new Label(metavariable, fileContext);
+          metavariable = Metavariable.fromLabelNode(labelNode, context),
+          label = new Label(context, metavariable);
 
     return label;
   }

package/src/dom/lemma.js

@@ -9,23 +9,23 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
     let verifies;
 
     const lemma = this, ///
-          fileContext = this.getFileContext(),
+          context = this.getContext(),
           lemmaString = lemma.getString();
 
     (lemmaString === null) ?
-      fileContext.trace(`Verifying a lemma...`) :
-        fileContext.trace(`Verifying the '${lemmaString}' lemma...`);
+      context.trace(`Verifying a lemma...`) :
+        context.trace(`Verifying the '${lemmaString}' lemma...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const lemma = this; ///
 
-      fileContext.addLemma(lemma);
+      context.addLemma(lemma);
 
       (lemmaString === null) ?
-        fileContext.debug(`...verified a lemma.`) :
-          fileContext.debug(`...verified the '${lemmaString}' lemma.`);
+        context.debug(`...verified a lemma.`) :
+          context.debug(`...verified the '${lemmaString}' lemma.`);
     }
 
     return verifies;
@@ -33,9 +33,9 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
 
   static name = "Lemma";
 
-  static fromLemmaNode(lemmaNode, fileContext) {
+  static fromLemmaNode(lemmaNode, context) {
     const node = lemmaNode, ///
-          lemma = TopLevelAssertion.fromNode(Lemma, node, fileContext);
+          lemma = TopLevelAssertion.fromNode(Lemma, node, context);
 
     return lemma;
   }

package/src/dom/metaLemma.js

@@ -8,20 +8,20 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const metaLemma = this, ///
-          fileContext = this.getFileContext(),
+    const context = this.getContext(),
+          metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    fileContext.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
+    context.trace(`Verifying the '${metaLemmaString}' meta-lemma...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const metaTheorem = this; ///
 
-      fileContext.addMetatheorem(metaTheorem);
+      context.addMetatheorem(metaTheorem);
 
-      fileContext.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
+      context.debug(`...verified the '${metaLemmaString}' meta-lemma.`);
     }
 
     return verifies;
@@ -29,11 +29,11 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
   static name = "MetaLemma";
 
-  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, context); }
 
-  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
+  static fromMetaLemmaNode(metaLemmaNode, context) {
     const node = metaLemmaNode, ///
-          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext);
+          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, context);
 
     return metaLemma;
   }

package/src/dom/metaType.js

@@ -1,7 +1,5 @@
 "use strict";
 
-import LocalContext from "../context/local";
-
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
@@ -43,7 +41,7 @@ class MetaType {
 
   static name = "MetaType";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
           metaTypeName = name,  ///
           metaType = metaTypeFromMetaTypeName(metaTypeName);
@@ -57,10 +55,8 @@ class MetaType {
     return metaType;
   }
 
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
           metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
 
     return metaType;

package/src/dom/metatheorem.js

@@ -8,20 +8,20 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
   verify() {
     let verifies;
 
-    const metaLemma = this, ///
-          fileContext = this.getFileContext(),
+    const context = this.getContext(),
+          metaLemma = this, ///
           metaLemmaString = metaLemma.getString();
 
-    fileContext.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
+    context.trace(`Verifying the '${metaLemmaString}' metatheorem...`);
 
     verifies = super.verify();
 
     if (verifies) {
       const metaTheorem = this; ///
 
-      fileContext.addMetatheorem(metaTheorem);
+      context.addMetatheorem(metaTheorem);
 
-      fileContext.debug(`...verified the '${metaLemmaString}' metatheorem.`);
+      context.debug(`...verified the '${metaLemmaString}' metatheorem.`);
     }
 
     return verifies;
@@ -29,11 +29,11 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
   static name = "Metatheorem";
 
-  static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
+  static fromJSON(json, context) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, context); }
 
-  static fromMetatheoremNode(metatheoremNode, fileContext) {
+  static fromMetatheoremNode(metatheoremNode, context) {
     const node = metatheoremNode, ///
-          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext);
+          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, context);
 
     return metatheorem;
   }

package/src/dom/metavariable.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import MetavariablePartialContext from "../context/partial/metavariable";
 
 import { domAssigned } from "../dom";
@@ -442,10 +441,10 @@ export default domAssigned(class Metavariable {
 
   static name = "Metavariable";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { string } = json,
-          lexer = fileContext.getLexer(),
-          parser = fileContext.getParser(),
+          lexer = context.getLexer(),
+          parser = context.getParser(),
           metavariablePartialContext = MetavariablePartialContext.fromStringLexerAndParser(string, lexer, parser),
           metavariableTokens = metavariablePartialContext.getMetavariableTokens(),
           metavariableNode = metavariablePartialContext.getMetavariableNode(),
@@ -453,8 +452,8 @@ export default domAssigned(class Metavariable {
           name = metavariableName,  ///
           node = metavariableNode,  ///
           tokens = metavariableTokens, ///
-          type = typeFromJSON(json, fileContext),
-          metaType = metaTypeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
+          metaType = metaTypeFromJSON(json, context),
           metavariable = new Metavariable(string, node, tokens, name, type, metaType);
 
     return metavariable;
@@ -510,12 +509,10 @@ export default domAssigned(class Metavariable {
     return metavariable;
   }
 
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const { MetaType } = dom,
           metavariableNode = metavariableDeclarationNode.getMetavariableNode(),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
+          type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           metaType = MetaType.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           metavariable = metavariableFromMetavariableNode(metavariableNode, context);
 
@@ -541,7 +538,7 @@ function metavariableFromMetavariableNode(metavariableNode, context) {
   return metavariable;
 }
 
-function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   let type = null;
 
   const typeNode = metavariableDeclarationNode.getTypeNode();
@@ -549,7 +546,7 @@ function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileCo
   if (typeNode !== null) {
     const typeName = typeNode.getTypeName();
 
-    type = fileContext.findTypeByTypeName(typeName);
+    type = context.findTypeByTypeName(typeName);
   }
 
   return type;

package/src/dom/parameter.js

@@ -46,7 +46,7 @@ export default domAssigned(class Parameter {
 
   static name = "Parameter";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
           parameter = new Parameter(name);
 

package/src/dom/premise.js

@@ -200,9 +200,9 @@ export default domAssigned(class Premise {
 
   static name = "Premise";
 
-  static fromJSON(json, fileContext) {
-    const statement = statementFromJSON(json, fileContext),
-          procedureCall = procedureCallFromJSON(json, fileContext);
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          procedureCall = procedureCallFromJSON(json, context);
 
     let string;
 
@@ -219,12 +219,12 @@ export default domAssigned(class Premise {
     return premise;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
+  static fromPremiseNode(premiseNode, context) {
     const { Statement, ProcedureCall } = dom,
-          node = premiseNode,
-          string = fileContext.nodeAsString(node),
-          statement = Statement.fromPremiseNode(premiseNode, fileContext),
-          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, fileContext),
+          node = premiseNode, ///
+          string = context.nodeAsString(node),
+          statement = Statement.fromPremiseNode(premiseNode, context),
+          procedureCall = ProcedureCall.fromPremiseNode(premiseNode, context),
           premise = new Premise(string, statement, procedureCall);
 
     return premise

package/src/dom/procedureCall.js

@@ -76,16 +76,16 @@ export default domAssigned(class ProcedureCall {
           nodes = this.findNodes(substitutions),
           expressions = Expressions.fromNodes(nodes, context);
 
-    try {
+    // try {
       const value = procedure.call(expressions, context),
             boolean = value.getBoolean();
 
       unifiesIndependently = boolean; ///
-    } catch (exception) {
-      const message = exception.getMessage();
-
-      context.info(message);
-    }
+    // } catch (exception) {
+    //   const message = exception.getMessage();
+    //
+    //   context.info(message);
+    // }
 
     if (unifiesIndependently) {
       context.debug(`...unified the '${procedureCallString}' procedure call independently.`);
@@ -109,9 +109,9 @@ export default domAssigned(class ProcedureCall {
 
   static name = "ProcedureCall";
 
-  static fromJSON(json, fileContext) {
-    const reference = referenceFromJSON(json, fileContext),
-          parameters = parametersFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const reference = referenceFromJSON(json, context),
+          parameters = parametersFromJSON(json, context),
           string = stringFromReferenceAndParameters(reference, parameters),
           procedureCall = new ProcedureCall(string, reference, parameters);
 

package/src/dom/proof.js

@@ -52,13 +52,13 @@ export default domAssigned(class Proof {
 
   static name = "Proof";
 
-  static fromProofNode(proofNode, fileContext) {
+  static fromProofNode(proofNode, context) {
     let proof = null;
 
     if (proofNode !== null) {
       const { Derivation } = dom,
             derivationNode = proofNode.getDerivationNode(),
-            derivation = Derivation.fromDerivationNode(derivationNode, fileContext);
+            derivation = Derivation.fromDerivationNode(derivationNode, context);
 
       proof = new Proof(derivation);
     }

package/src/dom/property.js

@@ -50,29 +50,29 @@ export default domAssigned(class Property {
 
   static name = "Property";
 
-  static fromJSON(json, fileContext) {
+  static fromJSON(json, context) {
     const { name } = json,
-          type = typeFromJSON(json, fileContext),
+          type = typeFromJSON(json, context),
           string = name, ///
           property = new Property(string, name, type);
 
     return property;
   }
 
-  static fromPropertyNode(propertyNode, fileContext) {
-    const property = propertyFromPropertyNode(propertyNode, fileContext)
+  static fromPropertyNode(propertyNode, context) {
+    const property = propertyFromPropertyNode(propertyNode, context)
 
     return property;
   }
 
-  static fromPropertyRelationNode(propertyRelationNode, fileContext) {
+  static fromPropertyRelationNode(propertyRelationNode, context) {
     const propertyNode = propertyRelationNode.getPropertyNode(),
-          property = propertyFromPropertyNode(propertyNode, fileContext);
+          property = propertyFromPropertyNode(propertyNode, context);
 
     return property;
   }
 
-  static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
+  static fromPropertyDeclarationNode(propertyDeclarationNode, context) {
     const { Type } = dom,
           type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
           propertyName = propertyDeclarationNode.getPropertyName(),
@@ -84,7 +84,7 @@ export default domAssigned(class Property {
   }
 });
 
-function propertyFromPropertyNode(propertyNode, fileContext) {
+function propertyFromPropertyNode(propertyNode, context) {
   const { Property } = dom,
         propertyName = propertyNode.getPropertyName(),
         name = propertyName,  ///

package/src/dom/reference.js

@@ -1,7 +1,6 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 
 import { domAssigned } from "../dom";
@@ -90,9 +89,11 @@ export default domAssigned(class Reference {
 
     context.trace(`Unifying the '${labelString}' label with the '${referenceString}' reference...`);
 
-    const fileContext = label.getFileContext(),
-          generalContext = context, ///
-          specificContext = fileContext,  ///
+    const generalContext = context; ///
+
+    context = label.getContext();
+
+    const specificContext = context,  ///
           labelMetavariable = label.getMetavariable(),
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = labelMetavariable, ///
@@ -116,10 +117,9 @@ export default domAssigned(class Reference {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const fileContext = context.getFileContext(),
-          substitutions = Substitutions.fromNothing(),
+    const substitutions = Substitutions.fromNothing(),
           generalContext = context, ///
-          specificContext = fileContext,  ///
+          specificContext = context,  ///
           generalMetavariable = this.metavariable,  ///
           specificMetavariable = metavariable, ///
           metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext);
@@ -167,78 +167,74 @@ export default domAssigned(class Reference {
 
   static name = "Reference";
 
-  static fromJSON(json, fileContext) {
-    const metavariable = metavariableFromJSON(json, fileContext),
+  static fromJSON(json, context) {
+    const metavariable = metavariableFromJSON(json, context),
           reference = new Reference(metavariable);
 
     return reference;
   }
 
-  static fromStepNode(stepNode, fileContext) {
+  static fromStepNode(stepNode, context) {
     let reference = null;
 
     const referenceNode = stepNode.getReferenceNode();
 
     if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, fileContext);
+      reference = referenceFromReferenceNode(referenceNode, context);
     }
 
     return reference;
   }
 
-  static fromReferenceNode(referenceNode, fileContext) {
-    const reference = referenceFromReferenceNode(referenceNode, fileContext);
+  static fromReferenceNode(referenceNode, context) {
+    const reference = referenceFromReferenceNode(referenceNode, context);
 
     return reference;
   }
 
-  static fromDeclarationNode(declarationNode, fileContext) {
+  static fromDeclarationNode(declarationNode, context) {
     const metavariableNode = declarationNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+          reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 
-  static fromMetavariableNode(metavariableNode, fileContext) {
-    const reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+  static fromMetavariableNode(metavariableNode, context) {
+    const reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 
-  static fromProcedureCallNode(procedureCallNode, fileContext) {
+  static fromProcedureCallNode(procedureCallNode, context) {
     let reference = null;
 
     const referenceNode = procedureCallNode.getReferenceNode();
 
     if (referenceNode !== null) {
-      reference = referenceFromReferenceNode(referenceNode, fileContext);
+      reference = referenceFromReferenceNode(referenceNode, context);
     }
 
     return reference;
   }
 
-  static fromSatisfiesAssertionNode(satisfiesAssertionNode, fileContext) {
+  static fromSatisfiesAssertionNode(satisfiesAssertionNode, context) {
     const metavariableNode = satisfiesAssertionNode.getMetavariableNode(),
-          reference = referenceFromMetavariableNode(metavariableNode, fileContext);
+          reference = referenceFromMetavariableNode(metavariableNode, context);
 
     return reference;
   }
 });
 
-function referenceFromReferenceNode(referenceNode, fileContext) {
+function referenceFromReferenceNode(referenceNode, context) {
   const { Reference, Metavariable } = dom,
-        localContext = LocalContext.fromFileContext(fileContext),
-        context = localContext, ///
         metavariable = Metavariable.fromReferenceNode(referenceNode, context),
         reference = new Reference(metavariable);
 
   return reference;
 }
 
-function referenceFromMetavariableNode(metavariableNode, fileContext) {
+function referenceFromMetavariableNode(metavariableNode, context) {
   const { Reference, Metavariable } = dom,
-        localContext = LocalContext.fromFileContext(fileContext),
-        context = localContext, ///
         metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
         reference = new Reference(metavariable);