@goast/kotlin 0.4.4-beta2 → 0.4.5

package/src/src/ast/nodes/constructor.ts

@@ -0,0 +1,126 @@
+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 { writeKtNodes } from '../utils/write-kt-node.js';
+import { type KtAnnotation, ktAnnotation } from './annotation.js';
+import { type KtArgument, ktArgument } from './argument.js';
+import { type KtParameter, ktParameter } from './parameter.js';
+import type { KtValue } from './types.js';
+
+type Injects = 'annotations' | 'modifiers' | 'params' | 'body' | 'delegate';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    accessModifier?: Nullable<KtAccessModifier>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    parameters?: Nullable<Nullable<KtParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    delegateTarget?: Nullable<KtDelegateTarget>;
+    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+  }
+>;
+
+export type KtDelegateTarget = 'this' | 'super';
+
+export class KtConstructor<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public accessModifier: KtAccessModifier | null;
+  public annotations: KtAnnotation<TBuilder>[];
+  public parameters: (KtParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
+  public body: AppendValue<TBuilder> | null;
+  public delegateTarget: KtDelegateTarget | null;
+  public delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[];
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.parameters = options.parameters?.filter(notNullish) ?? [];
+    this.body = options.body ?? null;
+    this.accessModifier = options.accessModifier ?? null;
+    this.annotations = options.annotations?.filter(notNullish) ?? [];
+    this.delegateTarget = options.delegateTarget ?? null;
+    this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? [];
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    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('constructor');
+
+    builder.append(this.inject.beforeParams);
+    ktParameter.write(builder, this.parameters);
+    builder.append(this.inject.afterParams);
+
+    if (this.delegateTarget) {
+      builder.append(' : ');
+      builder.append(this.inject.beforeDelegate);
+      builder.append(this.delegateTarget);
+      ktArgument.write(builder, this.delegateArguments);
+      builder.append(this.inject.afterDelegate);
+    }
+
+    builder.append(' ');
+    builder.append(this.inject.beforeBody);
+    builder.parenthesize('{}', this.body, { multiline: !!this.body });
+    builder.append(this.inject.afterBody);
+
+    builder.appendLine();
+  }
+
+  public writeAsPrimary(builder: TBuilder): void {
+    builder.append(this.inject.before);
+    this.onWriteAsPrimary(builder);
+    builder.append(this.inject.after);
+  }
+
+  protected onWriteAsPrimary(builder: TBuilder): void {
+    const needsCtorKeyword = this.annotations.length > 0 || !!this.accessModifier;
+    if (needsCtorKeyword) builder.append(' ');
+
+    builder.append(this.inject.beforeAnnotations);
+    ktAnnotation.write(builder, this.annotations);
+    builder.append(this.inject.afterAnnotations);
+
+    builder.append(this.inject.beforeModifiers);
+    if (this.accessModifier) builder.append(this.accessModifier, ' ');
+    builder.append(this.inject.afterModifiers);
+
+    if (needsCtorKeyword) builder.append('constructor');
+
+    if (needsCtorKeyword || this.parameters.length > 0) {
+      builder.append(this.inject.beforeParams);
+      ktParameter.write(builder, this.parameters);
+      builder.append(this.inject.afterParams);
+    }
+  }
+}
+
+const createConstructor = <TBuilder extends SourceBuilder>(
+  parameters?: Options<TBuilder>['parameters'],
+  body?: Options<TBuilder>['body'],
+  options?: Prettify<Omit<Options<TBuilder>, 'parameters' | 'body'>>,
+): KtConstructor<TBuilder> => new KtConstructor<TBuilder>({ ...options, parameters: parameters ?? undefined, body });
+
+export const ktConstructor: typeof createConstructor & { write: typeof writeKtNodes } = Object.assign(
+  createConstructor,
+  {
+    write: writeKtNodes,
+  },
+);

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

@@ -0,0 +1,84 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktDocTag } from './doc-tag.js';
+
+describe('ktDocTag', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write custom tag', () => {
+    builder.append(ktDocTag('custom'));
+    expect(builder.toString(false)).toBe('@custom');
+  });
+
+  it('should write custom tag with description', () => {
+    builder.append(ktDocTag('custom', { description: 'description' }));
+    expect(builder.toString(false)).toBe('@custom description');
+  });
+
+  it('should write param tag', () => {
+    builder.append(ktDocTag('param', 'x', 'description'));
+    expect(builder.toString(false)).toBe('@param x description');
+  });
+
+  it('should write return tag', () => {
+    builder.append(ktDocTag('return', 'description'));
+    expect(builder.toString(false)).toBe('@return description');
+  });
+
+  it('should write constructor tag', () => {
+    builder.append(ktDocTag('constructor', 'description'));
+    expect(builder.toString(false)).toBe('@constructor description');
+  });
+
+  it('should write receiver tag', () => {
+    builder.append(ktDocTag('receiver', 'description'));
+    expect(builder.toString(false)).toBe('@receiver description');
+  });
+
+  it('should write property tag', () => {
+    builder.append(ktDocTag('property', 'name', 'description'));
+    expect(builder.toString(false)).toBe('@property name description');
+  });
+
+  it('should write throws tag', () => {
+    builder.append(ktDocTag('throws', 'exception', 'description'));
+    expect(builder.toString(false)).toBe('@throws exception description');
+  });
+
+  it('should write exception tag', () => {
+    builder.append(ktDocTag('exception', 'exception', 'description'));
+    expect(builder.toString(false)).toBe('@exception exception description');
+  });
+
+  it('should write see tag', () => {
+    builder.append(ktDocTag('see', 'reference'));
+    expect(builder.toString(false)).toBe('@see reference');
+  });
+
+  it('should write author tag', () => {
+    builder.append(ktDocTag('author', 'name'));
+    expect(builder.toString(false)).toBe('@author name');
+  });
+
+  it('should write since tag', () => {
+    builder.append(ktDocTag('since', 'version'));
+    expect(builder.toString(false)).toBe('@since version');
+  });
+
+  it('should write supress tag', () => {
+    builder.append(ktDocTag('suppress'));
+    expect(builder.toString(false)).toBe('@suppress');
+  });
+
+  it('should render injections', () => {
+    builder.append(ktDocTag('custom', { inject: { before: 'before', after: 'after' } }));
+    expect(builder.toString(false)).toBe('before@customafter');
+  });
+});

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

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

