occam-verify-cli 1.0.126 → 1.0.127

package/src/dom/procedureCall.js

@@ -6,7 +6,7 @@ import dom from "../dom";
 
 import { domAssigned } from "../dom";
 import { nodeQuery, nodesQuery } from "../utilities/query";
-import {parametersFromJSON, parametersToParametersJSON, referenceFromJSON} from "../utilities/json";
+import { referenceFromJSON, parametersFromJSON, parametersToParametersJSON } from "../utilities/json";
 
 const parameterNodesQuery = nodesQuery("/procedureCall/parameter"),
       premiseProcedureCallNodeQuery = nodeQuery("/premise/procedureCall"),
@@ -129,13 +129,9 @@ export default domAssigned(class ProcedureCall {
     const premiseProcedureCallNode = premiseProcedureCallNodeQuery(premiseNode);
 
     if (premiseProcedureCallNode !== null) {
-      const { Reference } = dom,
-            procedureCallNode = premiseProcedureCallNode, ///
-            parameters = parametersFromProcedureCallNode(procedureCallNode, context),
-            reference = Reference.fromProcedureCallNode(procedureCallNode, context),
-            string = stringFromReferenceAndParameters(reference, parameters);
+      const procedureCallNode = premiseProcedureCallNode; ///
 
-      procedureCall = new ProcedureCall(string, reference, parameters);
+      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
 
     return procedureCall;
@@ -147,19 +143,25 @@ export default domAssigned(class ProcedureCall {
     const suppositionProcedureCallNode = suppositionProcedureCallNodeQuery(suppositionNode);
 
     if (suppositionProcedureCallNode !== null) {
-      const { Reference } = dom,
-            procedureCallNode = suppositionProcedureCallNode, ///
-            parameters = parametersFromProcedureCallNode(procedureCallNode, context),
-            reference = Reference.fromProcedureCallNode(procedureCallNode, context),
-            string = stringFromReferenceAndParameters(reference, parameters);
+      const procedureCallNode = suppositionProcedureCallNode; ///
 
-      procedureCall = new ProcedureCall(string, reference, parameters);
+      procedureCall = procedureCallFromProcedureCallNode(procedureCallNode, context);
     }
 
     return procedureCall;
   }
 });
 
+function procedureCallFromProcedureCallNode(procedureCallNode, context) {
+  const { Reference, ProcedureCall } = dom,
+        parameters = parametersFromProcedureCallNode(procedureCallNode, context),
+        reference = Reference.fromProcedureCallNode(procedureCallNode, context),
+        string = stringFromReferenceAndParameters(reference, parameters),
+        procedureCall = new ProcedureCall(string, reference, parameters);
+
+  return procedureCall;
+}
+
 function parametersFromProcedureCallNode(procedureCallNode, context) {
   const { Parameter } = dom,
         parameterNodes = parameterNodesQuery(procedureCallNode),

package/src/dom/property.js

@@ -11,8 +11,9 @@ import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 const { match } = arrayUtilities;
 
-const propertyNodeQuery = nodeQuery("/propertyDeclaration/property"),
-      nameTerminalNodesQuery = nodesQuery("/property/@name");
+const nameTerminalNodesQuery = nodesQuery("/property/@name"),
+      propertyRelationPropertyNodeQuery = nodeQuery("/propertyRelation/property"),
+      propertyDeclarationPropertyNodeQuery = nodeQuery("/propertyDeclaration/property");
 
 export default domAssigned(class Property {
   constructor(string, names, type) {
@@ -71,40 +72,57 @@ export default domAssigned(class Property {
   }
 
   static fromPropertyNode(propertyNode, fileContext) {
-    const node = propertyNode,  ///
-          names = namesFromPropertyNode(propertyNode),
-          type = null,
-          string = fileContext.nodeAsString(node),
-          property = new Property(string, names, type);
+    const property = propertyFromPropertyNode(propertyNode, fileContext)
+
+    return property;
+  }
+
+  static fromPropertyRelationNode(propertyRelationNode, fileContext) {
+    const propertyRelationPropertyNode = propertyRelationPropertyNodeQuery(propertyRelationNode),
+          propertyNode = propertyRelationPropertyNode,  ///
+          property = propertyFromPropertyNode(propertyNode, fileContext);
 
     return property;
   }
 
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
     const { Type } = dom,
-          propertyNode = propertyNodeQuery(propertyDeclarationNode),
-          node = propertyDeclarationNode,  ///
-          names = namesFromPropertyNode(propertyNode),
           type = Type.fromPropertyDeclarationNode(propertyDeclarationNode),
-          string = fileContext.nodeAsString(node),
-          property = new Property(string, names, type);
+          propertyDeclarationPropertyNode = propertyDeclarationPropertyNodeQuery(propertyDeclarationNode),
+          propertyNode = propertyDeclarationPropertyNode,  ///
+          property = propertyFromPropertyNode(propertyNode, fileContext);
+
+    property.setType(type);
 
     return property;
   }
 });
 
-function namesStringFromNames(names) {
-  const namesString = names.reduce((namesString, name) => {
-    const nameString = name;  ///
+function propertyFromPropertyNode(propertyNode, fileContext) {
+  const { Property } = dom,
+        node = propertyNode,  ///
+        names = namesFromPropertyNode(propertyNode),
+        type = null,
+        string = fileContext.nodeAsString(node),
+        property = new Property(string, names, type);
 
-    namesString = (namesString === null) ?
-                    nameString :  ///
-                     `${namesString} ${nameString}`;
+  return property;
+}
 
-    return namesString;
-  }, null);
+function stringFromNamesAndType(names, type) {
+  let string;
 
-  return namesString;
+  const namesString = namesStringFromNames(names);
+
+  if (type === objectType) {
+    string = namesString;  ///
+  } else {
+    const typeName = type.getName();
+
+    string = `${namesString}:${typeName}`;
+  }
+
+  return string;
 }
 
 function namesFromPropertyNode(propertyNode, fileContext) {
@@ -119,18 +137,17 @@ function namesFromPropertyNode(propertyNode, fileContext) {
   return names;
 }
 
-function stringFromNamesAndType(names, type) {
-  let string;
-
-  const namesString = namesStringFromNames(names);
+function namesStringFromNames(names) {
+  const namesString = names.reduce((namesString, name) => {
+    const nameString = name;  ///
 
-  if (type === objectType) {
-    string = namesString;  ///
-  } else {
-    const typeName = type.getName();
+    namesString = (namesString === null) ?
+                    nameString :  ///
+                     `${namesString} ${nameString}`;
 
-    string = `${namesString}:${typeName}`;
-  }
+    return namesString;
+  }, null);
 
-  return string;
+  return namesString;
 }
+

package/src/dom/{relation/property.js → propertyRelation.js}

@@ -1,12 +1,11 @@
 "use strict";
 
-import dom from "../../dom";
+import dom from "../dom";
 
-import { nodeQuery } from "../../utilities/query";
-import { domAssigned } from "../../dom";
+import { nodeQuery } from "../utilities/query";
+import { domAssigned } from "../dom";
 
-const termNodeQuery = nodeQuery("/propertyRelation/term"),
-      propertyNodeQuery = nodeQuery("/propertyRelation/property");
+const propertyAssertionPropertyRelationNodeQuery = nodeQuery("/propertyAssertion/propertyRelation");
 
 export default domAssigned(class PropertyRelation {
   constructor(string, node, tokens, property, term) {
@@ -130,15 +129,15 @@ export default domAssigned(class PropertyRelation {
 
   static name = "PropertyRelation";
 
-  static fromPropertyRelationNode(propertyRelationNode, context) {
+  static fromPropertyAssertionNode(propertyAssertionNode, context) {
     const { Term, Property } = dom,
+          propertyAssertionPropertyRelationNode = propertyAssertionPropertyRelationNodeQuery(propertyAssertionNode),
+          propertyRelationNode = propertyAssertionPropertyRelationNode, ///
           node = propertyRelationNode,  ///
           string = context.nodeAsString(node),
           tokens = context.nodeAsTokens(node),
-          propertyNode = propertyNodeQuery(propertyRelationNode),
-          termNode = termNodeQuery(propertyRelationNode),
-          property = Property.fromPropertyNode(propertyNode, context),
-          term = Term.fromTermNode(termNode, context),
+          property = Property.fromPropertyRelationNode(propertyRelationNode, context),
+          term = Term.fromPropertyRelationNode(propertyRelationNode, context),
           propertyRelation = new PropertyRelation(string, node, tokens, property, term);
 
     return propertyRelation;

package/src/dom/reference.js

@@ -180,12 +180,6 @@ export default domAssigned(class Reference {
     return reference;
   }
 
-  static fromReferenceNode(referenceNode, fileContext) {
-    const reference = referenceFromReferenceNode(referenceNode, fileContext);
-
-    return reference;
-  }
-
   static fromStepNode(stepNode, fileContext) {
     let reference = null;
 
@@ -200,6 +194,12 @@ export default domAssigned(class Reference {
     return reference;
   }
 
+  static fromReferenceNode(referenceNode, fileContext) {
+    const reference = referenceFromReferenceNode(referenceNode, fileContext);
+
+    return reference;
+  }
+
   static fromDeclarationNode(declarationNode, fileContext) {
     const declarationMetavariableNode = declarationMetavariableNodeQuery(declarationNode),
           metavariableNode = declarationMetavariableNode, ///

package/src/dom/statement.js

@@ -11,6 +11,7 @@ import { domAssigned } from "../dom";
 import { unifyStatement } from "../utilities/unification";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
+import { stripBracketsFromStatementNode } from "../utilities/brackets";
 import { definedAssertionFromStatement, containedAssertionFromStatement, subproofAssertionFromStatement } from "../utilities/context";
 
 const { match, backwardsSome } = arrayUtilities;
@@ -22,7 +23,9 @@ const stepStatementNodeQuery = nodeQuery("/step/statement"),
       deductionStatementNodeQuery = nodeQuery("/deduction/statement"),
       conclusionStatementNodeQuery = nodeQuery("/conclusion/statement"),
       suppositionStatementNodeQuery = nodeQuery("/supposition/statement"),
-      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement");
+      declarationStatementNodeQuery = nodeQuery("/declaration/statement"),
+      containedAssertionStatementNodeQuery = nodeQuery("/containedAssertion/statement"),
+      combinatorDeclarationStatementNodeQuery = nodeQuery("/combinatorDeclaration/statement");
 
 export default domAssigned(class Statement {
   constructor(string, node, tokens) {
@@ -271,31 +274,31 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromPremiseNode(premiseNode, fileContext) {
+  static fromStepNode(stepNode, fileContext) {
     let statement = null;
 
-    const premiseStatementNode = premiseStatementNodeQuery(premiseNode);
+    const stepStatementNode = stepStatementNodeQuery(stepNode);
 
-    if (premiseStatementNode !== null) {
-      const statementNode = premiseStatementNode, ///
-            localContext = LocalContext.fromFileContext(fileContext),
-            context = localContext;  ///
+    if (stepStatementNode !== null) {
+      const statementNode = stepStatementNode; ///
 
-      statement = statementFromStatementNode(statementNode, context);
+      statement = statementFromStatementNode(statementNode, fileContext);
     }
 
     return statement;
   }
 
-  static fromStepNode(stepNode, fileContext) {
+  static fromPremiseNode(premiseNode, fileContext) {
     let statement = null;
 
-    const stepStatementNode = stepStatementNodeQuery(stepNode);
+    const premiseStatementNode = premiseStatementNodeQuery(premiseNode);
 
-    if (stepStatementNode !== null) {
-      const statementNode = stepStatementNode; ///
+    if (premiseStatementNode !== null) {
+      const statementNode = premiseStatementNode, ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
 
-      statement = statementFromStatementNode(statementNode, fileContext);
+      statement = statementFromStatementNode(statementNode, context);
     }
 
     return statement;
@@ -355,10 +358,26 @@ export default domAssigned(class Statement {
     return statement;
   }
 
-  static fromContainedAssertionNode(suppositionNode, fileContext) {
+  static fromDeclarationNode(declarationNode, fileContext) {
+    let statementNode;
+
+    const declarationStatementNode = declarationStatementNodeQuery(declarationNode);
+
+    statementNode = declarationStatementNode; ///
+
+    statementNode = stripBracketsFromStatementNode(statementNode);  ///
+
+    const localContext = LocalContext.fromFileContext(fileContext),
+          context = localContext, ///
+          statement = statementFromStatementNode(statementNode, context);
+
+    return statement;
+  }
+
+  static fromContainedAssertionNode(containedAssertionNode, fileContext) {
     let statement = null;
 
-    const containedAssertionStatementNode = containedAssertionStatementNodeQuery(suppositionNode);
+    const containedAssertionStatementNode = containedAssertionStatementNodeQuery(containedAssertionNode);
 
     if (containedAssertionStatementNode !== null) {
       const statementNode = containedAssertionStatementNode, ///
@@ -370,6 +389,22 @@ export default domAssigned(class Statement {
 
     return statement;
   }
+
+  static fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext) {
+    let statement = null;
+
+    const combinatorDeclarationStatementNode = combinatorDeclarationStatementNodeQuery(combinatorDeclarationNode);
+
+    if (combinatorDeclarationStatementNode !== null) {
+      const statementNode = combinatorDeclarationStatementNode, ///
+            localContext = LocalContext.fromFileContext(fileContext),
+            context = localContext;  ///
+
+      statement = statementFromStatementNode(statementNode, context);
+    }
+
+    return statement;
+  }
 });
 
 function statementFromStatementNode(statementNode, context) {

package/src/dom/term.js

@@ -15,8 +15,12 @@ const { filter, compress } = arrayUtilities;
 
 const variableNodesQuery = nodesQuery("//variable"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
+      typeAssertionTermNodeQuery = nodeQuery("/typeAssertion/term"),
       definedAssertionTermNodeQuery = nodeQuery("/definedAssertion/term"),
-      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term");
+      propertyRelationTermNodeQuery = nodeQuery("/propertyRelation/term"),
+      propertyAssertionTermNodeQuery = nodeQuery("/propertyAssertion/term"),
+      containedAssertionTermNodeQuery = nodeQuery("/containedAssertion/term"),
+      constructorDeclarationTermNodeQuery = nodeQuery("/constructorDeclaration/term");
 
 export default domAssigned(class Term {
   constructor(string, node, type) {
@@ -82,6 +86,13 @@ export default domAssigned(class Term {
     return equalTo;
   }
 
+  isSimple() {
+    const termVariableNode = termVariableNodeQuery(this.node),
+          simple = (termVariableNode !== null);
+
+    return simple;
+  }
+
   isGrounded(definedVariables, context) {
     const variables = this.getVariables(context);
 
@@ -199,11 +210,7 @@ export default domAssigned(class Term {
     let term = null;
 
     if (termNode !== null) {
-      const node = termNode,  ///
-            string = context.nodeAsString(node),
-            type = null;
-
-      term = new Term(string, node, type);
+      term = termFromTermNode(termNode, context);
     }
 
     return term;
@@ -217,45 +224,83 @@ export default domAssigned(class Term {
     return term;
   }
 
+  static fromTypeAssertionNode(typeAssertionNode, context) {
+    let term = null;
+
+    const typeAssertionTermNode = typeAssertionTermNodeQuery(typeAssertionNode);
+
+    if (typeAssertionTermNode !== null) {
+      const termNode = typeAssertionTermNode;  ///
+
+      term = termFromTermNode(termNode, context);
+    }
+
+    return term;
+  }
+
   static fromDefinedAssertionNode(definedAssertionNode, context) {
     let term = null;
 
     const definedAssertionTermNode = definedAssertionTermNodeQuery(definedAssertionNode);
 
     if (definedAssertionTermNode !== null) {
-      const termNode = definedAssertionTermNode,  ///
-            termVariableNode = termVariableNodeQuery(termNode);
-
-      if (termVariableNode !== null) {
-        const node = termNode,  ///
-              string = context.nodeAsString(node),
-              type = null;
+      const termNode = definedAssertionTermNode;  ///
 
-        term = new Term(string, node, type);
-      }
+      term = termFromTermNode(termNode, context);
     }
 
     return term;
   }
 
+  static fromPropertyRelationNode(propertyRelationNode, context) {
+    const propertyRelationTermNode = propertyRelationTermNodeQuery(propertyRelationNode),
+          termNode = propertyRelationTermNode, ///
+          term = termFromTermNode(termNode, context);
+
+    return term;
+  }
+
+  static fromPropertyAssertionNode(propertyAssertionNode, context) {
+    const propertyAssertionTermNode = propertyAssertionTermNodeQuery(propertyAssertionNode),
+          termNode = propertyAssertionTermNode,
+          term = termFromTermNode(termNode, context);
+
+    return term;
+  }
+
   static fromContainedAssertionNode(containedAssertionNode, context) {
     let term = null;
 
     const containedAssertionTermNode = containedAssertionTermNodeQuery(containedAssertionNode);
 
     if (containedAssertionTermNode !== null) {
-      const termNode = containedAssertionTermNode,  ///
-            termVariableNode = termVariableNodeQuery(termNode);
-
-      if (termVariableNode !== null) {
-        const node = termNode,  ///
-              string = context.nodeAsString(node),
-              type = null;
+      const termNode = containedAssertionTermNode;
 
-        term = new Term(string, node, type);
-      }
+      term = termFromTermNode(termNode, context);
     }
 
     return term;
   }
+
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
+    const { Type } = dom,
+          constructorDeclarationTermNode = constructorDeclarationTermNodeQuery(constructorDeclarationNode),
+          termNode = constructorDeclarationTermNode,  ///
+          term = termFromTermNode(termNode, context),
+          type = Type.fromConstructorDeclarationNode(constructorDeclarationNode, context);
+
+    term.setType(type);
+
+    return term;
+  }
 });
+
+function termFromTermNode(termNode, context) {
+  const { Term } = dom,
+        node = termNode,  ///
+        string = context.nodeAsString(node),
+        type = null,
+        term = new Term(string, node, type);
+
+  return term;
+}

package/src/dom/theorem.js

@@ -30,5 +30,5 @@ export default domAssigned(class Theorem extends TopLevelAssertion {
 
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
-  static fromTheoremNode(metaLemmaNode, fileContext) { return TopLevelAssertion.fromNode(Theorem, metaLemmaNode, fileContext); }
+  static fromNode(node, fileContext) { return TopLevelAssertion.fromNode(Theorem, node, fileContext); }
 });

package/src/dom/type.js

@@ -13,12 +13,14 @@ import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, pro
 
 const { push, first } = arrayUtilities;
 
-const typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type"),
+const typeAssertionTypeNodeQuery = nodeQuery("/typeAssertion/type"),
+      typeDeclarationTypeNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/type"),
       propertyDeclarationNodesQuery = nodesQuery("/complexTypeDeclaration/propertyDeclaration"),
       propertyDeclarationTypeNodeQuery = nodeQuery("/propertyDeclaration/type"),
       typeDeclarationSuperTypeNodesQuery = nodesQuery("/typeDeclaration|complexTypeDeclaration/types/type"),
       firstPrimaryKeywordTerminalNodeQuery = nodeQuery("/typeDeclaration|complexTypeDeclaration/@primary-keyword[0]"),
-      variableDeclarationSuperTypeNodeQuery = nodeQuery("/variableDeclaration/type");
+      variableDeclarationSuperTypeNodeQuery = nodeQuery("/variableDeclaration/type"),
+      constructorDeclarationSuperTypeNodeQuery = nodeQuery("/constructorDeclaration/type");
 
 class Type {
   constructor(string, name, superTypes, properties, provisional) {
@@ -238,26 +240,21 @@ class Type {
     return type;
   }
 
-  static fromTypeNode(typeNode) {
-    let type;
+  static fromTypeNode(typeNode, fileContext) {
+    const type = typeFromTypeNode(typeNode, fileContext);
 
-    if (typeNode === null) {
-      type = objectType;
-    } else {
-      const typeName = typeNameFromTypeNode(typeNode),
-            name = typeName,  ///
-            string = name,  ///
-            superTypes = null,
-            properties = null,
-            provisional = null;
-
-      type = new Type(string, name, superTypes, properties, provisional);
-    }
+    return type;
+  }
+
+  static fromTypeAssertionNode(typeAssertionNode, fileContext) {
+    const typeAssertionTypeNode = typeAssertionTypeNodeQuery(typeAssertionNode),
+          typeNode = typeAssertionTypeNode, ///
+          type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
   }
 
-  static fromTypeAndProvisional(type, provisional, context) {
+  static fromTypeAndProvisional(type, provisional) {
     const name = type.getName(),
           superType = type, ///
           superTypes = [
@@ -283,45 +280,25 @@ class Type {
   }
 
   static fromPropertyDeclarationNode(propertyDeclarationNode, fileContext) {
-    let type;
-
-    const propertyDeclarationTypeNode = propertyDeclarationTypeNodeQuery(propertyDeclarationNode);
-
-    if (propertyDeclarationTypeNode === null) {
-      type = objectType;
-    } else {
-      const typeNode = propertyDeclarationTypeNode, ///
-            typeName = typeNameFromTypeNode(typeNode),
-            name = typeName,  ///
-            string = name,  ///
-            superTypes = null,
-            properties = null,
-            provisional = null;
-
-      type = new Type(string, name, superTypes, properties, provisional);
-    }
+    const propertyDeclarationTypeNode = propertyDeclarationTypeNodeQuery(propertyDeclarationNode),
+          typeNode = propertyDeclarationTypeNode, ///
+          type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
   }
 
   static fromVariableDeclarationNode(variableDeclarationNode, fileContext) {
-    let type;
+    const variableDeclarationSuperTypeNode = variableDeclarationSuperTypeNodeQuery(variableDeclarationNode),
+          typeNode = variableDeclarationSuperTypeNode,  ///
+          type = typeFromTypeNode(typeNode, fileContext);
 
-    const variableDeclarationSuperTypeNode = variableDeclarationSuperTypeNodeQuery(variableDeclarationNode);
+    return type;
+  }
 
-    if (variableDeclarationSuperTypeNode === null) {
-      type = objectType;
-    } else {
-      const typeNode = variableDeclarationSuperTypeNode,  ///
-            typeName = typeNameFromTypeNode(typeNode),
-            name = typeName,  ///
-            string = name,  ///
-            superTypes = null,
-            properties = null,
-            provisional = null;
-
-      type = new Type(string, name, superTypes, properties, provisional);
-    }
+  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+    const constructorDeclarationSuperTypeNode = constructorDeclarationSuperTypeNodeQuery(constructorDeclarationNode),
+          typeNode = constructorDeclarationSuperTypeNode, ///
+          type = typeFromTypeNode(typeNode, fileContext);
 
     return type;
   }
@@ -340,6 +317,26 @@ class Type {
 
 export default domAssigned(Type);
 
+function typeFromTypeNode(typeNode, fileContext) {
+  let type;
+
+  if (typeNode === null) {
+    type = objectType;
+  } else {
+    const { Type } = dom,
+          typeName = typeNameFromTypeNode(typeNode),
+          name = typeName,  ///
+          string = name,  ///
+          superTypes = null,
+          properties = null,
+          provisional = null;
+
+    type = new Type(string, name, superTypes, properties, provisional);
+  }
+
+  return type;
+}
+
 function stringFromNameAndSuperTypes(name, superTypes) {
   let string = name;  ///
 
@@ -381,7 +378,7 @@ function superTypesFromTypeDeclarationNode(typeDeclarationNode, fileContext) {
   const typeDeclarationSuperTypeNodes = typeDeclarationSuperTypeNodesQuery(typeDeclarationNode),
         superTypes = typeDeclarationSuperTypeNodes.map((typeDeclarationSuperTypeNode) => {
           const superTypeNode = typeDeclarationSuperTypeNode, ///
-                superType = Type.fromTypeNode(superTypeNode);
+                superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
         }),
@@ -416,7 +413,7 @@ function superTypesFromComplexTypeDeclarationNode(complexTypeDeclarationNode, fi
   const typeDeclarationSuperTypeNodes = typeDeclarationSuperTypeNodesQuery(complexTypeDeclarationNode),
         superTypes = typeDeclarationSuperTypeNodes.map((typeDeclarationSuperTypeNode) => {
           const superTypeNode = typeDeclarationSuperTypeNode, ///
-                superType = Type.fromTypeNode(superTypeNode);
+                superType = Type.fromTypeNode(superTypeNode, fileContext);
 
           return superType;
         }),