occam-verify-cli 1.0.184 → 1.0.192

package/src/dom/assertion/type.js

@@ -3,12 +3,8 @@
 import dom from "../../dom";
 import VariableAssignment from "../../assignment/variable";
 
-import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const variableNodeQuery = nodeQuery("/term/variable!"),
-      typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion");
-
 export default domAssigned(class TypeAssertion {
   constructor(string, term, type) {
     this.string = string;
@@ -155,8 +151,7 @@ export default domAssigned(class TypeAssertion {
     }
 
     const { Type, Variable } = dom,
-          termNode = this.term.getNode(),
-          variableNode = variableNodeQuery(termNode);
+          termNode = this.term.getNode();
 
     let type,
         provisional;
@@ -171,10 +166,12 @@ export default domAssigned(class TypeAssertion {
       type = Type.fromTypeAndProvisional(this.type, provisional);
     }
 
-    const variable = Variable.fromVariableNodeAndType(variableNode, type, context);
+    const singularVariableNode = termNode.getSingularVariableNode();
 
-    if (variable !== null) {
-      const variableAssignment = VariableAssignment.fromVariable(variable),
+    if (singularVariableNode !== null) {
+      const variableNode = singularVariableNode,  ///
+            variable = Variable.fromVariableNodeAndType(variableNode, type, context),
+            variableAssignment = VariableAssignment.fromVariable(variable),
             assignment = variableAssignment;  ///
 
       assignments.push(assignment);
@@ -186,7 +183,7 @@ export default domAssigned(class TypeAssertion {
   static fromStatementNode(statementNode, context) {
     let typeAssertion = null;
 
-    const typeAssertionNode = typeAssertionNodeQuery(statementNode);
+    const typeAssertionNode = statementNode.getTypeAssertionNode();
 
     if (typeAssertionNode !== null) {
       const { Term, Type } = dom,

package/src/dom/axiom.js

@@ -4,34 +4,12 @@ import { arrayUtilities } from "necessary";
 
 import TopLevelAssertion  from "./topLevelAssertion";
 
-import { nodeQuery } from "../utilities/query";
-import { SATISFIABLE } from "../constants";
 import { domAssigned } from "../dom";
-import { labelsFromJSON,
-         deductionFromJSON,
-         satisfiableFromJSON,
-         labelsToLabelsJSON,
-         suppositionsFromJSON,
-         deductionToDeductionJSON,
-         suppositionsToSuppositionsJSON } from "../utilities/json";
 import { satisfiesAssertionFromStatement } from "../utilities/context";
-import { proofFromNode, labelsFromNode, deductionFromNode, suppositionsFromNode, stringFromLabelsAndDeduction } from "./topLevelAssertion";
 
 const { match, backwardsSome } = arrayUtilities;
 
-const firstPrimaryKeywordTerminalNodeQuery = nodeQuery("/axiom/@primary-keyword[0]");
-
 export default domAssigned(class Axiom extends TopLevelAssertion {
-  constructor(fileContext, string, labels, suppositions, deduction, proof, satisfiable) {
-    super(fileContext, string, labels, suppositions, deduction, proof);
-
-    this.satisfiable = satisfiable;
-  }
-
-  isSatisfiable() {
-    return this.satisfiable;
-  }
-
   verify() {
     let verified;
 
@@ -163,7 +141,9 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     statementAndStepsOrSubproofsUnified = super.unifyStatementAndStepsOrSubproofs(statement, stepsOrSubproofs, substitutions, context);
 
     if (statementAndStepsOrSubproofsUnified) {
-      if (this.satisfiable) {
+      const satisfiable = this.isSatisfiable();
+
+      if (satisfiable) {
         const substitutionsMatch = backwardsSome(stepsOrSubproofs, (stepOrSubproof) => {
           const stepSubstep = stepOrSubproof.isStep();
 
@@ -189,64 +169,14 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
     return statementAndStepsOrSubproofsUnified;
   }
 
-  toJSON() {
-    let labels = this.getLabels(),
-        deduction = this.getDeduction(),
-        suppositions = this.getSuppositions();
-
-    const labelsJSON = labelsToLabelsJSON(labels),
-          deductionJSON = deductionToDeductionJSON(deduction),
-          suppositionsJSON = suppositionsToSuppositionsJSON(suppositions);
-
-    labels = labelsJSON;  ///
-    deduction = deductionJSON;  ///
-    suppositions = suppositionsJSON;  ///
-
-    const satisfiable = this.satisfiable,
-          json = {
-            labels,
-            deduction,
-            suppositions,
-            satisfiable
-          };
-
-    return json;
-  }
-
   static name = "Axiom";
 
-  static fromJSON(json, fileContext) {
-    const labels = labelsFromJSON(json, fileContext),
-          suppositions = suppositionsFromJSON(json, fileContext),
-          deduction = deductionFromJSON(json, fileContext),
-          proof = null,
-          satisfiable = satisfiableFromJSON(json, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
-
-    return topLevelAssertion;
-  }
+  static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Axiom, json, fileContext); }
 
   static fromAxiomNode(axiomNode, fileContext) {
     const node = axiomNode, ///
-          proof = proofFromNode(node, fileContext),
-          labels = labelsFromNode(node, fileContext),
-          deduction = deductionFromNode(node, fileContext),
-          satisfiable = satisfiableFromNode(node, fileContext),
-          suppositions = suppositionsFromNode(node, fileContext),
-          string = stringFromLabelsAndDeduction(labels, deduction),
-          topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
-
-    return topLevelAssertion;
+          axiom = TopLevelAssertion.fromNode(Axiom, node, fileContext);
+
+    return axiom;
   }
 });
-
-export function satisfiableFromNode(node, fileContext) {
-  const firstPrimaryKeywordTerminalNode = firstPrimaryKeywordTerminalNodeQuery(node),
-        content = firstPrimaryKeywordTerminalNode.getContent(),
-        contentSatisfiable = (content === SATISFIABLE),
-        satisfiable = contentSatisfiable; ///
-
-  return satisfiable;
-}
-

package/src/dom/conjecture.js

@@ -31,5 +31,10 @@ export default domAssigned(class Conjecture extends TopLevelAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Conjecture, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Conjecture, node, fileContext); }
+  static fromConjectureNode(conjectureNode, fileContext) {
+    const node = conjectureNode,  ///
+          conjecture = TopLevelAssertion.fromNode(Conjecture, node, fileContext);
+
+    return conjecture;
+  }
 });

package/src/dom/constructor/bracketed.js

@@ -4,11 +4,8 @@ import dom from "../../dom";
 import Constructor from "../constructor";
 import constructorBracketedContext from "../../context/bracketed/constructor";
 
-import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const termNodeQuery = nodeQuery("/term/argument/term");
-
 export default domAssigned(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
     let termUnified;
@@ -23,11 +20,13 @@ export default domAssigned(class BracketedConstructor extends Constructor {
       const { Term } = dom,
             bracketedTerm = term, ///
             bracketedTermNode = bracketedTerm.getNode(),
-            termNode = termNodeQuery(bracketedTermNode); ///
+            singularTermNode = bracketedTermNode.getSingularTermNode();
+
+      if (singularTermNode !== null) {
+        const termNode = singularTermNode;  ///
 
-      term = Term.fromTermNode(termNode, context);
+        term = Term.fromTermNode(termNode, context);
 
-      if (term !== null) {
         const termVVerified = term.verify(context, () => {
           let verifiedAhead;
 
@@ -60,8 +59,7 @@ export default domAssigned(class BracketedConstructor extends Constructor {
           context = constructorBracketedContext, ///
           term = Term.fromTermNode(termNode, context),
           string = term.getString(),
-          provisional = null,
-          bracketedConstructor = new BracketedConstructor(string, term, provisional);
+          bracketedConstructor = new BracketedConstructor(string, term);
 
     return bracketedConstructor;
   }

package/src/dom/declaration/complexType.js

@@ -3,7 +3,7 @@
 import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
-import { superTypesStringFromSuperTypes } from "../../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
   constructor(fileContext, string, type) {
@@ -145,11 +145,11 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     this.fileContext.trace(`Verifying the '${propertyString}' property...`);
 
-    const propertyNames = property.getNames(),
+    const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
-            const propertyNamesMatch = property.matchPropertyNames(propertyNames);
+            const propertyNameMatches = property.matchPropertyName(propertyName);
 
-            if (propertyNamesMatch) {
+            if (propertyNameMatches) {
               count++;
             }
 
@@ -259,9 +259,10 @@ export default domAssigned(class ComplexTypeDeclaration {
 
   static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
     const { Type } = dom,
-          node = complexTypeDeclarationNode,  ///
-          string = fileContext.nodeAsString(node),
           type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          typeName = type.getName(),
+          superTypes = type.getSuperTypes(),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           complexTypeDeclaration = new ComplexTypeDeclaration(fileContext, string, type);
 
     return complexTypeDeclaration;

package/src/dom/declaration/metavariable.js

@@ -2,12 +2,8 @@
 
 import dom from "../../dom";
 
-import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
 
-const termNodeQuery = nodeQuery("/metavariable/argument/term"),
-      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
-
 export default domAssigned(class MetavariableDeclaration {
   constructor(fileContext, string, metavariable) {
     this.fileContext = fileContext;
@@ -84,7 +80,7 @@ export default domAssigned(class MetavariableDeclaration {
     this.fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
 
     const metavariableNode = metavariable.getNode(), ///
-          termNode = termNodeQuery(metavariableNode);
+          termNode = metavariableNode.getTermNode();
 
     if (termNode !== null) {
       this.fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
@@ -140,7 +136,7 @@ function stringFromMetavariableAndMetaType(metavariable, metaType) {
 
 function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
   const { MetaType } = dom,
-        metaTypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
+        metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
         metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext);
 
   return metaType;

package/src/dom/declaration/type.js

@@ -4,6 +4,7 @@ import dom from "../../dom";
 
 import { domAssigned } from "../../dom";
 import { superTypesStringFromSuperTypes } from "../../utilities/type";
+import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class TypeDeclaration {
   constructor(fileContext, string, type) {
@@ -139,8 +140,9 @@ export default domAssigned(class TypeDeclaration {
   static fromTypeDeclarationNode(typeDeclarationNode, fileContext) {
     const { Type } = dom,
           type = Type.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
-          node = typeDeclarationNode, ///
-          string = fileContext.nodeAsString(node),
+          typeName = type.getName(),
+          superTypes = type.getSuperTypes(),
+          string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
           typeDeclaration = new TypeDeclaration(fileContext, string, type);
 
     return typeDeclaration;

package/src/dom/declaration.js

@@ -3,12 +3,9 @@
 import dom from "../dom";
 import Substitutions from "../substitutions";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
 
-const judgementDeclarationNodeQuery = nodeQuery("/judgement/declaration");
-
 export default domAssigned(class Declaration {
   constructor(string, reference, statement) {
     this.string = string;
@@ -255,8 +252,7 @@ export default domAssigned(class Declaration {
   static name = "Declaration";
 
   static fromJudgementNode(judgementNode, context) {
-    const judgementDeclarationNode = judgementDeclarationNodeQuery(judgementNode),
-          declarationNode = judgementDeclarationNode, ///
+    const declarationNode = judgementNode.getDeclarationNode(),
           declaration = declarationFromDeclarationNode(declarationNode, context);
 
     return declaration;

package/src/dom/derivation.js

@@ -4,14 +4,11 @@ import { arrayUtilities } from "necessary";
 
 import dom from "../dom";
 
-import { nodesQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { assignAssignments } from "../utilities/assignments";
 
 const { last } = arrayUtilities;
 
-const stepOrSubproofNodesQuery = nodesQuery("/derivation/step|subproof");
-
 export default domAssigned(class Derivation {
   constructor(stepsOrSubproofs) {
     this.stepsOrSubproofs = stepsOrSubproofs;
@@ -65,7 +62,7 @@ export default domAssigned(class Derivation {
 
 function stepsOrSubproofsFromDerivationNode(derivationNode, fileContext) {
   const { Step, Subproof } = dom,
-        stepOrSubproofNodes = stepOrSubproofNodesQuery(derivationNode),
+        stepOrSubproofNodes = derivationNode.getStepOrSubproofNodes(),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
           let stepOrSubproof;
 

package/src/dom/equality.js

@@ -4,15 +4,9 @@ import dom from "../dom";
 import EqualityAssignment from "../assignment/equality";
 import VariableAssignment from "../assignment/variable";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyEquality } from "../utilities/unification";
 
-const equalityNodeQuery = nodeQuery("/statement/equality"),
-      variableNodeQuery = nodeQuery("/term/variable!"),
-      leftTermNodeQuery = nodeQuery("/equality/term[0]"),
-      rightTermNodeQuery = nodeQuery("/equality/term[1]");
-
 export default domAssigned(class Equality {
   constructor(string, leftTerm, rightTerm) {
     this.string = string;
@@ -179,23 +173,25 @@ export default domAssigned(class Equality {
           type = this.getType(),
           leftTermNode = this.leftTerm.getNode(),
           rightTermNode = this.rightTerm.getNode(),
-          leftVariableNode = variableNodeQuery(leftTermNode),
-          rightVariableNode = variableNodeQuery(rightTermNode),
-          leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
-          rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context);
+          leftTermNodeSingularVariableNode = leftTermNode.getSingularVariableNode(),
+          rightTermNodeSingularVariableNode = rightTermNode.getSingularVariableNode(),
+          leftVariableNode = leftTermNodeSingularVariableNode,  ///
+          rightVariableNode = rightTermNodeSingularVariableNode;  ///
 
     let assignment;
 
-    if (leftVariable !== null) {
-      const leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
+    if (leftVariableNode !== null) {
+      const leftVariable = Variable.fromVariableNodeAndType(leftVariableNode, type, context),
+            leftVariableAssignment = VariableAssignment.fromVariable(leftVariable);
 
       assignment = leftVariableAssignment;  ///
 
       assignments.push(assignment);
     }
 
-    if (rightVariable !== null) {
-      const rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
+    if (rightVariableNode !== null) {
+      const rightVariable = Variable.fromVariableNodeAndType(rightVariableNode, type, context),
+            rightVariableAssignment = VariableAssignment.fromVariable(rightVariable);
 
       assignment = rightVariableAssignment;  ///
 
@@ -215,7 +211,7 @@ export default domAssigned(class Equality {
   static fromStatementNode(statementNode, context) {
     let equality = null;
 
-    const equalityNode = equalityNodeQuery(statementNode);
+    const equalityNode = statementNode.getEqualityNode();
 
     if (equalityNode !== null) {
       const node = equalityNode,  ///
@@ -232,7 +228,7 @@ export default domAssigned(class Equality {
 
 function leftTermFromEqualityNode(equalityNode, context) {
   const { Term } = dom,
-        leftTermNode = leftTermNodeQuery(equalityNode),
+        leftTermNode = equalityNode.getLeftTermNode(),
         leftTerm = Term.fromTermNode(leftTermNode, context);
 
   return leftTerm;
@@ -240,7 +236,7 @@ function leftTermFromEqualityNode(equalityNode, context) {
 
 function rightTermFromEqualityNode(equalityNode, context) {
   const { Term } = dom,
-        rightTermNode = rightTermNodeQuery(equalityNode),
+        rightTermNode = equalityNode.getRightTermNode(),
         rightTerm = Term.fromTermNode(rightTermNode, context);
 
   return rightTerm;

package/src/dom/frame.js

@@ -7,13 +7,6 @@ import dom from "../dom";
 import { S, NOTHING } from "../constants";
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
-import { nodeQuery, nodesQuery } from "../utilities/query";
-
-const declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodesQuery = nodesQuery("/frame/metavariable"),
-      judgementFrameNodeQuery = nodeQuery("/judgement/frame"),
-      definedAssertionFrameNodeQuery = nodeQuery("/definedAssertion/frame"),
-      containedAssertionFrameNodeQuery = nodeQuery("/containedAssertion/frame");
 
 const { first } = arrayUtilities;
 
@@ -308,8 +301,7 @@ export default domAssigned(class Frame {
   }
 
   static fromJudgementNode(judgementNode, context) {
-    const judgementFrameNode = judgementFrameNodeQuery(judgementNode),
-          frameNode = judgementFrameNode,
+    const frameNode = judgementNode.getFrameNode(),
           frame = frameFromFrameNode(frameNode, context);
 
     return frame;
@@ -318,11 +310,9 @@ export default domAssigned(class Frame {
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let frame = null;
 
-    const definedAssertionFrameNode = definedAssertionFrameNodeQuery(definedAssertionNode);
-
-    if (definedAssertionFrameNode !== null) {
-      const frameNode = definedAssertionFrameNode;  ///
+    const frameNode = definedAssertionNode.getFrameNode();
 
+    if (frameNode !== null) {
       frame = frameFromFrameNode(frameNode, context);
     }
 
@@ -332,11 +322,9 @@ export default domAssigned(class Frame {
   static fromContainedAssertionNode(containedAssertionNode, context) {
     let frame = null;
 
-    const containedAssertionFrameNode = containedAssertionFrameNodeQuery(containedAssertionNode);
-
-    if (containedAssertionFrameNode !== null) {
-      const frameNode = containedAssertionFrameNode;  ///
+    const frameNode = containedAssertionNode.getFrameNode();
 
+    if (frameNode !== null) {
       frame = frameFromFrameNode(frameNode, context)
     }
 
@@ -358,7 +346,7 @@ function frameFromFrameNode(frameNode, context) {
 
 function declarationsFromFrameNode(frameNode, context) {
   const { Declaration } = dom,
-        declarationNodes = declarationNodesQuery(frameNode),
+        declarationNodes = frameNode.getDeclarationNodes(),
         declarations = declarationNodes.map((declarationNode) => {
           const declaration = Declaration.fromDeclarationNode(declarationNode, context);
 
@@ -370,7 +358,7 @@ function declarationsFromFrameNode(frameNode, context) {
 
 function metavariablesFromFrameNode(frameNode, context) {
   const { Metavariable } = dom,
-        metavariableNodes = metavariableNodesQuery(frameNode),
+        metavariableNodes = frameNode.getMetavariableNodes(),
         metavariables = metavariableNodes.map((metavariableNode) => {
           const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
 

package/src/dom/judgement.js

@@ -3,11 +3,8 @@
 import dom from "../dom";
 import JudgementAssignment from "../assignment/judgement";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const judgementNodeQuery = nodeQuery("/statement/judgement");
-
 export default domAssigned(class Judgement {
   constructor(string, frame, declaration) {
     this.string = string;
@@ -158,7 +155,7 @@ export default domAssigned(class Judgement {
   static fromStatementNode(statementNode, context) {
     let judgement = null;
 
-    const judgementNode = judgementNodeQuery(statementNode);
+    const judgementNode = statementNode.getJudgementNode();
 
     if (judgementNode !== null) {
       const { Frame, Declaration} = dom,

package/src/dom/lemma.js

@@ -33,5 +33,10 @@ export default domAssigned(class Lemma extends TopLevelAssertion {
 
   static name = "Lemma";
 
-  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Lemma, node, fileContext); }
+  static fromLemmaNode(lemmaNode, fileContext) {
+    const node = lemmaNode, ///
+          lemma = TopLevelAssertion.fromNode(Lemma, node, fileContext);
+
+    return lemma;
+  }
 });

package/src/dom/metaLemma.js

@@ -31,5 +31,10 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext); }
+  static fromMetaLemmaNode(metaLemmaNode, fileContext) {
+    const node = metaLemmaNode, ///
+          metaLemma = TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext);
+
+    return metaLemma;
+  }
 });

package/src/dom/metaType.js

@@ -2,12 +2,9 @@
 
 import LocalContext from "../context/local";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-const metavariableDeclarationMetaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
-
 class MetaType {
   constructor(name) {
     this.name = name;
@@ -61,8 +58,7 @@ class MetaType {
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const metavariableDeclarationMetaTypeNode = metavariableDeclarationMetaTypeNodeQuery(metavariableDeclarationNode),
-          metaTypeNode = metavariableDeclarationMetaTypeNode, ///
+    const metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
           metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);

package/src/dom/metatheorem.js

@@ -31,5 +31,10 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
 
-  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext); }
+  static fromMetatheoremNode(metatheoremNode, fileContext) {
+    const node = metatheoremNode, ///
+          metatheorem = TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext);
+
+    return metatheorem;
+  }
 });