@goast/kotlin 0.5.8 → 0.5.9-beta.1

package/src/src/ast/nodes/doc-tag.ts

@@ -1,138 +0,0 @@
-import {
-  type AstNodeOptions,
-  type BasicAppendValue,
-  basicAppendValueGroup,
-  notNullish,
-  type Nullable,
-  type ParametersWithOverloads,
-  type Prettify,
-  type SingleOrMultiple,
-  type SourceBuilder,
-  type StringSuggestions,
-} from '@goast/core';
-
-import { isKotlinAppendValue } from '../../file-builder.js';
-import { KtNode } from '../node.js';
-import { type KtAppendValue, writeKtNodes } from '../utils/write-kt-node.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    tag: string;
-    args?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
-    description?: Nullable<BasicAppendValue<TBuilder>>;
-  }
->;
-
-export class KtDocTag<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public tag: string;
-  public args: BasicAppendValue<TBuilder>[];
-  public description: BasicAppendValue<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.tag = options.tag;
-    this.args = options.args?.filter(notNullish) ?? [];
-    this.description = options.description ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append('@', this.tag);
-    this.args.forEach((a) => builder.append(' ', a));
-    if (this.description) builder.append(' ', this.description);
-  }
-}
-
-type _KtDocTagOpt<TBuilder extends SourceBuilder> = Prettify<Omit<Options<TBuilder>, 'tag'>>;
-
-type _KtDocTagArgsMap<TBuilder extends SourceBuilder> =
-  & {
-    suppress(options?: _KtDocTagOpt<TBuilder>): never;
-  }
-  & {
-    [K in 'return' | 'constructor' | 'receiver' | 'author' | 'since']: (
-      description: BasicAppendValue<TBuilder>,
-      options?: _KtDocTagOpt<TBuilder>,
-    ) => never;
-  }
-  & {
-    [K in 'param' | 'property']: (
-      name: string,
-      description: BasicAppendValue<TBuilder>,
-      options?: _KtDocTagOpt<TBuilder>,
-    ) => never;
-  }
-  & {
-    [K in 'see' | 'sample']: (identifier: string, options?: _KtDocTagOpt<TBuilder>) => never;
-  }
-  & {
-    [K in 'throws' | 'exception']: (
-      $class: BasicAppendValue<TBuilder>,
-      description: BasicAppendValue<TBuilder>,
-      options?: _KtDocTagOpt<TBuilder>,
-    ) => never;
-  };
-
-const tagsWithDescription = [
-  'return',
-  'constructor',
-  'receiver',
-  'author',
-  'since',
-  'param',
-  'property',
-  'throws',
-  'exception',
-];
-
-type _KtDocTagArgs<
-  TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>,
-  TBuilder extends SourceBuilder,
-> = TTagName extends keyof _KtDocTagArgsMap<TBuilder>
-  // deno-lint-ignore no-explicit-any
-  ? _KtDocTagArgsMap<TBuilder>[TTagName] extends (...args: any[]) => any
-    ? ParametersWithOverloads<_KtDocTagArgsMap<TBuilder>[TTagName]>
-  : never
-  : [options?: _KtDocTagOpt<TBuilder>];
-
-function createDocTag<
-  TTagName extends StringSuggestions<keyof _KtDocTagArgsMap<TBuilder>>,
-  TBuilder extends SourceBuilder,
->(tag: TTagName, ...args: _KtDocTagArgs<TTagName, TBuilder>): KtDocTag<TBuilder>;
-function createDocTag<TBuilder extends SourceBuilder>(tag: string, ...args: unknown[]): KtDocTag<TBuilder> {
-  let opt: _KtDocTagOpt<TBuilder> = {};
-  if (args.length > 0) {
-    const lastArg = args[args.length - 1];
-    if (!isKotlinAppendValue(lastArg) && !!lastArg) {
-      opt = args.pop() as _KtDocTagOpt<TBuilder>;
-    }
-  }
-
-  const params = args as BasicAppendValue<TBuilder>[];
-  if (tagsWithDescription.includes(tag)) {
-    const description = params.pop();
-    if (opt.description && description) {
-      opt.description = basicAppendValueGroup<TBuilder>([description, opt.description], '\n');
-    } else if (description) {
-      opt.description = description;
-    }
-  }
-
-  return new KtDocTag({ ...opt, tag, args: params });
-}
-
-const writeDocTags = <TBuilder extends SourceBuilder>(
-  builder: TBuilder,
-  nodes: SingleOrMultiple<Nullable<KtAppendValue<TBuilder>>>,
-): void => {
-  writeKtNodes(builder, nodes, { separator: '\n' });
-};
-
-export const ktDocTag: typeof createDocTag & { write: typeof writeDocTags } = Object.assign(createDocTag, {
-  write: writeDocTags,
-});

