occam-verify-cli 0.0.1111 → 0.0.1112

package/src/{judgement.js → dom/judgement.js}

@@ -1,15 +1,16 @@
 "use strict";
 
-import shim from "./shim";
-import JudgementAssignment from "./assignment/judgement";
+import dom from "../dom";
+import JudgementAssignment from "../assignment/judgement";
 
-import { nodeQuery } from "./utilities/query";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
 
 const frameNodeQuery = nodeQuery("/judgement/frame"),
       judgementNodeQuery = nodeQuery("/statement/judgement"),
       declarationNodeQuery = nodeQuery("/judgement/declaration");
 
-class Judgement {
+export default domAssigned(class Judgement {
   constructor(string, frame, declaration) {
     this.string = string;
     this.frame = frame;
@@ -103,13 +104,15 @@ class Judgement {
     return verifiedWhenDerived;
   }
 
+  static name = "Judgement";
+
   static fromStatementNode(statementNode, context) {
     let judgement = null;
 
     const judgementNode = judgementNodeQuery(statementNode);
 
     if (judgementNode !== null) {
-      const { Frame, Declaration } = shim,
+      const { Frame, Declaration } = dom,
             frameNode = frameNodeQuery(judgementNode),
             declarationNode = declarationNodeQuery(judgementNode),
             node = judgementNode, ///
@@ -122,10 +125,4 @@ class Judgement {
 
     return judgement;
   }
-}
-
-Object.assign(shim, {
-  Judgement
 });
-
-export default Judgement;

package/src/{label.js → dom/label.js}

@@ -1,14 +1,12 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import dom from "../dom";
+import LocalContext from "../context/local";
 
-import { nodeQuery } from "./utilities/query";
-import { metavariableFromJSON, metavariableToMetavariableJSON } from "./utilities/json";
+import { domAssigned } from "../dom";
+import { metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
-const metavariableNodeQuery = nodeQuery("//label/metavariable");
-
-class Label {
+export default domAssigned(class Label {
   constructor(metavariable) {
     this.metavariable = metavariable;
   }
@@ -77,6 +75,8 @@ class Label {
     return json;
   }
 
+  static name = "Label";
+
   static fromJSON(json, fileContext) {
     const metavariable = metavariableFromJSON(json, fileContext),
           label = new Label(metavariable);
@@ -85,18 +85,11 @@ class Label {
   }
 
   static fromLabelNode(labelNode, fileContext) {
-    const { Metavariable } = shim,
-          metavariableNode = metavariableNodeQuery(labelNode),
+    const { Metavariable } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
-          metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+          metavariable = Metavariable.fromLabelNode(labelNode, localContext),
           label = new Label(metavariable);
 
     return label;
   }
-}
-
-Object.assign(shim, {
-  Label
 });
-
-export default Label;

package/src/{lemma.js → dom/lemma.js}

@@ -1,11 +1,11 @@
 "use strict";
 
-import shim from "./shim";
 import TopLevelAssertion from "./topLevelAssertion";
 
-import { EMPTY_STRING } from "./constants";
+import { domAssigned } from "../dom";
+import { EMPTY_STRING } from "../constants";
 
-class Lemma extends TopLevelAssertion {
+export default domAssigned(class Lemma extends TopLevelAssertion {
   verify() {
     let verified;
 
@@ -32,11 +32,7 @@ class Lemma extends TopLevelAssertion {
     return verified;
   }
 
-  static fromLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Lemma, metaLemmaNode, fileContext); }
-}
+  static name = "Lemma";
 
-Object.assign(shim, {
-  Lemma
+  static fromLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Lemma, metaLemmaNode, fileContext); }
 });
-
-export default Lemma;

package/src/{metaLemma.js → dom/metaLemma.js}

@@ -1,10 +1,11 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import LocalContext from "../context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
-class MetaLemma extends TopLevelAssertion {
+import { domAssigned } from "../dom";
+
+export default domAssigned(class MetaLemma extends TopLevelAssertion {
   unifyReference(reference, substitutions, context) {
     let referenceUnified;
 
@@ -101,11 +102,7 @@ class MetaLemma extends TopLevelAssertion {
     return labelsVerified;
   }
 
-  static fromMetaLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(MetaLemma, metaLemmaNode, fileContext); }
-}
+  static name = "MetaLemma";
 
-Object.assign(shim, {
-  MetaLemma
+  static fromMetaLemmaNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(MetaLemma, metaLemmaNode, fileContext); }
 });
-
-export default MetaLemma;

package/src/{metaType.js → dom/metaType.js}

@@ -1,10 +1,9 @@
 "use strict";
 
-import shim from "./shim";
-
-import { nodeQuery } from "./utilities/query";
-import { metaTypeNameFromMetaTypeNode } from "./utilities/name";
-import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
+import { metaTypeNameFromMetaTypeNode } from "../utilities/name";
+import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
 
@@ -44,6 +43,8 @@ class MetaType {
     return json;
   }
 
+  static name = "MetaType";
+
   static fromJSON(json, fileContext) {
     const { name } = json,
           metaTypeName = name,  ///
@@ -68,11 +69,7 @@ class MetaType {
   }
 }
 
-Object.assign(shim, {
-  MetaType
-});
-
-export default MetaType;
+export default domAssigned(MetaType);
 
 class FrameMetaType extends MetaType {
   static fromNothing() {

package/src/{metatheorem.js → dom/metatheorem.js}

@@ -1,9 +1,9 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
+import LocalContext from "../context/local";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { domAssigned } from "../dom";
 import { stringFromLabels } from "./topLevelAssertion";
 import { labelsFromJSON,
          labelsToLabelsJSON,
@@ -12,9 +12,9 @@ import { labelsFromJSON,
          substitutionsFromJSON,
          consequentToConsequentJSON,
          suppositionsToSuppositionsJSON,
-         substitutionsToSubstitutionsJSON } from "./utilities/json";
+         substitutionsToSubstitutionsJSON } from "../utilities/json";
 
-class Metatheorem extends TopLevelAssertion {
+export default domAssigned(class Metatheorem extends TopLevelAssertion {
   unifyReference(reference, substitutions, context) {
     let referenceUnified;
 
@@ -130,6 +130,8 @@ class Metatheorem extends TopLevelAssertion {
     return json;
   }
 
+  static name = "Metatheorem";
+
   static fromJSON(json, fileContext) {
     const labels = labelsFromJSON(json, fileContext),
           consequent = consequentFromJSON(json, fileContext),
@@ -143,10 +145,4 @@ class Metatheorem extends TopLevelAssertion {
   }
 
   static fromMetatheoremNode(metatheoremNode, fileContext) { return TopLevelAssertion.fromNode(Metatheorem, metatheoremNode, fileContext); }
-}
-
-Object.assign(shim, {
-  Metatheorem
 });
-
-export default Metatheorem;

package/src/{metavariable.js → dom/metavariable.js}

@@ -1,25 +1,28 @@
 "use strict";
 
-import shim from "./shim";
-import LocalContext from "./context/local";
-import FrameSubstitution from "./substitution/frame";
-import StatementSubstitution from "./substitution/statement";
-import MetavariableNodeAndTokens from "./nodeAndTokens/metavariable";
-
-import { nodeQuery } from "./utilities/query";
-import { objectType } from "./type";
-import { EMPTY_STRING } from "./constants";
-import { unifyMetavariable } from "./utilities/unification";
-import { typeFromJSON, typeToTypeJSON } from "./utilities/json";
-import { metavariableNameFromMetavariableNode } from "./utilities/name";
-import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "./utilities/json";
+import dom from "../dom";
+import LocalContext from "../context/local";
+import FrameSubstitution from "../substitution/frame";
+import StatementSubstitution from "../substitution/statement";
+import MetavariableNodeAndTokens from "../nodeAndTokens/metavariable";
+
+import { nodeQuery } from "../utilities/query";
+import { objectType } from "../dom/type";
+import { domAssigned } from "../dom";
+import { EMPTY_STRING } from "../constants";
+import { unifyMetavariable } from "../utilities/unification";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
+import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
-      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
+      labelMetavariableNodeQuery = nodeQuery("/label/metavariable"),
+      referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-class Metavariable {
+export default domAssigned(class Metavariable {
   constructor(string, node, tokens, name, type, metaType) {
     this.string = string;
     this.node = node;
@@ -65,22 +68,17 @@ class Metavariable {
     return metavariableNodeMatches;
   }
 
-  isEqualTo(metavariable) {
-    let equalTo = false;
-
-    if (metavariable !== null) {
-      const metavariableString = metavariable.getString();
+  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
-      equalTo = (metavariableString === this.string);
-    }
+  isEqualTo(metavariable) {
+    const metavariableString = metavariable.getString(),
+          equalTo = (metavariableString === this.string);
 
     return equalTo;
   }
 
-  isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
-
-  isEssentiallyEqualToFrame(frame, generalContext, specificContext) {
-    let essentiallyEqualToFrame = false;
+  isEffectivelyEqualToFrame(frame, generalContext, specificContext) {
+    let effectivelyEqualToFrame = false;
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -89,15 +87,15 @@ class Metavariable {
       const frameString = frame.getString();
 
       if (frameString === this.string) {
-        essentiallyEqualToFrame = true;
+        effectivelyEqualToFrame = true;
       }
     }
 
-    return essentiallyEqualToFrame;
+    return effectivelyEqualToFrame;
   }
 
-  isEssentiallyEqualToStatement(statement, generalContext, specificContext) {
-    let essentiallyEqualToStatement = false;
+  isEffectivelyEqualToStatement(statement, generalContext, specificContext) {
+    let effectivelyEqualToStatement = false;
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -106,11 +104,11 @@ class Metavariable {
       const statementString = statement.getString();
 
       if (statementString === this.string) {
-        essentiallyEqualToStatement = true;
+        effectivelyEqualToStatement = true;
       }
     }
 
-    return essentiallyEqualToStatement;
+    return effectivelyEqualToStatement;
   }
 
   unifyFrame(frame, substitutions, generalContext, specificContext) {
@@ -121,9 +119,9 @@ class Metavariable {
 
     specificContext.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
-    const essentiallyEqualToFrame = this.isEssentiallyEqualToFrame(frame, generalContext, specificContext);
+    const effectivelyEqualToFrame = this.isEffectivelyEqualToFrame(frame, generalContext, specificContext);
 
-    if (essentiallyEqualToFrame) {
+    if (effectivelyEqualToFrame) {
       frameUnified = true;
     } else {
       const metavariable = this, ///
@@ -167,25 +165,25 @@ class Metavariable {
 
     specificContext.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
-    const essentiallyEqualToStatement = this.isEssentiallyEqualToStatement(statement, generalContext, specificContext);
+    const effectivelyEqualToStatement = this.isEffectivelyEqualToStatement(statement, generalContext, specificContext);
 
-    if (essentiallyEqualToStatement) {
+    if (effectivelyEqualToStatement) {
       statementUnified = true;
     } else {
-      const metavariable = this, ///
+      const context = specificContext,  ///
+            metavariable = this, ///
             substitutionPresent = substitutions.isSubstitutionPresentByMetavariableAndSubstitution(metavariable, substitution);
 
       if (substitutionPresent) {
         substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
 
-        const substitutionStatementEqualToStatement = substitution.isStatementEqualTo(statement);
+        const substitutionStatementEqualToStatement = substitution.isStatementEqualTo(statement, context);
 
         if (substitutionStatementEqualToStatement) {
           statementUnified = true;
         }
       } else {
-        const context = specificContext,  ///
-              metavariable = this,
+        const metavariable = this,
               statementSubstitution = StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context);
 
         substitution = statementSubstitution;  ///
@@ -211,12 +209,12 @@ class Metavariable {
           generalMetavariableString = generalMetavariable.getString(),
           specificMetavariableString = specificMetavariable.getString();
 
-    specificContext.trace(`Unifying the '${specificMetavariableString}' metavariable against the '${generalMetavariableString}' metavariable...`);
+    specificContext.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable...`);
 
     metavariableUnified = unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     if (metavariableUnified) {
-      specificContext.debug(`...unified the '${specificMetavariableString}' metavariable against the '${generalMetavariableString}' metavariable.`);
+      specificContext.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable.`);
     }
 
     return metavariableUnified;
@@ -381,6 +379,8 @@ class Metavariable {
     return json;
   }
 
+  static name = "Metavariable";
+
   static fromJSON(json, fileContext) {
     const { string } = json,
           context = fileContext,  ///
@@ -404,37 +404,39 @@ class Metavariable {
     const frameMetavariableNode = frameMetavariableNodeQuery(frameNode);
 
     if (frameMetavariableNode !== null) {
-      const metavariableNode = frameMetavariableNode, ///
-            metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-            name = metavariableName,  ///
-            node = metavariableNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            type = null,
-            metaType = null;
-
-      metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+      const metavariableNode = frameMetavariableNode; ///
+
+      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
 
     return metavariable;
   }
 
+  static fromLabelNode(labelNode, context) {
+    const labelMetavariableNode = labelMetavariableNodeQuery(labelNode),
+          metavariableNode = labelMetavariableNode, ///
+          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+    return metavariable;
+  }
+
+  static fromReferenceNode(referenceNode, context) {
+    const referenceMetavariableNode = referenceMetavariableNodeQuery(referenceNode),
+          metavariableNode = referenceMetavariableNode, ///
+          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+    return metavariable;
+  }
+
   static fromStatementNode(statementNode, context) {
     let metavariable = null;
 
     const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
     if (statementMetavariableNode !== null) {
-      const metavariableNode = statementMetavariableNode, ///
-            metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-            name = metavariableName,  ///
-            node = metavariableNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            type = null,
-            metaType = null;
-
-      metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+      const metavariableNode = statementMetavariableNode; ///
+
+      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
 
     return metavariable;
@@ -444,22 +446,14 @@ class Metavariable {
     let metavariable = null;
 
     if (metavariableNode !== null) {
-      const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-            name = metavariableName,  ///
-            node = metavariableNode,  ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            type = null,
-            metaType = null;
-
-      metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+      metavariable = metavariableFromMetavariableNode(metavariableNode, context);
     }
 
     return metavariable;
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const { Type, MetaType } = shim,
+    const { Type, MetaType } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
           metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
@@ -474,10 +468,18 @@ class Metavariable {
 
     return metavariable;
   }
-}
-
-Object.assign(shim, {
-  Metavariable
 });
 
-export default Metavariable;
+function metavariableFromMetavariableNode(metavariableNode, context) {
+  const { Metavariable } = dom,
+        metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        name = metavariableName,  ///
+        node = metavariableNode,  ///
+        string = context.nodeAsString(node),
+        tokens = context.nodeAsTokens(node),
+        type = null,
+        metaType = null,
+        metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+
+  return metavariable;
+}