Cleanup

Author: captbaritone

src/Extractor.ts

@@ -27,7 +27,11 @@ import {
 } from "./utils/DiagnosticError";
 import { err, ok } from "./utils/Result";
 import * as ts from "typescript";
-import { NameDefinition, UNRESOLVED_REFERENCE_NAME } from "./TypeContext";
+import {
+  DeclarationDefinition,
+  NameDefinition,
+  UNRESOLVED_REFERENCE_NAME,
+} from "./TypeContext";
 import * as E from "./Errors";
 import { traverseJSDocTags } from "./utils/JSDoc";
 import { GraphQLConstructor } from "./GraphQLConstructor";
@@ -86,7 +90,10 @@ export type ExtractionSnapshot = {
   readonly definitions: DefinitionNode[];
   readonly unresolvedNames: Map<ts.EntityName, NameNode>;
   readonly nameDefinitions: Map<ts.DeclarationStatement, NameDefinition>;
-  readonly implicitNameDefinitions: Map<NameDefinition, ts.TypeReferenceNode>;
+  readonly implicitNameDefinitions: Map<
+    DeclarationDefinition,
+    ts.TypeReferenceNode
+  >;
   readonly typesWithTypename: Set<string>;
   readonly interfaceDeclarations: Array<ts.InterfaceDeclaration>;
 };
