@goast/kotlin 0.6.0 → 0.7.0-beta.2

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

package/src/src/ast/nodes/generic-parameter.ts

@@ -1,54 +0,0 @@
-import type { AstNodeOptions, BasicAppendValue, Nullable, Prettify, SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters.js';
-import { writeKtNode } from '../utils/write-kt-node.js';
-import type { KtType } from './types.js';
-
-type Injects = 'name' | 'constraint';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    name: string;
-    description?: Nullable<BasicAppendValue<TBuilder>>;
-    constraint?: Nullable<KtType<TBuilder>>;
-  }
->;
-
-export class KtGenericParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public name: string;
-  public description: BasicAppendValue<TBuilder> | null;
-  public constraint: KtType<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.name = options.name;
-    this.description = options.description ?? null;
-    this.constraint = options.constraint ?? null;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    if (this.constraint) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeConstraint);
-      writeKtNode(builder, this.constraint);
-      builder.append(this.inject.afterConstraint);
-    }
-  }
-}
-
-const createGenericParameter = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtGenericParameter<TBuilder> => new KtGenericParameter<TBuilder>({ ...options, name });
-
-export const ktGenericParameter: typeof createGenericParameter & { write: typeof writeKtGenericParameters } = Object
-  .assign(createGenericParameter, {
-    write: writeKtGenericParameters,
-  });

package/src/src/ast/nodes/init-block.ts