package/src/src/ast/nodes/doc.ts

@@ -1,111 +0,0 @@
-import {
-  type AstNodeOptions,
-  type BasicAppendValue,
-  createOverwriteProxy,
-  getIsInstanceOf,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtDocTag, ktDocTag } from './doc-tag.js';
-import { KtGenericParameter } from './generic-parameter.js';
-import { KtParameter } from './parameter.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    description?: Nullable<BasicAppendValue<TBuilder>>;
-    tags?: Nullable<Nullable<KtDocTag<TBuilder>>[]>;
-  }
->;
-
-export class KtDoc<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public description: BasicAppendValue<TBuilder> | null;
-  public tags: KtDocTag<TBuilder>[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.description = options.description ?? null;
-    this.tags = options.tags?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (!this.description && this.tags.length === 0) return;
-    builder
-      .ensureCurrentLineEmpty()
-      .parenthesize(
-        ['/**', ' */'],
-        (b) =>
-          b.appendWithLinePrefix(' * ', (b) => {
-            builder.append(this.description);
-            if (this.tags.length > 0) {
-              b.ensurePreviousLineEmpty();
-              ktDocTag.write(b, this.tags);
-            }
-          }),
-        { multiline: true, indent: false },
-      )
-      .appendLine();
-  }
-}
-
-const createDoc = <TBuilder extends SourceBuilder>(
-  description?: Options<TBuilder>['description'],
-  tags?: Options<TBuilder>['tags'],
-  options?: Prettify<Omit<Options<TBuilder>, 'description' | 'tags'>>,
-): KtDoc<TBuilder> => new KtDoc<TBuilder>({ ...options, description, tags: tags ?? undefined });
-
-function getDoc<TBuilder extends SourceBuilder>(
-  baseDoc: KtDoc<TBuilder> | null,
-  options: {
-    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-  },
-): KtDoc<TBuilder> | null {
-  const paramsWithDesc = options.parameters
-    ?.filter(getIsInstanceOf(KtParameter<TBuilder>))
-    .filter((x): x is KtParameter<TBuilder> & { description: NonNullable<unknown> } => !!x.description) ?? [];
-  const classParamsWithPropertyDesc = options.parameters
-    ?.filter(getIsInstanceOf(KtParameter<TBuilder>))
-    .filter(
-      (x): x is KtParameter<TBuilder> & { property: NonNullable<unknown>; propertyDescription: NonNullable<unknown> } =>
-        !!x.property && !!x.propertyDescription,
-    ) ?? [];
-  const genericsWithDesc = options.generics
-    ?.filter(getIsInstanceOf(KtGenericParameter<TBuilder>))
-    .filter((x): x is KtGenericParameter<TBuilder> & { description: NonNullable<unknown> } => !!x.description) ?? [];
-  if (
-    baseDoc === null &&
-    paramsWithDesc.length === 0 &&
-    genericsWithDesc.length === 0 &&
-    classParamsWithPropertyDesc.length === 0
-  ) {
-    return null;
-  }
-
-  const doc = baseDoc ? createOverwriteProxy(baseDoc) : ktDoc<TBuilder>();
-  const paramTags = paramsWithDesc.map<KtDocTag<TBuilder>>((p) => ktDocTag('param', p.name, p.description));
-  const propertyTags = classParamsWithPropertyDesc.map<KtDocTag<TBuilder>>((p) =>
-    ktDocTag('property', p.name, p.propertyDescription)
-  );
-  const genericTags = genericsWithDesc.map<KtDocTag<TBuilder>>((p) => ktDocTag('param', p.name, p.description));
-  doc.tags.splice(0, 0, ...genericTags, ...paramTags, ...propertyTags);
-  return doc;
-}
-
-export const ktDoc: typeof createDoc & {
-  write: typeof writeKtNodes;
-  get: typeof getDoc;
-} = Object.assign(createDoc, {
-  write: writeKtNodes,
-  get: getDoc,
-});

