@goast/kotlin 0.4.7-beta2 → 0.4.8

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

@@ -0,0 +1,176 @@
+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 { 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);
+    }
+
+    if (!this.abstract) {
+      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.test.ts

@@ -0,0 +1,60 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktGenericParameter } from './generic-parameter.js';
+
+describe('ktGenericParameter', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  describe('single', () => {
+    it('should write the name of the parameter', () => {
+      builder.append(ktGenericParameter('T'));
+      expect(builder.toString(false)).toBe('T');
+    });
+
+    it('should write the constraint if it exists', () => {
+      builder.append(ktGenericParameter('T', { constraint: 'number' }));
+      expect(builder.toString(false)).toBe('T : number');
+    });
+
+    it('should render injections', () => {
+      builder.append(
+        ktGenericParameter('T', {
+          constraint: 'number',
+          inject: {
+            before: '║b║',
+            after: '║a║',
+            beforeName: '║bn║',
+            afterName: '║an║',
+            beforeConstraint: '║bc║',
+            afterConstraint: '║ac║',
+          },
+        }),
+      );
+      expect(builder.toString(false)).toBe('║b║║bn║T║an║ : ║bc║number║ac║║a║');
+    });
+  });
+
+  describe('multiple', () => {
+    it('should not write anything if the node is empty', () => {
+      ktGenericParameter.write(builder, []);
+      expect(builder.toString(false)).toBe('');
+    });
+
+    it('should write a single parameter', () => {
+      ktGenericParameter.write(builder, [ktGenericParameter('T')]);
+      expect(builder.toString(false)).toBe('<T>');
+    });
+
+    it('should write all the parameters', () => {
+      ktGenericParameter.write(builder, [ktGenericParameter('T'), ktGenericParameter('U')]);
+      expect(builder.toString(false)).toBe('<T, U>');
+    });
+  });
+});

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

@@ -0,0 +1,54 @@
+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.test.ts

@@ -0,0 +1,36 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktInitBlock } from './init-block.js';
+
+describe('ktInitBlock', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write an empty init block', () => {
+    builder.append(ktInitBlock(''));
+    expect(builder.toString(false)).toBe(`init {}${EOL}`);
+  });
+
+  it('should write an init block with a single statement', () => {
+    builder.append(ktInitBlock('println("Hello")'));
+    expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}}${EOL}`);
+  });
+
+  it('should write an init block with multiple statements', () => {
+    builder.append(ktInitBlock((b) => b.appendLine('println("Hello")').appendLine('println("World")')));
+    expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}    println("World")${EOL}}${EOL}`);
+  });
+
+  it('should render injections', () => {
+    builder.append(ktInitBlock('println("Hello")', { inject: { before: ['before'], after: ['after'] } }));
+    expect(builder.toString(false)).toBe(`beforeinit {${EOL}    println("Hello")${EOL}}${EOL}after`);
+  });
+});

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

@@ -0,0 +1,38 @@
+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.test.ts

@@ -0,0 +1,151 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.9/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.6/bdd.js';
+
+import { normalizeEOL } from '@goast/test-utils';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import { ktInterface } from './interface.js';
+import { ktObject } from './object.js';
+
+describe('ktInterface', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write interface', () => {
+    builder.append(ktInterface('Foo'));
+    expect(builder.toString(false)).toBe(`interface Foo${EOL}`);
+  });
+
+  it('should write generics', () => {
+    builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T'), ktGenericParameter('U')] }));
+    expect(builder.toString(false)).toBe(`interface Foo<T, U>${EOL}`);
+  });
+
+  it('should write members', () => {
+    builder.append(
+      ktInterface('Foo', {
+        members: ['// Comment 1', '// Comment 2'],
+      }),
+    );
+    expect(builder.toString(false)).toBe(`interface Foo {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`);
+  });
+
+  it('should write extended interfaces', () => {
+    builder.append(ktInterface('Foo', { extends: ['Bar', 'Baz'] }));
+    expect(builder.toString(false)).toBe(`interface Foo : Bar, Baz${EOL}`);
+  });
+
+  it('should write annotations', () => {
+    builder.append(ktInterface('Foo', { annotations: [ktAnnotation('Deprecated')] }));
+    expect(builder.toString(false)).toBe(`@Deprecated${EOL}interface Foo${EOL}`);
+  });
+
+  it('should write access modifiers', () => {
+    builder.append(ktInterface('Foo', { accessModifier: 'private' }));
+    expect(builder.toString(false)).toBe(`private interface Foo${EOL}`);
+  });
+
+  it('should write documenation', () => {
+    builder.append(ktInterface('Foo', { doc: ktDoc('This is a foo') }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}interface Foo${EOL}`);
+  });
+
+  it('should write generic parameter description', () => {
+    builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T', { description: 'The type' })] }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * @param T The type${EOL} */${EOL}interface Foo<T>${EOL}`);
+  });
+
+  it('should write companion object', () => {
+    builder.append(ktInterface('Foo', { companionObject: ktObject() }));
+    expect(builder.toString(false)).toBe(`interface Foo {${EOL}    companion object {}${EOL}}${EOL}`);
+  });
+
+  it('should write all options', () => {
+    builder.append(
+      ktInterface('Foo', {
+        doc: ktDoc('This is a foo'),
+        annotations: [ktAnnotation('Deprecated')],
+        accessModifier: 'private',
+        extends: ['Bar', 'Baz'],
+        generics: [ktGenericParameter('T')],
+        members: ['// Comment 1', '// Comment 2'],
+        companionObject: ktObject(),
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      normalizeEOL(8)(
+        `/**
+         * This is a foo
+         */
+        @Deprecated
+        private interface Foo<T> : Bar, Baz {
+            companion object {}
+
+            // Comment 1
+            // Comment 2
+        }
+        `,
+      ),
+    );
+  });
+
+  it('should render injections', () => {
+    builder.append(
+      ktInterface('Foo', {
+        doc: ktDoc('This is a foo'),
+        annotations: [ktAnnotation('Deprecated')],
+        accessModifier: 'private',
+        extends: ['Bar', 'Baz'],
+        generics: [ktGenericParameter('T')],
+        members: ['// Comment 1', '// Comment 2'],
+        companionObject: ktObject(),
+        inject: {
+          before: '║b║',
+          after: '║a║',
+          beforeDoc: '║bd║',
+          afterDoc: '║ad║',
+          beforeAnnotations: '║ba║',
+          afterAnnotations: '║aa║',
+          beforeModifiers: '║bm║',
+          afterModifiers: '║am║',
+          beforeName: '║bn║',
+          afterName: '║an║',
+          beforeGenerics: '║bg║',
+          afterGenerics: '║ag║',
+          beforeExtends: '║be║',
+          afterExtends: '║ae║',
+          beforeBody: '║bb║',
+          afterBody: '║ab║',
+          beforeMembers: '║bm║',
+          afterMembers: '║am║',
+        },
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      normalizeEOL(8)(
+        `║b║║bd║
+        /**
+         * This is a foo
+         */
+        ║ad║║ba║@Deprecated
+        ║aa║║bm║private ║am║interface ║bn║Foo║an║║bg║<T>║ag║ : ║be║Bar, Baz║ae║ ║bb║{
+            ║bm║companion object {}
+
+            // Comment 1
+            // Comment 2
+            ║am║
+        }║ab║
+        ║a║`,
+      ),
+    );
+  });
+});

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

@@ -0,0 +1,133 @@
+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,
+});