@@ -1,38 +0,0 @@
-import type { AppendValue, AstNodeOptions, Prettify, SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { 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>,
-  {
-    body: AppendValue<TBuilder>;
-  }
->;
-
-export class KtInitBlock<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public body: AppendValue<TBuilder>;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.body = options.body;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append('init ').parenthesize('{}', this.body, { multiline: !!this.body }).appendLine();
-  }
-}
-
-const createInitBlock = <TBuilder extends SourceBuilder>(
-  body: Options<TBuilder>['body'],
-  options?: Prettify<Omit<Options<TBuilder>, 'body'>>,
-): KtInitBlock<TBuilder> => new KtInitBlock<TBuilder>({ ...options, body });
-
-export const ktInitBlock: typeof createInitBlock & { write: typeof writeKtNodes } = Object.assign(createInitBlock, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/interface.ts

@@ -1,133 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  type BasicAppendValue,
-  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 KtDoc, ktDoc } from './doc.js';
-import type { KtEnum } from './enum.js';
-import type { KtFunction } from './function.js';
-import { type KtGenericParameter, ktGenericParameter } from './generic-parameter.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' | 'generics' | 'extends' | 'body' | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    doc?: Nullable<KtDoc<TBuilder>>;
-    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
-    accessModifier?: Nullable<KtAccessModifier>;
-    name: string;
-    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    extends?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    members?: Nullable<Nullable<KtInterfaceMember<TBuilder>>[]>;
-    companionObject?: Nullable<KtObject<TBuilder>>;
-  }
->;
-
-export type KtInterfaceMember<TBuilder extends SourceBuilder> =
-  | KtEnum<TBuilder>
-  | KtInterface<TBuilder>
-  | KtProperty<TBuilder>
-  | KtFunction<TBuilder>
-  | KtClass<TBuilder>
-  | AppendValue<TBuilder>;
-
-export class KtInterface<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public doc: KtDoc<TBuilder> | null;
-  public annotations: KtAnnotation<TBuilder>[];
-  public accessModifier: KtAccessModifier | null;
-  public name: string;
-  public generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public extends: KtType<TBuilder>[];
-  public members: KtInterfaceMember<TBuilder>[];
-  public companionObject: KtObject<TBuilder> | null;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.accessModifier = options.accessModifier ?? null;
-    this.name = options.name;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.extends = options.extends?.filter(notNullish) ?? [];
-    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, { generics: this.generics })?.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('interface ');
-    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
-
-    builder.append(this.inject.beforeGenerics);
-    ktGenericParameter.write(builder, this.generics);
-    builder.append(this.inject.afterGenerics);
-
-    if (this.extends.length > 0) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeExtends);
-      writeKtNodes(builder, this.extends, { separator: ', ' });
-      builder.append(this.inject.afterExtends);
-    }
-
-    const allMembers = [
-      this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
-      ...this.members,
-    ].filter(notNullish);
-
-    if (allMembers.length > 0) {
-      builder.append(' ');
-      builder.append(this.inject.beforeBody);
-      builder.parenthesize(
-        '{}',
-        (b) => {
-          b.append(this.inject.beforeMembers);
-          writeKtMembers(b, allMembers);
-          b.append(this.inject.afterMembers);
-        },
-        { multiline: true },
-      );
-      builder.append(this.inject.afterBody);
-    }
-
-    builder.appendLine();
-  }
-}
-
-const createInterface = <TBuilder extends SourceBuilder>(
-  name: KtInterface<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtInterface<TBuilder> => new KtInterface<TBuilder>({ ...options, name });
-
-export const ktInterface: typeof createInterface & { write: typeof writeKtNodes } = Object.assign(createInterface, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/lambda-type.ts

@@ -1,73 +0,0 @@
-import { type AstNodeOptions, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { ktParameter } from './parameter.js';
-import type { KtType } from './types.js';
-
-type Injects = 'extensionFor' | 'params' | 'returnType';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    extensionFor?: Nullable<KtType<TBuilder>>;
-    parameters?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    returnType: KtType<TBuilder>;
-    suspend?: boolean;
-  }
->;
-
-export class KtLambdaType<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public extensionFor: KtType<TBuilder> | null;
-  public parameters: KtType<TBuilder>[];
-  public returnType: KtType<TBuilder>;
-  public suspend: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.extensionFor = options.extensionFor ?? null;
-    this.parameters = options.parameters?.filter(notNullish) ?? [];
-    this.returnType = options.returnType;
-    this.suspend = options.suspend ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    if (this.suspend) {
-      builder.append('suspend ');
-    }
-
-    if (this.extensionFor) {
-      builder.append(this.inject.beforeExtensionFor);
-      writeKtNode(builder, this.extensionFor);
-      builder.append(this.inject.afterExtensionFor);
-      builder.append('.');
-    }
-
-    builder.append(this.inject.beforeParams);
-    if (this.parameters.length === 0) {
-      builder.append('()');
-    } else {
-      ktParameter.write(builder, this.parameters);
-    }
-    builder.append(this.inject.afterParams);
-
-    builder.append(' -> ');
-
-    builder.append(this.inject.beforeReturnType);
-    writeKtNode(builder, this.returnType);
-    builder.append(this.inject.afterReturnType);
-  }
-}
-
-const createLambdaType = <TBuilder extends SourceBuilder>(
-  parameters: Options<TBuilder>['parameters'],
-  returnType: Options<TBuilder>['returnType'],
-  options?: Omit<Options<TBuilder>, 'parameters' | 'returnType'>,
-): KtLambdaType<TBuilder> => new KtLambdaType<TBuilder>({ ...options, parameters, returnType });
-
-export const ktLambdaType: typeof createLambdaType & { write: typeof writeKtNodes } = Object.assign(createLambdaType, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/lambda.ts

@@ -1,74 +0,0 @@
-import {
-  type AppendValue,
-  type AstNodeOptions,
-  type BasicAppendValue,
-  notNullish,
-  type Nullable,
-  type SourceBuilder,
-} from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-
-type Injects = 'arguments' | 'body';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    arguments?: Nullable<Nullable<BasicAppendValue<TBuilder>>[]>;
-    body?: Nullable<AppendValue<TBuilder>>;
-    singleline?: boolean;
-  }
->;
-
-export class KtLambda<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public arguments: BasicAppendValue<TBuilder>[];
-  public body: AppendValue<TBuilder> | null;
-  public singleline: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.arguments = options.arguments?.filter(notNullish) ?? [];
-    this.body = options.body ?? null;
-    this.singleline = options.singleline ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    const singleline = this.singleline || !this.body;
-
-    builder.parenthesize('{}', (b) => {
-      if (this.arguments.length > 0) {
-        b.append(' ', this.inject.beforeArguments);
-        writeKtNodes(b, this.arguments, { separator: ', ' });
-        b.append(this.inject.afterArguments);
-
-        b.append(' ->');
-      }
-
-      b.append(singleline ? ' ' : '\n');
-
-      b.append(this.inject.beforeBody, this.body, this.inject.afterBody);
-
-      if (singleline) {
-        if (!b.isCurrentLineEmpty) {
-          b.append(' ');
-        }
-      } else {
-        b.ensureCurrentLineEmpty();
-      }
-    });
-  }
-}
-
-const createLambda = <TBuilder extends SourceBuilder>(
-  args: Options<TBuilder>['arguments'],
-  body: Options<TBuilder>['body'],
-  options?: Omit<Options<TBuilder>, 'arguments' | 'body'>,
-): KtLambda<TBuilder> => new KtLambda<TBuilder>({ ...options, arguments: args, body });
-
-export const ktLambda: typeof createLambda & { write: typeof writeKtNodes } = Object.assign(createLambda, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/object.ts

@@ -1,102 +0,0 @@
-import { type AstNodeOptions, type BasicAppendValue, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtMembers } from '../utils/write-kt-members.js';
-import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtArgument, ktArgument } from './argument.js';
-import type { KtFunction } from './function.js';
-import type { KtInitBlock } from './init-block.js';
-import type { KtProperty } from './property.js';
-import type { KtType, KtValue } from './types.js';
-
-type Injects = 'modifiers' | 'name' | 'inheritList' | 'body' | 'members';
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    data?: boolean;
-    name?: Nullable<string>;
-    class?: KtType<TBuilder>;
-    classArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
-    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    members?: Nullable<Nullable<KtObjectMember<TBuilder>>[]>;
-    companion?: Nullable<boolean>;
-  }
->;
-
-export type KtObjectMember<TBuilder extends SourceBuilder> =
-  | KtInitBlock<TBuilder>
-  | KtProperty<TBuilder>
-  | KtFunction<TBuilder>
-  | BasicAppendValue<TBuilder>;
-
-export class KtObject<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public data: boolean;
-  public name: string | null;
-  public class: KtType<TBuilder> | null;
-  public classArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
-  public implements: KtType<TBuilder>[];
-  public members: KtObjectMember<TBuilder>[];
-  public companion: boolean;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.data = options.data ?? false;
-    this.name = options.name ?? null;
-    this.class = options.class ?? null;
-    this.classArguments = options.classArguments?.filter(notNullish) ?? [];
-    this.implements = options.implements?.filter(notNullish) ?? [];
-    this.members = options.members?.filter(notNullish) ?? [];
-    this.companion = options.companion ?? false;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeModifiers);
-    if (this.data) builder.append('data ');
-    if (this.companion) builder.append('companion ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('object');
-
-    if (this.name) {
-      builder.append(' ', this.inject.beforeName, this.name, this.inject.afterName);
-    }
-
-    if (this.class || this.implements.length > 0) {
-      builder.append(' : ', this.inject.beforeInheritList);
-
-      if (this.class) {
-        writeKtNode(builder, this.class);
-        ktArgument.write(builder, this.classArguments);
-        if (this.implements.length > 0) builder.append(', ');
-      }
-
-      writeKtNodes(builder, this.implements, { separator: ', ' });
-      builder.append(this.inject.afterInheritList);
-    }
-
-    builder.append(' ', this.inject.beforeBody);
-    builder.parenthesize(
-      '{}',
-      (b) => {
-        builder.append(this.inject.beforeMembers);
-        writeKtMembers(b, this.members);
-        builder.append(this.inject.afterMembers);
-      },
-      { multiline: this.members.length > 0 },
-    );
-    builder.append(this.inject.afterBody);
-
-    if (this.name) builder.appendLine();
-  }
-}
-
-const createObject = <TBuilder extends SourceBuilder>(options?: Options<TBuilder>): KtObject<TBuilder> =>
-  new KtObject<TBuilder>(options ?? {});
-
-export const ktObject: typeof createObject & { write: typeof writeKtNodes } = Object.assign(createObject, {
-  write: writeKtNodes,
-});