@@ -118,7 +125,7 @@ class Extractor {
   // Snapshot data
   unresolvedNames: Map<ts.EntityName, NameNode> = new Map();
   nameDefinitions: Map<ts.DeclarationStatement, NameDefinition> = new Map();
-  implicitNameDefinitions: Map<NameDefinition, ts.TypeReferenceNode> =
+  implicitNameDefinitions: Map<DeclarationDefinition, ts.TypeReferenceNode> =
     new Map();
   typesWithTypename: Set<string> = new Set();
   interfaceDeclarations: Array<ts.InterfaceDeclaration> = [];

src/TypeContext.ts

@@ -13,7 +13,6 @@ import {
   gqlRelated,
   DiagnosticsResult,
   FixableDiagnosticWithLocation,
-  tsRelated,
 } from "./utils/DiagnosticError";
 import { err, ok } from "./utils/Result";
 import * as E from "./Errors";
@@ -30,20 +29,20 @@ export type DerivedResolverDefinition = {
   kind: "DERIVED_CONTEXT";
 };
 
-export type NameDefinition =
-  | {
-      name: NameNode;
-      kind:
-        | "TYPE"
-        | "INTERFACE"
-        | "UNION"
-        | "SCALAR"
-        | "INPUT_OBJECT"
-        | "ENUM"
-        | "CONTEXT"
-        | "INFO";
-    }
-  | DerivedResolverDefinition;
+export type NameDefinition = {
+  name: NameNode;
+  kind:
+    | "TYPE"
+    | "INTERFACE"
+    | "UNION"
+    | "SCALAR"
+    | "INPUT_OBJECT"
+    | "ENUM"
+    | "CONTEXT"
+    | "INFO";
+};
+
+export type DeclarationDefinition = NameDefinition | DerivedResolverDefinition;
 
 type TsIdentifier = number;
 
@@ -62,7 +61,8 @@ type TsIdentifier = number;
 export class TypeContext {
   checker: ts.TypeChecker;
 
-  _declarationToName: Map<ts.Declaration, NameDefinition> = new Map();
+  _declarationToDefinition: Map<ts.Declaration, DeclarationDefinition> =
+    new Map();
   _unresolvedNodes: Map<TsIdentifier, ts.EntityName> = new Map();
   _idToDeclaration: Map<TsIdentifier, ts.Declaration> = new Map();
 
@@ -76,15 +76,15 @@ export class TypeContext {
       self._markUnresolvedType(node, typeName);
     }
     for (const [node, definition] of snapshot.nameDefinitions) {
-      self._recordTypeName(node, definition);
+      self._recordDeclaration(node, definition);
     }
     for (const [definition, reference] of snapshot.implicitNameDefinitions) {
       const declaration = self.maybeTsDeclarationForTsName(reference.typeName);
       if (declaration == null) {
         errors.push(tsErr(reference.typeName, E.unresolvedTypeReference()));
         continue;
       }
-      const existing = self._declarationToName.get(declaration);
+      const existing = self._declarationToDefinition.get(declaration);
       if (existing != null) {
         errors.push(
           tsErr(
@@ -98,8 +98,7 @@ export class TypeContext {
         );
         continue;
       }
-
-      self._recordTypeName(declaration, definition);
+      self._recordDeclaration(declaration, definition);
     }
 
     if (errors.length > 0) {
@@ -114,18 +113,21 @@ export class TypeContext {
 
   // Record that a GraphQL construct of type `kind` with the name `name` is
   // declared at `node`.
-  private _recordTypeName(node: ts.Declaration, definition: NameDefinition) {
+  private _recordDeclaration(
+    node: ts.Declaration,
+    definition: DeclarationDefinition,
+  ) {
     this._idToDeclaration.set(definition.name.tsIdentifier, node);
-    this._declarationToName.set(node, definition);
+    this._declarationToDefinition.set(node, definition);
   }
 
   // Record that a type references `node`
   private _markUnresolvedType(node: ts.EntityName, name: NameNode) {
     this._unresolvedNodes.set(name.tsIdentifier, node);
   }
 
-  allNameDefinitions(): Iterable<NameDefinition> {
-    return this._declarationToName.values();
+  allDefinitions(): Iterable<DeclarationDefinition> {
+    return this._declarationToDefinition.values();
   }
 
   findSymbolDeclaration(startSymbol: ts.Symbol): ts.Declaration | null {
@@ -173,7 +175,9 @@ export class TypeContext {
       );
     }
 
-    const nameDefinition = this._declarationToName.get(declarationResult.value);
+    const nameDefinition = this._declarationToDefinition.get(
+      declarationResult.value,
+    );
     if (nameDefinition == null) {
       return err(gqlErr(unresolved, E.unresolvedTypeReference()));
     }
@@ -194,12 +198,12 @@ export class TypeContext {
     if (referenceNode == null) return false;
     const declaration = this.maybeTsDeclarationForTsName(referenceNode);
     if (declaration == null) return false;
-    return this._declarationToName.has(declaration);
+    return this._declarationToDefinition.has(declaration);
   }
 
   gqlNameDefinitionForGqlName(
     nameNode: NameNode,
-  ): DiagnosticResult<NameDefinition> {
+  ): DiagnosticResult<DeclarationDefinition> {
     const referenceNode = this.getEntityName(nameNode);
     if (referenceNode == null) {
       throw new Error("Expected to find reference node for name node.");
@@ -209,7 +213,7 @@ export class TypeContext {
     if (declaration == null) {
       return err(gqlErr(nameNode, E.unresolvedTypeReference()));
     }
-    const definition = this._declarationToName.get(declaration);
+    const definition = this._declarationToDefinition.get(declaration);
     if (definition == null) {
       return err(gqlErr(nameNode, E.unresolvedTypeReference()));
     }
@@ -230,7 +234,9 @@ export class TypeContext {
       );
     }
 
-    const nameDefinition = this._declarationToName.get(declarationResult.value);
+    const nameDefinition = this._declarationToDefinition.get(
+      declarationResult.value,
+    );
     if (nameDefinition == null) {
       return err(tsErr(node, E.unresolvedTypeReference()));
     }

src/validations/validateDuplicateContextOrInfo.ts

@@ -14,7 +14,7 @@ export function validateDuplicateContextOrInfo(
   const errors: FixableDiagnosticWithLocation[] = [];
   let infoDefinition: null | NameDefinition = null;
   let ctxDefinition: null | NameDefinition = null;
-  for (const namedDefinition of ctx.allNameDefinitions()) {
+  for (const namedDefinition of ctx.allDefinitions()) {
     switch (namedDefinition.kind) {
       case "CONTEXT":
         if (ctxDefinition != null) {