@prisma-next/psl-parser 0.13.0 → 0.14.0

package/src/parser.ts

@@ -14,9 +14,9 @@ import type {
   PslDiagnostic,
   PslDiagnosticCode,
   PslDocumentAst,
-  PslEnum,
-  PslEnumValue,
   PslExtensionBlock,
+  PslExtensionBlockAttribute,
+  PslExtensionBlockAttributeArg,
   PslExtensionBlockParamValue,
   PslField,
   PslFieldAttribute,
@@ -80,7 +80,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
   interface NamespaceAccumulator {
     name: string;
     models: PslModel[];
-    enums: PslEnum[];
     compositeTypes: PslCompositeType[];
     extensionBlocks: PslExtensionBlock[];
     span: PslSpan | undefined;
@@ -97,7 +96,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
       acc = {
         name,
         models: [],
-        enums: [],
         compositeTypes: [],
         extensionBlocks: [],
         span: spanIfNew,
@@ -145,21 +143,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
         continue;
       }
 
-      const enumMatch = line.match(/^enum\s+([A-Za-z_]\w*)\s*\{$/);
-      if (enumMatch) {
-        const bounds = findBlockBounds(context, lineIndex);
-        const name = enumMatch[1] ?? '';
-        if (name.length > 0) {
-          const acc = getOrCreateNamespace(
-            currentNamespaceName,
-            createTrimmedLineSpan(context, lineIndex),
-          );
-          acc.enums.push(parseEnumBlock(context, name, bounds));
-        }
-        lineIndex = bounds.endLine + 1;
-        continue;
-      }
-
       const compositeTypeMatch = line.match(/^type\s+([A-Za-z_]\w*)\s*\{$/);
       if (compositeTypeMatch) {
         const bounds = findBlockBounds(context, lineIndex);
@@ -266,15 +249,13 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
 
   // Named-type validation: types are document-scoped (one block, outside any
   // namespace), so collision checks compare named-type names against every
-  // model/enum/composite-type in every namespace.
+  // model/composite-type in every namespace.
   const allModels: PslModel[] = [];
-  const allEnums: PslEnum[] = [];
   const allCompositeTypes: PslCompositeType[] = [];
   for (const name of namespaceOrder) {
     const acc = namespacesByName.get(name);
     if (!acc) continue;
     allModels.push(...acc.models);
-    allEnums.push(...acc.enums);
     allCompositeTypes.push(...acc.compositeTypes);
   }
 
@@ -282,7 +263,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
     (typesBlock?.declarations ?? []).map((declaration) => declaration.name),
   );
   const modelNames = new Set(allModels.map((model) => model.name));
-  const enumNames = new Set(allEnums.map((enumBlock) => enumBlock.name));
   const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
   for (const declaration of typesBlock?.declarations ?? []) {
     if (SCALAR_TYPES.has(declaration.name)) {
@@ -299,14 +279,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
         message: `Named type "${declaration.name}" conflicts with model name "${declaration.name}"`,
         span: declaration.span,
       });
-      continue;
-    }
-    if (enumNames.has(declaration.name)) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_TYPES_MEMBER',
-        message: `Named type "${declaration.name}" conflicts with enum name "${declaration.name}"`,
-        span: declaration.span,
-      });
     }
   }
 
@@ -330,7 +302,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
     if (
       name === UNSPECIFIED_PSL_NAMESPACE_ID &&
       acc.models.length === 0 &&
-      acc.enums.length === 0 &&
       acc.compositeTypes.length === 0 &&
       acc.extensionBlocks.length === 0
     ) {
@@ -348,7 +319,6 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
         if (
           hasRelationAttribute ||
           modelNames.has(field.typeName) ||
-          enumNames.has(field.typeName) ||
           compositeTypeNames.has(field.typeName) ||
           SCALAR_TYPES.has(field.typeName)
         ) {
@@ -364,12 +334,7 @@ export function parsePslDocument(input: ParsePslDocumentInput): ParsePslDocument
       makePslNamespace({
         kind: 'namespace',
         name,
-        entries: makePslNamespaceEntries(
-          normalizedModels,
-          acc.enums,
-          acc.compositeTypes,
-          acc.extensionBlocks,
-        ),
+        entries: makePslNamespaceEntries(normalizedModels, acc.compositeTypes, acc.extensionBlocks),
         span: acc.span ?? documentSpan,
       }),
     );
@@ -502,89 +467,6 @@ function parseCompositeTypeBlock(
   };
 }
 
