@goast/kotlin 0.4.7-beta2 → 0.4.8

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

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

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

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

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

@@ -0,0 +1,101 @@
+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 { ktObject } from './object.js';
+
+describe('ktObject', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write object', () => {
+    builder.append(ktObject());
+    expect(builder.toString(false)).toBe(`object {}`);
+  });
+
+  it('should write object with name', () => {
+    builder.append(ktObject({ name: 'Foo' }));
+    expect(builder.toString(false)).toBe(`object Foo {}${EOL}`);
+  });
+
+  it('should write data object', () => {
+    builder.append(ktObject({ name: 'Foo', data: true }));
+    expect(builder.toString(false)).toBe(`data object Foo {}${EOL}`);
+  });
+
+  it('should write base class', () => {
+    builder.append(ktObject({ class: 'Bar' }));
+    expect(builder.toString(false)).toBe(`object : Bar() {}`);
+  });
+
+  it('should write base class arguments', () => {
+    builder.append(ktObject({ class: 'Bar', classArguments: ['1', '2'] }));
+    expect(builder.toString(false)).toBe(`object : Bar(1, 2) {}`);
+  });
+
+  it('should write implemented interfaces', () => {
+    builder.append(ktObject({ implements: ['Bar', 'Baz'] }));
+    expect(builder.toString(false)).toBe(`object : Bar, Baz {}`);
+  });
+
+  it('should write object with members', () => {
+    builder.append(
+      ktObject({
+        members: ['// Comment 1', '// Comment 2'],
+      }),
+    );
+    expect(builder.toString(false)).toBe(`object {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}`);
+  });
+
+  it('should write object with all options', () => {
+    builder.append(
+      ktObject({
+        name: 'Foo',
+        data: true,
+        class: 'Bar',
+        classArguments: ['1', '2'],
+        implements: ['Bar', 'Baz'],
+        members: ['// Comment 1', '// Comment 2'],
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      `data object Foo : Bar(1, 2), Bar, Baz {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`,
+    );
+  });
+
+  it('should render injections', () => {
+    builder.append(
+      ktObject({
+        name: 'Foo',
+        data: true,
+        class: 'Bar',
+        classArguments: ['1', '2'],
+        implements: ['Bar', 'Baz'],
+        members: ['// Comment 1', '// Comment 2'],
+        inject: {
+          before: '║b║',
+          after: '║a║',
+          beforeModifiers: '║bm║',
+          afterModifiers: '║am║',
+          beforeName: '║bn║',
+          afterName: '║an║',
+          beforeInheritList: '║bi║',
+          afterInheritList: '║ai║',
+          beforeBody: '║bb║',
+          afterBody: '║ab║',
+          beforeMembers: '║bm║',
+          afterMembers: '║am║',
+        },
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      `║b║║bm║data ║am║object ║bn║Foo║an║ : ║bi║Bar(1, 2), Bar, Baz║ai║ ║bb║{${EOL}    ║bm║// Comment 1${EOL}    // Comment 2${EOL}    ║am║${EOL}}║ab║${EOL}║a║`,
+    );
+  });
+});

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

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

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

@@ -0,0 +1,191 @@
+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 { ktAnnotation } from './annotation.js';
+import { ktParameter } from './parameter.js';
+
+describe('ktParameter', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  describe('single parameter', () => {
+    it('should write the name and type of the parameter', () => {
+      builder.append(ktParameter('x', 'Int'));
+      expect(builder.toString(false)).toBe('x: Int');
+    });
+
+    it('should write the default if it exists', () => {
+      builder.append(ktParameter('x', 'Int', { default: '42' }));
+      expect(builder.toString(false)).toBe('x: Int = 42');
+    });
+
+    it('should write vararg if it exists', () => {
+      builder.append(ktParameter('x', 'Int', { vararg: true }));
+      expect(builder.toString(false)).toBe('vararg x: Int');
+    });
+
+    it('should write all annotations', () => {
+      builder.append(ktParameter('x', 'Int', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
+      expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}x: Int`);
+    });
+
+    it('should write all the parts of the parameter', () => {
+      builder.append(
+        ktParameter('x', 'Int', {
+          default: '42',
+          vararg: true,
+          annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+        }),
+      );
+      expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}vararg x: Int = 42`);
+    });
+
+    it('should render injections', () => {
+      builder.append(ktParameter('x', 'Int', { inject: { before: ['before'], after: ['after'] } }));
+      expect(builder.toString(false)).toBe('beforex: Intafter');
+    });
+  });
+
+  describe('multiple', () => {
+    it('should write parenthesis if the node is empty', () => {
+      ktParameter.write(builder, []);
+      expect(builder.toString(false)).toBe('()');
+    });
+
+    it('should write a single parameter', () => {
+      ktParameter.write(builder, [ktParameter('x', 'Int')]);
+      expect(builder.toString(false)).toBe(`(x: Int)`);
+    });
+
+    it('should write all the parameters', () => {
+      ktParameter.write(builder, [ktParameter('x', 'Int'), ktParameter('y', 'String')]);
+      expect(builder.toString(false)).toBe(`(x: Int, y: String)`);
+    });
+
+    it('should multiline if there are more than 2 parameters', () => {
+      ktParameter.write(builder, [ktParameter('x', 'Int'), ktParameter('y', 'String'), ktParameter('z', 'Boolean')]);
+      expect(builder.toString(false)).toBe(`(${EOL}    x: Int,${EOL}    y: String,${EOL}    z: Boolean${EOL})`);
+    });
+
+    it('should multiline if there are annotations', () => {
+      ktParameter.write(builder, [ktParameter('x', 'Int', { annotations: [ktAnnotation('Inject')] })]);
+      expect(builder.toString(false)).toBe(`(${EOL}    @Inject${EOL}    x: Int${EOL})`);
+    });
+
+    it('shoudl add spacing if one parameter has annotations', () => {
+      ktParameter.write(builder, [
+        ktParameter('x', 'Int'),
+        ktParameter('y', 'String', { annotations: [ktAnnotation('Inject')] }),
+      ]);
+      expect(builder.toString(false)).toBe(`(${EOL}    x: Int,${EOL}${EOL}    @Inject${EOL}    y: String${EOL})`);
+    });
+  });
+});
+
+describe('ktClassParameter', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  describe('single class parameter', () => {
+    it('should write the name and type of the parameter', () => {
+      builder.append(ktParameter.class('x', 'Int'));
+      expect(builder.toString(false)).toBe('x: Int');
+    });
+
+    it('should write the default if it exists', () => {
+      builder.append(ktParameter.class('x', 'Int', { default: '42' }));
+      expect(builder.toString(false)).toBe('x: Int = 42');
+    });
+
+    it('should write override if it exists', () => {
+      builder.append(ktParameter.class('x', 'Int', { override: true, property: 'mutable' }));
+      expect(builder.toString(false)).toBe('override var x: Int');
+    });
+
+    it('should write vararg if it exists', () => {
+      builder.append(ktParameter.class('x', 'Int', { vararg: true }));
+      expect(builder.toString(false)).toBe('vararg x: Int');
+    });
+
+    it('should write val keyword if readonly property', () => {
+      builder.append(ktParameter.class('x', 'Int', { property: 'readonly' }));
+      expect(builder.toString(false)).toBe('val x: Int');
+    });
+
+    it('should write var keyword if mutable property', () => {
+      builder.append(ktParameter.class('x', 'Int', { property: 'mutable' }));
+      expect(builder.toString(false)).toBe('var x: Int');
+    });
+
+    it('should write accessModifier if also property', () => {
+      builder.append(ktParameter.class('x', 'Int', { accessModifier: 'private', property: 'mutable' }));
+      expect(builder.toString(false)).toBe('private var x: Int');
+    });
+
+    it('should not write accessModifier if no property', () => {
+      builder.append(ktParameter.class('x', 'Int', { accessModifier: 'private' }));
+      expect(builder.toString(false)).toBe('x: Int');
+    });
+
+    it('should write all annotations', () => {
+      builder.append(
+        ktParameter.class('x', 'Int', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }),
+      );
+      expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}x: Int`);
+    });
+
+    it('should write all the parts of the class parameter', () => {
+      builder.append(
+        ktParameter.class('x', 'Int', {
+          default: '42',
+          override: true,
+          vararg: true,
+          property: 'mutable',
+          accessModifier: 'private',
+          annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+        }),
+      );
+      expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}private override vararg var x: Int = 42`);
+    });
+
+    it('should render injections', () => {
+      builder.append(
+        ktParameter.class('x', 'Int', {
+          default: '42',
+          override: true,
+          vararg: true,
+          property: 'mutable',
+          accessModifier: 'private',
+          annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+          inject: {
+            before: '║b║',
+            after: '║a║',
+            beforeAnnotations: '║ba║',
+            afterAnnotations: '║aa║',
+            beforeModifiers: '║bm║',
+            afterModifiers: '║am║',
+            beforeName: '║bn║',
+            afterName: '║an║',
+            beforeType: '║bt║',
+            afterType: '║at║',
+            beforeDefault: '║bd║',
+            afterDefault: '║ad║',
+          },
+        }),
+      );
+      expect(builder.toString(false)).toBe(
+        `║b║║ba║@Inject${EOL}@Optional${EOL}║aa║║bm║private override vararg ║am║var ║bn║x║an║: ║bt║Int║at║ = ║bd║42║ad║║a║`,
+      );
+    });
+  });
+});

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

