Subclass Lexer for schema coordinates

Author: benjie

src/language/lexer.ts

@@ -6,18 +6,6 @@ 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
@@ -49,17 +37,14 @@ export class Lexer {
    */
   lineStart: number;
 
-  protected _options: LexerOptions;
-
-  constructor(source: Source, options: LexerOptions = {}) {
+  constructor(source: Source) {
     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]() {
@@ -99,14 +84,22 @@ export class Lexer {
     return token;
   }
 
-  validateIgnoredToken(position: number): void {
-    if (this._options.noIgnoredTokens === true) {
-      throw syntaxError(
-        this.source,
-        position,
-        `Invalid character: ${printCodePointAt(this, position)}.`,
-      );
-    }
+  validateIgnoredToken(_position: number): void {
+    /* noop - ignored tokens are ignored */
+  }
+}
+
+export class SchemaCoordinateLexer extends Lexer {
+  override get [Symbol.toStringTag]() {
+    return 'SchemaCoordinateLexer';
+  }
+
+  override validateIgnoredToken(position: number): void {
+    throw syntaxError(
+      this.source,
+      position,
+      `Invalid character: ${printCodePointAt(this, position)}.`,
+    );
   }
 }
 

src/language/parser.ts

@@ -70,23 +70,18 @@ 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 {
+  isPunctuatorTokenKind,
+  Lexer,
+  SchemaCoordinateLexer,
+} from './lexer.js';
 import { isSource, Source } from './source.js';
 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
@@ -123,6 +118,21 @@ export interface ParseOptions {
    * ```
    */
   experimentalFragmentArguments?: boolean | undefined;
+
+  /**
+   * You may override the Lexer class used to lex the source; this is used by
+   * schema coordinates to introduce a lexer that forbids ignored tokens.
+   */
+  Lexer?: typeof Lexer | undefined;
+}
+
+export interface ParseSchemaCoordinateOptions {
+  /**
+   * By default, the parser creates AST nodes that know the location
+   * in the source that they correspond to. This configuration flag
+   * disables that behavior for performance or testing.
+   */
+  noLocation?: boolean | undefined;
 }
 
 /**
@@ -208,12 +218,11 @@ export function parseType(
  */
 export function parseSchemaCoordinate(
   source: string | Source,
-  options: ParseOptions & { noIgnoredTokens?: true } = {},
+  options: ParseSchemaCoordinateOptions,
 ): SchemaCoordinateNode {
   // Ignored tokens are excluded syntax for the schema coordinates.
-  const _options = { ...options, noIgnoredTokens: true };
-
-  const parser = new Parser(source, _options);
+  const parserOptions = { ...options, Lexer: SchemaCoordinateLexer };
+  const parser = new Parser(source, parserOptions);
   parser.expectToken(TokenKind.SOF);
   const coordinate = parser.parseSchemaCoordinate();
   parser.expectToken(TokenKind.EOF);
@@ -239,11 +248,8 @@ export class Parser {
   constructor(source: string | Source, options: ParseOptions = {}) {
     const sourceObj = isSource(source) ? source : new Source(source);
 
-    const lexerOptions: LexerOptions = {
-      noIgnoredTokens: options.noIgnoredTokens ?? false,
-    };
-
-    this._lexer = new Lexer(sourceObj, lexerOptions);
+    const LexerClass = options.Lexer ?? Lexer;
+    this._lexer = new LexerClass(sourceObj);
     this._options = options;
     this._tokenCounter = 0;
   }