no ignored tokens for schema coordinates

Author: magicmark

src/language/__tests__/parser-test.ts

@@ -751,11 +751,11 @@ describe('Parser', () => {
     });
 
     it('rejects Name . Name ( Name : Name )', () => {
-      expect(() => parseSchemaCoordinate('MyType.field(arg: value)'))
+      expect(() => parseSchemaCoordinate('MyType.field(arg:value)'))
         .to.throw()
         .to.deep.include({
           message: 'Syntax Error: Expected ")", found Name "value".',
-          locations: [{ line: 1, column: 19 }],
+          locations: [{ line: 1, column: 18 }],
         });
     });
 

src/language/__tests__/printer-test.ts

@@ -301,16 +301,24 @@ describe('Printer: Query document', () => {
   });
 
   it('prints schema coordinates', () => {
-    expect(print(parseSchemaCoordinate('  Name  '))).to.equal('Name');
-    expect(print(parseSchemaCoordinate('  Name . field '))).to.equal(
-      'Name.field',
-    );
-    expect(print(parseSchemaCoordinate('  Name . field ( arg: )'))).to.equal(
+    expect(print(parseSchemaCoordinate('Name'))).to.equal('Name');
+    expect(print(parseSchemaCoordinate('Name.field'))).to.equal('Name.field');
+    expect(print(parseSchemaCoordinate('Name.field(arg:)'))).to.equal(
       'Name.field(arg:)',
     );
-    expect(print(parseSchemaCoordinate(' @ name  '))).to.equal('@name');
-    expect(print(parseSchemaCoordinate(' @ name (arg:) '))).to.equal(
-      '@name(arg:)',
+    expect(print(parseSchemaCoordinate('@name'))).to.equal('@name');
+    expect(print(parseSchemaCoordinate('@name(arg:)'))).to.equal('@name(arg:)');
+  });
+
+  it('throws syntax error for ignored tokens in schema coordinates', () => {
+    expect(() => print(parseSchemaCoordinate('# foo\nName'))).to.throw(
+      'Syntax Error: Invalid character: "#"',
+    );
+    expect(() => print(parseSchemaCoordinate('\nName'))).to.throw(
+      'Syntax Error: Invalid character: U+000A.',
+    );
+    expect(() => print(parseSchemaCoordinate('Name .field'))).to.throw(
+      'Syntax Error: Invalid character: " "',
     );
   });
 });

src/language/lexer.ts

@@ -6,6 +6,18 @@ import { isDigit, isNameContinue, isNameStart } from './characterClasses.js';
 import type { Source } from './source.js';
 import { TokenKind } from './tokenKind.js';
 
+/**
+ * Configuration options to control lexer behavior
+ */
+export interface LexerOptions {
+  /**
+   * By default, ignored tokens are valid syntax and ignored when lexing.
+   * This may be disabled for certain grammars that specifically disallow
+   * ignored tokens (e.g. schema coordinates).
+   */
+  noIgnoredTokens?: boolean | undefined;
+}
+
 /**
  * Given a Source object, creates a Lexer for that source.
  * A Lexer is a stateful stream generator in that every time
@@ -37,14 +49,17 @@ export class Lexer {
    */
   lineStart: number;
 
-  constructor(source: Source) {
+  protected _options: LexerOptions;
+
+  constructor(source: Source, options: LexerOptions = {}) {
     const startOfFileToken = new Token(TokenKind.SOF, 0, 0, 0, 0);
 
     this.source = source;
     this.lastToken = startOfFileToken;
     this.token = startOfFileToken;
     this.line = 1;
     this.lineStart = 0;
+    this._options = options;
   }
 
   get [Symbol.toStringTag]() {
@@ -83,6 +98,16 @@ export class Lexer {
     }
     return token;
   }
+
+  validateIgnoredToken(position: number): void {
+    if (this._options.noIgnoredTokens === true) {
+      throw syntaxError(
+        this.source,
+        position,
+        `Invalid character: ${printCodePointAt(this, position)}.`,
+      );
+    }
+  }
 }
 
 /**
@@ -217,18 +242,21 @@ function readNextToken(lexer: Lexer, start: number): Token {
       case 0x0009: // \t
       case 0x0020: // <space>
       case 0x002c: // ,
+        lexer.validateIgnoredToken(position);
         ++position;
         continue;
       // LineTerminator ::
       //   - "New Line (U+000A)"
       //   - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"]
       //   - "Carriage Return (U+000D)" "New Line (U+000A)"
       case 0x000a: // \n
+        lexer.validateIgnoredToken(position);
         ++position;
         ++lexer.line;
         lexer.lineStart = position;
         continue;
       case 0x000d: // \r
+        lexer.validateIgnoredToken(position);
         if (body.charCodeAt(position + 1) === 0x000a) {
           position += 2;
         } else {
@@ -239,6 +267,7 @@ function readNextToken(lexer: Lexer, start: number): Token {
         continue;
       // Comment
       case 0x0023: // #
+        lexer.validateIgnoredToken(position);
         return readComment(lexer, position);
       // Token ::
       //   - Punctuator

src/language/parser.ts

@@ -70,6 +70,7 @@ import type {
 import { Location, OperationTypeNode } from './ast.js';
 import { DirectiveLocation } from './directiveLocation.js';
 import { Kind } from './kinds.js';
+import type { LexerOptions } from './lexer.js';
 import { isPunctuatorTokenKind, Lexer } from './lexer.js';
 import { isSource, Source } from './source.js';
 import { TokenKind } from './tokenKind.js';
@@ -78,6 +79,14 @@ import { TokenKind } from './tokenKind.js';
  * Configuration options to control parser behavior
  */
 export interface ParseOptions {
+  /**
+   * By default, ignored tokens are valid syntax and ignored when lexing.
+   * This may be disabled for certain grammars that specifically disallow
+   * ignored tokens (e.g. schema coordinates).
+   * This is passed down to the lexer to enforce.
+   */
+  noIgnoredTokens?: boolean | undefined;
+
   /**
    * By default, the parser creates AST nodes that know the location
    * in the source that they correspond to. This configuration flag
@@ -199,9 +208,12 @@ export function parseType(
  */
 export function parseSchemaCoordinate(
   source: string | Source,
-  options?: ParseOptions,
+  options: ParseOptions & { noIgnoredTokens?: true } = {},
 ): SchemaCoordinateNode {
-  const parser = new Parser(source, options);
+  // Ignored tokens are excluded syntax for the schema coordinates.
+  const _options = { ...options, noIgnoredTokens: true };
+
+  const parser = new Parser(source, _options);
   parser.expectToken(TokenKind.SOF);
   const coordinate = parser.parseSchemaCoordinate();
   parser.expectToken(TokenKind.EOF);
@@ -227,7 +239,11 @@ export class Parser {
   constructor(source: string | Source, options: ParseOptions = {}) {
     const sourceObj = isSource(source) ? source : new Source(source);
 
-    this._lexer = new Lexer(sourceObj);
+    const lexerOptions: LexerOptions = {
+      noIgnoredTokens: options.noIgnoredTokens ?? false,
+    };
+
+    this._lexer = new Lexer(sourceObj, lexerOptions);
     this._options = options;
     this._tokenCounter = 0;
   }