@goast/kotlin 0.4.3 → 0.4.4-beta1

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.test.ts

@@ -1,167 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
-
-import { normalizeEOL } from '@goast/test-utils';
-
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktConstructor } from './constructor.js';
-import { ktDoc } from './doc.js';
-import { ktEnumValue } from './enum-value.js';
-import { ktEnum } from './enum.js';
-import { ktObject } from './object.js';
-import { ktParameter } from './parameter.js';
-
-describe('ktEnum', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should write enum', () => {
-    builder.append(ktEnum('Foo'));
-    expect(builder.toString(false)).toBe(`enum class Foo${EOL}`);
-  });
-
-  it('should write enum with values', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')]));
-    expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR, BAZ${EOL}}${EOL}`);
-  });
-
-  it('should write documenation', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { doc: ktDoc('This is a foo') }));
-    expect(builder.toString(false)).toBe(
-      `/**${EOL} * This is a foo${EOL} */${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`,
-    );
-  });
-
-  it('should write annotations', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { annotations: [ktAnnotation('Deprecated')] }));
-    expect(builder.toString(false)).toBe(`@Deprecated${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
-  });
-
-  it('should write access modifiers', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { accessModifier: 'private' }));
-    expect(builder.toString(false)).toBe(`private enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
-  });
-
-  it('should write primary constructor', () => {
-    builder.append(
-      ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-        primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-      }),
-    );
-    expect(builder.toString(false)).toBe(`enum class Foo(x: Int, y: Int) {${EOL}    BAR(0, 1)${EOL}}${EOL}`);
-  });
-
-  it('should write members', () => {
-    builder.append(
-      ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')], { members: ['// Comment 1', '// Comment 2'] }),
-    );
-    expect(builder.toString(false)).toBe(
-      `enum class Foo {${EOL}    BAR, BAZ;${EOL}${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`,
-    );
-  });
-
-  it('should write implemented interfaces', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { implements: ['Bar', 'Baz'] }));
-    expect(builder.toString(false)).toBe(`enum class Foo : Bar, Baz {${EOL}    BAR${EOL}}${EOL}`);
-  });
-
-  it('should write companion object', () => {
-    builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { companionObject: ktObject() }));
-    expect(builder.toString(false)).toBe(
-      `enum class Foo {${EOL}    BAR;${EOL}${EOL}    companion object {}${EOL}}${EOL}`,
-    );
-  });
-
-  it('should write all options', () => {
-    builder.append(
-      ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-        doc: ktDoc('This is a foo'),
-        annotations: [ktAnnotation('Deprecated')],
-        accessModifier: 'private',
-        primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-        implements: ['Bar', 'Baz'],
-        members: ['// Comment 1', '// Comment 2'],
-        companionObject: ktObject(),
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `/**
-         * This is a foo
-         */
-        @Deprecated
-        private enum class Foo(x: Int, y: Int) : Bar, Baz {
-            BAR(0, 1);
-
-            companion object {}
-
-            // Comment 1
-            // Comment 2
-        }
-        `,
-      ),
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
-        doc: ktDoc('This is a foo'),
-        annotations: [ktAnnotation('Deprecated')],
-        accessModifier: 'private',
-        primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
-        implements: ['Bar', 'Baz'],
-        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║',
-          beforePrimaryConstructor: '║bpc║',
-          afterPrimaryConstructor: '║apc║',
-          beforeImplements: '║bi║',
-          afterImplements: '║ai║',
-          beforeBody: '║bb║',
-          afterBody: '║ab║',
-          beforeValues: '║bv║',
-          afterValues: '║av║',
-          beforeMembers: '║bm║',
-          afterMembers: '║am║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `║b║║bd║
-        /**
-         * This is a foo
-         */
-        ║ad║║ba║@Deprecated
-        ║aa║║bm║private ║am║enum class ║bn║Foo║an║║bpc║(x: Int, y: Int)║apc║ : ║bi║Bar, Baz║ai║ ║bb║{
-            ║bv║BAR(0, 1);
-
-            ║av║║bm║companion object {}
-
-            // Comment 1
-            // Comment 2
-            ║am║
-        }║ab║
-        ║a║`,
-      ),
-    );
-  });
-});

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.test.ts

@@ -1,194 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
-import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
-
-import { KotlinFileBuilder } from '../../file-builder.js';
-import { ktAnnotation } from './annotation.js';
-import { ktDoc } from './doc.js';
-import { ktFunction } from './function.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import { ktParameter } from './parameter.js';
-
-describe('ktFunction', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should write an empty function', () => {
-    builder.append(ktFunction('foo'));
-    expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-  });
-
-  it('should write a function with generics', () => {
-    builder.append(ktFunction('foo', { generics: [ktGenericParameter('T')] }));
-    expect(builder.toString(false)).toBe(`fun <T> foo() {}${EOL}`);
-  });
-
-  it('should write a function with a single parameter', () => {
-    builder.append(ktFunction('foo', { parameters: [ktParameter('x', 'Int')] }));
-    expect(builder.toString(false)).toBe(`fun foo(x: Int) {}${EOL}`);
-  });
-
-  it('should write a function with a return type', () => {
-    builder.append(ktFunction('foo', { returnType: 'Int' }));
-    expect(builder.toString(false)).toBe(`fun foo(): Int {}${EOL}`);
-  });
-
-  it('should write a function with a body', () => {
-    builder.append(ktFunction('foo', { body: 'println("Hello")' }));
-    expect(builder.toString(false)).toBe(`fun foo() {${EOL}    println("Hello")${EOL}}${EOL}`);
-  });
-
-  it('should write access modifiers if they exist', () => {
-    builder.append(ktFunction('foo', { accessModifier: 'private' }));
-    expect(builder.toString(false)).toBe(`private fun foo() {}${EOL}`);
-  });
-
-  it('should write all annotations', () => {
-    builder.append(ktFunction('foo', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-    expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}fun foo() {}${EOL}`);
-  });
-
-  it('should write receiver type if it exists', () => {
-    builder.append(ktFunction('foo', { receiverType: 'String' }));
-    expect(builder.toString(false)).toBe(`fun String.foo() {}${EOL}`);
-  });
-
-  it('should write receiver annotations if they exist and a receiver type exists', () => {
-    builder.append(ktFunction('foo', { receiverType: 'String', receiverAnnotations: [ktAnnotation('Fancy')] }));
-    expect(builder.toString(false)).toBe(`fun @Fancy String.foo() {}${EOL}`);
-  });
-
-  it('shoudl not write receiver annotations if they exist and a receiver type does not exist', () => {
-    builder.append(ktFunction('foo', { receiverAnnotations: [ktAnnotation('Fancy')] }));
-    expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-  });
-
-  it('should write single expression if configured and body exists', () => {
-    builder.append(ktFunction('foo', { body: '42', singleExpression: true }));
-    expect(builder.toString(false)).toBe(`fun foo() = 42${EOL}`);
-  });
-
-  it('should not write single expression if configured and body does not exist', () => {
-    builder.append(ktFunction('foo', { singleExpression: true }));
-    expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
-  });
-
-  it('should write open keyword if configured', () => {
-    builder.append(ktFunction('foo', { open: true }));
-    expect(builder.toString(false)).toBe(`open fun foo() {}${EOL}`);
-  });
-
-  it('should write inline keyword if configured', () => {
-    builder.append(ktFunction('foo', { inline: true }));
-    expect(builder.toString(false)).toBe(`inline fun foo() {}${EOL}`);
-  });
-
-  it('should write infix keyword if configured', () => {
-    builder.append(ktFunction('foo', { infix: true }));
-    expect(builder.toString(false)).toBe(`infix fun foo() {}${EOL}`);
-  });
-
-  it('should write tailrec keyword if configured', () => {
-    builder.append(ktFunction('foo', { tailrec: true }));
-    expect(builder.toString(false)).toBe(`tailrec fun foo() {}${EOL}`);
-  });
-
-  it('should write operator keyword if configured', () => {
-    builder.append(ktFunction('foo', { operator: true }));
-    expect(builder.toString(false)).toBe(`operator fun foo() {}${EOL}`);
-  });
-
-  it('should write override keyword if configured', () => {
-    builder.append(ktFunction('foo', { override: true }));
-    expect(builder.toString(false)).toBe(`override fun foo() {}${EOL}`);
-  });
-
-  it('should write abstract keyword if configured', () => {
-    builder.append(ktFunction('foo', { abstract: true }));
-    expect(builder.toString(false)).toBe(`abstract fun foo()${EOL}`);
-  });
-
-  it('should write documenation if it exists', () => {
-    builder.append(ktFunction('foo', { doc: ktDoc('This is a function') }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * This is a function${EOL} */${EOL}fun foo() {}${EOL}`);
-  });
-
-  it('should write all the parts of the function', () => {
-    builder.append(
-      ktFunction('foo', {
-        generics: [ktGenericParameter('T')],
-        parameters: [ktParameter('x', 'Int')],
-        returnType: 'Int',
-        doc: ktDoc('This is a function'),
-        body: 'println("Hello")',
-        accessModifier: 'private',
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        receiverType: 'String',
-        receiverAnnotations: [ktAnnotation('Fancy')],
-        singleExpression: true,
-        open: true,
-        inline: true,
-        infix: true,
-        tailrec: true,
-        operator: true,
-        override: true,
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      `/**${EOL} * This is a function${EOL} */${EOL}@Inject${EOL}@Optional${EOL}private inline infix tailrec open override operator fun <T> @Fancy String.foo(x: Int): Int = println("Hello")${EOL}`,
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      ktFunction('foo', {
-        generics: [ktGenericParameter('T')],
-        parameters: [ktParameter('x', 'Int')],
-        doc: ktDoc('This is a function'),
-        returnType: 'Int',
-        body: 'println("Hello")',
-        accessModifier: 'private',
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        receiverType: 'String',
-        receiverAnnotations: [ktAnnotation('Fancy')],
-        singleExpression: true,
-        open: true,
-        inline: true,
-        infix: true,
-        tailrec: true,
-        operator: true,
-        override: true,
-        inject: {
-          before: '║bg║',
-          after: '║ag║',
-          beforeGenerics: '║bgg║',
-          afterGenerics: '║agg║',
-          beforeModifiers: '║bm║',
-          afterModifiers: '║am║',
-          beforeName: '║bn║',
-          afterName: '║an║',
-          beforeParameters: '║bp║',
-          afterParameters: '║ap║',
-          beforeReturnType: '║br║',
-          afterReturnType: '║ar║',
-          beforeReceiverType: '║brt║',
-          afterReceiverType: '║art║',
-          beforeReceiverAnnotations: '║bra║',
-          afterReceiverAnnotations: '║ara║',
-          beforeAnnotations: '║ba║',
-          afterAnnotations: '║aa║',
-          beforeDoc: '║bd║',
-          afterDoc: '║ad║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      `║bg║║bd║${EOL}/**${EOL} * This is a function${EOL} */${EOL}║ad║║ba║@Inject${EOL}@Optional${EOL}║aa║║bm║private inline infix tailrec open override operator ║am║fun ║bgg║<T>║agg║ ║bra║@Fancy ║ara║║brt║String║art║.║bn║foo║an║║bp║(x: Int)║ap║: ║br║Int║ar║ = println("Hello")${EOL}║ag║`,
-    );
-  });
-});