@@ -0,0 +1,118 @@
+import {
+  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 } from '../utils/write-kt-node.js';
+import { writeKtParameters } from '../utils/write-kt-parameters.js';
+import { type KtAnnotation, ktAnnotation } from './annotation.js';
+import type { KtType, KtValue } from './types.js';
+
+type Injects = 'modifiers' | 'annotations' | 'name' | 'type' | 'default';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    name: string;
+    type: KtType<TBuilder>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    default?: Nullable<KtValue<TBuilder>>;
+    vararg?: Nullable<boolean>;
+    description?: Nullable<BasicAppendValue<TBuilder>>;
+
+    // class parameter options
+    accessModifier?: Nullable<KtAccessModifier>;
+    property?: Nullable<'readonly' | 'mutable'>;
+    propertyDescription?: Nullable<BasicAppendValue<TBuilder>>;
+    override?: Nullable<boolean>;
+  }
+>;
+
+export class KtParameter<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public name: string;
+  public type: KtType<TBuilder>;
+  public annotations: KtAnnotation<TBuilder>[];
+  public default: KtValue<TBuilder> | null;
+  public vararg: boolean;
+  public description: BasicAppendValue<TBuilder> | null;
+
+  // class parameter options
+  public accessModifier: KtAccessModifier | null;
+  public property: 'readonly' | 'mutable' | null;
+  public propertyDescription: BasicAppendValue<TBuilder> | null;
+  public override: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options.name;
+    this.type = options.type;
+    this.annotations = options.annotations?.filter(notNullish) ?? [];
+    this.default = options.default ?? null;
+    this.vararg = options.vararg ?? false;
+    this.description = options.description ?? null;
+
+    this.accessModifier = options.accessModifier ?? null;
+    this.property = options.property ?? null;
+    this.propertyDescription = options.propertyDescription ?? null;
+    this.override = options.override ?? false;
+  }
+
+  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 && this.property) builder.append(this.accessModifier, ' ');
+    if (this.override && this.property) builder.append('override ');
+    if (this.vararg) builder.append('vararg ');
+    builder.append(this.inject.afterModifiers);
+
+    if (this.property) builder.append(this.property === 'mutable' ? 'var' : 'val', ' ');
+    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+
+    builder.append(': ');
+
+    builder.append(this.inject.beforeType);
+    writeKtNode(builder, this.type);
+    builder.append(this.inject.afterType);
+
+    if (this.default) {
+      builder.append(' = ');
+      builder.append(this.inject.beforeDefault);
+      writeKtNode(builder, this.default);
+      builder.append(this.inject.afterDefault);
+    }
+  }
+}
+
+const createParameter = <TBuilder extends SourceBuilder>(
+  name: KtParameter<TBuilder>['name'],
+  type: KtParameter<TBuilder>['type'],
+  options?: Prettify<
+    Omit<Options<TBuilder>, 'name' | 'type' | 'accessModifier' | 'property' | 'propertyDescription' | 'override'>
+  >,
+): KtParameter<TBuilder> => new KtParameter<TBuilder>({ ...options, name, type });
+
+const createClassParameter = <TBuilder extends SourceBuilder>(
+  name: KtParameter<TBuilder>['name'],
+  type: KtParameter<TBuilder>['type'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'type'>>,
+): KtParameter<TBuilder> => new KtParameter<TBuilder>({ ...options, name, type });
+
+export const ktParameter: typeof createParameter & {
+  class: typeof createClassParameter;
+  write: typeof writeKtParameters;
+} = Object.assign(createParameter, {
+  class: createClassParameter,
+  write: writeKtParameters,
+});