@prisma-next/psl-parser 0.14.0-dev.4 → 0.14.0-dev.40

package/src/resolve.ts

@@ -0,0 +1,123 @@
+import type { PslSpan } from '@prisma-next/framework-components/psl-ast';
+import type { Position, Range, SourceFile } from './source-file';
+import type {
+  AttributeArgListAst,
+  FieldAttributeAst,
+  ModelAttributeAst,
+} from './syntax/ast/attributes';
+import type { ExpressionAst } from './syntax/ast/expressions';
+import type { QualifiedNameAst } from './syntax/ast/qualified-name';
+import type { TypeAnnotationAst } from './syntax/ast/type-annotation';
+import { printSyntax } from './syntax/ast-helpers';
+import type { SyntaxNode } from './syntax/red';
+
+export interface ResolvedAttributeArg {
+  readonly kind: 'positional' | 'named';
+  readonly name?: string;
+  readonly value: string;
+  readonly expression?: ExpressionAst;
+  readonly span: PslSpan;
+}
+
+export interface ResolvedAttribute {
+  readonly name: string;
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+
+export interface ResolvedTypeConstructorCall {
+  readonly path: readonly string[];
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+
+export function readResolvedAttribute(
+  attribute: FieldAttributeAst | ModelAttributeAst,
+  sourceFile: SourceFile,
+): ResolvedAttribute {
+  return {
+    name: attributeName(attribute.name()),
+    args: readResolvedArgList(attribute.argList(), sourceFile),
+    span: nodePslSpan(attribute.syntax, sourceFile),
+  };
+}
+
+export function readResolvedAttributes(
+  attributes: Iterable<FieldAttributeAst | ModelAttributeAst>,
+  sourceFile: SourceFile,
+): readonly ResolvedAttribute[] {
+  return Array.from(attributes, (attribute) => readResolvedAttribute(attribute, sourceFile));
+}
+
+export function readResolvedConstructorCall(
+  annotation: TypeAnnotationAst | undefined,
+  sourceFile: SourceFile,
+): ResolvedTypeConstructorCall | undefined {
+  const argList = annotation?.argList();
+  if (annotation === undefined || argList === undefined) return undefined;
+  return {
+    path: annotation.name()?.path() ?? [],
+    args: readResolvedArgList(argList, sourceFile),
+    span: nodePslSpan(annotation.syntax, sourceFile),
+  };
+}
+
+function readResolvedArgList(
+  argList: AttributeArgListAst | undefined,
+  sourceFile: SourceFile,
+): readonly ResolvedAttributeArg[] {
+  if (argList === undefined) return [];
+  const args: ResolvedAttributeArg[] = [];
+  for (const arg of argList.args()) {
+    const name = arg.name()?.name();
+    const expression = arg.value();
+    args.push({
+      kind: name !== undefined ? 'named' : 'positional',
+      ...(name !== undefined ? { name } : {}),
+      value: renderExpression(expression),
+      ...(expression !== undefined ? { expression } : {}),
+      span: nodePslSpan(arg.syntax, sourceFile),
+    });
+  }
+  return args;
+}
+
+function attributeName(name: QualifiedNameAst | undefined): string {
+  return name?.path().join('.') ?? '';
+}
+
+function renderExpression(expression: ExpressionAst | undefined): string {
+  if (expression === undefined) return '';
+  return printSyntax(expression.syntax).trim();
+}
+
+export function nodePslSpan(node: SyntaxNode, sourceFile: SourceFile): PslSpan {
+  const start = node.offset;
+  const end = start + node.green.textLength;
+  return {
+    start: offsetToPslPosition(start, sourceFile),
+    end: offsetToPslPosition(end, sourceFile),
+  };
+}
+
+/** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
+export function keywordPslSpan(node: SyntaxNode, keyword: string, sourceFile: SourceFile): PslSpan {
+  const start = node.offset;
+  const end = start + keyword.length;
+  return {
+    start: offsetToPslPosition(start, sourceFile),
+    end: offsetToPslPosition(end, sourceFile),
+  };
+}
+
+export function rangeToPslSpan(range: Range, sourceFile: SourceFile): PslSpan {
+  return {
+    start: offsetToPslPosition(sourceFile.offsetAt(range.start), sourceFile),
+    end: offsetToPslPosition(sourceFile.offsetAt(range.end), sourceFile),
+  };
+}
+
+function offsetToPslPosition(offset: number, sourceFile: SourceFile): PslSpan['start'] {
+  const position: Position = sourceFile.positionAt(offset);
+  return { offset, line: position.line + 1, column: position.character + 1 };
+}

package/src/source-file.ts

@@ -1,3 +1,4 @@
+const CARRIAGE_RETURN = 13;
 const LINE_FEED = 10;
 
 export interface Position {
@@ -41,6 +42,30 @@ export class SourceFile {
     return this.#lineStarts;
   }
 
+  lineStartOffset(line: number): number {
+    if (line <= 0) {
+      return 0;
+    }
+    return this.#lineStarts[line] ?? this.#text.length;
+  }
+
+  lineEndOffset(line: number): number {
+    if (line < 0) {
+      return 0;
+    }
+
+    const nextLineStart = this.#lineStarts[line + 1];
+    if (nextLineStart === undefined) {
+      return this.#text.length;
+    }
+
+    const lineFeedOffset = nextLineStart - 1;
+    const carriageReturnOffset = lineFeedOffset - 1;
+    return this.#text.charCodeAt(carriageReturnOffset) === CARRIAGE_RETURN
+      ? carriageReturnOffset
+      : lineFeedOffset;
+  }
+
   positionAt(offset: number): Position {
     const clamped = clamp(offset, 0, this.#text.length);
     const line = this.#lineIndexAt(clamped);

package/src/symbol-table.ts

@@ -0,0 +1,446 @@
+import type { AuthoringPslBlockDescriptorNamespace } from '@prisma-next/framework-components/authoring';
+import type { PslExtensionBlock, PslSpan } from '@prisma-next/framework-components/psl-ast';
+import { reconstructExtensionBlock } from './block-reconstruction';
+import { findBlockDescriptor } from './extension-block';
+import type { ParseDiagnostic } from './parse';
+import {
+  nodePslSpan,
+  type ResolvedAttribute,
+  type ResolvedTypeConstructorCall,
+  readResolvedAttributes,
+  readResolvedConstructorCall,
+} from './resolve';
+import type { Range, SourceFile } from './source-file';
+import {
+  CompositeTypeDeclarationAst,
+  type DocumentAst,
+  type FieldDeclarationAst,
+  GenericBlockDeclarationAst,
+  ModelDeclarationAst,
+  type NamedTypeDeclarationAst,
+  NamespaceDeclarationAst,
+  TypesBlockAst,
+} from './syntax/ast/declarations';
+import type { IdentifierAst } from './syntax/ast/identifier';
+import type { SyntaxNode } from './syntax/red';
+
+export type {
+  ResolvedAttribute,
+  ResolvedAttributeArg,
+  ResolvedTypeConstructorCall,
+} from './resolve';
+
+export interface SymbolTable {
+  readonly topLevel: TopLevelScope;
+}
+
+export interface TopLevelScope {
+  readonly namespaces: Record<string, NamespaceSymbol>;
+  readonly scalars: Record<string, ScalarSymbol>;
+  readonly typeAliases: Record<string, TypeAliasSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+}
+
+export interface NamespaceSymbol {
+  readonly kind: 'namespace';
+  readonly name: string;
+  readonly node: NamespaceDeclarationAst;
+  readonly span: PslSpan;
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+}
+
+export interface ModelSymbol {
+  readonly kind: 'model';
+  readonly name: string;
+  readonly node: ModelDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+
+export interface CompositeTypeSymbol {
+  readonly kind: 'compositeType';
+  readonly name: string;
+  readonly node: CompositeTypeDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+
+export interface BlockSymbol {
+  readonly kind: 'block';
+  readonly name: string;
+  readonly keyword: string;
+  readonly node: GenericBlockDeclarationAst;
+  readonly span: PslSpan;
+  /** Resolved once so consumers do not independently classify block parameters. */
+  readonly block: PslExtensionBlock;
+}
+
+export interface ResolvedNamedTypeBinding {
+  readonly baseType?: string;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly isConstructor: boolean;
+  readonly attributes: readonly ResolvedAttribute[];
+}
+
+export interface ScalarSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'scalar';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+
+export interface TypeAliasSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'typeAlias';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+
+export interface FieldSymbol {
+  readonly kind: 'field';
+  readonly name: string;
+  readonly node: FieldDeclarationAst;
+  readonly span: PslSpan;
+  readonly typeName: string;
+  readonly typeNamespaceId?: string;
+  readonly typeContractSpaceId?: string;
+  readonly optional: boolean;
+  readonly list: boolean;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly attributes: readonly ResolvedAttribute[];
+  /** Prevents cascading unsupported-type diagnostics after invalid qualification. */
+  readonly malformedType?: boolean;
+}
+
+export interface BuildSymbolTableOptions {
+  readonly document: DocumentAst;
+  readonly sourceFile: SourceFile;
+  readonly scalarTypes: readonly string[];
+  readonly pslBlockDescriptors: AuthoringPslBlockDescriptorNamespace;
+}
+
+export interface SymbolTableResult {
+  readonly table: SymbolTable;
+  readonly diagnostics: readonly ParseDiagnostic[];
+}
+
+/**
+ * Owns duplicate-declaration detection for all PSL scopes; downstream consumers
+ * should consume first-wins symbols rather than re-emitting duplicate diagnostics.
+ */
+export function buildSymbolTable(options: BuildSymbolTableOptions): SymbolTableResult {
+  const { document, sourceFile, scalarTypes, pslBlockDescriptors } = options;
+  const diagnostics: ParseDiagnostic[] = [];
+  const scalarSet = new Set(scalarTypes);
+
+  const namespaces: Record<string, NamespaceSymbol> = {};
+  const scalars: Record<string, ScalarSymbol> = {};
+  const typeAliases: Record<string, TypeAliasSymbol> = {};
+  const blocks: Record<string, BlockSymbol> = {};
+  const models: Record<string, ModelSymbol> = {};
+  const compositeTypes: Record<string, CompositeTypeSymbol> = {};
+  const topLevelNames = new Set<string>();
+
+  const claim = (taken: Set<string>, name: IdentifierAst | undefined): string | undefined => {
+    const text = name?.name();
+    if (text === undefined) return undefined;
+    if (taken.has(text)) {
+      const range = nameRange(name, sourceFile);
+      if (range) {
+        diagnostics.push({
+          code: 'PSL_DUPLICATE_DECLARATION',
+          message: `Duplicate declaration of "${text}"`,
+          range,
+        });
+      }
+      return undefined;
+    }
+    taken.add(text);
+    return text;
+  };
+
+  for (const declaration of document.declarations()) {
+    if (declaration instanceof ModelDeclarationAst) {
+      const name = claim(topLevelNames, declaration.name());
+      if (name !== undefined) models[name] = buildModel(name, declaration, sourceFile, diagnostics);
+    } else if (declaration instanceof CompositeTypeDeclarationAst) {
+      const name = claim(topLevelNames, declaration.name());
+      if (name !== undefined) {
+        compositeTypes[name] = buildCompositeType(name, declaration, sourceFile, diagnostics);
+      }
+    } else if (declaration instanceof GenericBlockDeclarationAst) {
+      const name = claim(topLevelNames, declaration.name());
+      if (name !== undefined) {
+        blocks[name] = buildBlock(name, declaration, sourceFile, pslBlockDescriptors, diagnostics);
+      }
+    } else if (declaration instanceof NamespaceDeclarationAst) {
+      const name = claim(topLevelNames, declaration.name());
+      if (name !== undefined) {
+        namespaces[name] = buildNamespace(
+          name,
+          declaration,
+          diagnostics,
+          sourceFile,
+          pslBlockDescriptors,
+        );
+      }
+    } else if (declaration instanceof TypesBlockAst) {
+      for (const binding of declaration.declarations()) {
+        const name = claim(topLevelNames, binding.name());
+        if (name === undefined) continue;
+        const resolved = resolveNamedTypeBinding(binding, sourceFile);
+        const span = nodePslSpan(binding.syntax, sourceFile);
+        if (isScalarBinding(binding, scalarSet)) {
+          scalars[name] = { kind: 'scalar', name, node: binding, span, ...resolved };
+        } else {
+          typeAliases[name] = { kind: 'typeAlias', name, node: binding, span, ...resolved };
+        }
+      }
+    }
+  }
+
+  const table: SymbolTable = {
+    topLevel: { namespaces, scalars, typeAliases, blocks, models, compositeTypes },
+  };
+  return { table, diagnostics };
+}
+
+function buildModel(
+  name: string,
+  node: ModelDeclarationAst,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): ModelSymbol {
+  return {
+    kind: 'model',
+    name,
+    node,
+    span: nodePslSpan(node.syntax, sourceFile),
+    fields: buildFields(name, node.fields(), sourceFile, diagnostics),
+    attributes: readResolvedAttributes(node.attributes(), sourceFile),
+  };
+}
+
+function buildCompositeType(
+  name: string,
+  node: CompositeTypeDeclarationAst,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): CompositeTypeSymbol {
+  return {
+    kind: 'compositeType',
+    name,
+    node,
+    span: nodePslSpan(node.syntax, sourceFile),
+    fields: buildFields(name, node.fields(), sourceFile, diagnostics),
+    attributes: readResolvedAttributes(node.attributes(), sourceFile),
+  };
+}
+
+function buildBlock(
+  name: string,
+  node: GenericBlockDeclarationAst,
+  sourceFile: SourceFile,
+  pslBlockDescriptors: AuthoringPslBlockDescriptorNamespace,
+  diagnostics: ParseDiagnostic[],
+): BlockSymbol {
+  const keyword = node.keyword()?.text ?? '';
+  const descriptor = findBlockDescriptor(pslBlockDescriptors, keyword);
+  return {
+    kind: 'block',
+    name,
+    keyword,
+    node,
+    span: nodePslSpan(node.syntax, sourceFile),
+    block: reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics),
+  };
+}
+
+function buildNamespace(
+  name: string,
+  node: NamespaceDeclarationAst,
+  diagnostics: ParseDiagnostic[],
+  sourceFile: SourceFile,
+  pslBlockDescriptors: AuthoringPslBlockDescriptorNamespace,
+): NamespaceSymbol {
+  const models: Record<string, ModelSymbol> = {};
+  const compositeTypes: Record<string, CompositeTypeSymbol> = {};
+  const blocks: Record<string, BlockSymbol> = {};
+  const taken = new Set<string>();
+
+  for (const member of node.declarations()) {
+    const memberName = member.name()?.name();
+    if (memberName === undefined) continue;
+    if (taken.has(memberName)) {
+      const range = nameRange(member.name(), sourceFile);
+      if (range) {
+        diagnostics.push({
+          code: 'PSL_DUPLICATE_DECLARATION',
+          message: `Duplicate declaration of "${memberName}"`,
+          range,
+        });
+      }
+      continue;
+    }
+    taken.add(memberName);
+    if (member instanceof ModelDeclarationAst) {
+      models[memberName] = buildModel(memberName, member, sourceFile, diagnostics);
+    } else if (member instanceof CompositeTypeDeclarationAst) {
+      compositeTypes[memberName] = buildCompositeType(memberName, member, sourceFile, diagnostics);
+    } else if (member instanceof GenericBlockDeclarationAst) {
+      blocks[memberName] = buildBlock(
+        memberName,
+        member,
+        sourceFile,
+        pslBlockDescriptors,
+        diagnostics,
+      );
+    }
+  }
+
+  return {
+    kind: 'namespace',
+    name,
+    node,
+    span: nodePslSpan(node.syntax, sourceFile),
+    models,
+    compositeTypes,
+    blocks,
+  };
+}
+
+function buildFields(
+  ownerName: string,
+  fields: Iterable<FieldDeclarationAst>,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): Record<string, FieldSymbol> {
+  const result: Record<string, FieldSymbol> = {};
+  for (const field of fields) {
+    const nameNode = field.name();
+    const name = nameNode?.name();
+    if (name === undefined) continue;
+    if (Object.hasOwn(result, name)) {
+      const range = nameRange(nameNode, sourceFile);
+      if (range) {
+        diagnostics.push({
+          code: 'PSL_DUPLICATE_DECLARATION',
+          message: `Duplicate declaration of "${name}"`,
+          range,
+        });
+      }
+      continue;
+    }
+    result[name] = buildField(ownerName, name, field, sourceFile, diagnostics);
+  }
+  return result;
+}
+
+function buildField(
+  ownerName: string,
+  name: string,
+  node: FieldDeclarationAst,
+  sourceFile: SourceFile,
+  diagnostics: ParseDiagnostic[],
+): FieldSymbol {
+  const attributes = readResolvedAttributes(node.attributes(), sourceFile);
+  const span = nodePslSpan(node.syntax, sourceFile);
+  const annotation = node.typeAnnotation();
+  const typeName = annotation?.name();
+
+  if (typeName?.isOverQualified()) {
+    const path = typeName.path();
+    diagnostics.push({
+      code: 'PSL_INVALID_QUALIFIED_TYPE',
+      message: `Field "${ownerName}.${name}" has an invalid qualified type "${path.join('.')}"; use at most one namespace qualifier (e.g. "ns.TypeName")`,
+      range: nodeRange(typeName.syntax, sourceFile),
+    });
+    return {
+      kind: 'field',
+      name,
+      node,
+      span,
+      typeName: path[path.length - 1] ?? '',
+      optional: false,
+      list: false,
+      malformedType: true,
+      attributes,
+    };
+  }
+
+  const typeConstructor = annotation?.isConstructor()
+    ? readResolvedConstructorCall(annotation, sourceFile)
+    : undefined;
+  const typeNamespaceId = typeName?.namespace()?.name();
+  const typeContractSpaceId = typeName?.space()?.name();
+
+  return {
+    kind: 'field',
+    name,
+    node,
+    span,
+    typeName: typeName?.identifier()?.name() ?? '',
+    ...(typeNamespaceId !== undefined ? { typeNamespaceId } : {}),
+    ...(typeContractSpaceId !== undefined ? { typeContractSpaceId } : {}),
+    optional: annotation?.isOptional() ?? false,
+    list: annotation?.isList() ?? false,
+    ...(typeConstructor !== undefined ? { typeConstructor } : {}),
+    attributes,
+  };
+}
+
+function resolveNamedTypeBinding(
+  node: NamedTypeDeclarationAst,
+  sourceFile: SourceFile,
+): {
+  baseType?: string;
+  typeConstructor?: ResolvedTypeConstructorCall;
+  isConstructor: boolean;
+  attributes: readonly ResolvedAttribute[];
+} {
+  const annotation = node.typeAnnotation();
+  const isConstructor = annotation?.isConstructor() ?? false;
+  const baseType = annotation?.name()?.identifier()?.name();
+  const typeConstructor = readResolvedConstructorCall(annotation, sourceFile);
+  return {
+    isConstructor,
+    ...(!isConstructor && baseType !== undefined ? { baseType } : {}),
+    ...(typeConstructor !== undefined ? { typeConstructor } : {}),
+    attributes: readResolvedAttributes(node.attributes(), sourceFile),
+  };
+}
+
+function isScalarBinding(node: NamedTypeDeclarationAst, scalarTypes: Set<string>): boolean {
+  const annotation = node.typeAnnotation();
+  if (annotation === undefined || annotation.isConstructor()) return false;
+  const base = annotation.name()?.identifier()?.name();
+  return base !== undefined && scalarTypes.has(base);
+}
+
+function nameRange(name: IdentifierAst | undefined, sourceFile: SourceFile): Range | undefined {
+  if (name === undefined) return undefined;
+  for (const token of name.syntax.tokens()) {
+    if (token.kind === 'Ident') {
+      return {
+        start: sourceFile.positionAt(token.offset),
+        end: sourceFile.positionAt(token.offset + token.text.length),
+      };
+    }
+  }
+  return undefined;
+}
+
+function nodeRange(node: SyntaxNode, sourceFile: SourceFile): Range {
+  const start = node.offset;
+  const end = start + node.green.textLength;
+  return {
+    start: sourceFile.positionAt(start),
+    end: sourceFile.positionAt(end),
+  };
+}

package/src/syntax/ast/attributes.ts

@@ -1,7 +1,6 @@
-import type { Token } from '../../tokenizer';
 import type { AstNode } from '../ast-helpers';
 import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
-import type { SyntaxNode } from '../red';
+import type { SyntaxNode, SyntaxToken } from '../red';
 import { AttributeArgAst } from './expressions';
 import { QualifiedNameAst } from './qualified-name';
 
@@ -12,11 +11,11 @@ export class AttributeArgListAst implements AstNode {
     this.syntax = syntax;
   }
 
-  lparen(): Token | undefined {
+  lparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'LParen');
   }
 
-  rparen(): Token | undefined {
+  rparen(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'RParen');
   }
 
@@ -36,7 +35,7 @@ export class FieldAttributeAst implements AstNode {
     this.syntax = syntax;
   }
 
-  at(): Token | undefined {
+  at(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'At');
   }
 
@@ -60,7 +59,7 @@ export class ModelAttributeAst implements AstNode {
     this.syntax = syntax;
   }
 
-  doubleAt(): Token | undefined {
+  doubleAt(): SyntaxToken | undefined {
     return findChildToken(this.syntax, 'DoubleAt');
   }