graphql · JoviDeCroock · Feb 15, 2025
diff --git a/src/language/__tests__/parser-test.ts b/src/language/__tests__/parser-test.ts
@@ -658,63 +658,20 @@ describe('Parser', () => {
     });
   });
 
-  describe('parseDocumentDirective', () => {
-    it("doesn't throw on document-level directive", () => {
-      parse(dedent`
-        @SemanticNullability
-        type Query {
-          hello: String
-          world: String?
-          foo: String!
-        }
-      `);
-    });
-
-    it('parses semantic-non-null types', () => {
-      const result = parseType('MyType', { allowSemanticNullability: true });
-      expectJSON(result).toDeepEqual({
-        kind: Kind.SEMANTIC_NON_NULL_TYPE,
-        loc: { start: 0, end: 6 },
-        type: {
-          kind: Kind.NAMED_TYPE,
-          loc: { start: 0, end: 6 },
-          name: {
-            kind: Kind.NAME,
-            loc: { start: 0, end: 6 },
-            value: 'MyType',
-          },
-        },
-      });
-    });
-
-    it('parses nullable types', () => {
-      const result = parseType('MyType?', { allowSemanticNullability: true });
-      expectJSON(result).toDeepEqual({
+  it('parses semantic-non-null types', () => {
+    const result = parseType('MyType*');
+    expectJSON(result).toDeepEqual({
+      kind: Kind.SEMANTIC_NON_NULL_TYPE,
+      loc: { start: 0, end: 7 },
+      type: {
         kind: Kind.NAMED_TYPE,
         loc: { start: 0, end: 6 },
         name: {
           kind: Kind.NAME,
           loc: { start: 0, end: 6 },
           value: 'MyType',
         },
-      });
-    });
-
-    it('parses non-nullable types', () => {
-      const result = parseType('MyType!', { allowSemanticNullability: true });
-      expectJSON(result).toDeepEqual({
-        kind: Kind.NON_NULL_TYPE,
-        loc: { start: 0, end: 7 },
-        type: {
-          kind: Kind.NAMED_TYPE,
-          loc: { start: 0, end: 6 },
-          name: {
-            kind: Kind.NAME,
-            loc: { start: 0, end: 6 },
-            value: 'MyType',
-          },
-        },
-      });
+      },
     });
   });
 });
diff --git a/src/language/__tests__/schema-printer-test.ts b/src/language/__tests__/schema-printer-test.ts
@@ -182,39 +182,18 @@ describe('Printer: SDL document', () => {
   });
 
   it('prints NamedType', () => {
-    expect(
-      print(parseType('MyType', { allowSemanticNullability: false }), {
-        useSemanticNullability: false,
-      }),
-    ).to.equal(dedent`MyType`);
+    expect(print(parseType('MyType'))).to.equal(dedent`MyType`);
   });
 
-  it('prints SemanticNullableType', () => {
-    expect(
-      print(parseType('MyType?', { allowSemanticNullability: true }), {
-        useSemanticNullability: true,
-      }),
-    ).to.equal(dedent`MyType?`);
+  it('prints nullable types', () => {
+    expect(print(parseType('MyType'))).to.equal(dedent`MyType`);
   });
 
   it('prints SemanticNonNullType', () => {
-    expect(
-      print(parseType('MyType', { allowSemanticNullability: true }), {
-        useSemanticNullability: true,
-      }),
-    ).to.equal(dedent`MyType`);
+    expect(print(parseType('MyType*'))).to.equal(dedent`MyType*`);
   });
 
   it('prints NonNullType', () => {
-    expect(
-      print(parseType('MyType!', { allowSemanticNullability: true }), {
-        useSemanticNullability: true,
-      }),
-    ).to.equal(dedent`MyType!`);
-    expect(
-      print(parseType('MyType!', { allowSemanticNullability: false }), {
-        useSemanticNullability: true,
-      }),
-    ).to.equal(dedent`MyType!`);
+    expect(print(parseType('MyType!'))).to.equal(dedent`MyType!`);
   });
 });
diff --git a/src/language/lexer.ts b/src/language/lexer.ts
@@ -91,7 +91,7 @@ export class Lexer {
 export function isPunctuatorTokenKind(kind: TokenKind): boolean {
   return (
     kind === TokenKind.BANG ||
-    kind === TokenKind.QUESTION_MARK ||
+    kind === TokenKind.STAR ||
     kind === TokenKind.DOLLAR ||
     kind === TokenKind.AMP ||
     kind === TokenKind.PAREN_L ||
@@ -247,16 +247,11 @@ function readNextToken(lexer: Lexer, start: number): Token {
       //   - FloatValue
       //   - StringValue
       //
-      // Punctuator :: one of ! ? $ & ( ) ... : = @ [ ] { | }
+      // Punctuator :: one of ! * $ & ( ) ... : = @ [ ] { | }
       case 0x0021: // !
         return createToken(lexer, TokenKind.BANG, position, position + 1);
-      case 0x003f: // ?
-        return createToken(
-          lexer,
-          TokenKind.QUESTION_MARK,
-          position,
-          position + 1,
-        );
+      case 0x002a: // *
+        return createToken(lexer, TokenKind.STAR, position, position + 1);
       case 0x0024: // $
         return createToken(lexer, TokenKind.DOLLAR, position, position + 1);
       case 0x0026: // &

diff --git a/src/language/parser.ts b/src/language/parser.ts
@@ -104,18 +104,6 @@ export interface ParseOptions {
    * ```
    */
   allowLegacyFragmentVariables?: boolean;
-
-  /**
-   * When enabled, the parser will understand and parse semantic nullability
-   * annotations. This means that every type suffixed with `!` will remain
-   * non-nullable, every type suffixed with `?` will be the classic nullable, and
-   * types without a suffix will be semantically nullable. Semantic nullability
-   * will be the new default when this is enabled. A semantically nullable type
-   * can only be null when there's an error associated with the field.
-   *
-   * @experimental
-   */
-  allowSemanticNullability?: boolean;
 }
 
 /**
@@ -187,7 +175,7 @@ export function parseType(
 ): TypeNode | SemanticNonNullTypeNode {
   const parser = new Parser(source, options);
   parser.expectToken(TokenKind.SOF);
-  const type = parser.parseTypeReference();
+  const type = parser.parseTypeReference(true);
   parser.expectToken(TokenKind.EOF);
   return type;
 }
@@ -271,16 +259,6 @@ export class Parser {
    *   - InputObjectTypeDefinition
    */
   parseDefinition(): DefinitionNode {
-    const directives = this.parseDirectives(false);
-    // If a document-level SemanticNullability directive exists as
-    // the first element in a document, then all parsing will
-    // happen in SemanticNullability mode.
-    for (const directive of directives) {
-      if (directive.name.value === 'SemanticNullability') {
-        this._options.allowSemanticNullability = true;
-      }
-    }
-
     if (this.peek(TokenKind.BRACE_L)) {
       return this.parseOperationDefinition();
     }
@@ -404,7 +382,7 @@ export class Parser {
       kind: Kind.VARIABLE_DEFINITION,
       variable: this.parseVariable(),
       type: (this.expectToken(TokenKind.COLON),
-      this.parseTypeReference()) as TypeNode,
+      this.parseTypeReference(false)) as TypeNode,
       defaultValue: this.expectOptionalToken(TokenKind.EQUALS)
         ? this.parseConstValueLiteral()
         : undefined,
@@ -774,11 +752,13 @@ export class Parser {
    *   - ListType
    *   - NonNullType
    */
-  parseTypeReference(): TypeNode | SemanticNonNullTypeNode {
+  parseTypeReference(
+    allowSemanticNonNull: boolean,
+  ): TypeNode | SemanticNonNullTypeNode {
     const start = this._lexer.token;
     let type;
     if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
-      const innerType = this.parseTypeReference();
+      const innerType = this.parseTypeReference(allowSemanticNonNull);
       this.expectToken(TokenKind.BRACKET_R);
       type = this.node<ListTypeNode>(start, {
         kind: Kind.LIST_TYPE,
@@ -788,27 +768,19 @@ export class Parser {
       type = this.parseNamedType();
     }
 
-    if (this._options.allowSemanticNullability) {
-      if (this.expectOptionalToken(TokenKind.BANG)) {
-        return this.node<NonNullTypeNode>(start, {
-          kind: Kind.NON_NULL_TYPE,
-          type,
-        });
-      } else if (this.expectOptionalToken(TokenKind.QUESTION_MARK)) {
-        return type;
-      }
-
-      return this.node<SemanticNonNullTypeNode>(start, {
-        kind: Kind.SEMANTIC_NON_NULL_TYPE,
-        type,
-      });
-    }
-
     if (this.expectOptionalToken(TokenKind.BANG)) {
       return this.node<NonNullTypeNode>(start, {
         kind: Kind.NON_NULL_TYPE,
         type,
       });
+    } else if (
+      allowSemanticNonNull &&
+      this.expectOptionalToken(TokenKind.STAR)
+    ) {
+      return this.node<SemanticNonNullTypeNode>(start, {
+        kind: Kind.SEMANTIC_NON_NULL_TYPE,
+        type,
+      });
     }
 
     return type;
@@ -951,7 +923,7 @@ export class Parser {
     const name = this.parseName();
     const args = this.parseArgumentDefs();
     this.expectToken(TokenKind.COLON);
-    const type = this.parseTypeReference();
+    const type = this.parseTypeReference(true);
     const directives = this.parseConstDirectives();
     return this.node<FieldDefinitionNode>(start, {
       kind: Kind.FIELD_DEFINITION,
@@ -983,7 +955,7 @@ export class Parser {
     const description = this.parseDescription();
     const name = this.parseName();
     this.expectToken(TokenKind.COLON);
-    const type = this.parseTypeReference();
+    const type = this.parseTypeReference(false);
     let defaultValue;
     if (this.expectOptionalToken(TokenKind.EQUALS)) {
       defaultValue = this.parseConstValueLiteral();

diff --git a/src/language/printer.ts b/src/language/printer.ts
@@ -2,22 +2,14 @@ import type { Maybe } from '../jsutils/Maybe';
 
 import type { ASTNode } from './ast';
 import { printBlockString } from './blockString';
-import { Kind } from './kinds';
 import { printString } from './printString';
 import { visit } from './visitor';
 
-/**
- * Configuration options to control parser behavior
- */
-export interface PrintOptions {
-  useSemanticNullability?: boolean;
-}
-
 /**
  * Converts an AST into a string, using one set of reasonable
  * formatting rules.
  */
-export function print(ast: ASTNode, options: PrintOptions = {}): string {
+export function print(ast: ASTNode): string {
   return visit<string>(ast, {
     Name: { leave: (node) => node.value },
     Variable: { leave: (node) => '$' + node.name },
@@ -131,19 +123,11 @@ export function print(ast: ASTNode, options: PrintOptions = {}): string {
     // Type
 
     NamedType: {
-      leave: ({ name }, _, parent) =>
-        parent &&
-        !Array.isArray(parent) &&
-        ((parent as ASTNode).kind === Kind.SEMANTIC_NON_NULL_TYPE ||
-          (parent as ASTNode).kind === Kind.NON_NULL_TYPE)
-          ? name
-          : options?.useSemanticNullability
-          ? `${name}?`
-          : name,
+      leave: ({ name }) => name,
     },
     ListType: { leave: ({ type }) => '[' + type + ']' },
     NonNullType: { leave: ({ type }) => type + '!' },
-    SemanticNonNullType: { leave: ({ type }) => type },
+    SemanticNonNullType: { leave: ({ type }) => type + '*' },
 
     // Type System Definitions
 

diff --git a/src/language/tokenKind.ts b/src/language/tokenKind.ts
@@ -6,7 +6,7 @@ enum TokenKind {
   SOF = '<SOF>',
   EOF = '<EOF>',
   BANG = '!',
-  QUESTION_MARK = '?',
+  STAR = '*',
   DOLLAR = '$',
   AMP = '&',
   PAREN_L = '(',

diff --git a/src/type/__tests__/introspection-test.ts b/src/type/__tests__/introspection-test.ts
@@ -1798,11 +1798,10 @@ describe('Introspection', () => {
   describe('semantic nullability', () => {
     it('casts semantic-non-null types to nullable types in traditional mode', () => {
       const schema = buildSchema(`
-        @SemanticNullability
         type Query {
           someField: String!
-          someField2: String
-          someField3: String?
+          someField2: String*
+          someField3: String
         }
       `);
 
@@ -1847,11 +1846,10 @@ describe('Introspection', () => {
 
     it('returns semantic-non-null types in full mode', () => {
       const schema = buildSchema(`
-        @SemanticNullability
         type Query {
           someField: String!
-          someField2: String
-          someField3: String?
+          someField2: String*
+          someField3: String
         }
       `);
 

diff --git a/src/type/definition.ts b/src/type/definition.ts
@@ -502,7 +502,7 @@ export class GraphQLSemanticNonNull<T extends GraphQLNullableType> {
   }
 
   toString(): string {
-    return String(this.ofType);
+    return String(this.ofType) + '*';
   }
 
   toJSON(): string {

diff --git a/src/utilities/__tests__/TypeInfo-test.ts b/src/utilities/__tests__/TypeInfo-test.ts
@@ -460,11 +460,10 @@ describe('visitWithTypeInfo', () => {
 
   it('supports traversals of semantic non-null types', () => {
     const schema = buildSchema(`
-      @SemanticNullability
       type Query {
         id: String!
-        name: String
-        something: String?
+        name: String*
+        something: String
       }
     `);
 
@@ -506,10 +505,10 @@ describe('visitWithTypeInfo', () => {
       ['enter', 'Name', 'id', 'String!'],
       ['leave', 'Name', 'id', 'String!'],
       ['leave', 'Field', null, 'String!'],
-      ['enter', 'Field', null, 'String'],
-      ['enter', 'Name', 'name', 'String'],
-      ['leave', 'Name', 'name', 'String'],
-      ['leave', 'Field', null, 'String'],
+      ['enter', 'Field', null, 'String*'],
+      ['enter', 'Name', 'name', 'String*'],
+      ['leave', 'Name', 'name', 'String*'],
+      ['leave', 'Field', null, 'String*'],
       ['enter', 'Field', null, 'String'],
       ['enter', 'Name', 'something', 'String'],
       ['leave', 'Name', 'something', 'String'],