-function parseEnumBlock(context: ParserContext, name: string, bounds: BlockBounds): PslEnum {
-  const values: PslEnumValue[] = [];
-  const attributes: PslAttribute[] = [];
-
-  for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
-    const raw = context.lines[lineIndex] ?? '';
-    const line = stripInlineComment(raw).trim();
-    if (line.length === 0) {
-      continue;
-    }
-
-    if (line.startsWith('@@')) {
-      const attribute = parseEnumAttribute(context, line, lineIndex);
-      if (attribute) {
-        attributes.push(attribute);
-      }
-      continue;
-    }
-
-    // An enum member line is the bare member identifier, optionally followed
-    // by a `@map("storage-label")` attribute. The map attribute lets the
-    // printer round-trip enum values whose original storage label is not a
-    // valid PSL identifier (e.g. PostgreSQL enum labels with hyphens).
-    const valueMatch = line.match(/^([A-Za-z_]\w*)(?:\s+@map\(\s*"((?:[^"\\]|\\.)*)"\s*\))?$/);
-    if (!valueMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_ENUM_MEMBER',
-        message: `Invalid enum value declaration "${line}"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
-      continue;
-    }
-
-    const mapName = valueMatch[2] !== undefined ? unescapePslString(valueMatch[2]) : undefined;
-
-    values.push({
-      kind: 'enumValue',
-      name: valueMatch[1] ?? '',
-      ...(mapName !== undefined ? { mapName } : {}),
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-  }
-
-  return {
-    kind: 'enum',
-    name,
-    values,
-    attributes,
-    span: createLineRangeSpan(context, bounds.startLine, bounds.endLine),
-  };
-}
-
-/**
- * Decode PSL escape sequences (`\\`, `\"`, `\'`, `\n`, `\r`) inside a
- * quoted-literal body. The argument is the body of the literal with the
- * surrounding quotes already stripped by the caller. Mirrors the inverse
- * helper in `@prisma-next/psl-printer`'s `escapePslString` so a string
- * round-trips parser → printer → parser unchanged.
- */
-function unescapePslString(value: string): string {
-  let result = '';
-  for (let i = 0; i < value.length; i++) {
-    const ch = value.charCodeAt(i);
-    if (ch !== 0x5c /* '\\' */ || i + 1 >= value.length) {
-      result += value[i];
-      continue;
-    }
-    const next = value[i + 1];
-    if (next === '\\' || next === '"' || next === "'") {
-      result += next;
-    } else if (next === 'n') {
-      result += '\n';
-    } else if (next === 'r') {
-      result += '\r';
-    } else {
-      result += '\\';
-      result += next;
-    }
-    i++;
-  }
-  return result;
-}
-
 function parseTypesBlock(context: ParserContext, bounds: BlockBounds): PslTypesBlock {
   const declarations: PslNamedTypeDeclaration[] = [];
 
@@ -792,50 +674,6 @@ function parseModelAttribute(
   });
 }
 
-function parseEnumAttribute(
-  context: ParserContext,
-  line: string,
-  lineIndex: number,
-): PslAttribute | undefined {
-  const rawLine = context.lines[lineIndex] ?? '';
-  const tokenParse = extractAttributeTokensWithSpans(
-    context,
-    lineIndex,
-    line,
-    firstNonWhitespaceColumn(rawLine),
-  );
-  if (!tokenParse.ok || tokenParse.tokens.length !== 1) {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ENUM_MEMBER',
-      message: `Invalid enum value declaration "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-  const token = tokenParse.tokens[0];
-  if (!token) {
-    return undefined;
-  }
-  const parsed = parseAttributeToken(context, {
-    token: token.text,
-    target: 'enum',
-    lineIndex,
-    span: token.span,
-  });
-  if (!parsed) {
-    return undefined;
-  }
-  if (parsed.name !== 'map') {
-    pushDiagnostic(context, {
-      code: 'PSL_INVALID_ENUM_MEMBER',
-      message: `Invalid enum value declaration "${line}"`,
-      span: createTrimmedLineSpan(context, lineIndex),
-    });
-    return undefined;
-  }
-  return parsed;
-}
-
 function parseField(context: ParserContext, line: string, lineIndex: number): PslField | undefined {
   const fieldMatch = line.match(/^([A-Za-z_]\w*)(\s+)(.+)$/);
   if (!fieldMatch) {
@@ -1592,18 +1430,15 @@ function lookupExtensionBlockDescriptor(
 
 /**
  * Reads an extension block body generically, driven by the descriptor's
- * `parameters` map. Each `key = <rhs>` line in the body is matched against
- * a declared parameter and the RHS is captured per the parameter's kind:
+ * `parameters` map. Each body line is one of:
  *
- * - `ref`    → the bareword identifier token (`PslExtensionBlockParamRef`)
- * - `value`  → the raw RHS text verbatim (`PslExtensionBlockParamScalarValue`)
- * - `option` → the chosen bareword token (`PslExtensionBlockParamOption`)
- * - `list`   → bracketed `[a, b, …]` list, each element captured per `of`
- *   (`PslExtensionBlockParamList`)
+ * - `@@name(args…)` — a block attribute, captured in `blockAttributes`
+ * - `key = <rhs>` — a parameter entry, captured in `parameters` per descriptor
+ * - `key` — a bare-identifier entry (no `= value`), captured as `kind:'bare'`
  *
- * No validation runs here (unknown key, missing required, codec acceptance,
- * option-in-set, ref resolution). A body line that is not `key = value`
- * shaped emits a `PSL_INVALID_EXTENSION_BLOCK_MEMBER` parse diagnostic.
+ * Duplicate parameter keys emit `PSL_EXTENSION_DUPLICATE_PARAMETER`; the first
+ * occurrence wins. `@@` attribute lines are not validated here (name or args);
+ * that is a concern of the consuming interpreter.
  */
 function parseExtensionBlock(
   context: ParserContext,
@@ -1613,6 +1448,7 @@ function parseExtensionBlock(
   bounds: BlockBounds,
 ): PslExtensionBlock {
   const parameters: Record<string, PslExtensionBlockParamValue> = {};
+  const blockAttributes: PslExtensionBlockAttribute[] = [];
 
   for (let lineIndex = bounds.startLine + 1; lineIndex < bounds.endLine; lineIndex += 1) {
     const raw = context.lines[lineIndex] ?? '';
@@ -1621,44 +1457,137 @@ function parseExtensionBlock(
       continue;
     }
 
-    const assignMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
-    if (!assignMatch) {
-      pushDiagnostic(context, {
-        code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
-        message: `Invalid extension block body line "${line}"; expected "key = value"`,
-        span: createTrimmedLineSpan(context, lineIndex),
-      });
+    if (line.startsWith('@@')) {
+      const attr = parseExtensionBlockAttribute(context, line, lineIndex);
+      if (attr !== undefined) {
+        blockAttributes.push(attr);
+      }
       continue;
     }
 
-    const key = assignMatch[1] ?? '';
-    const rhsRaw = (assignMatch[2] ?? '').trim();
-    const paramDescriptor = descriptor.parameters[key];
+    const assignMatch = line.match(/^([A-Za-z_]\w*)\s*=\s*(.+)$/);
+    if (assignMatch) {
+      const key = assignMatch[1] ?? '';
+      const rhsRaw = (assignMatch[2] ?? '').trim();
 
-    if (paramDescriptor === undefined) {
-      // Unknown parameter — captured as a raw value; the generic validator reports this.
-      parameters[key] = {
-        kind: 'value',
-        raw: rhsRaw,
-        span: createTrimmedLineSpan(context, lineIndex),
-      };
+      if (Object.hasOwn(parameters, key)) {
+        pushDiagnostic(context, {
+          code: 'PSL_EXTENSION_DUPLICATE_PARAMETER',
+          message: `Duplicate parameter "${key}" in "${descriptor.keyword}" block "${blockName}"; first occurrence wins`,
+          span: createTrimmedLineSpan(context, lineIndex),
+        });
+        continue;
+      }
+
+      const paramDescriptor = descriptor.parameters[key];
+      if (paramDescriptor === undefined) {
+        parameters[key] = {
+          kind: 'value',
+          raw: rhsRaw,
+          span: createTrimmedLineSpan(context, lineIndex),
+        };
+      } else {
+        const captured = captureParamRhs(context, lineIndex, rhsRaw, paramDescriptor);
+        if (captured !== undefined) {
+          parameters[key] = captured;
+        }
+      }
       continue;
     }
 
-    const captured = captureParamRhs(context, lineIndex, rhsRaw, paramDescriptor);
-    if (captured !== undefined) {
-      parameters[key] = captured;
+    const bareMatch = line.match(/^([A-Za-z_]\w*)$/);
+    if (bareMatch) {
+      const key = bareMatch[1] ?? '';
+
+      if (!descriptor.variadicParameters) {
+        pushDiagnostic(context, {
+          code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
+          message: `Invalid extension block body line "${line}"; expected "key = value" or "@@attribute"`,
+          span: createTrimmedLineSpan(context, lineIndex),
+        });
+        continue;
+      }
+
+      if (Object.hasOwn(descriptor.parameters, key)) {
+        pushDiagnostic(context, {
+          code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
+          message: `Parameter "${key}" in "${descriptor.keyword}" block "${blockName}" is declared in the descriptor and must be supplied as "${key} = value"`,
+          span: createTrimmedLineSpan(context, lineIndex),
+        });
+        continue;
+      }
+
+      if (Object.hasOwn(parameters, key)) {
+        pushDiagnostic(context, {
+          code: 'PSL_EXTENSION_DUPLICATE_PARAMETER',
+          message: `Duplicate parameter "${key}" in "${descriptor.keyword}" block "${blockName}"; first occurrence wins`,
+          span: createTrimmedLineSpan(context, lineIndex),
+        });
+        continue;
+      }
+
+      parameters[key] = { kind: 'bare', span: createTrimmedLineSpan(context, lineIndex) };
+      continue;
     }
+
+    pushDiagnostic(context, {
+      code: 'PSL_INVALID_EXTENSION_BLOCK_MEMBER',
+      message: `Invalid extension block body line "${line}"; expected "key = value", "key", or "@@attribute"`,
+      span: createTrimmedLineSpan(context, lineIndex),
+    });
   }
 
   return {
     kind: descriptor.discriminator,
     name: blockName,
     parameters,
+    blockAttributes,
     span: createLineRangeSpan(context, keywordLineIndex, bounds.endLine),
   };
 }
 
+/**
+ * Parses a `@@name(args…)` block-attribute line inside an extension block
+ * using the shared block-attribute tokeniser (`extractAttributeTokensWithSpans`
+ * + `parseAttributeToken`).  Returns undefined (and emits a diagnostic) on
+ * malformed syntax.
+ */
+function parseExtensionBlockAttribute(
+  context: ParserContext,
+  line: string,
+  lineIndex: number,
+): PslExtensionBlockAttribute | undefined {
+  const rawLine = context.lines[lineIndex] ?? '';
+  const startCol = firstNonWhitespaceColumn(rawLine);
+
+  const tokenParse = extractAttributeTokensWithSpans(context, lineIndex, line, startCol);
+  if (!tokenParse.ok || tokenParse.tokens.length !== 1) {
+    pushDiagnostic(context, {
+      code: 'PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE',
+      message: `Invalid extension block attribute "${line}"`,
+      span: createTrimmedLineSpan(context, lineIndex),
+    });
+    return undefined;
+  }
+  const token = tokenParse.tokens[0];
+  if (!token) {
+    return undefined;
+  }
+  const parsed = parseAttributeToken(context, {
+    token: token.text,
+    target: 'model',
+    lineIndex,
+    span: token.span,
+  });
+  if (!parsed) {
+    return undefined;
+  }
+  const args: PslExtensionBlockAttributeArg[] = parsed.args
+    .filter((a): a is PslAttributeArgument & { kind: 'positional' } => a.kind === 'positional')
+    .map((a) => ({ kind: 'positional' as const, value: a.value, span: a.span }));
+  return { name: parsed.name, args, span: parsed.span };
+}
+
 /**
  * Captures a single parameter RHS string according to the declared parameter
  * kind. Returns `undefined` and pushes a diagnostic only if the syntax is

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/attributes.ts

@@ -3,7 +3,7 @@ import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
 import type { SyntaxNode } from '../red';
 import { AttributeArgAst } from './expressions';
-import { IdentifierAst } from './identifier';
+import { QualifiedNameAst } from './qualified-name';
 
 export class AttributeArgListAst implements AstNode {
   readonly syntax: SyntaxNode;
@@ -40,27 +40,8 @@ export class FieldAttributeAst implements AstNode {
     return findChildToken(this.syntax, 'At');
   }
 
-  name(): IdentifierAst | undefined {
-    if (this.dot()) {
-      let count = 0;
-      for (const child of this.syntax.childNodes()) {
-        if (child.kind === 'Identifier') {
-          count++;
-          if (count === 2) return new IdentifierAst(child);
-        }
-      }
-      return undefined;
-    }
-    return findFirstChild(this.syntax, IdentifierAst.cast);
-  }
-
-  dot(): Token | undefined {
-    return findChildToken(this.syntax, 'Dot');
-  }
-
-  namespaceName(): IdentifierAst | undefined {
-    if (!this.dot()) return undefined;
-    return findFirstChild(this.syntax, IdentifierAst.cast);
+  name(): QualifiedNameAst | undefined {
+    return findFirstChild(this.syntax, QualifiedNameAst.cast);
   }
 
   argList(): AttributeArgListAst | undefined {
@@ -83,8 +64,8 @@ export class ModelAttributeAst implements AstNode {
     return findChildToken(this.syntax, 'DoubleAt');
   }
 
-  name(): IdentifierAst | undefined {
-    return findFirstChild(this.syntax, IdentifierAst.cast);
+  name(): QualifiedNameAst | undefined {
+    return findFirstChild(this.syntax, QualifiedNameAst.cast);
   }
 
   argList(): AttributeArgListAst | undefined {