@prisma-next/psl-parser 0.13.0-dev.20 → 0.13.0-dev.22

package/src/source-file.ts

@@ -0,0 +1,89 @@
+const LINE_FEED = 10;
+
+export interface Position {
+  readonly line: number;
+  readonly character: number;
+}
+
+export interface Range {
+  readonly start: Position;
+  readonly end: Position;
+}
+
+export class SourceFile {
+  readonly #text: string;
+  readonly #lineStarts: readonly number[];
+
+  constructor(text: string) {
+    this.#text = text;
+    const lineStarts: number[] = [0];
+    for (let offset = 0; offset < text.length; offset++) {
+      if (text.charCodeAt(offset) === LINE_FEED) {
+        lineStarts.push(offset + 1);
+      }
+    }
+    this.#lineStarts = lineStarts;
+  }
+
+  get text(): string {
+    return this.#text;
+  }
+
+  get length(): number {
+    return this.#text.length;
+  }
+
+  get lineCount(): number {
+    return this.#lineStarts.length;
+  }
+
+  lineStartOffsets(): readonly number[] {
+    return this.#lineStarts;
+  }
+
+  positionAt(offset: number): Position {
+    const clamped = clamp(offset, 0, this.#text.length);
+    const line = this.#lineIndexAt(clamped);
+    return { line, character: clamped - this.#lineStartAt(line) };
+  }
+
+  offsetAt(position: Position): number {
+    const line = clamp(position.line, 0, this.#lineStarts.length - 1);
+    const lineStart = this.#lineStartAt(line);
+    const lineEnd = this.#lineEndAt(line);
+    return clamp(lineStart + position.character, lineStart, lineEnd);
+  }
+
+  #lineStartAt(line: number): number {
+    return this.#lineStarts[line] ?? 0;
+  }
+
+  #lineEndAt(line: number): number {
+    return line + 1 < this.#lineStarts.length ? this.#lineStartAt(line + 1) - 1 : this.#text.length;
+  }
+
+  #lineIndexAt(offset: number): number {
+    const lineStarts = this.#lineStarts;
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+      const mid = (low + high + 1) >>> 1;
+      if ((lineStarts[mid] ?? 0) <= offset) {
+        low = mid;
+      } else {
+        high = mid - 1;
+      }
+    }
+    return low;
+  }
+}
+
+function clamp(value: number, min: number, max: number): number {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}

package/src/syntax/ast/declarations.ts

@@ -18,14 +18,14 @@ export type NamespaceMemberAst =
   | ModelDeclarationAst
   | EnumDeclarationAst
   | CompositeTypeDeclarationAst
-  | BlockDeclarationAst;
+  | GenericBlockDeclarationAst;
 
 function castNamespaceMember(node: SyntaxNode): NamespaceMemberAst | undefined {
   return (
     ModelDeclarationAst.cast(node) ??
     EnumDeclarationAst.cast(node) ??
     CompositeTypeDeclarationAst.cast(node) ??
-    BlockDeclarationAst.cast(node)
+    GenericBlockDeclarationAst.cast(node)
   );
 }
 
@@ -219,7 +219,7 @@ export class TypesBlockAst implements AstNode {
   }
 }
 