package/src/src/ast/nodes/enum-value.ts

@@ -1,100 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtEnumValues } from '../utils/write-kt-enum-values.js';
-import { writeKtMembers } from '../utils/write-kt-members.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import type { KtDoc } from './doc.js';
-import type { KtFunction } from './function.js';
-import type { KtParameter } from './parameter.js';
-
-type Injects = 'doc' | 'annotations' | 'name' | 'arguments' | 'body' | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    doc?: Nullable<KtDoc<TBuilder>>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    arguments?: Nullable<Nullable<KtArgument<TBuilder> | AppendValue<TBuilder>>[]>;
-    members?: Nullable<Nullable<KtEnumValueMember<TBuilder>>[]>;
-  }
->;
-
-export type KtEnumValueMember<TBuilder extends SourceBuilder> =
-  | KtParameter<TBuilder>
-  | KtFunction<TBuilder>
-  | AppendValue<TBuilder>;
-
-export class KtEnumValue<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public doc: KtDoc<TBuilder> | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public arguments: (KtArgument<TBuilder> | AppendValue<TBuilder>)[];
-  public members: KtEnumValueMember<TBuilder>[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.doc = options.doc ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.arguments = options.arguments?.filter(notNullish) ?? [];
-    this.members = options.members?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    this.doc?.write(builder);
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    if (this.arguments.length > 0) {
-      builder.append(this.inject.beforeArguments);
-      ktArgument.write(builder, this.arguments);
-      builder.append(this.inject.afterArguments);
-    }
-
-    if (this.members.length > 0) {
-      builder.append(' ');
-      builder.append(this.inject.beforeBody);
-      builder.parenthesize(
-        '{}',
-        (b) => {
-          builder.append(this.inject.beforeMembers);
-          writeKtMembers(b, this.members);
-          builder.append(this.inject.afterMembers);
-        },
-        { multiline: true },
-      );
-      builder.append(this.inject.afterBody);
-    }
-  }
-}
-
-const createEnumValue = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtEnumValue<TBuilder> => new KtEnumValue<TBuilder>({ ...options, name });
-
-export const ktEnumValue: typeof createEnumValue & { write: typeof writeKtEnumValues } = Object.assign(
-  createEnumValue,
-  {
-    write: writeKtEnumValues,
-  },
-);

package/src/src/ast/nodes/enum.ts

