@goast/kotlin 0.4.3 → 0.4.4-beta2

package/src/src/ast/nodes/class.test.ts

@@ -1,274 +0,0 @@
-import "../../../_dnt.test_polyfills.js";
-import { EOL } from 'node:os';
-
-import { appendValueGroup } from '@goast/core';
-import { normalizeEOL } from '@goast/test-utils';
-
-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 { ktClass } from './class.js';
-import { ktConstructor } from './constructor.js';
-import { ktDoc } from './doc.js';
-import { ktFunction } from './function.js';
-import { ktGenericParameter } from './generic-parameter.js';
-import { ktInitBlock } from './init-block.js';
-import { ktObject } from './object.js';
-import { ktParameter } from './parameter.js';
-import { ktProperty } from './property.js';
-
-describe('ktClass', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should write class', () => {
-    builder.append(ktClass('Foo'));
-    expect(builder.toString(false)).toBe(`class Foo${EOL}`);
-  });
-
-  it('should write generics', () => {
-    builder.append(ktClass('Foo', { generics: [ktGenericParameter('T'), ktGenericParameter('U')] }));
-    expect(builder.toString(false)).toBe(`class Foo<T, U>${EOL}`);
-  });
-
-  it('should write primary constructor without body', () => {
-    builder.append(ktClass('Foo', { primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null) }));
-    expect(builder.toString(false)).toBe(`class Foo(x: Int)${EOL}`);
-  });
-
-  it('should write primary constructor with body', () => {
-    builder.append(
-      ktClass('Foo', { primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], 'println(x)') }),
-    );
-    expect(builder.toString(false)).toBe(
-      `class Foo(x: Int) {${EOL}    init {${EOL}        println(x)${EOL}    }${EOL}}${EOL}`,
-    );
-  });
-
-  it('should write members', () => {
-    builder.append(
-      ktClass('Foo', {
-        members: [
-          ktConstructor([ktParameter('x', 'Int')], 'println(x)'),
-          ktInitBlock('println("Hello")'),
-          ktProperty('y', { type: 'Int?' }),
-          ktProperty('z', { type: 'String?' }),
-          ktFunction('bar', { parameters: [ktParameter('x', 'Int')], body: 'println(x)' }),
-          ktClass('Bar'),
-          '// Comment 1',
-          appendValueGroup(['// Comment 2', '// Comment 3'], '\n'),
-        ],
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `class Foo {
-            constructor(x: Int) {
-                println(x)
-            }
-
-            init {
-                println("Hello")
-            }
-
-            val y: Int?
-            val z: String?
-
-            fun bar(x: Int) {
-                println(x)
-            }
-
-            class Bar
-
-            // Comment 1
-            // Comment 2
-            // Comment 3
-        }
-        `,
-      ),
-    );
-  });
-
-  it('should write annotations', () => {
-    builder.append(ktClass('Foo', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-    expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}class Foo${EOL}`);
-  });
-
-  it('should write documentation', () => {
-    builder.append(ktClass('Foo', { doc: ktDoc('This is a class') }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * This is a class${EOL} */${EOL}class Foo${EOL}`);
-  });
-
-  it('should write primary constructor parameter description', () => {
-    builder.append(
-      ktClass('Foo', {
-        primaryConstructor: ktConstructor([ktParameter.class('x', 'Int', { description: 'The number' })]),
-      }),
-    );
-    expect(builder.toString(false)).toBe(`/**${EOL} * @param x The number${EOL} */${EOL}class Foo(x: Int)${EOL}`);
-  });
-
-  it('should write primary constructor parameter property description', () => {
-    builder.append(
-      ktClass('Foo', {
-        primaryConstructor: ktConstructor([
-          ktParameter.class('x', 'Int', { property: 'readonly', propertyDescription: 'The number' }),
-        ]),
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      `/**${EOL} * @property x The number${EOL} */${EOL}class Foo(val x: Int)${EOL}`,
-    );
-  });
-
-  it('should ignore primary constructor parameter property description if property is not set', () => {
-    builder.append(
-      ktClass('Foo', {
-        primaryConstructor: ktConstructor([ktParameter.class('x', 'Int', { propertyDescription: 'The number' })]),
-      }),
-    );
-    expect(builder.toString(false)).toBe(`class Foo(x: Int)${EOL}`);
-  });
-
-  it('should write generic parameter description', () => {
-    builder.append(ktClass('Foo', { generics: [ktGenericParameter('T', { description: 'The type' })] }));
-    expect(builder.toString(false)).toBe(`/**${EOL} * @param T The type${EOL} */${EOL}class Foo<T>${EOL}`);
-  });
-
-  it('should write modifiers', () => {
-    builder.append(ktClass('Foo', { accessModifier: 'private', open: true, abstract: true }));
-    expect(builder.toString(false)).toBe(`private open abstract class Foo${EOL}`);
-  });
-
-  it('should write class kind', () => {
-    builder.append(ktClass('Foo', { classKind: 'annotation' }));
-    expect(builder.toString(false)).toBe(`annotation class Foo${EOL}`);
-  });
-
-  it('should write base class', () => {
-    builder.append(ktClass('Foo', { extends: 'Bar' }));
-    expect(builder.toString(false)).toBe(`class Foo : Bar${EOL}`);
-  });
-
-  it('should write base class constructor arguments', () => {
-    builder.append(
-      ktClass('Foo', {
-        extends: 'Bar',
-        primaryConstructor: ktConstructor([], null, { delegateTarget: 'super', delegateArguments: ['1337', '4711'] }),
-      }),
-    );
-    expect(builder.toString(false)).toBe(`class Foo : Bar(1337, 4711)${EOL}`);
-  });
-
-  it('should write implemented interfaces', () => {
-    builder.append(ktClass('Foo', { implements: ['Bar', 'Baz'] }));
-    expect(builder.toString(false)).toBe(`class Foo : Bar, Baz${EOL}`);
-  });
-
-  it('should write companion object', () => {
-    builder.append(ktClass('Foo', { companionObject: ktObject() }));
-    expect(builder.toString(false)).toBe(`class Foo {${EOL}    companion object {}${EOL}}${EOL}`);
-  });
-
-  it('should write all parts of the class', () => {
-    builder.append(
-      ktClass('Foo', {
-        generics: [ktGenericParameter('T'), ktGenericParameter('U')],
-        primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null, {
-          delegateTarget: 'super',
-          delegateArguments: ['x'],
-        }),
-        members: [ktProperty('y', { type: 'Int?' })],
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        doc: ktDoc('This is a class'),
-        accessModifier: 'private',
-        open: true,
-        abstract: true,
-        classKind: 'annotation',
-        extends: 'Bar',
-        implements: ['Baz'],
-        companionObject: ktObject(),
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `/**
-         * This is a class
-         */
-        @Inject
-        @Optional
-        private open abstract annotation class Foo<T, U>(x: Int) : Bar(x), Baz {
-            companion object {}
-
-            val y: Int?
-        }
-        `,
-      ),
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      ktClass('Foo', {
-        generics: [ktGenericParameter('T'), ktGenericParameter('U')],
-        primaryConstructor: ktConstructor([ktParameter.class('x', 'Int')], null, {
-          delegateTarget: 'super',
-          delegateArguments: ['x'],
-        }),
-        members: [ktProperty('y', { type: 'Int?' })],
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        doc: ktDoc('This is a class'),
-        accessModifier: 'private',
-        open: true,
-        abstract: true,
-        classKind: 'annotation',
-        extends: 'Bar',
-        implements: ['Baz'],
-        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║',
-          beforePrimaryConstructor: '║bpc║',
-          afterPrimaryConstructor: '║apc║',
-          beforeInheritList: '║bil║',
-          afterInheritList: '║ail║',
-          beforeBody: '║bb║',
-          afterBody: '║ab║',
-          beforeMembers: '║bmb║',
-          afterMembers: '║amb║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `║b║║bd║
-        /**
-         * This is a class
-         */
-        ║ad║║ba║@Inject
-        @Optional
-        ║aa║║bm║private open abstract annotation ║am║class ║bn║Foo║an║║bg║<T, U>║ag║║bpc║(x: Int)║apc║ : ║bil║Bar(x), Baz║ail║ ║bb║{
-            ║bmb║companion object {}
-
-            val y: Int?
-            ║amb║
-        }║ab║
-        ║a║`,
-      ),
-    );
-  });
-});

package/src/src/ast/nodes/class.ts

@@ -1,178 +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 { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
-import { type KtAnnotation, ktAnnotation } from './annotation.js';
-import { ktArgument } from './argument.js';
-import type { KtConstructor } from './constructor.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 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'
-  | 'generics'
-  | 'primaryConstructor'
-  | 'inheritList'
-  | '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>;
-    open?: Nullable<boolean>;
-    abstract?: Nullable<boolean>;
-    classKind?: Nullable<KtClassKind>;
-    name: string;
-    generics?: Nullable<Nullable<KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>>[]>;
-    primaryConstructor?: Nullable<KtConstructor<TBuilder>>;
-    extends?: Nullable<KtType<TBuilder>>;
-    implements?: Nullable<Nullable<KtType<TBuilder>>[]>;
-    companionObject?: Nullable<KtObject<TBuilder>>;
-    members?: Nullable<Nullable<KtClassMember<TBuilder>>[]>;
-  }
->;
-
-export type KtClassKind = 'data' | 'value' | 'annotation' | 'sealed';
-export type KtClassMember<TBuilder extends SourceBuilder> =
-  | KtConstructor<TBuilder>
-  | KtEnum<TBuilder>
-  | KtInitBlock<TBuilder>
-  | KtInterface<TBuilder>
-  | KtProperty<TBuilder>
-  | KtFunction<TBuilder>
-  | KtClass<TBuilder>
-  | AppendValue<TBuilder>;
-
-export class KtClass<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 open: boolean;
-  public abstract: boolean;
-  public classKind: KtClassKind | null;
-  public name: string;
-  public generics: (KtGenericParameter<TBuilder> | BasicAppendValue<TBuilder>)[];
-  public primaryConstructor: KtConstructor<TBuilder> | null;
-  public extends: KtType<TBuilder> | null;
-  public implements: KtType<TBuilder>[];
-  public members: KtClassMember<TBuilder>[];
-  public companionObject: Nullable<KtObject<TBuilder>>;
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.doc = options.doc ?? null;
-    this.annotations = options.annotations?.filter(notNullish) ?? [];
-    this.accessModifier = options.accessModifier ?? null;
-    this.open = options.open ?? false;
-    this.abstract = options.abstract ?? false;
-    this.classKind = options.classKind ?? null;
-    this.name = options.name;
-    this.generics = options.generics?.filter(notNullish) ?? [];
-    this.primaryConstructor = options.primaryConstructor ?? null;
-    this.extends = options.extends ?? null;
-    this.implements = options.implements?.filter(notNullish) ?? [];
-    this.members = options.members?.filter(notNullish) ?? [];
-    this.companionObject = options.companionObject;
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    builder.append(this.inject.beforeDoc);
-    ktDoc.get(this.doc, { generics: this.generics, 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, ' ');
-    if (this.open) builder.append('open ');
-    if (this.abstract) builder.append('abstract ');
-    if (this.classKind) builder.append(this.classKind, ' ');
-    builder.append(this.inject.afterModifiers);
-
-    builder.append('class ');
-    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.primaryConstructor) {
-      builder.append(this.inject.beforePrimaryConstructor);
-      this.primaryConstructor.writeAsPrimary(builder);
-      builder.append(this.inject.afterPrimaryConstructor);
-    }
-
-    if (this.extends || this.implements.length > 0) {
-      builder.append(' : ');
-      builder.append(this.inject.beforeInheritList);
-      writeKtNode(builder, this.extends);
-      if (this.extends && this.primaryConstructor?.delegateTarget === 'super') {
-        ktArgument.write(builder, this.primaryConstructor.delegateArguments);
-      }
-      if (this.extends && this.implements.length > 0) {
-        builder.append(', ');
-      }
-      writeKtNodes(builder, this.implements, { separator: ', ' });
-      builder.append(this.inject.afterInheritList);
-    }
-
-    if (this.members.length > 0 || this.primaryConstructor?.body || this.companionObject) {
-      builder.append(' ');
-      builder.append(this.inject.beforeBody);
-      builder.parenthesize(
-        '{}',
-        (b) => {
-          b.append(this.inject.beforeMembers);
-          writeKtMembers(b, [
-            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
-            this.primaryConstructor?.body ? ktInitBlock(this.primaryConstructor?.body) : null,
-            ...this.members,
-          ]);
-          b.append(this.inject.afterMembers);
-        },
-        { multiline: true },
-      );
-      builder.append(this.inject.afterBody);
-    }
-
-    builder.appendLine();
-  }
-}
-
-const createClass = <TBuilder extends SourceBuilder>(
-  name: Options<TBuilder>['name'],
-  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
-): KtClass<TBuilder> => new KtClass<TBuilder>({ ...options, name });
-
-export const ktClass: typeof createClass & { write: typeof writeKtNodes } = Object.assign(createClass, {
-  write: writeKtNodes,
-});

package/src/src/ast/nodes/collection-literal.ts

@@ -1,49 +0,0 @@
-import { type AstNodeOptions, notNullish, type Nullable, type SourceBuilder } from '@goast/core';
-
-import { KtNode } from '../node.js';
-import { writeKtNodes } from '../utils/write-kt-node.js';
-import type { KtValue } from './types.js';
-
-type Injects = never;
-
-type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
-  typeof KtNode<TBuilder, TInjects | Injects>,
-  {
-    elements: Nullable<Nullable<KtValue<TBuilder>>[]>;
-  }
->;
-
-export class KtCollectionLiteral<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
-  TBuilder,
-  TInjects | Injects
-> {
-  public elements: KtValue<TBuilder>[];
-
-  constructor(options: Options<TBuilder, TInjects>) {
-    super(options);
-    this.elements = options.elements?.filter(notNullish) ?? [];
-  }
-
-  protected override onWrite(builder: TBuilder): void {
-    const multiline = this.elements.length > 2;
-    builder.parenthesize(
-      '[]',
-      (b) => {
-        writeKtNodes(b, this.elements, { separator: multiline ? ',\n' : ', ' });
-      },
-      { multiline },
-    );
-  }
-}
-
-const createCollectionLiteral = <TBuilder extends SourceBuilder>(
-  elements: Options<TBuilder>['elements'],
-  options?: Omit<Options<TBuilder>, 'elements'>,
-): KtCollectionLiteral<TBuilder> => new KtCollectionLiteral<TBuilder>({ ...options, elements });
-
-export const ktCollectionLiteral: typeof createCollectionLiteral & { write: typeof writeKtNodes } = Object.assign(
-  createCollectionLiteral,
-  {
-    write: writeKtNodes,
-  },
-);

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

@@ -1,178 +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 { ktParameter } from './parameter.js';
-
-describe('ktConstructor', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should write an empty constructor', () => {
-    builder.append(ktConstructor([], null));
-    expect(builder.toString(false)).toBe(`constructor() {}${EOL}`);
-  });
-
-  it('should write a constructor with parameters', () => {
-    builder.append(ktConstructor([ktParameter('x', 'Int')], null));
-    expect(builder.toString(false)).toBe(`constructor(x: Int) {}${EOL}`);
-  });
-
-  it('should write a constructor with a body', () => {
-    builder.append(ktConstructor([], 'println("Hello")'));
-    expect(builder.toString(false)).toBe(`constructor() {${EOL}    println("Hello")${EOL}}${EOL}`);
-  });
-
-  it('should write access modifiers if they exist', () => {
-    builder.append(ktConstructor([], null, { accessModifier: 'private' }));
-    expect(builder.toString(false)).toBe(`private constructor() {}${EOL}`);
-  });
-
-  it('should write all annotations', () => {
-    builder.append(ktConstructor([], null, { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
-    expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}constructor() {}${EOL}`);
-  });
-
-  it('should write delegation without arguments', () => {
-    builder.append(ktConstructor([], null, { delegateTarget: 'this' }));
-    expect(builder.toString(false)).toBe(`constructor() : this() {}${EOL}`);
-  });
-
-  it('should write delegation with arguments', () => {
-    builder.append(ktConstructor([], null, { delegateTarget: 'super', delegateArguments: ['42', 'true'] }));
-    expect(builder.toString(false)).toBe(`constructor() : super(42, true) {}${EOL}`);
-  });
-
-  it('should write all the parts of the constructor', () => {
-    builder.append(
-      ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-        accessModifier: 'private',
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        delegateTarget: 'this',
-        delegateArguments: ['42', 'true'],
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `@Inject
-        @Optional
-        private constructor(x: Int) : this(42, true) {
-            println("Hello")
-        }
-        `,
-      ),
-    );
-  });
-
-  it('should render injections', () => {
-    builder.append(
-      ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-        accessModifier: 'private',
-        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-        delegateTarget: 'this',
-        delegateArguments: ['42', 'true'],
-        inject: {
-          before: '║b║',
-          after: '║a║',
-          beforeAnnotations: '║ba║',
-          afterAnnotations: '║aa║',
-          beforeModifiers: '║bm║',
-          afterModifiers: '║am║',
-          beforeParams: '║bp║',
-          afterParams: '║ap║',
-          beforeDelegate: '║bd║',
-          afterDelegate: '║ad║',
-          beforeBody: '║bb║',
-          afterBody: '║ab║',
-        },
-      }),
-    );
-    expect(builder.toString(false)).toBe(
-      normalizeEOL(8)(
-        `║b║║ba║@Inject
-        @Optional
-        ║aa║║bm║private ║am║constructor║bp║(x: Int)║ap║ : ║bd║this(42, true)║ad║ ║bb║{
-            println("Hello")
-        }║ab║
-        ║a║`,
-      ),
-    );
-  });
-});
-
-describe('ktPrimaryConstructor', () => {
-  let builder: KotlinFileBuilder;
-
-  beforeEach(() => {
-    builder = new KotlinFileBuilder();
-  });
-
-  it('should not write anything if there are no parameters, accessModifier, or annotations', () => {
-    ktConstructor().writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe('');
-  });
-
-  it('should not write body', () => {
-    ktConstructor([], 'println("Hello")').writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe('');
-  });
-
-  it('should write accessModifier', () => {
-    ktConstructor([], null, { accessModifier: 'private' }).writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe(' private constructor()');
-  });
-
-  it('should write annotations', () => {
-    ktConstructor([], null, { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }).writeAsPrimary(
-      builder,
-    );
-    expect(builder.toString(false)).toBe(' @Inject @Optional constructor()');
-  });
-
-  it('should write parameters', () => {
-    ktConstructor([ktParameter('x', 'Int')], null).writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe('(x: Int)');
-  });
-
-  it('should write all the parts of the primary constructor', () => {
-    ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-      accessModifier: 'private',
-      annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-    }).writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe(' @Inject @Optional private constructor(x: Int)');
-  });
-
-  it('should render injections', () => {
-    ktConstructor([ktParameter('x', 'Int')], 'println("Hello")', {
-      accessModifier: 'private',
-      annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
-      inject: {
-        before: '║b║',
-        after: '║a║',
-        beforeAnnotations: '║ba║',
-        afterAnnotations: '║aa║',
-        beforeModifiers: '║bm║',
-        afterModifiers: '║am║',
-        beforeParams: '║bp║',
-        afterParams: '║ap║',
-        beforeDelegate: '║bd║',
-        afterDelegate: '║ad║',
-        beforeBody: '║bb║',
-        afterBody: '║ab║',
-      },
-    }).writeAsPrimary(builder);
-    expect(builder.toString(false)).toBe(
-      '║b║ ║ba║@Inject @Optional ║aa║║bm║private ║am║constructor║bp║(x: Int)║ap║║a║',
-    );
-  });
-});