@prisma-next/psl-parser 0.12.0-dev.9 → 0.13.0-dev.1

package/src/syntax/ast/attributes.ts

@@ -0,0 +1,97 @@
+import type { Token } from '../../tokenizer';
+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';
+
+export class AttributeArgListAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  lparen(): Token | undefined {
+    return findChildToken(this.syntax, 'LParen');
+  }
+
+  rparen(): Token | undefined {
+    return findChildToken(this.syntax, 'RParen');
+  }
+
+  *args(): Iterable<AttributeArgAst> {
+    yield* filterChildren(this.syntax, AttributeArgAst.cast);
+  }
+
+  static cast(node: SyntaxNode): AttributeArgListAst | undefined {
+    return node.kind === 'AttributeArgList' ? new AttributeArgListAst(node) : undefined;
+  }
+}
+
+export class FieldAttributeAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  at(): Token | undefined {
+    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);
+  }
+
+  argList(): AttributeArgListAst | undefined {
+    return findFirstChild(this.syntax, AttributeArgListAst.cast);
+  }
+
+  static cast(node: SyntaxNode): FieldAttributeAst | undefined {
+    return node.kind === 'FieldAttribute' ? new FieldAttributeAst(node) : undefined;
+  }
+}
+
+export class ModelAttributeAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  doubleAt(): Token | undefined {
+    return findChildToken(this.syntax, 'DoubleAt');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  argList(): AttributeArgListAst | undefined {
+    return findFirstChild(this.syntax, AttributeArgListAst.cast);
+  }
+
+  static cast(node: SyntaxNode): ModelAttributeAst | undefined {
+    return node.kind === 'ModelAttribute' ? new ModelAttributeAst(node) : undefined;
+  }
+}

package/src/syntax/ast/declarations.ts