-export class BlockDeclarationAst implements AstNode {
+export class GenericBlockDeclarationAst implements AstNode {
   readonly syntax: SyntaxNode;
 
   constructor(syntax: SyntaxNode) {
@@ -246,8 +246,10 @@ export class BlockDeclarationAst implements AstNode {
     yield* filterChildren(this.syntax, KeyValuePairAst.cast);
   }
 
-  static cast(node: SyntaxNode): BlockDeclarationAst | undefined {
-    return node.kind === 'BlockDeclaration' ? new BlockDeclarationAst(node) : undefined;
+  static cast(node: SyntaxNode): GenericBlockDeclarationAst | undefined {
+    return node.kind === 'GenericBlockDeclaration'
+      ? new GenericBlockDeclarationAst(node)
+      : undefined;
   }
 }
 

package/src/syntax/ast/expressions.ts

@@ -56,6 +56,78 @@ export class ArrayLiteralAst implements AstNode {
   }
 }
 
+const HEX = /^[0-9a-fA-F]+$/;
+
+function decodeFixedHex(raw: string, start: number, width: number): string | undefined {
+  if (start + width > raw.length) return undefined;
+  const hex = raw.slice(start, start + width);
+  if (!HEX.test(hex)) return undefined;
+  return String.fromCharCode(Number.parseInt(hex, 16));
+}
+
+function decodeStringLiteral(raw: string): string {
+  let out = '';
+  let i = 0;
+  while (i < raw.length) {
+    const ch = raw.charAt(i);
+    if (ch !== '\\' || i + 1 >= raw.length) {
+      out += ch;
+      i++;
+      continue;
+    }
+    const next = raw.charAt(i + 1);
+    switch (next) {
+      case 'n':
+        out += '\n';
+        i += 2;
+        continue;
+      case 'r':
+        out += '\r';
+        i += 2;
+        continue;
+      case 't':
+        out += '\t';
+        i += 2;
+        continue;
+      case '"':
+        out += '"';
+        i += 2;
+        continue;
+      case '\\':
+        out += '\\';
+        i += 2;
+        continue;
+      case 'x': {
+        const decoded = decodeFixedHex(raw, i + 2, 2);
+        if (decoded === undefined) {
+          out += '\\x';
+          i += 2;
+          continue;
+        }
+        out += decoded;
+        i += 4;
+        continue;
+      }
+      case 'u': {
+        const decoded = decodeFixedHex(raw, i + 2, 4);
+        if (decoded === undefined) {
+          out += '\\u';
+          i += 2;
+          continue;
+        }
+        out += decoded;
+        i += 6;
+        continue;
+      }
+      default:
+        out += `\\${next}`;
+        i += 2;
+        continue;
+    }
+  }
+  return out;
+}
+
 export class StringLiteralExprAst implements AstNode {
   readonly syntax: SyntaxNode;
 
@@ -70,23 +142,7 @@ export class StringLiteralExprAst implements AstNode {
   value(): string | undefined {
     const tok = this.token();
     if (!tok) return undefined;
-    const raw = tok.text.slice(1, -1);
-    return raw.replace(/\\(.)/g, (_match, char: string) => {
-      switch (char) {
-        case 'n':
-          return '\n';
-        case 'r':
-          return '\r';
-        case 't':
-          return '\t';
-        case '"':
-          return '"';
-        case '\\':
-          return '\\';
-        default:
-          return `\\${char}`;
-      }
-    });
+    return decodeStringLiteral(tok.text.slice(1, -1));
   }
 
   static cast(node: SyntaxNode): StringLiteralExprAst | undefined {
@@ -140,12 +196,82 @@ export class BooleanLiteralExprAst implements AstNode {
   }
 }
 
+export class ObjectLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *fields(): Iterable<ObjectFieldAst> {
+    yield* filterChildren(this.syntax, ObjectFieldAst.cast);
+  }
+
+  static cast(node: SyntaxNode): ObjectLiteralExprAst | undefined {
+    return node.kind === 'ObjectLiteralExpr' ? new ObjectLiteralExprAst(node) : undefined;
+  }
+}
+
+export class ObjectFieldAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  key(): IdentifierAst | undefined {
+    for (const child of this.syntax.children()) {
+      if (!(child instanceof SyntaxNode)) {
+        if (child.kind === 'Colon') break;
+        continue;
+      }
+      return IdentifierAst.cast(child);
+    }
+    return undefined;
+  }
+
+  colon(): Token | undefined {
+    return findChildToken(this.syntax, 'Colon');
+  }
+
+  value(): ExpressionAst | undefined {
+    if (this.colon()) {
+      let pastColon = false;
+      for (const child of this.syntax.children()) {
+        if (!(child instanceof SyntaxNode)) {
+          if (child.kind === 'Colon') pastColon = true;
+          continue;
+        }
+        if (pastColon) {
+          const expr = castExpression(child);
+          if (expr) return expr;
+        }
+      }
+      return undefined;
+    }
+    return findFirstChild(this.syntax, castExpression);
+  }
+
+  static cast(node: SyntaxNode): ObjectFieldAst | undefined {
+    return node.kind === 'ObjectField' ? new ObjectFieldAst(node) : undefined;
+  }
+}
+
 export type ExpressionAst =
   | FunctionCallAst
   | ArrayLiteralAst
   | StringLiteralExprAst
   | NumberLiteralExprAst
   | BooleanLiteralExprAst
+  | ObjectLiteralExprAst
   | IdentifierAst;
 
 export function castExpression(node: SyntaxNode): ExpressionAst | undefined {
@@ -155,6 +281,7 @@ export function castExpression(node: SyntaxNode): ExpressionAst | undefined {
     StringLiteralExprAst.cast(node) ??
     NumberLiteralExprAst.cast(node) ??
     BooleanLiteralExprAst.cast(node) ??
+    ObjectLiteralExprAst.cast(node) ??
     IdentifierAst.cast(node)
   );
 }

package/src/syntax/syntax-kind.ts

@@ -5,7 +5,10 @@ export type SyntaxKind =
   | 'CompositeTypeDeclaration'
   | 'Namespace'
   | 'TypesBlock'
-  | 'BlockDeclaration'
+  // The generic/extension block node — the `kw [name] { key = value }` form
+  // produced by `parseGenericBlock`. Deliberately distinct from the reserved
+  // `model`/`enum`/`namespace`/`type`/`types` declarations above.
+  | 'GenericBlockDeclaration'
   | 'FieldDeclaration'
   | 'EnumValueDeclaration'
   | 'NamedTypeDeclaration'
@@ -20,4 +23,6 @@ export type SyntaxKind =
   | 'ArrayLiteral'
   | 'StringLiteralExpr'
   | 'NumberLiteralExpr'
-  | 'BooleanLiteralExpr';
+  | 'BooleanLiteralExpr'
+  | 'ObjectLiteralExpr'
+  | 'ObjectField';

package/src/tokenizer.ts

@@ -86,6 +86,7 @@ function scan(source: string, pos: number): Token {
     scanWhitespace(source, pos) ??
     scanComment(source, pos) ??
     scanAt(source, pos) ??
+    scanKeywordNumber(source, pos) ??
     scanIdent(source, pos) ??
     scanNumber(source, pos) ??
     scanString(source, pos) ??
@@ -151,6 +152,22 @@ function scanIdent(source: string, pos: number): Token | undefined {
   return { kind: 'Ident', text: source.slice(pos, end) };
 }
 
+const KEYWORD_NUMBERS = ['-Infinity', 'Infinity', 'NaN'] as const;
+
+// `NaN`, `Infinity`, and `-Infinity` are numeric literals, not identifiers.
+// They must match before `scanIdent` (which would otherwise claim the
+// identifier-led words) and are word-bounded: a following identifier-part char
+// (so `Infinityx` / `NaNxyz`) keeps the run an `Ident` rather than a number.
+function scanKeywordNumber(source: string, pos: number): Token | undefined {
+  for (const word of KEYWORD_NUMBERS) {
+    if (!source.startsWith(word, pos)) continue;
+    const after = readChar(source, pos + word.length);
+    if (after !== '' && isIdentPart(after)) return undefined;
+    return { kind: 'NumberLiteral', text: word };
+  }
+  return undefined;
+}
+
 function scanNumber(source: string, pos: number): Token | undefined {
   let end = pos;
   if (source.charAt(end) === '-') {
@@ -195,6 +212,37 @@ function scanString(source: string, pos: number): Token | undefined {
   return { kind: 'StringLiteral', text: source.slice(pos, end) };
 }
 
+/**
+ * Whether a `StringLiteral` token's text is properly closed. `scanString` emits
+ * the same `StringLiteral` kind for both well-formed and unterminated strings —
+ * it stops at a newline or EOF when no closing quote is found — so callers that
+ * need to distinguish the two ask here.
+ *
+ * Because `scanString` stops at the *first* unescaped `"`, the only quote whose
+ * escaping can be in question is the **last character**: the text is terminated
+ * iff it opens with `"`, ends with `"`, and that closing `"` is not escaped.
+ * Under the `\\`-escapes-the-next-character rule, a `"` is unescaped iff an
+ * **even** number of backslashes immediately precede it — each `\\` pair cancels,
+ * and an odd run leaves the final `\` escaping the quote. So it suffices to
+ * count the trailing backslash run; no full re-scan is needed:
+ *
+ * - `"ok"`  → 0 backslashes (even) → closing quote stands → terminated
+ * - `"a\"`  → 1 backslash  (odd)   → the `"` is escaped     → unterminated
+ * - `"a\\"` → 2 backslashes (even) → escaped `\`, real `"`  → terminated
+ *
+ * A lone `"` (length 1) or a text with no closing `"` is unterminated.
+ */
+export function isTerminatedStringLiteral(text: string): boolean {
+  if (text.length < 2 || text.charAt(0) !== '"' || text.charAt(text.length - 1) !== '"') {
+    return false;
+  }
+  let backslashes = 0;
+  for (let i = text.length - 2; i >= 1 && text.charAt(i) === '\\'; i--) {
+    backslashes++;
+  }
+  return backslashes % 2 === 0;
+}
+
 function scanPunctuation(source: string, pos: number): Token | undefined {
   const kind = PUNCTUATION[source.charAt(pos)];
   if (kind === undefined) return undefined;

package/dist/tokenizer.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"tokenizer.mjs","names":["#source","#buffer","#pos","#scanNext"],"sources":["../src/tokenizer.ts"],"sourcesContent":["export type TokenKind =\n  | 'Ident'\n  | 'StringLiteral'\n  | 'NumberLiteral'\n  | 'At'\n  | 'DoubleAt'\n  | 'LBrace'\n  | 'RBrace'\n  | 'LParen'\n  | 'RParen'\n  | 'LBracket'\n  | 'RBracket'\n  | 'Equals'\n  | 'Question'\n  | 'Dot'\n  | 'Comma'\n  | 'Colon'\n  | 'Whitespace'\n  | 'Newline'\n  | 'Comment'\n  | 'Invalid'\n  | 'Eof';\n\nexport interface Token {\n  readonly kind: TokenKind;\n  readonly text: string;\n}\n\nexport class Tokenizer {\n  readonly #source: string;\n  #pos: number;\n  readonly #buffer: Token[];\n\n  constructor(source: string) {\n    this.#source = source;\n    this.#pos = 0;\n    this.#buffer = [];\n  }\n\n  next(): Token {\n    const next = this.#buffer.shift();\n    if (next) {\n      return next;\n    }\n    return this.#scanNext();\n  }\n\n  peek(offset = 0): Token {\n    if (offset > this.#buffer.length) {\n      const last = this.#buffer.at(-1);\n      if (last?.kind === 'Eof') {\n        return last;\n      }\n    }\n\n    const token = this.#buffer[offset];\n    if (token) {\n      return token;\n    }\n\n    while (this.#buffer.length <= offset) {\n      const token = this.#scanNext();\n      if (token.kind === 'Eof') {\n        return token;\n      }\n      this.#buffer.push(token);\n    }\n\n    return this.#buffer[offset] as Token;\n  }\n\n  #scanNext(): Token {\n    const token = scan(this.#source, this.#pos);\n    this.#pos += token.text.length;\n    return token;\n  }\n}\n\nfunction scan(source: string, pos: number): Token {\n  if (pos >= source.length) {\n    return { kind: 'Eof', text: '' };\n  }\n\n  return (\n    scanNewline(source, pos) ??\n    scanWhitespace(source, pos) ??\n    scanComment(source, pos) ??\n    scanAt(source, pos) ??\n    scanIdent(source, pos) ??\n    scanNumber(source, pos) ??\n    scanString(source, pos) ??\n    scanPunctuation(source, pos) ?? {\n      kind: 'Invalid' as const,\n      text: readChar(source, pos),\n    }\n  );\n}\n\nfunction scanNewline(source: string, pos: number): Token | undefined {\n  const ch = source.charAt(pos);\n  if (ch !== '\\r' && ch !== '\\n') return undefined;\n  if (ch === '\\r' && source.charAt(pos + 1) === '\\n') {\n    return { kind: 'Newline', text: '\\r\\n' };\n  }\n  return { kind: 'Newline', text: ch };\n}\n\nfunction scanWhitespace(source: string, pos: number): Token | undefined {\n  const ch = source.charAt(pos);\n  if (ch !== ' ' && ch !== '\\t') return undefined;\n  let end = pos + 1;\n  while (end < source.length) {\n    const c = source.charAt(end);\n    if (c !== ' ' && c !== '\\t') break;\n    end++;\n  }\n  return { kind: 'Whitespace', text: source.slice(pos, end) };\n}\n\nfunction scanComment(source: string, pos: number): Token | undefined {\n  if (source.charAt(pos) !== '/' || source.charAt(pos + 1) !== '/') return undefined;\n  let end = pos + 2;\n  while (end < source.length) {\n    const c = source.charAt(end);\n    if (c === '\\n' || c === '\\r') break;\n    end++;\n  }\n  return { kind: 'Comment', text: source.slice(pos, end) };\n}\n\nfunction scanAt(source: string, pos: number): Token | undefined {\n  if (source.charAt(pos) !== '@') return undefined;\n  if (source.charAt(pos + 1) === '@') {\n    return { kind: 'DoubleAt', text: '@@' };\n  }\n  return { kind: 'At', text: '@' };\n}\n\nfunction scanIdent(source: string, pos: number): Token | undefined {\n  const ch = readChar(source, pos);\n  if (!isIdentStart(ch)) return undefined;\n  let end = pos + ch.length;\n  while (end < source.length) {\n    const c = readChar(source, end);\n    if (isIdentPart(c)) {\n      end += c.length;\n    } else {\n      break;\n    }\n  }\n  return { kind: 'Ident', text: source.slice(pos, end) };\n}\n\nfunction scanNumber(source: string, pos: number): Token | undefined {\n  let end = pos;\n  if (source.charAt(end) === '-') {\n    if (end + 1 >= source.length || !isDigit(source.charAt(end + 1))) return undefined;\n    end++;\n  } else if (!isDigit(source.charAt(end))) {\n    return undefined;\n  }\n  end++;\n  while (end < source.length && isDigit(source.charAt(end))) {\n    end++;\n  }\n  if (source.charAt(end) === '.' && end + 1 < source.length && isDigit(source.charAt(end + 1))) {\n    end++; // consume the dot\n    while (end < source.length && isDigit(source.charAt(end))) {\n      end++;\n    }\n  }\n  return { kind: 'NumberLiteral', text: source.slice(pos, end) };\n}\n\nfunction scanString(source: string, pos: number): Token | undefined {\n  if (source.charAt(pos) !== '\"') return undefined;\n  let end = pos + 1;\n  while (end < source.length) {\n    const c = source.charAt(end);\n    if (c === '\\\\' && end + 1 < source.length) {\n      end += 2; // skip escape sequence\n      continue;\n    }\n    if (c === '\"') {\n      end++; // include closing quote\n      return { kind: 'StringLiteral', text: source.slice(pos, end) };\n    }\n    if (c === '\\n' || c === '\\r') {\n      // Unterminated: stop before newline\n      return { kind: 'StringLiteral', text: source.slice(pos, end) };\n    }\n    end++;\n  }\n  // Unterminated at EOF\n  return { kind: 'StringLiteral', text: source.slice(pos, end) };\n}\n\nfunction scanPunctuation(source: string, pos: number): Token | undefined {\n  const kind = PUNCTUATION[source.charAt(pos)];\n  if (kind === undefined) return undefined;\n  return { kind, text: source.charAt(pos) };\n}\n\nfunction readChar(source: string, pos: number): string {\n  const cp = source.codePointAt(pos);\n  return cp !== undefined ? String.fromCodePoint(cp) : '';\n}\n\nfunction isIdentStart(ch: string): boolean {\n  return /\\p{L}/u.test(ch) || ch === '_';\n}\n\nfunction isIdentPart(ch: string): boolean {\n  return isIdentStart(ch) || isDigit(ch) || ch === '-';\n}\n\nfunction isDigit(ch: string): boolean {\n  return ch >= '0' && ch <= '9';\n}\n\nconst PUNCTUATION: Record<string, TokenKind> = {\n  '{': 'LBrace',\n  '}': 'RBrace',\n  '(': 'LParen',\n  ')': 'RParen',\n  '[': 'LBracket',\n  ']': 'RBracket',\n  '=': 'Equals',\n  '?': 'Question',\n  '.': 'Dot',\n  ',': 'Comma',\n  ':': 'Colon',\n};\n"],"mappings":"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"}