@goast/kotlin 0.4.18-springwebclient1 → 0.4.19

package/src/src/ast/nodes/argument.ts

@@ -0,0 +1,62 @@
+import type { AstNodeOptions, Nullable, Prettify, SourceBuilder } from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtArguments } from '../utils/write-kt-arguments.js';
+import { writeKtNode } from '../utils/write-kt-node.js';
+import type { KtValue } from './types.js';
+
+type Injects = 'name' | 'value';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    name?: Nullable<string>;
+    value: KtValue<TBuilder>;
+  }
+>;
+
+export class KtArgument<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public name: string | null;
+  public value: KtValue<TBuilder>;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options?.name ?? null;
+    this.value = options.value;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.name) {
+      builder.append(this.inject.beforeName);
+      builder.append(this.name);
+      builder.append(this.inject.afterName);
+      builder.append(' = ');
+    }
+
+    builder.append(this.inject.beforeValue);
+    writeKtNode(builder, this.value);
+    builder.append(this.inject.afterValue);
+  }
+}
+
+const createArgument = <TBuilder extends SourceBuilder>(
+  value: Options<TBuilder>['value'],
+  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
+): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value });
+
+const createNamedArgument = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  value: Options<TBuilder>['value'],
+  options?: Prettify<Omit<Options<TBuilder>, 'value' | 'name'>>,
+): KtArgument<TBuilder> => new KtArgument<TBuilder>({ ...options, value, name });
+
+export const ktArgument: typeof createArgument & {
+  named: typeof createNamedArgument;
+  write: typeof writeKtArguments;
+} = Object.assign(createArgument, {
+  named: createNamedArgument,
+  write: writeKtArguments,
+});

package/src/src/ast/nodes/call.ts

@@ -0,0 +1,75 @@
+import {
+  type ArrayItem,
+  type AstNodeOptions,
+  notNullish,
+  type Nullable,
+  type Prettify,
+  type SourceBuilder,
+} from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { type KtArgument, ktArgument } from './argument.js';
+import type { KtType, KtValue } from './types.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    path: Nullable<KtType<TBuilder> | KtValue<TBuilder>>[];
+    arguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    infix?: boolean;
+  }
+>;
+
+export class KtCall<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public path: (KtType<TBuilder> | KtValue<TBuilder>)[];
+  public arguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
+  public infix: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.path = options.path.filter(notNullish);
+    this.arguments = options.arguments?.filter(notNullish) ?? null;
+    this.infix = options.infix ?? false;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.infix && this.arguments?.length === 1 && this.path.length > 1) {
+      writeKtNodes(builder, this.path.slice(0, 1), { separator: '.' });
+      builder.append(' ');
+      writeKtNode(builder, this.path.at(-1));
+      builder.append(' ');
+      writeKtNode(builder, this.arguments[0]);
+    } else {
+      if (this.path.length > 2) {
+        writeKtNode(builder, this.path[0]);
+        builder.ensureCurrentLineEmpty();
+        builder.indent((builder) => {
+          builder.append('.');
+          writeKtNodes(builder, this.path.slice(1), { separator: '\n.' });
+        });
+      } else {
+        writeKtNodes(builder, this.path, { separator: '.' });
+      }
+
+      if (this.arguments) {
+        ktArgument.write(builder, this.arguments);
+      }
+    }
+  }
+}
+
+const createCall = <TBuilder extends SourceBuilder>(
+  path: Options<TBuilder>['path'] | ArrayItem<Options<TBuilder>['path']>,
+  args?: Options<TBuilder>['arguments'],
+  options?: Prettify<Omit<Options<TBuilder>, 'path' | 'arguments'>>,
+): KtCall<TBuilder> => new KtCall<TBuilder>({ ...options, path: Array.isArray(path) ? path : [path], arguments: args });
+
+export const ktCall: typeof createCall & { write: typeof writeKtNodes } = Object.assign(createCall, {
+  write: writeKtNodes,
+});

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

@@ -0,0 +1,178 @@
+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

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