Clarify types of types, remove some flow casting

Author: leebyron

src/execution/values.js

@@ -126,16 +126,15 @@ function coerceValue(type: GraphQLInputType, value: any): any {
   if (type instanceof GraphQLNonNull) {
     // Note: we're not checking that the result of coerceValue is non-null.
     // We only call this function after calling isValidJSValue.
-    const nullableType: GraphQLInputType = (type.ofType: any);
-    return coerceValue(nullableType, value);
+    return coerceValue(type.ofType, value);
   }
 
   if (isNullish(value)) {
     return null;
   }
 
   if (type instanceof GraphQLList) {
-    const itemType: GraphQLInputType = (type.ofType: any);
+    const itemType = type.ofType;
     // TODO: support iterable input
     if (Array.isArray(value)) {
       return value.map(item => coerceValue(itemType, item));

src/type/definition.js

@@ -56,8 +56,13 @@ export type GraphQLInputType =
   GraphQLScalarType |
   GraphQLEnumType |
   GraphQLInputObjectType |
-  GraphQLList |
-  GraphQLNonNull;
+  GraphQLList<GraphQLInputType> |
+  GraphQLNonNull<
+    GraphQLScalarType |
+    GraphQLEnumType |
+    GraphQLInputObjectType |
+    GraphQLList<GraphQLInputType>
+  >;
 
 export function isInputType(type: ?GraphQLType): boolean {
   const namedType = getNamedType(type);
@@ -77,8 +82,15 @@ export type GraphQLOutputType =
   GraphQLInterfaceType |
   GraphQLUnionType |
   GraphQLEnumType |
-  GraphQLList |
-  GraphQLNonNull;
+  GraphQLList<GraphQLOutputType> |
+  GraphQLNonNull<
+    GraphQLScalarType |
+    GraphQLObjectType |
+    GraphQLInterfaceType |
+    GraphQLUnionType |
+    GraphQLEnumType |
+    GraphQLList<GraphQLOutputType>
+  >;
 
 export function isOutputType(type: ?GraphQLType): boolean {
   const namedType = getNamedType(type);
@@ -995,10 +1007,10 @@ export type InputObjectFieldMap = {
  *     })
  *
  */
-export class GraphQLList {
-  ofType: GraphQLType;
+export class GraphQLList<T: GraphQLType> {
+  ofType: T;
 
-  constructor(type: GraphQLType) {
+  constructor(type: T) {
     invariant(
       isType(type),
       `Can only create List of a GraphQLType but got: ${type}.`
@@ -1032,10 +1044,10 @@ export class GraphQLList {
  *
  * Note: the enforcement of non-nullability occurs within the executor.
  */
-export class GraphQLNonNull {
-  ofType: GraphQLNullableType;
+export class GraphQLNonNull<T: GraphQLNullableType> {
+  ofType: T;
 
-  constructor(type: GraphQLNullableType) {
+  constructor(type: T) {
     invariant(
       isType(type) && !(type instanceof GraphQLNonNull),
       `Can only create NonNull of a Nullable GraphQLType but got: ${type}.`

src/utilities/TypeInfo.js

@@ -171,9 +171,7 @@ export class TypeInfo {
       case Kind.LIST:
         const listType = getNullableType(this.getInputType());
         this._inputTypeStack.push(
-          listType instanceof GraphQLList ?
-            ((listType.ofType: any): GraphQLInputType) :
-            undefined
+          listType instanceof GraphQLList ? listType.ofType : undefined
         );
         break;
       case Kind.OBJECT_FIELD:

src/utilities/astFromValue.js

@@ -73,7 +73,7 @@ export function astFromValue(
     // Because GraphQL will accept single values as a "list of one" when
     // expecting a list, if there's a non-array value and an expected list type,
     // create an AST using the list's item type.
-    return astFromValue(value, (type: any).ofType);
+    return astFromValue(value, type.ofType);
   }
 
   if (typeof value === 'boolean') {

src/utilities/isValidJSValue.js

@@ -28,14 +28,13 @@ import type { GraphQLInputType } from '../type/definition';
 export function isValidJSValue(value: any, type: GraphQLInputType): [ string ] {
   // A value must be provided if the type is non-null.
   if (type instanceof GraphQLNonNull) {
-    const ofType: GraphQLInputType = (type.ofType: any);
     if (isNullish(value)) {
-      if (ofType.name) {
-        return [ `Expected "${ofType.name}!", found null.` ];
+      if (type.ofType.name) {
+        return [ `Expected "${type.ofType.name}!", found null.` ];
       }
       return [ 'Expected non-null value, found null.' ];
     }
-    return isValidJSValue(value, ofType);
+    return isValidJSValue(value, type.ofType);
   }
 
   if (isNullish(value)) {
@@ -44,7 +43,7 @@ export function isValidJSValue(value: any, type: GraphQLInputType): [ string ] {
 
   // Lists accept a non-list value as a list of one.
   if (type instanceof GraphQLList) {
-    const itemType: GraphQLInputType = (type.ofType: any);
+    const itemType = type.ofType;
     if (Array.isArray(value)) {
       return value.reduce((acc, item, index) => {
         const errors = isValidJSValue(item, itemType);

src/utilities/isValidLiteralValue.js

@@ -41,14 +41,13 @@ export function isValidLiteralValue(
 ): [ string ] {
   // A value must be provided if the type is non-null.
   if (type instanceof GraphQLNonNull) {
-    const ofType: GraphQLInputType = (type.ofType: any);
     if (!valueAST) {
-      if (ofType.name) {
-        return [ `Expected "${ofType.name}!", found null.` ];
+      if (type.ofType.name) {
+        return [ `Expected "${type.ofType.name}!", found null.` ];
       }
       return [ 'Expected non-null value, found null.' ];
     }
-    return isValidLiteralValue(ofType, valueAST);
+    return isValidLiteralValue(type.ofType, valueAST);
   }
 
   if (!valueAST) {
@@ -63,7 +62,7 @@ export function isValidLiteralValue(
 
   // Lists accept a non-list value as a list of one.
   if (type instanceof GraphQLList) {
-    const itemType: GraphQLInputType = (type.ofType: any);
+    const itemType = type.ofType;
     if (valueAST.kind === LIST) {
       return (valueAST: ListValue).values.reduce((acc, itemAST, index) => {
         const errors = isValidLiteralValue(itemType, itemAST);

src/utilities/valueFromAST.js

@@ -49,11 +49,10 @@ export function valueFromAST(
   variables?: ?{ [key: string]: any }
 ): any {
   if (type instanceof GraphQLNonNull) {
-    const nullableType: GraphQLInputType = (type.ofType: any);
     // Note: we're not checking that the result of valueFromAST is non-null.
     // We're assuming that this query has been validated and the value used
     // here is of the correct type.
-    return valueFromAST(valueAST, nullableType, variables);
+    return valueFromAST(valueAST, type.ofType, variables);
   }
 
   if (!valueAST) {
@@ -72,7 +71,7 @@ export function valueFromAST(
   }
 
   if (type instanceof GraphQLList) {
-    const itemType: GraphQLInputType = (type.ofType: any);
+    const itemType = type.ofType;
     if (valueAST.kind === Kind.LIST) {
       return (valueAST: ListValue).values.map(
         itemAST => valueFromAST(itemAST, itemType, variables)