@prisma-next/psl-parser 0.14.0-dev.5 → 0.14.0-dev.51

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');
   }