occam-verify-cli 0.0.1068 → 0.0.1069

package/src/substitution/frameForMetavariable.js

@@ -4,31 +4,32 @@ import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
-import { metavariableNameFromMetavariableNode } from "../utilities/name";
-import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
-import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
+import { substitutionNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromSubstitutionString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
+import { unqualifiedStatementTokensFromUnqualifiedStatementString,
+         substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } from "../utilities/tokens";
 
 const frameNodeQuery = nodeQuery("/substitution/frame[0]"),
       metavariableNodeQuery = nodeQuery("/substitution/frame[1]/metavariable!"),
-      substitutionNodeQuery = nodeQuery("/statement/substitution"),
-      frameMetavariableNodeQuery = nodeQuery("/frame/metavariable");
+      substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class FrameForMetavariableSubstitution extends Substitution {
-  constructor(string, frameNode, metavariableNode, substitutionNode, substitutionTokens) {
+  constructor(string, frame, metavariable, substitutionNode, substitutionTokens) {
     super(string);
 
-    this.frameNode = frameNode;
-    this.metavariableNode = metavariableNode;
+    this.frame = frame;
+    this.metavariable = metavariable;
     this.substitutionNode = substitutionNode;
     this.substitutionTokens = substitutionTokens;
   }
 
-  getFrameNode() {
-    return this.frameNode;
+  getFrame() {
+    return this.frame;
   }
 
-  getMetavariableNode() {
-    return this.metavariableNode;
+  getMetavariable() {
+    return this.metavariable;
   }
 
   getSubstitutionNode() {
@@ -40,22 +41,33 @@ export default class FrameForMetavariableSubstitution extends Substitution {
   }
 
   getMetavariableName() {
-    const metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
+    const metavariableName = this.metavariable.getName();
 
     return metavariableName;
   }
 
-  setSubstitutionNode() {
-    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
+  getSubstitutionString() {
+    const frameString = this.frame.getString(),
+          metavariableString = this.metavariable.getString(),
+          substitutionString = `[[${frameString}] for [${metavariableString}]]`;
+
+    return substitutionString;
   }
 
-  setSubstitutionTokens() {
-    const frameMetavariableNode = frameMetavariableNodeQuery(this.frameNode),
-        frameMetavariableName = metavariableNameFromMetavariableNode(frameMetavariableNode),
-        metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode),
-        substitutionString = `[[${frameMetavariableName}] for [${metavariableName}]]`;
+  setSubstitutionNodeAndTokens(localContext) {
+    const lexer = localContext.getLexer(),
+          parser = localContext.getParser(),
+          substitutionString = this.getSubstitutionString(),
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
+
+    this.substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+    this.substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, this.substitutionNode);
+  }
 
-    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
+  setSubstitutionTokens(localContext) {
   }
 
   isEqualTo(substitution) {
@@ -74,18 +86,14 @@ export default class FrameForMetavariableSubstitution extends Substitution {
     return equalTo;
   }
 
-  matchFrameNode(frameNode) {
-    const frameNodeMatches = this.frameNode.match(frameNode);
-
-    return frameNodeMatches;
-  }
+  matchFrameNode(frameNode) { return this.frame.matchFrameNode(frameNode); }
 
   matchMetavariableName(metavariableName) {
     let metavariableNameMatches;
 
     const metavariableNameA = metavariableName; ///
 
-    metavariableName = metavariableNameFromMetavariableNode(this.metavariableNode);
+    metavariableName = this.metavariable.getName();
 
     const metavariableNameB = metavariableName; ///
 
@@ -130,11 +138,11 @@ export default class FrameForMetavariableSubstitution extends Substitution {
       if ((frameNode !== null) && (metavariableNode !== null)) {
         const { Frame, Metavariable } = shim,
               frame = Frame.fromFrameNode(frameNode, localContext),
-              variable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
-              string = stringFromFrameAndMetavariable(frame, variable, localContext),
+              metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContext),
+              string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
               substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
+        frameForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
       }
     }
 
@@ -143,11 +151,9 @@ export default class FrameForMetavariableSubstitution extends Substitution {
 
   static fromFrameAndMetavariable(frame, metavariable, localContext) {
     const string = stringFromFrameAndMetavariable(frame, metavariable, localContext),
-          frameNode = frame.getNode(),
-          metavariableNode = metavariable.getNode(),
           substitutionNode = null,
           substitutionTokens = null,
-          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frameNode, metavariableNode, substitutionNode, substitutionTokens);
+          statementForMetavariableSubstitution = new FrameForMetavariableSubstitution(string, frame, metavariable, substitutionNode, substitutionTokens);
 
     return statementForMetavariableSubstitution;
   }

package/src/substitution/statementForMetavariable.js

@@ -6,7 +6,8 @@ import LocalContext from "../context/local";
 import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 
-import { stripBracketsFromStatement } from "../utilities/brackets";
+import { stripBracketsFromStatementNode } from "../utilities/brackets";
+import { statementFromJSON, statementToStatementJSON, metavariableFromJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
   constructor(string, statement, metavariable, substitution) {
@@ -29,18 +30,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
-  getStatementNode() {
-    const statementNode = this.statement.getNode();
-
-    return statementNode;
-  }
-
-  getMetavariableNode() {
-    const metavariableNode = this.metavariable.getNode();
-
-    return metavariableNode;
-  }
-
   getMetavariableName() {
     const metavariableName = this.metavariable.getName();
 
@@ -84,20 +73,17 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const substitutionA = substitution; ///
-
-    substitution = this.unifyStatement(statement, localContextA, localContextB);
+    const substitutionA = substitution, ///
+          substitutionB = this.unifyStatement(statement, localContextB, localContextB);  ///
 
-    if (substitution !== null) {
-      substitutions.snapshot();
+    if (substitutionB !== null) {
+      localContextA = localContextFromLocalContextAndSubstitution(localContextA, substitutionA);  ///
 
-      const substitutionTokens = substitution.getSubstitutionTokens(),
-            tokens = substitutionTokens;  ///
+      localContextB = localContextFromLocalContextAndSubstitution(localContextB, substitutionB);  ///
 
-      localContextB = LocalContext.fromLocalContextAndTokens(localContextB, tokens);  ///
+      substitutions.snapshot();
 
-      const substitutionB = substitution, ///
-            nodeA = substitutionA.getSubstitutionNode(),  ///
+      const nodeA = substitutionA.getSubstitutionNode(),  ///
             nodeB = substitutionB.getSubstitutionNode(),  ///
             unifiedAtMetaLevel = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
@@ -118,8 +104,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   unifyStatement(statement, localContextA, localContextB) {
     let substitution = null;
 
-    localContextA = localContextB;  ///
-
     const substitutions = Substitutions.fromNothing(),
           statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
@@ -130,10 +114,6 @@ export default class StatementForMetavariableSubstitution extends Substitution {
         const firstSubstitution = substitutions.getFirstSubstitution();
 
         substitution = firstSubstitution; ///
-
-        substitution.setSubstitutionTokens();
-
-        substitution.setSubstitutionNode();
       }
     }
 
@@ -141,7 +121,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   matchStatementNode(statementNode) {
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const statementNodeMatches = this.statement.matchStatementNode(statementNode);
 
@@ -174,10 +154,51 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return metavariableNameAndSubstitutionNodeMatches;
   }
 
+  toJSON() {
+    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
+          statementJSON = statementToStatementJSON(this.statement),
+          metavariable = metavariableJSON,  ///
+          statement = statementJSON,  ///
+          string = this.string,
+          json = {
+            string,
+            statement,
+            metavariable
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, fileContext) {
+    const { string } = json,
+          statement = statementFromJSON(json, fileContext),
+          metavariable = metavariableFromJSON(json, fileContext),
+          substitution = null,  ///
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
+  }
+
+  static fromStatementAndMetavariable(statement, metavariable, localContext) {
+    let statementNode = statement.getNode();
+
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
+
+    const { Statement } = shim;
+
+    statement = Statement.fromStatementNode(statementNode, localContext);
+
+    const substitution = null,
+          string = stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext),
+          statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(string, statement, metavariable, substitution);
+
+    return statementForMetavariableSubstitution;
+  }
+
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
     let statementNode = statement.getNode();
 
-    statementNode = stripBracketsFromStatement(statementNode); ///
+    statementNode = stripBracketsFromStatementNode(statementNode); ///
 
     const { Statement } = shim;
 
@@ -190,6 +211,18 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
+function localContextFromLocalContextAndSubstitution(localContext, substitution) {
+  substitution.setSubstitutionNodeAndTokens(localContext);
+
+  const substitutionTokens = substitution.getSubstitutionTokens(),
+        context = localContext, ///
+        tokens = substitutionTokens; ///
+
+  localContext = LocalContext.fromContextAndTokens(context, tokens); ///
+
+  return localContext;
+}
+
 function stringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution, localContext) {
   let string;
 

package/src/substitution/termForVariable.js

@@ -4,32 +4,33 @@ import shim from "../shim";
 import Substitution from "../substitution";
 
 import { nodeQuery } from "../utilities/query";
-import { stripBracketsFromTerm } from "../utilities/brackets";
-import { variableNameFromVariableNode } from "../utilities/name";
-import { substitutionNodeFromSubstitutionTokens } from "../utilities/node";
-import { substitutionTokensFromSubstitutionString } from "../utilities/tokens";
+import { stripBracketsFromTermNode } from "../utilities/brackets";
+import { substitutionNodeFromUnqualifiedStatementNode,
+         unqualifiedStatementStringFromSubstitutionString,
+         unqualifiedStatementNodeFromUnqualifiedStatementTokens } from "../utilities/node";
+import { unqualifiedStatementTokensFromUnqualifiedStatementString,
+         substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode } from "../utilities/tokens";
 
 const termNodeQuery = nodeQuery("/substitution/term[0]"),
       variableNodeQuery = nodeQuery("/substitution/term[1]/variable!"),
-      termVariableNodeQuery = nodeQuery("/term/variable"),
       substitutionNodeQuery = nodeQuery("/statement/substitution");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode, substitutionNode, substitutionTokens) {
+  constructor(string, term, variable, substitutionNode, substitutionTokens) {
     super(string);
 
-    this.termNode = termNode;
-    this.variableNode = variableNode;
+    this.term = term;
+    this.variable = variable;
     this.substitutionNode = substitutionNode;
     this.substitutionTokens = substitutionTokens;
   }
 
-  getTermNode() {
-    return this.termNode;
+  getTerm() {
+    return this.term;
   }
 
-  getVariableNode() {
-    return this.variableNode;
+  getVariable() {
+    return this.variable;
   }
 
   getSubstitutionNode() {
@@ -40,33 +41,37 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.substitutionTokens;
   }
 
-  getVariableName() {
-    const variableName = variableNameFromVariableNode(this.variableNode);
+  getSubstitutionString() {
+    const termString = this.term.getString(),
+          variableString = this.variable.getString(),
+          substitutionString = `[${termString} for ${variableString}]`;
 
-    return variableName;
+    return substitutionString;
   }
 
-  setSubstitutionNode() {
-    this.substitutionNode = substitutionNodeFromSubstitutionTokens(this.substitutionTokens);
-  }
+  setSubstitutionNodeAndTokens(localContext) {
+    const lexer = localContext.getLexer(),
+          parser = localContext.getParser(),
+          substitutionString = this.getSubstitutionString(),
+          unqualifiedStatementString = unqualifiedStatementStringFromSubstitutionString(substitutionString),
+          unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
+          unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
 
-  setSubstitutionTokens() {
-    const termVariableNode = termVariableNodeQuery(this.termNode),
-          termVariableName = variableNameFromVariableNode(termVariableNode),
-          variableName = variableNameFromVariableNode(this.variableNode),
-          substitutionString = `[${termVariableName} for ${variableName}]`;
+    this.substitutionNode = substitutionNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
 
-    this.substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString);
+    this.substitutionTokens = substitutionTokensFromUnqualifiedStatementTokensAndSubstitutionNode(unqualifiedStatementTokens, this.substitutionNode);
   }
 
   isEqualTo(substitution) {
     let equalTo = false;
 
-    const termNode = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode();
+    const term = substitution.getTerm(),
+          variable = substitution.getVariable();
 
-    if ((termNode !== null) && (variableNode !== null)) {
-      const termNodeMatches = this.matchTermNode(termNode),
+    if ((term !== null) && (variable !== null)) {
+      const termNode = term.getNode(),
+            variableNode = variable.getNode(),
+            termNodeMatches = this.matchTermNode(termNode),
             variableNodeMatches = this.matchVariableNode(variableNode);
 
       equalTo = (termNodeMatches && variableNodeMatches);
@@ -76,9 +81,9 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   matchTermNode(termNode) {
-    termNode = stripBracketsFromTerm(termNode); ///
+    termNode = stripBracketsFromTermNode(termNode); ///
 
-    const termNodeMatches = this.termNode.match(termNode);
+    const termNodeMatches = this.term.matchTermNode(termNode);
 
     return termNodeMatches;
   }
@@ -88,7 +93,7 @@ export default class TermForVariableSubstitution extends Substitution {
 
     const variableNameA = variableName; ///
 
-    variableName = variableNameFromVariableNode(this.variableNode);
+    variableName = this.variable.getName();
 
     const variableNameB = variableName; ///
 
@@ -116,10 +121,12 @@ export default class TermForVariableSubstitution extends Substitution {
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedWithEquivalence;
 
-    const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
+    const termNode = this.term.getNode(),
+          equivalenceMatchesTermNode = equivalence.matchTermNode(termNode);
 
     if (equivalenceMatchesTermNode) {
-      const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
+      const variableNode = this.variable.getNode(),
+            equivalenceMatchesVariableNode = equivalence.matchVariableNode(variableNode);
 
       if (equivalenceMatchesVariableNode) {
           unifiedWithEquivalence = true;
@@ -145,7 +152,7 @@ export default class TermForVariableSubstitution extends Substitution {
               string = stringFromTermAndVariable(term, variable, localContext),
               substitutionTokens = localContext.nodeAsTokens(substitutionNode);
 
-        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, substitutionNode, substitutionTokens);
       }
     }
 
@@ -155,13 +162,16 @@ export default class TermForVariableSubstitution extends Substitution {
   static fromTernAndVariable(term, variable, localContext) {
     let termNode = term.getNode();
 
-    termNode = stripBracketsFromTerm(termNode); ///
+    termNode = stripBracketsFromTermNode(termNode); ///
+
+    const { Term } = shim;
+
+    term = Term.fromTermNode(termNode, localContext);
 
     const string = stringFromTermAndVariable(term, variable, localContext),
-          variableNode = variable.getNode(),
           substitutionNode = null,
           substitutionTokens = null,
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode, substitutionTokens);
+          termForVariableSubstitution = new TermForVariableSubstitution(string, term, variable, substitutionNode, substitutionTokens);
 
     return termForVariableSubstitution;
   }

package/src/substitution.js

@@ -1,6 +1,8 @@
 "use strict";
 
-export default class Substitution {
+import shim from "./shim";
+
+class Substitution {
   constructor(string) {
     this.string = string;
   }
@@ -9,22 +11,22 @@ export default class Substitution {
     return this.string;
   }
 
-  getTermNode() {
-    const termNode = null;
+  getTerm() {
+    const term = null;
 
-    return termNode;
+    return term;
   }
 
-  getFrameNode() {
-    const frameNode = null;
+  getFrame() {
+    const frame = null;
 
-    return frameNode;
+    return frame;
   }
 
-  getStatementNode() {
-    const statementNode = null;
+  getStatement() {
+    const statement = null;
 
-    return statementNode;
+    return statement;
   }
 
   getSubstitutionNode() {
@@ -33,12 +35,6 @@ export default class Substitution {
     return substitutionNode;
   }
 
-  getVariableName() {
-    const variableName = null;
-
-    return variableName;
-  }
-
   getMetavariableName() {
     const metavariableName = null;
 
@@ -124,3 +120,9 @@ export default class Substitution {
     return unifiedWithEquivalences;
   }
 }
+
+Object.assign(shim, {
+  Substitution
+});
+
+export default Substitution;

package/src/substitutions.js

@@ -54,6 +54,8 @@ export default class Substitutions {
     return metavariableNames;
   }
 
+  mapSubstitution(callback) { return this.array.map(callback); }
+
   findSubstitution(callback) { return this.array.find(callback) || null; }  ///
 
   someSubstitution(callback) { return this.array.some(callback); }

package/src/supposition.js

@@ -7,10 +7,11 @@ import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
+import { unqualifiedStatementFromJSON, unqualifiedStatementToUnqualifiedStatementJSON } from "./utilities/json";
 
 const unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement");
 
-export default class Supposition {
+class Supposition {
   constructor(fileContext, unqualifiedStatement) {
     this.fileContext = fileContext;
     this.unqualifiedStatement = unqualifiedStatement;
@@ -71,7 +72,13 @@ export default class Supposition {
 
     const statement = this.unqualifiedStatement.getStatement(),
           statementNode = statement.getNode(),
-          subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, this.fileContext);
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
 
     if (subproofAssertion !== null) {
       subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
@@ -131,7 +138,7 @@ export default class Supposition {
   }
 
   toJSON() {
-    const unqualifiedStatementJSON = this.unqualifiedStatement.toJSON(),
+    const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///
           json = {
             unqualifiedStatement
@@ -141,13 +148,8 @@ export default class Supposition {
   }
 
   static fromJSON(json, fileContext) {
-    let { unqualifiedStatement } = json;
-
-    json = unqualifiedStatement;  ///
-
-    unqualifiedStatement = UnqualifiedStatement.fromJSON(json, fileContext);
-
-    const supposition = new Supposition(fileContext, unqualifiedStatement);
+    const unqualifiedStatement = unqualifiedStatementFromJSON(json, fileContext),
+          supposition = new Supposition(fileContext, unqualifiedStatement);
 
     return supposition;
   }
@@ -160,3 +162,9 @@ export default class Supposition {
     return supposition
   }
 }
+
+Object.assign(shim, {
+  Supposition
+});
+
+export default Supposition;

package/src/term.js

@@ -11,6 +11,7 @@ import { objectType } from "./type";
 import { nodeQuery, nodesQuery } from "./utilities/query"
 import { termNodeFromTermString } from "./utilities/node";
 import { variableNameFromVariableNode } from "./utilities/name";
+import { typeFromJSON, typeToTypeJSON } from "./utilities/json";
 
 const { filter } = arrayUtilities;
 
@@ -236,12 +237,12 @@ class Term {
   }
 
   toJSON() {
-    const typeJSON = this.type.toJSON(),
+    const typeJSON = typeToTypeJSON(this.type),
           string = this.string,
           type = typeJSON,  ///
           json = {
-            string,
-            type
+            type,
+            string
           };
 
     return json;
@@ -249,9 +250,9 @@ class Term {
 
   static fromJSON(json, fileContext) {
     const { string } = json,
-          termString = string,  ///
           lexer = fileContext.getLexer(),
           parser = fileContext.getParser(),
+          termString = string,  ///
           termNode = termNodeFromTermString(termString, lexer, parser),
           node = termNode,  ///
           type = typeFromJSON(json, fileContext),
@@ -328,14 +329,3 @@ Object.assign(shim, {
 });
 
 export default Term;
-
-function typeFromJSON(json, fileContext) {
-  let { type } = json;
-
-  const { name } = type,
-        typeName = name;  ///
-
-  type = fileContext.findTypeByTypeName(typeName);
-
-  return type;
-}