parser tests passing

Author: twof

src/language/__tests__/parser-test.ts

@@ -11,6 +11,7 @@ import { Kind } from '../kinds';
 import { parse, parseConstValue, parseType, parseValue } from '../parser';
 import { Source } from '../source';
 import { TokenKind } from '../tokenKind';
+import { Console } from 'console';
 
 function expectSyntaxError(text: string) {
   return expectToThrowJSON(() => parse(text));
@@ -631,11 +632,46 @@ describe('Parser', () => {
       });
     });
 
+    it('parses nested types', () => {
+      const result = parseType('[MyType!]');
+      expectJSON(result).toDeepEqual({
+        kind: Kind.LIST_TYPE,
+        loc: { start: 0, end: 9 },
+        type: {
+          kind: Kind.NON_NULL_TYPE,
+          loc: { start: 1, end: 8 },
+          type: {
+            kind: Kind.NAMED_TYPE,
+            loc: { start: 1, end: 7 },
+            name: {
+              kind: Kind.NAME,
+              loc: { start: 1, end: 7 },
+              value: 'MyType',
+            },
+          },
+        },
+      });
+    });
+  });
+
+  describe('parseDocumentDirective', () => {
+    it('doesnt 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*');
+      const result = parseType('MyType', { useSemanticNullability: true });
       expectJSON(result).toDeepEqual({
         kind: Kind.SEMANTIC_NON_NULL_TYPE,
-        loc: { start: 0, end: 7 },
+        loc: { start: 0, end: 6 },
         type: {
           kind: Kind.NAMED_TYPE,
           loc: { start: 0, end: 6 },
@@ -648,22 +684,31 @@ describe('Parser', () => {
       });
     });
 
-    it('parses nested types', () => {
-      const result = parseType('[MyType!]');
+    it('parses nullable types', () => {
+      const result = parseType('MyType?', { useSemanticNullability: true });
       expectJSON(result).toDeepEqual({
-        kind: Kind.LIST_TYPE,
-        loc: { start: 0, end: 9 },
+        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!', { useSemanticNullability: true });
+      expectJSON(result).toDeepEqual({
+        kind: Kind.NON_NULL_TYPE,
+        loc: { start: 0, end: 7 },
         type: {
-          kind: Kind.NON_NULL_TYPE,
-          loc: { start: 1, end: 8 },
-          type: {
-            kind: Kind.NAMED_TYPE,
-            loc: { start: 1, end: 7 },
-            name: {
-              kind: Kind.NAME,
-              loc: { start: 1, end: 7 },
-              value: 'MyType',
-            },
+          kind: Kind.NAMED_TYPE,
+          loc: { start: 0, end: 6 },
+          name: {
+            kind: Kind.NAME,
+            loc: { start: 0, end: 6 },
+            value: 'MyType',
           },
         },
       });

src/language/lexer.ts

@@ -91,7 +91,7 @@ export class Lexer {
 export function isPunctuatorTokenKind(kind: TokenKind): boolean {
   return (
     kind === TokenKind.BANG ||
-    kind === TokenKind.ASTERISK ||
+    kind === TokenKind.QUESTION_MARK ||
     kind === TokenKind.DOLLAR ||
     kind === TokenKind.AMP ||
     kind === TokenKind.PAREN_L ||
@@ -247,7 +247,7 @@ 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 0x0024: // $
@@ -258,8 +258,8 @@ function readNextToken(lexer: Lexer, start: number): Token {
         return createToken(lexer, TokenKind.PAREN_L, position, position + 1);
       case 0x0029: // )
         return createToken(lexer, TokenKind.PAREN_R, position, position + 1);
-      case 0x002a: // *
-        return createToken(lexer, TokenKind.ASTERISK, position, position + 1);
+      case 0x003f: // ?
+        return createToken(lexer, TokenKind.QUESTION_MARK, position, position + 1);
       case 0x002e: // .
         if (
           body.charCodeAt(position + 1) === 0x002e &&

src/language/parser.ts

@@ -104,6 +104,8 @@ export interface ParseOptions {
    * ```
    */
   allowLegacyFragmentVariables?: boolean;
+
+  useSemanticNullability?: boolean;
 }
 
 /**
@@ -250,6 +252,14 @@ export class Parser {
    *   - InputObjectTypeDefinition
    */
   parseDefinition(): DefinitionNode {
+    // TODO: I don't know what isConst represents. Every other callsite has it false
+    let directives = this.parseDirectives(false);
+    for (let directive of directives) {
+      if (directive.name.value == "SemanticNullability") {
+        this._options.useSemanticNullability = true;
+      }
+    }
+
     if (this.peek(TokenKind.BRACE_L)) {
       return this.parseOperationDefinition();
     }
@@ -757,20 +767,30 @@ export class Parser {
       type = this.parseNamedType();
     }
 
-    if (this.expectOptionalToken(TokenKind.BANG)) {
-      return this.node<NonNullTypeNode>(start, {
-        kind: Kind.NON_NULL_TYPE,
-        type,
-      });
-    }
-    if (this.expectOptionalToken(TokenKind.ASTERISK)) {
-      return this.node<SemanticNonNullTypeNode>(start, {
-        kind: Kind.SEMANTIC_NON_NULL_TYPE,
-        type,
-      });
-    }
+    if (this._options.useSemanticNullability) {
+      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;
+      } else {
+        return this.node<SemanticNonNullTypeNode>(start, {
+          kind: Kind.SEMANTIC_NON_NULL_TYPE,
+          type,
+        });
+      }
+    } else {
+      if (this.expectOptionalToken(TokenKind.BANG)) {
+        return this.node<NonNullTypeNode>(start, {
+          kind: Kind.NON_NULL_TYPE,
+          type,
+        });
+      }
 
-    return type;
+      return type;
+    }
   }
 
   /**

src/language/tokenKind.ts

@@ -6,7 +6,7 @@ enum TokenKind {
   SOF = '<SOF>',
   EOF = '<EOF>',
   BANG = '!',
-  ASTERISK = '*',
+  QUESTION_MARK = '?',
   DOLLAR = '$',
   AMP = '&',
   PAREN_L = '(',