@@ -0,0 +1,359 @@
+import type { Token } from '../../tokenizer';
+import type { AstNode } from '../ast-helpers';
+import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
+import { SyntaxNode } from '../red';
+import { FieldAttributeAst, ModelAttributeAst } from './attributes';
+import type { ExpressionAst } from './expressions';
+import { castExpression } from './expressions';
+import { IdentifierAst } from './identifier';
+import { TypeAnnotationAst } from './type-annotation';
+
+/**
+ * What may appear inside a `namespace` block: models, enums, composite types,
+ * and extension (block) declarations. Mirrors what `parsePslDocument` accepts
+ * in a namespace body. `types {}` blocks and nested `namespace` blocks are
+ * document-only, so they are not namespace members.
+ */
+export type NamespaceMemberAst =
+  | ModelDeclarationAst
+  | EnumDeclarationAst
+  | CompositeTypeDeclarationAst
+  | BlockDeclarationAst;
+
+function castNamespaceMember(node: SyntaxNode): NamespaceMemberAst | undefined {
+  return (
+    ModelDeclarationAst.cast(node) ??
+    EnumDeclarationAst.cast(node) ??
+    CompositeTypeDeclarationAst.cast(node) ??
+    BlockDeclarationAst.cast(node)
+  );
+}
+
+export class DocumentAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  *declarations(): Iterable<NamespaceMemberAst | TypesBlockAst | NamespaceDeclarationAst> {
+    yield* filterChildren(
+      this.syntax,
+      (node) =>
+        castNamespaceMember(node) ?? TypesBlockAst.cast(node) ?? NamespaceDeclarationAst.cast(node),
+    );
+  }
+
+  static cast(node: SyntaxNode): DocumentAst | undefined {
+    return node.kind === 'Document' ? new DocumentAst(node) : undefined;
+  }
+}
+
+export class ModelDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *fields(): Iterable<FieldDeclarationAst> {
+    yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
+  }
+
+  *attributes(): Iterable<ModelAttributeAst> {
+    yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): ModelDeclarationAst | undefined {
+    return node.kind === 'ModelDeclaration' ? new ModelDeclarationAst(node) : undefined;
+  }
+}
+
+export class EnumDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *values(): Iterable<EnumValueDeclarationAst> {
+    yield* filterChildren(this.syntax, EnumValueDeclarationAst.cast);
+  }
+
+  *attributes(): Iterable<ModelAttributeAst> {
+    yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): EnumDeclarationAst | undefined {
+    return node.kind === 'EnumDeclaration' ? new EnumDeclarationAst(node) : undefined;
+  }
+}
+
+export class CompositeTypeDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *fields(): Iterable<FieldDeclarationAst> {
+    yield* filterChildren(this.syntax, FieldDeclarationAst.cast);
+  }
+
+  *attributes(): Iterable<ModelAttributeAst> {
+    yield* filterChildren(this.syntax, ModelAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): CompositeTypeDeclarationAst | undefined {
+    return node.kind === 'CompositeTypeDeclaration'
+      ? new CompositeTypeDeclarationAst(node)
+      : undefined;
+  }
+}
+
+export class NamespaceDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *declarations(): Iterable<NamespaceMemberAst> {
+    yield* filterChildren(this.syntax, castNamespaceMember);
+  }
+
+  static cast(node: SyntaxNode): NamespaceDeclarationAst | undefined {
+    return node.kind === 'Namespace' ? new NamespaceDeclarationAst(node) : undefined;
+  }
+}
+
+export class TypesBlockAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *declarations(): Iterable<NamedTypeDeclarationAst> {
+    yield* filterChildren(this.syntax, NamedTypeDeclarationAst.cast);
+  }
+
+  static cast(node: SyntaxNode): TypesBlockAst | undefined {
+    return node.kind === 'TypesBlock' ? new TypesBlockAst(node) : undefined;
+  }
+}
+
+export class BlockDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  keyword(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'LBrace');
+  }
+
+  rbrace(): Token | undefined {
+    return findChildToken(this.syntax, 'RBrace');
+  }
+
+  *entries(): Iterable<KeyValuePairAst> {
+    yield* filterChildren(this.syntax, KeyValuePairAst.cast);
+  }
+
+  static cast(node: SyntaxNode): BlockDeclarationAst | undefined {
+    return node.kind === 'BlockDeclaration' ? new BlockDeclarationAst(node) : undefined;
+  }
+}
+
+export class KeyValuePairAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  key(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  equals(): Token | undefined {
+    return findChildToken(this.syntax, 'Equals');
+  }
+
+  value(): ExpressionAst | undefined {
+    let pastEquals = false;
+    for (const child of this.syntax.children()) {
+      if (!(child instanceof SyntaxNode)) {
+        if (child.kind === 'Equals') pastEquals = true;
+        continue;
+      }
+      if (pastEquals) {
+        const expr = castExpression(child);
+        if (expr) return expr;
+      }
+    }
+    return undefined;
+  }
+
+  static cast(node: SyntaxNode): KeyValuePairAst | undefined {
+    return node.kind === 'KeyValuePair' ? new KeyValuePairAst(node) : undefined;
+  }
+}
+
+export class FieldDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  typeAnnotation(): TypeAnnotationAst | undefined {
+    return findFirstChild(this.syntax, TypeAnnotationAst.cast);
+  }
+
+  *attributes(): Iterable<FieldAttributeAst> {
+    yield* filterChildren(this.syntax, FieldAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): FieldDeclarationAst | undefined {
+    return node.kind === 'FieldDeclaration' ? new FieldDeclarationAst(node) : undefined;
+  }
+}
+
+export class EnumValueDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  *attributes(): Iterable<FieldAttributeAst> {
+    yield* filterChildren(this.syntax, FieldAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): EnumValueDeclarationAst | undefined {
+    return node.kind === 'EnumValueDeclaration' ? new EnumValueDeclarationAst(node) : undefined;
+  }
+}
+
+export class NamedTypeDeclarationAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  equals(): Token | undefined {
+    return findChildToken(this.syntax, 'Equals');
+  }
+
+  typeAnnotation(): TypeAnnotationAst | undefined {
+    return findFirstChild(this.syntax, TypeAnnotationAst.cast);
+  }
+
+  *attributes(): Iterable<FieldAttributeAst> {
+    yield* filterChildren(this.syntax, FieldAttributeAst.cast);
+  }
+
+  static cast(node: SyntaxNode): NamedTypeDeclarationAst | undefined {
+    return node.kind === 'NamedTypeDeclaration' ? new NamedTypeDeclarationAst(node) : undefined;
+  }
+}

package/src/syntax/ast/expressions.ts