@@ -0,0 +1,42 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/bdd.js';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktDocTag } from './doc-tag.js';
+import { ktDoc } from './doc.js';
+
+describe('ktDoc', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should not write anything if the node is empty', () => {
+    builder.append(ktDoc(null));
+    expect(builder.toString(false)).toBe('');
+  });
+
+  it('should write description', () => {
+    builder.append(ktDoc('description'));
+    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} */${EOL}`);
+  });
+
+  it('should write tags', () => {
+    builder.append(ktDoc(null, [ktDocTag('tag1'), ktDocTag('tag2')]));
+    expect(builder.toString(false)).toBe(`/**${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
+  });
+
+  it('should write all the parts of the node', () => {
+    builder.append(ktDoc('description', [ktDocTag('tag1'), ktDocTag('tag2')]));
+    expect(builder.toString(false)).toBe(`/**${EOL} * description${EOL} *${EOL} * @tag1${EOL} * @tag2${EOL} */${EOL}`);
+  });
+
+  it('should render injections', () => {
+    builder.append(ktDoc('hello', [], { inject: { before: ['before'], after: ['after'] } }));
+    expect(builder.toString(false)).toBe(`before${EOL}/**${EOL} * hello${EOL} */${EOL}after`);
+  });
+});

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

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

@@ -0,0 +1,146 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.8/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.5/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 { ktEnumValue } from './enum-value.js';
+
+describe('ktEnumValue', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write enum value', () => {
+    builder.append(ktEnumValue('FOO'));
+    expect(builder.toString(false)).toBe('FOO');
+  });
+
+  it('should write enum value with arguments', () => {
+    builder.append(ktEnumValue('FOO', { arguments: ['x', 'y'] }));
+    expect(builder.toString(false)).toBe('FOO(x, y)');
+  });
+
+  it('should write enum value with documenation', () => {
+    builder.append(ktEnumValue('FOO', { doc: ktDoc('This is a foo') }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}FOO`);
+  });
+
+  it('should write enum value with annotations', () => {
+    builder.append(ktEnumValue('FOO', { annotations: [ktAnnotation('Deprecated')] }));
+    expect(builder.toString(false)).toBe(`@Deprecated${EOL}FOO`);
+  });
+
+  it('should write enum value with members', () => {
+    builder.append(
+      ktEnumValue('FOO', {
+        members: ['// Comment 1', '// Comment 2'],
+      }),
+    );
+    expect(builder.toString(false)).toBe(`FOO {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}`);
+  });
+
+  it('should write enum value with all options', () => {
+    builder.append(
+      ktEnumValue('FOO', {
+        doc: ktDoc('This is a foo'),
+        annotations: [ktAnnotation('Deprecated')],
+        arguments: ['x', 'y'],
+        members: ['// Comment 1', '// Comment 2'],
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      normalizeEOL(8)(
+        `/**
+         * This is a foo
+         */
+        @Deprecated
+        FOO(x, y) {
+            // Comment 1
+            // Comment 2
+        }`,
+      ),
+    );
+  });
+
+  it('should render injections', () => {
+    builder.append(
+      ktEnumValue('FOO', {
+        doc: ktDoc('This is a foo'),
+        annotations: [ktAnnotation('Deprecated')],
+        arguments: ['x', 'y'],
+        members: ['// Comment 1', '// Comment 2'],
+        inject: {
+          before: '║b║',
+          after: '║a║',
+          beforeDoc: '║bd║',
+          afterDoc: '║ad║',
+          beforeAnnotations: '║ba║',
+          afterAnnotations: '║aa║',
+          beforeName: '║bn║',
+          afterName: '║an║',
+          beforeArguments: '║ba║',
+          afterArguments: '║aa║',
+          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║║bn║FOO║an║║ba║(x, y)║aa║ ║bb║{
+            ║bm║// Comment 1
+            // Comment 2
+            ║am║
+        }║ab║║a║`,
+      ),
+    );
+  });
+});
+
+describe('writeKtEnumValues', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write enum values in single line', () => {
+    ktEnumValue.write(builder, [ktEnumValue('FOO'), ktEnumValue('BAR')]);
+    expect(builder.toString(false)).toBe('FOO, BAR');
+  });
+
+  it('should write enum values in multiline', () => {
+    ktEnumValue.write(builder, [
+      ktEnumValue('FOO'),
+      ktEnumValue('BAR'),
+      ktEnumValue('BAZ'),
+      ktEnumValue('QUX'),
+      ktEnumValue('QUUX'),
+    ]);
+    expect(builder.toString(false)).toBe(`FOO,${EOL}BAR,${EOL}BAZ,${EOL}QUX,${EOL}QUUX`);
+  });
+
+  it('should write enum values with space between', () => {
+    ktEnumValue.write(builder, [
+      ktEnumValue('FOO'),
+      ktEnumValue('BAR', { annotations: [ktAnnotation('Deprecated')] }),
+      ktEnumValue('BAZ'),
+    ]);
+    expect(builder.toString(false)).toBe(`FOO,${EOL}${EOL}@Deprecated${EOL}BAR,${EOL}${EOL}BAZ`);
+  });
+});