occam-verify-cli 1.0.230 → 1.0.234

package/src/dom/declaration/complexType.js

@@ -7,14 +7,14 @@ import { domAssigned } from "../../dom";
 import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class ComplexTypeDeclaration {
-  constructor(fileContext, string, type) {
-    this.fileContext = fileContext;
+  constructor(context, string, type) {
+    this.context = context;
     this.string = string;
     this.type = type;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -25,16 +25,16 @@ export default domAssigned(class ComplexTypeDeclaration {
     return this.type;
   }
 
-  getReleaseContext() { return this.fileContext.getReleaseContext(); }
+  getReleaseContext() { return this.context.getReleaseContext(); }
 
   getReleaseTypes() {
     const includeDependencies = false,
           includeRelease = false,
           releaseContext = this.getReleaseContext(),
-          fileContextTypes = this.fileContext.getTypes(includeRelease),
+          contextTypes = this.context.getTypes(includeRelease),
           releaseContextTypes = releaseContext.getTypes(includeDependencies),
           releaseTypes = [
-            ...fileContextTypes,
+            ...contextTypes,
             ...releaseContextTypes
           ];
 
@@ -46,7 +46,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const complexTypeDeclarationString = this.getString();
 
-    this.fileContext.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
+    this.context.trace(`Verifying the '${complexTypeDeclarationString}' complex type declaration...`);
 
     const typeVerifies = this.verifyType();
 
@@ -57,7 +57,7 @@ export default domAssigned(class ComplexTypeDeclaration {
         const propertiesVerify = this.verifyProperties();
 
         if (propertiesVerify) {
-          this.fileContext.addType(this.type);
+          this.context.addType(this.type);
 
           verifies = true;
         }
@@ -65,7 +65,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
+      this.context.debug(`...verified the '${complexTypeDeclarationString}' complex type declaration.`);
     }
 
     return verifies;
@@ -76,7 +76,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const complexTypeString = this.type.getString();
 
-    this.fileContext.trace(`Verifying the '${complexTypeString}' complex type...`);
+    this.context.trace(`Verifying the '${complexTypeString}' complex type...`);
 
     const typeName = this.type.getName(),
           releaseTypes = this.getReleaseTypes(),
@@ -89,13 +89,13 @@ export default domAssigned(class ComplexTypeDeclaration {
           });
 
     if (typePresent) {
-      this.fileContext.debug(`The type '${complexTypeString}' is already present in the package.`);
+      this.context.debug(`The type '${complexTypeString}' is already present in the package.`);
     } else {
       typeVerifies = true;
     }
 
     if (typeVerifies) {
-      this.fileContext.debug(`...verified the '${complexTypeString}' complex type.`);
+      this.context.debug(`...verified the '${complexTypeString}' complex type.`);
     }
 
     return typeVerifies;
@@ -106,17 +106,17 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const superTypeString = superType.getString();
 
-    this.fileContext.trace(`Verifying the '${superTypeString}' super-type...`);
+    this.context.trace(`Verifying the '${superTypeString}' super-type...`);
 
     const superTypeName = superType.getName(),
-          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+          superTypePresent = this.context.isTypePresentByTypeName(superTypeName);
 
     if (superTypePresent) {
       superTypeVerifies = true;
     }
 
     if (superTypeVerifies) {
-      this.fileContext.debug(`...verified the '${superTypeString}' super-type.`);
+      this.context.debug(`...verified the '${superTypeString}' super-type.`);
     }
 
     return superTypeVerifies;
@@ -125,7 +125,7 @@ export default domAssigned(class ComplexTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerify = false;
 
-    this.fileContext.trace(`Verifying the super-types...`);
+    this.context.trace(`Verifying the super-types...`);
 
     let superTypes;
 
@@ -135,7 +135,7 @@ export default domAssigned(class ComplexTypeDeclaration {
           superTypesLength = superTypes.length;
 
     if (superTypesLength === 0) {
-      const type = this.fileContext.findTypeByTypeName(typeName);
+      const type = this.context.findTypeByTypeName(typeName);
 
       if (type === null) {
         const superType = objectType; ///
@@ -150,7 +150,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     if (typeBasic) {
       superTypesVerify = true;
 
-      this.fileContext.trace(`The '${typeString}' type is basic.`)
+      this.context.trace(`The '${typeString}' type is basic.`)
     } else {
       const superTypeNames = superTypes.map((superType) => {
               const superTypeName = superType.getName();
@@ -160,10 +160,10 @@ export default domAssigned(class ComplexTypeDeclaration {
             superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
 
       if (superTypeNamesIncludesTypeName) {
-        this.fileContext.trace(`The '${typeName}' type cannot be a super-type `);
+        this.context.trace(`The '${typeName}' type cannot be a super-type `);
       } else {
         if (superTypesLength === 0) {
-          const type = this.fileContext.findTypeByTypeName(typeName),
+          const type = this.context.findTypeByTypeName(typeName),
                 superType = type; ///
 
           superTypes.push(superType);
@@ -181,7 +181,7 @@ export default domAssigned(class ComplexTypeDeclaration {
           superTypes = superTypes.map((superType) => {
             const superTypeName = superType.getName();
 
-            superType = this.fileContext.findTypeByTypeName(superTypeName);
+            superType = this.context.findTypeByTypeName(superTypeName);
 
             return superType;
           });
@@ -197,7 +197,7 @@ export default domAssigned(class ComplexTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.fileContext.debug(`...verified the super-types.`);
+      this.context.debug(`...verified the super-types.`);
     }
 
     return superTypesVerify;
@@ -208,7 +208,7 @@ export default domAssigned(class ComplexTypeDeclaration {
 
     const propertyString = property.getString();
 
-    this.fileContext.trace(`Verifying the '${propertyString}' property...`);
+    this.context.trace(`Verifying the '${propertyString}' property...`);
 
     const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
@@ -222,7 +222,7 @@ export default domAssigned(class ComplexTypeDeclaration {
           }, 0);
 
     if (count > 1) {
-      this.fileContext.debug(`The '${propertyString}' property appears more than once.`);
+      this.context.debug(`The '${propertyString}' property appears more than once.`);
     } else {
       const superTypeProperty = superTypeProperties.find((superTypeProperty) => {
         const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
@@ -235,7 +235,7 @@ export default domAssigned(class ComplexTypeDeclaration {
       if (superTypeProperty !== null) {
         const superTypePropertyString = superTypeProperty.getString();
 
-        this.fileContext.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`);
+        this.context.debug(`The '${propertyString}' property matches the super-type's '${superTypePropertyString}' property.`);
       } else {
         let propertyType;
 
@@ -246,7 +246,7 @@ export default domAssigned(class ComplexTypeDeclaration {
         if (propertyTypeVerifies) {
           const propertyTypeName = propertyType.getName();
 
-          propertyType = this.fileContext.findTypeByTypeName(propertyTypeName);
+          propertyType = this.context.findTypeByTypeName(propertyTypeName);
 
           const type = propertyType;  ///
 
@@ -265,7 +265,7 @@ export default domAssigned(class ComplexTypeDeclaration {
         property.setType(this.type);
       }
 
-      this.fileContext.debug(`verifies the '${propertyString}' property.`);
+      this.context.debug(`verifies the '${propertyString}' property.`);
     }
 
     return propertyVerifies;
@@ -306,21 +306,21 @@ export default domAssigned(class ComplexTypeDeclaration {
     } else  {
       const propertyTypeString = propertyType.getString(); ///
 
-      this.fileContext.trace(`Verifying the '${propertyTypeString}' property type...`);
+      this.context.trace(`Verifying the '${propertyTypeString}' property type...`);
 
       const propertyTypeName = propertyType.getName(),
-            propertyTypePresent = this.fileContext.isTypePresentByTypeName(propertyTypeName);
+            propertyTypePresent = this.context.isTypePresentByTypeName(propertyTypeName);
 
       if (!propertyTypePresent) {
         const propertyTypeString = propertyType.getString();
 
-        this.fileContext.debug(`The '${propertyTypeString}' property type is not present.`);
+        this.context.debug(`The '${propertyTypeString}' property type is not present.`);
       } else {
         propertyTypeVerifies = true;
       }
 
       if (propertyTypeVerifies) {
-        this.fileContext.debug(`...verified the '${propertyTypeString}' property type.`);
+        this.context.debug(`...verified the '${propertyTypeString}' property type.`);
       }
     }
 
@@ -329,13 +329,13 @@ export default domAssigned(class ComplexTypeDeclaration {
 
   static name = "ComplexTypeDeclaration";
 
-  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext) {
+  static fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context) {
     const { Type } = dom,
-          type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
+          type = Type.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, context),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          complexTypeDeclaration = new ComplexTypeDeclaration(fileContext, string, type);
+          complexTypeDeclaration = new ComplexTypeDeclaration(context, string, type);
 
     return complexTypeDeclaration;
   }

package/src/dom/declaration/constructor.js

@@ -7,14 +7,14 @@ import constructorVerifier from "../../verifier/constructor";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class ConstructorDeclaration {
-  constructor(fileContext, string, constructor) {
-    this.fileContext = fileContext;
+  constructor(context, string, constructor) {
+    this.context = context;
     this.string = string;
     this.constructor = constructor;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -30,7 +30,7 @@ export default domAssigned(class ConstructorDeclaration {
 
     const constructorDeclarationString = this.getString(); ///
 
-    this.fileContext.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
+    this.context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
     const constructorTypeVerifies = this.verifyConstructorType();
 
@@ -38,14 +38,14 @@ export default domAssigned(class ConstructorDeclaration {
       const constructorVerifies = this.verifyConstructor();
 
       if (constructorVerifies) {
-        this.fileContext.addConstructor(this.constructor);
+        this.context.addConstructor(this.constructor);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+      this.context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
     }
 
     return verifies;
@@ -56,15 +56,15 @@ export default domAssigned(class ConstructorDeclaration {
 
     const constructorString = this.constructor.getString();
 
-    this.fileContext.trace(`Verifying the '${constructorString}' constructor...`);
+    this.context.trace(`Verifying the '${constructorString}' constructor...`);
 
     const term = this.constructor.getTerm(),
           termNode = term.getNode();
 
-    constructorVerifies = constructorVerifier.verifyTerm(termNode, this.fileContext);
+    constructorVerifies = constructorVerifier.verifyTerm(termNode, this.context);
 
     if (constructorVerifies) {
-      this.fileContext.debug(`...verified the '${constructorString}' constructor.`);
+      this.context.debug(`...verified the '${constructorString}' constructor.`);
     }
 
     return constructorVerifies;
@@ -80,24 +80,24 @@ export default domAssigned(class ConstructorDeclaration {
     const typeName = type.getName(),
           typeString = type.getString();
 
-    this.fileContext.trace(`Verifying the '${typeString}' type...`);
+    this.context.trace(`Verifying the '${typeString}' type...`);
 
     const includeSupertypes = false,
           provisional = type.isProvisional(includeSupertypes);
 
-    type = this.fileContext.findTypeByTypeName(typeName);
+    type = this.context.findTypeByTypeName(typeName);
 
     const typePresent = (type !== null)
 
     if (!typePresent) {
-      this.fileContext.debug(`The '${typeString}' type is not present.`);
+      this.context.debug(`The '${typeString}' type is not present.`);
     } else {
       const provisionalMatches = type.matchProvisional(provisional);
 
       if (!provisionalMatches) {
         provisional ?
-          this.fileContext.debug(`The '${typeString}' type is present but not provisional.`) :
-            this.fileContext.debug(`The '${typeString}' type is present but provisional.`);
+          this.context.debug(`The '${typeString}' type is present but not provisional.`) :
+            this.context.debug(`The '${typeString}' type is present but provisional.`);
       } else {
         this.constructor.setType(type);
 
@@ -106,7 +106,7 @@ export default domAssigned(class ConstructorDeclaration {
     }
 
     if (constructorTypeVerifies) {
-      this.fileContext.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`);
     }
 
     return constructorTypeVerifies;
@@ -114,12 +114,12 @@ export default domAssigned(class ConstructorDeclaration {
 
   static name = "ConstructorDeclaration";
 
-  static fromConstructorDeclarationNode(constructorDeclarationNode, fileContext) {
+  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
     const { Constructor } = dom,
           node = constructorDeclarationNode,  ///
-          string = fileContext.nodeAsString(node),
-          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
-          constructorDeclaration = new ConstructorDeclaration(fileContext, string, constructor);
+          string = context.nodeAsString(node),
+          constructor = Constructor.fromConstructorDeclarationNode(constructorDeclarationNode, context),
+          constructorDeclaration = new ConstructorDeclaration(context, string, constructor);
 
     return constructorDeclaration;
   }

package/src/dom/declaration/metavariable.js

@@ -5,14 +5,14 @@ import dom from "../../dom";
 import { domAssigned } from "../../dom";
 
 export default domAssigned(class MetavariableDeclaration {
-  constructor(fileContext, string, metavariable) {
-    this.fileContext = fileContext;
+  constructor(context, string, metavariable) {
+    this.context = context;
     this.string = string;
     this.metavariable = metavariable;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -28,18 +28,18 @@ export default domAssigned(class MetavariableDeclaration {
 
     const metavariableDeclarationString = this.string; ///
 
-    this.fileContext.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
+    this.context.trace(`Verifying the '${metavariableDeclarationString}' metavariable declaration...`);
 
     const metavariableVerifies = this.verifyMetavariable(this.metavariable);
 
     if (metavariableVerifies) {
-      this.fileContext.addMetavariable(this.metavariable);
+      this.context.addMetavariable(this.metavariable);
 
       verifies = true;
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
+      this.context.debug(`...verified the '${metavariableDeclarationString}' metavariable declaration.`);
     }
 
     return verifies;
@@ -54,18 +54,18 @@ export default domAssigned(class MetavariableDeclaration {
       const typeName = type.getName(),
             typeString = type.getString();
 
-      this.fileContext.trace(`Verifying the '${typeString}' type...`);
+      this.context.trace(`Verifying the '${typeString}' type...`);
 
-      const typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+      const typePresent = this.context.isTypePresentByTypeName(typeName);
 
       if (!typePresent) {
-        this.fileContext.debug(`The '${typeString}' type is not present.`);
+        this.context.debug(`The '${typeString}' type is not present.`);
       } else {
         typeVerifies = true;
       }
 
       if (typeVerifies) {
-        this.fileContext.debug(`...verified the '${typeString}' type.`);
+        this.context.debug(`...verified the '${typeString}' type.`);
       }
     }
 
@@ -77,19 +77,19 @@ export default domAssigned(class MetavariableDeclaration {
 
     const metavariableString = metavariable.getString();
 
-    this.fileContext.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
+    this.context.trace(`Verifying the '${metavariableString}' metavariable when declared...`);
 
     const metavariableNode = metavariable.getNode(), ///
           termNode = metavariableNode.getTermNode();
 
     if (termNode !== null) {
-      this.fileContext.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
+      this.context.debug(`A term was found in the '${metavariableString}' metavariable when a type should have been present.`);
     } else {
       const metavariableName = metavariable.getName(),
-            metavariablePresent = this.fileContext.isMetavariablePresentByMetavariableName(metavariableName);
+            metavariablePresent = this.context.isMetavariablePresentByMetavariableName(metavariableName);
 
       if (metavariablePresent) {
-        this.fileContext.debug(`The '${metavariableName}' metavariable is already present.`);
+        this.context.debug(`The '${metavariableName}' metavariable is already present.`);
       } else {
         const type = metavariable.getType(),
               typeVerifies = this.verifyType(type);
@@ -99,7 +99,7 @@ export default domAssigned(class MetavariableDeclaration {
     }
 
     if (metavariableVerifies) {
-      this.fileContext.debug(`...verified the '${metavariableString}' metavariable when declared.`);
+      this.context.debug(`...verified the '${metavariableString}' metavariable when declared.`);
     }
 
     return metavariableVerifies;
@@ -107,12 +107,12 @@ export default domAssigned(class MetavariableDeclaration {
 
   static name = "MetavariableDeclaration";
 
-  static fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+  static fromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
     const { Metavariable } = dom,
-          metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
-          metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
+          metaType = metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context),
+          metavariable = Metavariable.fromMetavariableDeclarationNode(metavariableDeclarationNode, context),
           string = stringFromMetavariableAndMetaType(metavariable, metaType),
-          metavariableDeclaration = new MetavariableDeclaration(fileContext, string, metavariable);
+          metavariableDeclaration = new MetavariableDeclaration(context, string, metavariable);
 
     return metavariableDeclaration;
   }
@@ -134,10 +134,10 @@ function stringFromMetavariableAndMetaType(metavariable, metaType) {
   return string;
 }
 
-function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext) {
+function metaTypeFromMetavariableDeclarationNode(metavariableDeclarationNode, context) {
   const { MetaType } = dom,
         metaTypeNode = metavariableDeclarationNode.getMetaTypeNode(),
-        metaType = MetaType.fromMetaTypeNode(metaTypeNode, fileContext);
+        metaType = MetaType.fromMetaTypeNode(metaTypeNode, context);
 
   return metaType;
 }

package/src/dom/declaration/simpleType.js

@@ -7,14 +7,14 @@ import { domAssigned } from "../../dom";
 import { stringFromTypeNameNameAndSuperTypes } from "../../utilities/type";
 
 export default domAssigned(class SimpleTypeDeclaration {
-  constructor(fileContext, string, type) {
-    this.fileContext = fileContext;
+  constructor(context, string, type) {
+    this.context = context;
     this.string = string;
     this.type = type;
   }
 
-  getFileContext() {
-    return this.fileContext;
+  getContext() {
+    return this.context;
   }
 
   getString() {
@@ -30,7 +30,7 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     const typeDeclarationString = this.getString(); ///
 
-    this.fileContext.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
+    this.context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
 
     const typeVerifies = this.verifyType();
 
@@ -38,14 +38,14 @@ export default domAssigned(class SimpleTypeDeclaration {
       const superTypesVerify = this.verifySuperTypes();
 
       if (superTypesVerify) {
-        this.fileContext.addType(this.type);
+        this.context.addType(this.type);
 
         verifies = true;
       }
     }
 
     if (verifies) {
-      this.fileContext.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+      this.context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
     }
 
     return verifies;
@@ -56,19 +56,19 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     const typeString = this.type.getString();
 
-    this.fileContext.trace(`Verifying the '${typeString}' type...`);
+    this.context.trace(`Verifying the '${typeString}' type...`);
 
     const typeName = this.type.getName(),
-          typePresent = this.fileContext.isTypePresentByTypeName(typeName);
+          typePresent = this.context.isTypePresentByTypeName(typeName);
 
     if (typePresent) {
-      this.fileContext.debug(`The type '${typeString}' is already present.`);
+      this.context.debug(`The type '${typeString}' is already present.`);
     } else {
       typeVerifies = true;
     }
 
     if (typeVerifies) {
-      this.fileContext.debug(`...verified the '${typeString}' type.`);
+      this.context.debug(`...verified the '${typeString}' type.`);
     }
 
     return typeVerifies;
@@ -79,17 +79,17 @@ export default domAssigned(class SimpleTypeDeclaration {
 
     const superTypeString = superType.getString();
 
-    this.fileContext.trace(`Verifying the '${superTypeString}' super-type...`);
+    this.context.trace(`Verifying the '${superTypeString}' super-type...`);
 
     const superTypeName = superType.getName(),
-          superTypePresent = this.fileContext.isTypePresentByTypeName(superTypeName);
+          superTypePresent = this.context.isTypePresentByTypeName(superTypeName);
 
     if (superTypePresent) {
       superTypeVerifies = true;
     }
 
     if (superTypeVerifies) {
-      this.fileContext.debug(`...verified the '${superTypeString}' super-type.`);
+      this.context.debug(`...verified the '${superTypeString}' super-type.`);
     }
 
     return superTypeVerifies;
@@ -98,7 +98,7 @@ export default domAssigned(class SimpleTypeDeclaration {
   verifySuperTypes() {
     let superTypesVerify = false;
 
-    this.fileContext.trace(`Verifying the super-types...`);
+    this.context.trace(`Verifying the super-types...`);
 
     let superTypes;
 
@@ -119,7 +119,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     if (typeBasic) {
       superTypesVerify = true;
 
-      this.fileContext.trace(`The '${typeString}' type is basic.`)
+      this.context.trace(`The '${typeString}' type is basic.`)
     } else  {
       const superTypeNames = superTypes.map((superType) => {
               const superTypeName = superType.getName();
@@ -129,7 +129,7 @@ export default domAssigned(class SimpleTypeDeclaration {
             superTypeNamesIncludesTypeName = superTypeNames.includes(typeName);
 
       if (superTypeNamesIncludesTypeName) {
-        this.fileContext.trace(`The '${typeName}' type cannot be a super-type `);
+        this.context.trace(`The '${typeName}' type cannot be a super-type `);
       } else {
         superTypesVerify = superTypes.every((superType) => {
           const superTypeVerifies = this.verifySuperType(superType);
@@ -143,7 +143,7 @@ export default domAssigned(class SimpleTypeDeclaration {
           superTypes = superTypes.map((superType) => {
             const superTypeName = superType.getName();
 
-            superType = this.fileContext.findTypeByTypeName(superTypeName);
+            superType = this.context.findTypeByTypeName(superTypeName);
 
             return superType;
           });
@@ -158,7 +158,7 @@ export default domAssigned(class SimpleTypeDeclaration {
     }
 
     if (superTypesVerify) {
-      this.fileContext.debug(`...verified the super-types.`);
+      this.context.debug(`...verified the super-types.`);
     }
 
     return superTypesVerify;
@@ -166,13 +166,13 @@ export default domAssigned(class SimpleTypeDeclaration {
 
   static name = "SimpleTypeDeclaration";
 
-  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext) {
+  static fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context) {
     const { Type } = dom,
-          type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext),
+          type = Type.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, context),
           typeName = type.getName(),
           superTypes = type.getSuperTypes(),
           string = stringFromTypeNameNameAndSuperTypes(typeName, superTypes),
-          simpleTypeDeclaration = new SimpleTypeDeclaration(fileContext, string, type);
+          simpleTypeDeclaration = new SimpleTypeDeclaration(context, string, type);
 
     return simpleTypeDeclaration;
   }