occam-verify-cli 1.0.126 → 1.0.127

package/src/dom/assertion/type.js

@@ -7,9 +7,7 @@ import { nodeQuery } from "../../utilities/query";
 import { objectType } from "../type";
 import { domAssigned } from "../../dom";
 
-const termNodeQuery = nodeQuery("/typeAssertion/term"),
-      typeNodeQuery = nodeQuery("/typeAssertion/type"),
-      variableNodeQuery = nodeQuery("/term/variable!"),
+const variableNodeQuery = nodeQuery("/term/variable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion");
 
 export default domAssigned(class TypeAssertion {
@@ -175,7 +173,7 @@ export default domAssigned(class TypeAssertion {
     } else {
       provisional = false;
 
-      type = Type.fromTypeAndProvisional(this.type, provisional, context);
+      type = Type.fromTypeAndProvisional(this.type, provisional);
     }
 
     const variable = Variable.fromVariableNodeAndType(variableNode, type, context);
@@ -197,11 +195,10 @@ export default domAssigned(class TypeAssertion {
 
     if (typeAssertionNode !== null) {
       const { Term, Type } = dom,
-            termNode = termNodeQuery(typeAssertionNode),
-            typeNode = typeNodeQuery(typeAssertionNode),
-            term = Term.fromTermNode(termNode, context),
-            type = Type.fromTypeNode(typeNode),
-            string = stringFromTermAndType(term, type);
+            node = typeAssertionNode, ///
+            string = context.nodeAsString(node),
+            term = Term.fromTypeAssertionNode(typeAssertionNode, context),
+            type = Type.fromTypeAssertionNode(typeAssertionNode, context);
 
       typeAssertion = new TypeAssertion(string, term, type);
     }
@@ -209,11 +206,3 @@ export default domAssigned(class TypeAssertion {
     return typeAssertion;
   }
 });
-
-function stringFromTermAndType(term, type) {
-  const termString = term.getString(),
-        typeName = type.getName(),
-        string = `${termString}:${typeName}`;
-
-  return string;
-}

package/src/dom/axiom.js

@@ -229,11 +229,11 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
 
   static fromAxiomNode(axiomNode, fileContext) {
     const node = axiomNode, ///
+          proof = proofFromNode(node, fileContext),
           labels = labelsFromNode(node, fileContext),
-          suppositions = suppositionsFromNode(node, fileContext),
           deduction = deductionFromNode(node, fileContext),
-          proof = proofFromNode(node, fileContext),
           satisfiable = satisfiableFromNode(node, fileContext),
+          suppositions = suppositionsFromNode(node, fileContext),
           string = stringFromLabelsAndDeduction(labels, deduction),
           topLevelAssertion = new Axiom(fileContext, string, labels, suppositions, deduction, proof, satisfiable);
 
@@ -241,7 +241,7 @@ export default domAssigned(class Axiom extends TopLevelAssertion {
   }
 });
 
-function satisfiableFromNode(node, fileContext) {
+export function satisfiableFromNode(node, fileContext) {
   const firstPrimaryKeywordTerminalNode = firstPrimaryKeywordTerminalNodeQuery(node),
         content = firstPrimaryKeywordTerminalNode.getContent(),
         contentSatisfiable = (content === SATISFIABLE),

package/src/dom/combinator.js

@@ -1,15 +1,11 @@
 "use strict";
 
 import dom from "../dom";
-import LocalContext from "../context/local";
 
-import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyStatementWithCombinator } from "../utilities/unification";
 import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
 
-const statementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
-
 export default domAssigned(class Combinator {
   constructor(statement) {
     this.statement = statement;
@@ -66,10 +62,7 @@ export default domAssigned(class Combinator {
 
   static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
     const { Statement } = dom,
-          statementNode = statementNodeQuery(combinatorDeclarationNode),
-          localContext = LocalContext.fromFileContext(fileContext),
-          context = localContext, ///
-          statement = Statement.fromStatementNode(statementNode, context),
+          statement = Statement.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
           combinator = new Combinator(statement);
 
     return combinator;

package/src/dom/conjecture.js

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

package/src/dom/constructor/bracketed.js

@@ -6,7 +6,6 @@ import constructorBracketedContext from "../../context/bracketed/constructor";
 
 import { nodeQuery } from "../../utilities/query";
 import { domAssigned } from "../../dom";
-import { stringFromTermAndType } from "../constructor";
 
 const termNodeQuery = nodeQuery("/term/argument/term");
 
@@ -60,9 +59,9 @@ export default domAssigned(class BracketedConstructor extends Constructor {
           termNode = bracketedTermNode,  ///
           context = constructorBracketedContext, ///
           term = Term.fromTermNode(termNode, context),
-          type = null,
-          string = stringFromTermAndType(term, type),
-          bracketedConstructor = new BracketedConstructor(string, term);
+          string = term.getString(),
+          provisional = null,
+          bracketedConstructor = new BracketedConstructor(string, term, provisional);
 
     return bracketedConstructor;
   }

package/src/dom/constructor.js

@@ -4,14 +4,13 @@ import dom from "../dom";
 import LocalContext from "../context/local";
 
 import { nodeQuery } from "../utilities/query";
+import { objectType } from "./type";
 import { domAssigned } from "../dom";
 import { PROVISIONALLY } from "../constants";
 import { unifyTermWithConstructor } from "../utilities/unification";
 import { termFromJSON, termToTermJSON } from "../utilities/json";
 
-const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
-      typeNodeQuery = nodeQuery("/constructorDeclaration/type"),
-      lastSecondaryKeywordTerminalNodeQuery = nodeQuery("/constructorDeclaration/@secondary-keyword[-1]");
+const lastSecondaryKeywordTerminalNodeQuery = nodeQuery("/constructorDeclaration/@secondary-keyword[-1]");
 
 export default domAssigned(class Constructor {
   constructor(string, term, provisional) {
@@ -81,40 +80,41 @@ export default domAssigned(class Constructor {
   static fromJSON(json, fileContext) {
     const { provisional } = json,
           term = termFromJSON(json, fileContext),
-          type = term.getType(),
-          string = stringFromTermAndType(term, type),
+          string = stringFromTermAndProvisional(term, provisional),
           constructor = new Constructor(string, term, provisional);
 
     return constructor;
   }
 
   static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
-    const { Term, Type } = dom,
-          termNode = termNodeQuery(constructorDeclarationNode),
-          typeNode = typeNodeQuery(constructorDeclarationNode),
+    const { Term } = dom,
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
-          type = Type.fromTypeNode(typeNode),
-          term = Term.fromTermNodeAndType(termNode, type, context),
-          string = stringFromTermAndType(term, type),
+          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
           provisional = provisionalFromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
+          string = stringFromTermAndProvisional(term, provisional),
           constructor = new Constructor(string, term, provisional);
 
     return constructor;
   }
 });
 
-export function stringFromTermAndType(term, type) {
+function stringFromTermAndProvisional(term, provisional) {
   let string;
 
-  const termString = term.getString();
+  const type = term.getType(),
+        termString = term.getString();
 
-  if (type === null) {
-    string = `${termString}`;
+  if (type === objectType) {
+    string = termString;  ///
   } else {
-    const typeName = type.getName();
+    const typeString = type.getString();
 
-    string = `${termString}:${typeName}`;
+    string = `${termString}:${typeString}`;
+  }
+
+  if (provisional) {
+    string = `${string} ${PROVISIONALLY}`;
   }
 
   return string;

package/src/dom/declaration.js

@@ -6,9 +6,8 @@ import Substitutions from "../substitutions";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 import { unifyStatementIntrinsically } from "../utilities/unification";
-import { stripBracketsFromStatementNode } from "../utilities/brackets";
 
-const statementNodeQuery = nodeQuery("/declaration/statement");
+const judgementDeclarationNodeQuery = nodeQuery("/judgement/declaration");
 
 export default domAssigned(class Declaration {
   constructor(string, reference, statement) {
@@ -255,21 +254,28 @@ export default domAssigned(class Declaration {
 
   static name = "Declaration";
 
-  static fromDeclarationNode(declarationNode, context) {
-    const { Reference, Statement } = dom,
-          node = declarationNode,  ///
-          string = context.nodeAsString(node);
-
-    let statementNode;
+  static fromJudgementNode(judgementNode, context) {
+    const judgementDeclarationNode = judgementDeclarationNodeQuery(judgementNode),
+          declarationNode = judgementDeclarationNode, ///
+          declaration = declarationFromDeclarationNode(declarationNode, context);
 
-    statementNode = statementNodeQuery(declarationNode);
-
-    statementNode = stripBracketsFromStatementNode(statementNode);  ///
+    return declaration;
+  }
 
-    const reference = Reference.fromDeclarationNode(declarationNode, context),
-          statement = Statement.fromStatementNode(statementNode, context),
-          declaration = new Declaration(string, reference, statement);
+  static fromDeclarationNode(declarationNode, context) {
+    const declaration = declarationFromDeclarationNode(declarationNode, context);
 
     return declaration;
   }
 });
+
+function declarationFromDeclarationNode(declarationNode, context) {
+  const { Declaration, Reference, Statement } = dom,
+        node = declarationNode,  ///
+        string = context.nodeAsString(node),
+        reference = Reference.fromDeclarationNode(declarationNode, context),
+        statement = Statement.fromDeclarationNode(declarationNode, context),
+        declaration = new Declaration(string, reference, statement);
+
+  return declaration;
+}

package/src/dom/derivation.js

@@ -67,9 +67,18 @@ function stepsOrSubproofsFromDerivationNode(derivationNode, fileContext) {
   const { Step, Subproof } = dom,
         stepOrSubproofNodes = stepOrSubproofNodesQuery(derivationNode),
         stepsOrSubproofs = stepOrSubproofNodes.map((stepOrSubproofNode) => {
-          const subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
-                step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
-                stepOrSubproof = (step || subproof);
+          let stepOrSubproof;
+
+          const step = Step.fromStepOrSubproofNode(stepOrSubproofNode, fileContext),
+                subproof = Subproof.fromStepOrSubproofNode(stepOrSubproofNode, fileContext);
+
+          if (false) {
+            ///
+          } else if (step !== null) {
+            stepOrSubproof = step;  ///
+          } else if (subproof !== null) {
+            stepOrSubproof = subproof;  ///
+          }
 
           return stepOrSubproof;
         });

package/src/dom/frame.js

@@ -10,8 +10,8 @@ import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
 const declarationNodesQuery = nodesQuery("/frame/declaration"),
-      metavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       metavariableNodesQuery = nodesQuery("/frame/metavariable"),
+      judgementFrameNodeQuery = nodeQuery("/judgement/frame"),
       definedAssertionFrameNodeQuery = nodeQuery("/definedAssertion/frame"),
       containedAssertionFrameNodeQuery = nodeQuery("/containedAssertion/frame");
 
@@ -49,16 +49,12 @@ export default domAssigned(class Frame {
   getMetavariable() {
     let metavariable = null;
 
-    const declarationsLength = this.declarations.length;
-
-    if (declarationsLength === 0) {
-      const metavariablesLength = this.metavariables.length;
+    const simple = this.isSimple();
 
-      if (metavariablesLength === 1) {
-        const firstMetavariable = first(this.metavariables);
+    if (simple) {
+      const firstMetavariable = first(this.metavariables);
 
-        metavariable = firstMetavariable; ///
-      }
+      metavariable = firstMetavariable; ///
     }
 
     return metavariable;
@@ -71,6 +67,14 @@ export default domAssigned(class Frame {
     return equalTo;
   }
 
+  isSimple() {
+    const metavariablesLength = this.metavariables.length,
+          declarationsLength = this.declarations.length,
+          simple = ((metavariablesLength === 1) && (declarationsLength === 0));
+
+    return simple;
+  }
+
   matchSubstitution(substitution, context) {
     let substitutionMatches = false;
 
@@ -250,7 +254,7 @@ export default domAssigned(class Frame {
                            S :
                              NOTHING,
             frameString = this.string,  ///
-            metavariablesString = metavariablesStringFromDeclarations(this.metavariables);
+            metavariablesString = metavariablesStringFromMetavariables(this.metavariables);
 
       context.trace(`Verifying the '${frameString}' frame's '${metavariablesString}' metavariable${sOrNothing}...`);
 
@@ -297,30 +301,29 @@ export default domAssigned(class Frame {
     let frame = null;
 
     if (frameNode !== null) {
-      const node = frameNode, ///
-            string = context.nodeAsString(node),
-            tokens = context.nodeAsTokens(node),
-            declarations = declarationsFromFrameNode(frameNode, context),
-            metavariables = metavariablesFromFrameNode(frameNode, context);
-
-      frame = new Frame(string, node, tokens, declarations, metavariables);
+      frame = frameFromFrameNode(frameNode, context);
     }
 
     return frame;
   }
 
+  static fromJudgementNode(judgementNode, context) {
+    const judgementFrameNode = judgementFrameNodeQuery(judgementNode),
+          frameNode = judgementFrameNode,
+          frame = frameFromFrameNode(frameNode, context);
+
+    return frame;
+  }
+
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let frame = null;
 
     const definedAssertionFrameNode = definedAssertionFrameNodeQuery(definedAssertionNode);
 
     if (definedAssertionFrameNode !== null) {
-      const frameNode = definedAssertionFrameNode,  ///
-            metavariableNode = metavariableNodeQuery(frameNode);
+      const frameNode = definedAssertionFrameNode;  ///
 
-      if (metavariableNode !== null) {
-        frame = frameFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, context)
-      }
+      frame = frameFromFrameNode(frameNode, context);
     }
 
     return frame;
@@ -332,28 +335,22 @@ export default domAssigned(class Frame {
     const containedAssertionFrameNode = containedAssertionFrameNodeQuery(containedAssertionNode);
 
     if (containedAssertionFrameNode !== null) {
-      const frameNode = containedAssertionFrameNode,  ///
-            metavariableNode = metavariableNodeQuery(frameNode);
+      const frameNode = containedAssertionFrameNode;  ///
 
-      if (metavariableNode !== null) {
-        frame = frameFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, context)
-      }
+      frame = frameFromFrameNode(frameNode, context)
     }
 
     return frame;
   }
 });
 
-function frameFromFrameNodeAndMetavariableNode(frameNode, metavariableNode, context) {
-  const { Frame, Metavariable } = dom,
-        metavariable = Metavariable.fromMetavariableNode(metavariableNode, context),
-        declarations = [],
-        metavariables = [
-          metavariable
-        ],
-        node = frameNode,  ///
+function frameFromFrameNode(frameNode, context) {
+  const { Frame } = dom,
+        node = frameNode, ///
         string = context.nodeAsString(node),
         tokens = context.nodeAsTokens(node),
+        declarations = declarationsFromFrameNode(frameNode, context),
+        metavariables = metavariablesFromFrameNode(frameNode, context),
         frame = new Frame(string, node, tokens, declarations, metavariables);
 
   return frame;
@@ -397,7 +394,7 @@ function declarationsStringFromDeclarations(declarations) {
   return declarationsString;
 }
 
-function metavariablesStringFromDeclarations(metavariable) {
+function metavariablesStringFromMetavariables(metavariable) {
   const metavariablesString = metavariable.reduce((metavariablesString, metavariable) => {
     const metavariableString = metavariable.getString();
 

package/src/dom/judgement.js

@@ -6,9 +6,7 @@ import JudgementAssignment from "../assignment/judgement";
 import { nodeQuery } from "../utilities/query";
 import { domAssigned } from "../dom";
 
-const frameNodeQuery = nodeQuery("/judgement/frame"),
-      judgementNodeQuery = nodeQuery("/statement/judgement"),
-      declarationNodeQuery = nodeQuery("/judgement/declaration");
+const judgementNodeQuery = nodeQuery("/statement/judgement");
 
 export default domAssigned(class Judgement {
   constructor(string, frame, declaration) {
@@ -29,6 +27,8 @@ export default domAssigned(class Judgement {
     return this.declaration;
   }
 
+  isSimple() { return this.frame.isSimple(); }
+
   getMetavariable() { return this.frame.getMetavariable(); }
 
   verify(assignments, stated, context) {
@@ -161,10 +161,11 @@ export default domAssigned(class Judgement {
     const judgementNode = judgementNodeQuery(statementNode);
 
     if (judgementNode !== null) {
-      const node = judgementNode, ///
+      const { Frame, Declaration} = dom,
+            node = judgementNode, ///
             string = context.nodeAsString(node),
-            frame = frameFromJudgementNode(judgementNode, context),
-            declaration = declarationFromJudgementNode(judgementNode, context);
+            frame = Frame.fromJudgementNode(judgementNode, context),
+            declaration = Declaration.fromJudgementNode(judgementNode, context);
 
       judgement = new Judgement(string, frame, declaration);
     }
@@ -172,19 +173,3 @@ export default domAssigned(class Judgement {
     return judgement;
   }
 });
-
-function frameFromJudgementNode(judgementNode, context) {
-  const { Frame } = dom,
-        frameNode = frameNodeQuery(judgementNode),
-        frame = Frame.fromFrameNode(frameNode, context);
-
-  return frame;
-}
-
-function declarationFromJudgementNode(judgementNode, context) {
-  const { Declaration } = dom,
-        declarationNode = declarationNodeQuery(judgementNode),
-        declaration = Declaration.fromDeclarationNode(declarationNode, context);
-
-  return declaration;
-}

package/src/dom/lemma.js

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

package/src/dom/metaLemma.js

@@ -31,5 +31,5 @@ export default domAssigned(class MetaLemma extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(MetaLemma, json, fileContext); }
 
-  static fromMetaLemmaNode(axiomNode, fileContext) { return TopLevelMetaAssertion.fromNode(MetaLemma, axiomNode, fileContext); }
+  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(MetaLemma, node, fileContext); }
 });

package/src/dom/metaType.js

@@ -1,11 +1,13 @@
 "use strict";
 
+import LocalContext from "../context/local";
+
 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");
+const metavariableDeclarationMetaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType");
 
 class MetaType {
   constructor(name) {
@@ -54,21 +56,29 @@ class MetaType {
   }
 
   static fromMetaTypeNode(metaTypeNode, context) {
-    const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          metaType = metaTypeFromMetaTypeName(metaTypeName);
+    const metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
 
     return metaType;
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const metatypeNode = metaTypeNodeQuery(metavariableDeclarationNode),
-          metaTypeName = metaTypeNameFromMetaTypeNode(metatypeNode),
-          metaType = fileContext.findMetaTypeByMetaTypeName(metaTypeName);
+    const metavariableDeclarationMetaTypeNode = metavariableDeclarationMetaTypeNodeQuery(metavariableDeclarationNode),
+          metaTypeNode = metavariableDeclarationMetaTypeNode, ///
+          localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
+          metaType = metaTypeFromMetaTypeNode(metaTypeNode, context);
 
     return metaType;
   }
 }
 
+function metaTypeFromMetaTypeNode(metaTypeNode, context) {
+  const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
+        metaType = metaTypeFromMetaTypeName(metaTypeName);
+
+  return metaType;
+}
+
 export default domAssigned(MetaType);
 
 class FrameMetaType extends MetaType {

package/src/dom/metatheorem.js

@@ -31,5 +31,5 @@ export default domAssigned(class Metatheorem extends TopLevelMetaAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelMetaAssertion.fromJSON(Metatheorem, json, fileContext); }
 
-  static fromMetatheoremNode(axiomNode, fileContext) { return TopLevelMetaAssertion.fromNode(Metatheorem, axiomNode, fileContext); }
+  static fromNode(node, fileContext) { return TopLevelMetaAssertion.fromNode(Metatheorem, node, fileContext); }
 });

package/src/dom/metavariable.js

@@ -16,12 +16,12 @@ import { metavariableFromFrame, metavariableFromStatement } from "../utilities/c
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../utilities/unification";
 import { typeNameFromTypeNode, metavariableNameFromMetavariableNode } from "../utilities/name";
 
-const metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
+const frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       labelMetavariableNodeQuery = nodeQuery("/label/metavariable"),
       referenceMetavariableNodeQuery = nodeQuery("/reference/metavariable"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable"),
-      metavariableDeclarationTypeNodeQuery = nodeQuery("/metavariableDeclaration/metavariable/type");
+      metavariableDeclarationMetavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable"),
+      metavariableDeclarationMetavariableTypeNodeQuery = nodeQuery("/metavariableDeclaration/metavariable/type");
 
 export default domAssigned(class Metavariable {
   constructor(string, node, tokens, name, type, metaType) {
@@ -57,6 +57,26 @@ export default domAssigned(class Metavariable {
     return this.metaType;
   }
 
+  setNode(node) {
+    this.node = node;
+  }
+
+  setTokens(tokens) {
+    this.tokens = tokens;
+  }
+
+  setName(name) {
+    this.name = name;
+  }
+
+  setType(type) {
+    this.type = type;
+  }
+
+  setMetaType(metaType) {
+    this.metaType = metaType;
+  }
+
   matchName(name) {
     const nameMatches = (name === this.name);
 
@@ -504,18 +524,18 @@ export default domAssigned(class Metavariable {
   }
 
   static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
-    const { Type, MetaType } = dom,
+    const { MetaType } = dom,
+          metavariableDeclarationMetavariableNode = metavariableDeclarationMetavariableNodeQuery(metavariableDeclarationNode),
+          metavariableNode = metavariableDeclarationMetavariableNode, ///
           localContext = LocalContext.fromFileContext(fileContext),
           context = localContext, ///
-          metavariableNode = metavariableNodeQuery(metavariableDeclarationNode),
-          node = metavariableNode,  ///
-          string = fileContext.nodeAsString(node),
-          tokens = fileContext.nodeAsTokens(node),
-          metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-          name = metavariableName,  ///
           type = typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
           metaType = MetaType.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
-          metavariable = new Metavariable(string, node, tokens, name, type, metaType);
+          metavariable = metavariableFromMetavariableNode(metavariableNode, context);
+
+    metavariable.setType(type);
+
+    metavariable.setMetaType(metaType);
 
     return metavariable;
   }
@@ -524,11 +544,11 @@ export default domAssigned(class Metavariable {
 function metavariableFromMetavariableNode(metavariableNode, context) {
   const { Metavariable } = dom,
         metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        type = null,
         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);
 
@@ -538,10 +558,10 @@ function metavariableFromMetavariableNode(metavariableNode, context) {
 function typeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
   let type = null;
 
-  const metavariableDeclarationTypeNode = metavariableDeclarationTypeNodeQuery(metavariableDeclarationNode);
+  const metavariableDeclarationMetavariableTypeNode = metavariableDeclarationMetavariableTypeNodeQuery(metavariableDeclarationNode);
 
-  if (metavariableDeclarationTypeNode !== null) {
-    const typeNode = metavariableDeclarationTypeNode, ///
+  if (metavariableDeclarationMetavariableTypeNode !== null) {
+    const typeNode = metavariableDeclarationMetavariableTypeNode, ///
           typeName = typeNameFromTypeNode(typeNode);
 
     type = fileContext.findTypeByTypeName(typeName);