@@ -0,0 +1,199 @@
+import type { Token } from '../../tokenizer';
+import type { AstNode } from '../ast-helpers';
+import { filterChildren, findChildToken, findFirstChild } from '../ast-helpers';
+import { SyntaxNode } from '../red';
+import { IdentifierAst } from './identifier';
+
+export class FunctionCallAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  name(): IdentifierAst | undefined {
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  lparen(): Token | undefined {
+    return findChildToken(this.syntax, 'LParen');
+  }
+
+  rparen(): Token | undefined {
+    return findChildToken(this.syntax, 'RParen');
+  }
+
+  *args(): Iterable<AttributeArgAst> {
+    yield* filterChildren(this.syntax, AttributeArgAst.cast);
+  }
+
+  static cast(node: SyntaxNode): FunctionCallAst | undefined {
+    return node.kind === 'FunctionCall' ? new FunctionCallAst(node) : undefined;
+  }
+}
+
+export class ArrayLiteralAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  lbracket(): Token | undefined {
+    return findChildToken(this.syntax, 'LBracket');
+  }
+
+  rbracket(): Token | undefined {
+    return findChildToken(this.syntax, 'RBracket');
+  }
+
+  *elements(): Iterable<ExpressionAst> {
+    yield* filterChildren(this.syntax, castExpression);
+  }
+
+  static cast(node: SyntaxNode): ArrayLiteralAst | undefined {
+    return node.kind === 'ArrayLiteral' ? new ArrayLiteralAst(node) : undefined;
+  }
+}
+
+export class StringLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  token(): Token | undefined {
+    return findChildToken(this.syntax, 'StringLiteral');
+  }
+
+  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}`;
+      }
+    });
+  }
+
+  static cast(node: SyntaxNode): StringLiteralExprAst | undefined {
+    return node.kind === 'StringLiteralExpr' ? new StringLiteralExprAst(node) : undefined;
+  }
+}
+
+export class NumberLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  token(): Token | undefined {
+    return findChildToken(this.syntax, 'NumberLiteral');
+  }
+
+  value(): number | undefined {
+    const tok = this.token();
+    if (!tok) return undefined;
+    return Number(tok.text);
+  }
+
+  static cast(node: SyntaxNode): NumberLiteralExprAst | undefined {
+    return node.kind === 'NumberLiteralExpr' ? new NumberLiteralExprAst(node) : undefined;
+  }
+}
+
+export class BooleanLiteralExprAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  token(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  value(): boolean | undefined {
+    const tok = this.token();
+    if (!tok) return undefined;
+    if (tok.text === 'true') return true;
+    if (tok.text === 'false') return false;
+    return undefined;
+  }
+
+  static cast(node: SyntaxNode): BooleanLiteralExprAst | undefined {
+    return node.kind === 'BooleanLiteralExpr' ? new BooleanLiteralExprAst(node) : undefined;
+  }
+}
+
+export type ExpressionAst =
+  | FunctionCallAst
+  | ArrayLiteralAst
+  | StringLiteralExprAst
+  | NumberLiteralExprAst
+  | BooleanLiteralExprAst
+  | IdentifierAst;
+
+export function castExpression(node: SyntaxNode): ExpressionAst | undefined {
+  return (
+    FunctionCallAst.cast(node) ??
+    ArrayLiteralAst.cast(node) ??
+    StringLiteralExprAst.cast(node) ??
+    NumberLiteralExprAst.cast(node) ??
+    BooleanLiteralExprAst.cast(node) ??
+    IdentifierAst.cast(node)
+  );
+}
+
+export class AttributeArgAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  name(): IdentifierAst | undefined {
+    if (!this.colon()) return undefined;
+    return findFirstChild(this.syntax, IdentifierAst.cast);
+  }
+
+  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): AttributeArgAst | undefined {
+    return node.kind === 'AttributeArg' ? new AttributeArgAst(node) : undefined;
+  }
+}

package/src/syntax/ast/identifier.ts

@@ -0,0 +1,20 @@
+import type { Token } from '../../tokenizer';
+import type { AstNode } from '../ast-helpers';
+import { findChildToken } from '../ast-helpers';
+import type { SyntaxNode } from '../red';
+
+export class IdentifierAst implements AstNode {
+  readonly syntax: SyntaxNode;
+
+  constructor(syntax: SyntaxNode) {
+    this.syntax = syntax;
+  }
+
+  token(): Token | undefined {
+    return findChildToken(this.syntax, 'Ident');
+  }
+
+  static cast(node: SyntaxNode): IdentifierAst | undefined {
+    return node.kind === 'Identifier' ? new IdentifierAst(node) : undefined;
+  }
+}