@@ -1,163 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  createOverwriteProxy,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtMembers } from '../utils/write-kt-members.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import type { KtClass } from './class.js';
-import type { KtConstructor } from './constructor.js';
-import { type KtDoc, ktDoc } from './doc.js';
-import { type KtEnumValue, ktEnumValue } from './enum-value.js';
-import type { KtFunction } from './function.js';
-import { type KtInitBlock, ktInitBlock } from './init-block.js';
-import type { KtInterface } from './interface.js';
-import type { KtObject } from './object.js';
-import type { KtProperty } from './property.js';
-import type { KtType } from './types.js';
-
-type Injects =
-  | 'doc'
-  | 'annotations'
-  | 'modifiers'
-  | 'name'
-  | 'primaryConstructor'
-  | 'implements'
-  | 'body'
-  | 'values'
-  | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    doc?: Nullable<KtDoc<TBuilder>>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    accessModifier?: Nullable<KtAccessModifier>;
-    primaryConstructor?: Nullable<KtConstructor<TBuilder>>;
-    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    values?: Nullable<KtEnumValue<TBuilder>[]>;
-    members?: Nullable<Nullable<KtEnumMember<TBuilder>>[]>;
-    companionObject?: Nullable<KtObject<TBuilder>>;
-  }
->;
-
-export type KtEnumMember<TBuilder extends SourceBuilder> =
-  | KtConstructor<TBuilder>
-  | KtEnum<TBuilder>
-  | KtInitBlock<TBuilder>
-  | KtInterface<TBuilder>
-  | KtProperty<TBuilder>
-  | KtFunction<TBuilder>
-  | KtClass<TBuilder>
-  | AppendValue<TBuilder>;
-
-export class KtEnum<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public doc: KtDoc<TBuilder> | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public accessModifier: KtAccessModifier | null;
-  public primaryConstructor: KtConstructor<TBuilder> | null;
-  public implements: KtType<TBuilder>[];
-  public values: KtEnumValue<TBuilder>[];
-  public members: KtEnumMember<TBuilder>[];
-  public companionObject: KtObject<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.doc = options.doc ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.accessModifier = options.accessModifier ?? null;
-    this.primaryConstructor = options.primaryConstructor ?? null;
-    this.implements = options.implements?.filter(notNullish) ?? [];
-    this.values = options.values ?? [];
-    this.members = options.members?.filter(notNullish) ?? [];
-    this.companionObject = options.companionObject ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    ktDoc.get(this.doc, { parameters: this.primaryConstructor?.parameters })?.write(builder);
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier) builder.append(this.accessModifier, ' ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('enum class ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    if (this.primaryConstructor) {
-      builder.append(this.inject.beforePrimaryConstructor);
-      this.primaryConstructor.writeAsPrimary(builder);
-      builder.append(this.inject.afterPrimaryConstructor);
-    }
-
-    if (this.implements.length > 0) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeImplements);
-      writeKtNodes(builder, this.implements, { separator: ', ' });
-      builder.append(this.inject.afterImplements);
-    }
-
-    const allMembers = [
-      this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
-      this.primaryConstructor?.body ? ktInitBlock(this.primaryConstructor?.body) : null,
-      ...this.members,
-    ].filter(notNullish);
-
-    if (this.values.length > 0 || allMembers.length > 0) {
-      builder.append(' ');
-      builder.append(this.inject.beforeBody);
-      builder.parenthesize(
-        '{}',
-        (b) => {
-          if (this.values.length > 0) {
-            b.append(this.inject.beforeValues);
-            ktEnumValue.write(b, this.values);
-            if (allMembers.length > 0) {
-              b.append(';\n\n');
-            }
-            b.append(this.inject.afterValues);
-          }
-
-          if (allMembers.length > 0) {
-            b.append(this.inject.beforeMembers);
-            writeKtMembers(b, allMembers);
-            b.append(this.inject.afterMembers);
-          }
-        },
-        { multiline: true },
-      );
-      builder.append(this.inject.afterBody);
-    }
-
-    builder.appendLine();
-  }
-}
-
-const createEnum = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  values?: Options<TBuilder>['values'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'values'>>,
-): KtEnum<TBuilder> => new KtEnum<TBuilder>({ ...options, name, values: values ?? undefined });
-
-export const ktEnum: typeof createEnum & { write: typeof writeKtNodes } = Object.assign(createEnum, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/function.ts

@@ -1,178 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  type BasicAppendValue,
-  notNullish,
-  type Nullable,
-  type Prettify,
-  type SourceBuilder,
-} from '@goast/core';
-
-import type { KtAccessModifier } from '../common.js';
-import { KtNode } from '../node.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import { type KtDoc, ktDoc } from './doc.js';
-import { type KtGenericParameter, ktGenericParameter } from './generic-parameter.js';
-import { KtInterface } from './interface.js';
-import { type KtParameter, ktParameter } from './parameter.js';
-import type { KtType } from './types.js';
-
-type Injects =
-  | 'doc'
-  | 'annotations'
-  | 'modifiers'
-  | 'generics'
-  | 'receiverAnnotations'
-  | 'receiverType'
-  | 'name'
-  | 'parameters'
-  | 'returnType';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    doc?: Nullable<KtDoc<TBuilder>>;
-    returnType?: Nullable<KtType<TBuilder>>;
-    body?: Nullable<AppendValue<TBuilder>>;
-    accessModifier?: Nullable<KtAccessModifier>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    receiverType?: Nullable<KtType<TBuilder>>;
-    receiverAnnotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    singleExpression?: Nullable<boolean>;
-    open?: Nullable<boolean>;
-    inline?: Nullable<boolean>;
-    infix?: Nullable<boolean>;
-    tailrec?: Nullable<boolean>;
-    suspend?: Nullable<boolean>;
-    operator?: Nullable<boolean>;
-    override?: Nullable<boolean>;
-    abstract?: Nullable<boolean>;
-  }
->;
-
-export class KtFunction<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public doc: KtDoc<TBuilder> | null;
-  public returnType: KtType<TBuilder> | null;
-  public body: AppendValue<TBuilder> | null;
-  public accessModifier: KtAccessModifier | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public receiverType: KtType<TBuilder> | null;
-  public receiverAnnotations: KtAnnotation<TBuilder>[];
-  public singleExpression: boolean;
-  public open: boolean;
-  public inline: boolean;
-  public infix: boolean;
-  public tailrec: boolean;
-  public suspend: boolean;
-  public operator: boolean;
-  public override: boolean;
-  public abstract: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.parameters = options.parameters?.filter(notNullish) ?? [];
-    this.doc = options.doc ?? null;
-    this.returnType = options.returnType ?? null;
-    this.body = options.body ?? null;
-    this.accessModifier = options.accessModifier ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.receiverType = options.receiverType ?? null;
-    this.receiverAnnotations = options.receiverAnnotations?.filter(notNullish) ?? [];
-    this.singleExpression = options.singleExpression ?? false;
-    this.open = options.open ?? false;
-    this.inline = options.inline ?? false;
-    this.infix = options.infix ?? false;
-    this.tailrec = options.tailrec ?? false;
-    this.suspend = options.suspend ?? false;
-    this.operator = options.operator ?? false;
-    this.override = options.override ?? false;
-    this.abstract = options.abstract ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    ktDoc.get(this.doc, { generics: this.generics, parameters: this.parameters })?.write(builder);
-    builder.append(this.inject.afterDoc);
-
-    builder.append(this.inject.beforeAnnotations);
-    ktAnnotation.write(builder, this.annotations, { multiline: true });
-    builder.append(this.inject.afterAnnotations);
-
-    builder.append(this.inject.beforeModifiers);
-    if (this.accessModifier) builder.append(this.accessModifier, ' ');
-    if (this.inline) builder.append('inline ');
-    if (this.infix) builder.append('infix ');
-    if (this.tailrec) builder.append('tailrec ');
-    if (this.suspend) builder.append('suspend ');
-    if (this.open) builder.append('open ');
-    if (this.override) builder.append('override ');
-    if (this.abstract) builder.append('abstract ');
-    if (this.operator) builder.append('operator ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('fun ');
-
-    builder.append(this.inject.beforeGenerics);
-    ktGenericParameter.write(builder, this.generics);
-    builder.append(this.inject.afterGenerics);
-    if (this.generics.length > 0) builder.append(' ');
-
-    if (this.receiverType) {
-      builder.append(this.inject.beforeReceiverAnnotations);
-      ktAnnotation.write(builder, this.receiverAnnotations, { multiline: false });
-      builder.append(this.inject.afterReceiverAnnotations);
-
-      builder.append(this.inject.beforeReceiverType);
-      writeKtNode(builder, this.receiverType);
-      builder.append(this.inject.afterReceiverType);
-      builder.append('.');
-    }
-
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    builder.append(this.inject.beforeParameters);
-    ktParameter.write(builder, this.parameters);
-    builder.append(this.inject.afterParameters);
-
-    if (this.returnType) {
-      builder.append(': ');
-      builder.append(this.inject.beforeReturnType);
-      writeKtNode(builder, this.returnType);
-      builder.append(this.inject.afterReturnType);
-    }
-
-    const isInInterface = this.getParentNode(builder) instanceof KtInterface;
-    if (!this.abstract && (this.body || !isInInterface)) {
-      builder.append(' ');
-      if (this.singleExpression && this.body) {
-        builder.append('= ');
-        builder.indent(this.body);
-      } else {
-        builder.parenthesize('{}', this.body, { multiline: !!this.body });
-      }
-    }
-
-    builder.appendLine();
-  }
-}
-
-const createFunction = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtFunction<TBuilder> => new KtFunction<TBuilder>({ ...options, name });
-
-export const ktFunction: typeof createFunction & { write: typeof writeKtNodes } = Object.assign(createFunction, {
-  write: writeKtNodes,
-});