Remove SemanticNonNull from TypeNode

This type is reused for variables, inputs and list-types which
can't be smantically non-null. list-types can be but only if they
are used in an SDL context.

This is kind of a short-coming of our types, we conflate SDL
and execution language.

Author: JoviDeCroock

src/execution/__tests__/semantic-nullability-test.ts

@@ -53,11 +53,8 @@ describe('Execute: Handles Semantic Nullability', () => {
       rootValue: data,
     });
 
-    const executable = document.definitions?.values().next()
-      .value as ExecutableDefinitionNode;
-    const selectionSet = executable.selectionSet.selections
-      .values()
-      .next().value;
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const selectionSet = executable.selectionSet.selections[0];
 
     expect(result).to.deep.equal({
       data: {
@@ -90,11 +87,8 @@ describe('Execute: Handles Semantic Nullability', () => {
         }
       `);
 
-    const executable = document.definitions?.values().next()
-      .value as ExecutableDefinitionNode;
-    const selectionSet = executable.selectionSet.selections
-      .values()
-      .next().value;
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const selectionSet = executable.selectionSet.selections[0];
 
     const result = await execute({
       schema: new GraphQLSchema({ query: DataType }),
@@ -141,13 +135,9 @@ describe('Execute: Handles Semantic Nullability', () => {
       rootValue: data,
     });
 
-    const executable = document.definitions?.values().next()
-      .value as ExecutableDefinitionNode;
-    const dSelectionSet = executable.selectionSet.selections.values().next()
-      .value as FieldNode;
-    const fSelectionSet = dSelectionSet.selectionSet?.selections
-      .values()
-      .next().value;
+    const executable = document.definitions[0] as ExecutableDefinitionNode;
+    const dSelectionSet = executable.selectionSet.selections[0] as FieldNode;
+    const fSelectionSet = dSelectionSet.selectionSet?.selections[0];
 
     expect(result).to.deep.equal({
       data: {

src/language/ast.ts

@@ -529,11 +529,7 @@ export interface SemanticNonNullTypeNode {
 
 /** Type Reference */
 
-export type TypeNode =
-  | NamedTypeNode
-  | ListTypeNode
-  | NonNullTypeNode
-  | SemanticNonNullTypeNode;
+export type TypeNode = NamedTypeNode | ListTypeNode | NonNullTypeNode;
 
 export interface NamedTypeNode {
   readonly kind: Kind.NAMED_TYPE;
@@ -544,7 +540,7 @@ export interface NamedTypeNode {
 export interface ListTypeNode {
   readonly kind: Kind.LIST_TYPE;
   readonly loc?: Location;
-  readonly type: TypeNode;
+  readonly type: TypeNode | SemanticNonNullTypeNode;
 }
 
 export interface NonNullTypeNode {
@@ -609,7 +605,7 @@ export interface FieldDefinitionNode {
   readonly description?: StringValueNode;
   readonly name: NameNode;
   readonly arguments?: ReadonlyArray<InputValueDefinitionNode>;
-  readonly type: TypeNode;
+  readonly type: TypeNode | SemanticNonNullTypeNode;
   readonly directives?: ReadonlyArray<ConstDirectiveNode>;
 }
 

src/language/parser.ts

@@ -184,7 +184,7 @@ export function parseConstValue(
 export function parseType(
   source: string | Source,
   options?: ParseOptions | undefined,
-): TypeNode {
+): TypeNode | SemanticNonNullTypeNode {
   const parser = new Parser(source, options);
   parser.expectToken(TokenKind.SOF);
   const type = parser.parseTypeReference();
@@ -403,7 +403,8 @@ export class Parser {
     return this.node<VariableDefinitionNode>(this._lexer.token, {
       kind: Kind.VARIABLE_DEFINITION,
       variable: this.parseVariable(),
-      type: (this.expectToken(TokenKind.COLON), this.parseTypeReference()),
+      type: (this.expectToken(TokenKind.COLON),
+      this.parseTypeReference()) as TypeNode,
       defaultValue: this.expectOptionalToken(TokenKind.EQUALS)
         ? this.parseConstValueLiteral()
         : undefined,
@@ -773,15 +774,15 @@ export class Parser {
    *   - ListType
    *   - NonNullType
    */
-  parseTypeReference(): TypeNode {
+  parseTypeReference(): TypeNode | SemanticNonNullTypeNode {
     const start = this._lexer.token;
     let type;
     if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
       const innerType = this.parseTypeReference();
       this.expectToken(TokenKind.BRACKET_R);
       type = this.node<ListTypeNode>(start, {
         kind: Kind.LIST_TYPE,
-        type: innerType,
+        type: innerType as TypeNode,
       });
     } else {
       type = this.parseNamedType();
@@ -992,7 +993,7 @@ export class Parser {
       kind: Kind.INPUT_VALUE_DEFINITION,
       description,
       name,
-      type,
+      type: type as TypeNode,
       defaultValue,
       directives,
     });

src/utilities/extendSchema.ts

@@ -24,6 +24,7 @@ import type {
   ScalarTypeExtensionNode,
   SchemaDefinitionNode,
   SchemaExtensionNode,
+  SemanticNonNullTypeNode,
   TypeDefinitionNode,
   TypeNode,
   UnionTypeDefinitionNode,
@@ -431,7 +432,9 @@ export function extendSchemaImpl(
     return type;
   }
 
-  function getWrappedType(node: TypeNode): GraphQLType {
+  function getWrappedType(
+    node: TypeNode | SemanticNonNullTypeNode,
+  ): GraphQLType {
     if (node.kind === Kind.LIST_TYPE) {
       return new GraphQLList(getWrappedType(node.type));
     }

src/utilities/typeFromAST.ts

@@ -7,11 +7,7 @@ import type {
 import { Kind } from '../language/kinds';
 
 import type { GraphQLNamedType, GraphQLType } from '../type/definition';
-import {
-  GraphQLList,
-  GraphQLNonNull,
-  GraphQLSemanticNonNull,
-} from '../type/definition';
+import { GraphQLList, GraphQLNonNull } from '../type/definition';
 import type { GraphQLSchema } from '../type/schema';
 
 /**
@@ -43,19 +39,13 @@ export function typeFromAST(
 ): GraphQLType | undefined {
   switch (typeNode.kind) {
     case Kind.LIST_TYPE: {
-      const innerType = typeFromAST(schema, typeNode.type);
+      const innerType = typeFromAST(schema, typeNode.type as TypeNode);
       return innerType && new GraphQLList(innerType);
     }
     case Kind.NON_NULL_TYPE: {
       const innerType = typeFromAST(schema, typeNode.type);
       return innerType && new GraphQLNonNull(innerType);
     }
-    // We only use typeFromAST for fragment/variable type inference
-    // which should not be affected by semantic non-null types
-    // case Kind.SEMANTIC_NON_NULL_TYPE: {
-    //   const innerType = typeFromAST(schema, typeNode.type);
-    //   return innerType && new GraphQLSemanticNonNull(innerType);
-    // }
     case Kind.NAMED_TYPE:
       return schema.getType(typeNode.name.value);
   }