@goast/kotlin 0.4.18-springwebclient1 → 0.4.19

package/src/src/ast/nodes/property.ts

@@ -0,0 +1,225 @@
+import {
+  type AppendValue,
+  type AstNodeOptions,
+  notNullish,
+  type Nullable,
+  type Prettify,
+  type SourceBuilder,
+} from '@goast/core';
+
+import type { KtAccessModifier } from '../common.js';
+import { KtNode } from '../node.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { type KtAnnotation, ktAnnotation } from './annotation.js';
+import { type KtArgument, ktArgument } from './argument.js';
+import type { KtDoc } from './doc.js';
+import type { KtType, KtValue } from './types.js';
+
+type AccessorInjects = 'annotations' | 'modifiers' | 'params' | 'body';
+
+type AccessorOptions<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | AccessorInjects>,
+  {
+    accessModifier?: Nullable<KtAccessModifier>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    body?: Nullable<AppendValue<TBuilder>>;
+    singleExpression?: Nullable<boolean>;
+  }
+>;
+
+export abstract class KtPropertyAccessor<
+  TBuilder extends SourceBuilder,
+  TInjects extends string = never,
+> extends KtNode<TBuilder, TInjects | AccessorInjects> {
+  public abstract get kind(): 'get' | 'set';
+  public accessModifier: KtAccessModifier | null;
+  public annotations: KtAnnotation<TBuilder>[];
+  public body: AppendValue<TBuilder> | null;
+  public singleExpression: boolean;
+
+  constructor(options: AccessorOptions<TBuilder, TInjects>) {
+    super(options);
+    this.accessModifier = options.accessModifier ?? null;
+    this.annotations = options.annotations?.filter(notNullish) ?? [];
+    this.body = options.body ?? null;
+    this.singleExpression = options.singleExpression ?? 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) builder.append(this.accessModifier, ' ');
+    builder.append(this.inject.afterModifiers);
+
+    builder.append(this.kind);
+
+    if (this.body) {
+      builder.append(this.inject.beforeParams);
+      builder.append(this.kind === 'set' ? '(value)' : '()');
+      builder.append(this.inject.afterParams);
+
+      if (this.singleExpression) {
+        builder.append(' = ', this.inject.beforeBody);
+        builder.indent(this.body);
+      } else {
+        builder.append(' ', this.inject.beforeBody);
+        builder.parenthesize('{}', this.body, { multiline: true });
+      }
+      builder.append(this.inject.afterBody);
+    }
+
+    builder.appendLine();
+  }
+}
+export class KtPropertyGetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
+  public override readonly kind = 'get' as const;
+}
+export class KtPropertySetter<TBuilder extends SourceBuilder> extends KtPropertyAccessor<TBuilder> {
+  public override readonly kind = 'set' as const;
+}
+
+type Injects = 'doc' | 'annotations' | 'modifiers' | 'name' | 'type' | 'default' | 'delegate';
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    doc?: Nullable<KtDoc<TBuilder>>;
+    name: string;
+    type?: KtType<TBuilder>;
+    annotations?: Nullable<Nullable<KtAnnotation<TBuilder>>[]>;
+    accessModifier?: Nullable<KtAccessModifier>;
+    getter?: Nullable<KtPropertyGetter<TBuilder>>;
+    setter?: Nullable<KtPropertySetter<TBuilder>>;
+    default?: Nullable<KtValue<TBuilder>>;
+    delegate?: Nullable<KtType<TBuilder>>;
+    delegateArguments?: Nullable<Nullable<KtArgument<TBuilder> | KtValue<TBuilder>>[]>;
+    mutable?: Nullable<boolean>;
+    const?: Nullable<boolean>;
+    lateinit?: Nullable<boolean>;
+    open?: Nullable<boolean>;
+    override?: Nullable<boolean>;
+    abstract?: Nullable<boolean>;
+  }
+>;
+
+export class KtProperty<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public doc: KtDoc<TBuilder> | null;
+  public name: string;
+  public type: KtType<TBuilder> | null;
+  public annotations: KtAnnotation<TBuilder>[];
+  public accessModifier: KtAccessModifier | null;
+  public getter: KtPropertyGetter<TBuilder> | null;
+  public setter: KtPropertySetter<TBuilder> | null;
+  public default: KtValue<TBuilder> | null;
+  public delegate: KtType<TBuilder> | null;
+  public delegateArguments: (KtArgument<TBuilder> | KtValue<TBuilder>)[] | null;
+  public mutable: boolean;
+  public const: boolean;
+  public lateinit: boolean;
+  public open: boolean;
+  public override: boolean;
+  public abstract: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.doc = options.doc ?? null;
+    this.name = options.name;
+    this.type = options.type ?? null;
+    this.annotations = options.annotations?.filter(notNullish) ?? [];
+    this.accessModifier = options.accessModifier ?? null;
+    this.getter = options.getter ?? null;
+    this.setter = options.setter ?? null;
+    this.default = options.default ?? null;
+    this.delegate = options.delegate ?? null;
+    this.delegateArguments = options.delegateArguments?.filter(notNullish) ?? null;
+    this.mutable = options.mutable ?? false;
+    this.const = options.const ?? false;
+    this.lateinit = options.lateinit ?? false;
+    this.open = options.open ?? false;
+    this.override = options.override ?? false;
+    this.abstract = options.abstract ?? false;
+  }
+
+  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.beforeModifiers);
+    if (this.accessModifier) builder.append(this.accessModifier, ' ');
+    if (this.const) builder.append('const ');
+    if (this.lateinit) builder.append('lateinit ');
+    if (this.abstract) builder.append('abstract ');
+    if (this.override) builder.append('override ');
+    if (this.open) builder.append('open ');
+    builder.append(this.inject.afterModifiers);
+
+    builder.append(this.mutable || !!this.setter ? 'var ' : 'val ');
+    builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+
+    if (this.type || (!this.default && !this.getter?.body)) {
+      builder.append(': ', this.inject.beforeType);
+      writeKtNode(builder, this.type ?? 'Any?');
+      builder.append(this.inject.afterType);
+    }
+
+    if (this.default) {
+      builder.append(' = ', this.inject.beforeDefault);
+      writeKtNode(builder, this.default);
+      builder.append(this.inject.afterDefault);
+    }
+
+    if (this.delegate) {
+      builder.append(' by ', this.inject.beforeDelegate);
+      writeKtNode(builder, this.delegate);
+      if (this.delegateArguments) {
+        ktArgument.write(builder, this.delegateArguments);
+      }
+      builder.append(this.inject.afterDelegate);
+    }
+
+    builder.appendLine();
+
+    if (this.getter || this.setter) {
+      builder.indent((b) => {
+        this.getter?.write(b);
+        this.setter?.write(b);
+      });
+    }
+
+    builder.ensureCurrentLineEmpty();
+  }
+}
+
+const createPropertyGetter = <TBuilder extends SourceBuilder>(
+  options?: AccessorOptions<TBuilder>,
+): KtPropertyGetter<TBuilder> => new KtPropertyGetter<TBuilder>(options ?? {});
+
+const createPropertySetter = <TBuilder extends SourceBuilder>(
+  options?: AccessorOptions<TBuilder>,
+): KtPropertySetter<TBuilder> => new KtPropertySetter<TBuilder>(options ?? {});
+
+const createProperty = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name'>>,
+): KtProperty<TBuilder> => new KtProperty<TBuilder>({ ...options, name });
+
+export const ktProperty: typeof createProperty & {
+  getter: typeof createPropertyGetter;
+  setter: typeof createPropertySetter;
+  write: typeof writeKtNodes;
+} = Object.assign(createProperty, {
+  getter: createPropertyGetter,
+  setter: createPropertySetter,
+  write: writeKtNodes,
+});

package/src/src/ast/nodes/reference.ts

@@ -0,0 +1,178 @@
+import {
+  type AstNodeOptions,
+  notNullish,
+  type Nullable,
+  type Prettify,
+  type SourceBuilder,
+  type TupleWithCount,
+} from '@goast/core';
+
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { KtNode } from '../node.js';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import type { KtType } from './types.js';
+
+import type { KtCall } from './call.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    name: string;
+    packageName?: Nullable<string>;
+    generics?: Nullable<Nullable<KtType<TBuilder>>[]>;
+    nullable?: Nullable<boolean>;
+    classReference?: Nullable<boolean>;
+    subReference?: Nullable<KtReference<TBuilder> | KtCall<TBuilder>>;
+  }
+>;
+
+type _AddImportHandler<T> = {
+  // deno-lint-ignore no-explicit-any
+  builderClass: abstract new (...args: any) => T;
+  // deno-lint-ignore no-explicit-any
+  handler: (builder: T, reference: KtReference<any>) => void;
+};
+
+export class KtReference<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  // deno-lint-ignore no-explicit-any
+  private static readonly addImportHandlers: _AddImportHandler<any>[] = [
+    {
+      builderClass: KotlinFileBuilder,
+      handler: (builder, reference) => builder.addImport(reference.name, reference.packageName),
+    },
+  ];
+
+  public name: string;
+  public packageName: string | null;
+  public generics: KtType<TBuilder>[];
+  public nullable: boolean;
+  public classReference: boolean;
+  public subReference: KtReference<TBuilder> | KtCall<TBuilder> | null;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.name = options.name;
+    this.packageName = options.packageName ?? null;
+    this.generics = options.generics?.filter(notNullish) ?? [];
+    this.nullable = options.nullable ?? false;
+    this.classReference = options.classReference ?? false;
+    this.subReference = options.subReference ?? null;
+  }
+
+  public addImport(builder: TBuilder): void {
+    if (this.packageName) {
+      const handler = KtReference.addImportHandlers.find((h) => builder instanceof h.builderClass);
+      if (handler) {
+        handler.handler(builder, this);
+      }
+    }
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    builder.append(this.name);
+    ktGenericParameter.write(builder, this.generics);
+    if (this.classReference) {
+      builder.append('::class');
+    } else if (this.subReference) {
+      builder.append('::');
+      writeKtNode(builder, this.subReference);
+    } else if (this.nullable) {
+      builder.append('?');
+    }
+
+    this.addImport(builder);
+  }
+
+  public static registerAddImportHandler<TBuilder extends SourceBuilder>(
+    builderClass: _AddImportHandler<TBuilder>['builderClass'],
+    handler: _AddImportHandler<TBuilder>['handler'],
+  ): void {
+    KtReference.addImportHandlers.push({ builderClass, handler });
+  }
+}
+
+const createReference = <TBuilder extends SourceBuilder>(
+  name: Options<TBuilder>['name'],
+  packageName?: Options<TBuilder>['packageName'],
+  options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>,
+): KtReference<TBuilder> => new KtReference<TBuilder>({ ...options, name, packageName });
+
+export type KtReferenceFactory =
+  & (<TBuilder extends SourceBuilder>(
+    options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>,
+  ) => KtReference<TBuilder>)
+  & {
+    refName: string;
+    packageName: Nullable<string>;
+    matches: (value: unknown) => value is KtReference<never>;
+  };
+
+export type KtGenericReferenceFactory<TGenericCount extends number | number[]> =
+  & (<TBuilder extends SourceBuilder>(
+    generics: TupleWithCount<KtType<TBuilder>, TGenericCount>,
+    options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
+  ) => KtReference<TBuilder>)
+  & {
+    refName: string;
+    packageName: Nullable<string>;
+    infer: <TBuilder extends SourceBuilder>(
+      options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
+    ) => KtReference<TBuilder>;
+    matches: (value: unknown) => value is KtReference<never>;
+  };
+
+const createFactory = (name: string, packageName?: Nullable<string>): KtReferenceFactory => {
+  return Object.assign(
+    <TBuilder extends SourceBuilder>(options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName'>>) =>
+      createReference<TBuilder>(name, packageName, options),
+    {
+      refName: name,
+      packageName,
+      matches: (value: unknown): value is KtReference<never> =>
+        value instanceof KtReference && value.name === name && value.packageName === (packageName ?? null),
+    },
+  );
+};
+
+const createGenericFactory = <TGenericCount extends number | number[]>(
+  name: string,
+  packageName?: Nullable<string>,
+): KtGenericReferenceFactory<TGenericCount> => {
+  return Object.assign(
+    <TBuilder extends SourceBuilder>(
+      generics: TupleWithCount<KtType<TBuilder>, TGenericCount>,
+      options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
+    ) => createReference<TBuilder>(name, packageName, { ...options, generics }),
+    {
+      refName: name,
+      packageName,
+      infer: <TBuilder extends SourceBuilder>(
+        options?: Prettify<Omit<Options<TBuilder>, 'name' | 'packageName' | 'generics'>>,
+      ) => createReference<TBuilder>(name, packageName, options),
+      matches: (value: unknown): value is KtReference<never> =>
+        value instanceof KtReference && value.name === name && value.packageName === (packageName ?? null),
+    },
+  );
+};
+
+const importRefs = <TBuilder extends SourceBuilder>(builder: TBuilder, references: KtReference<TBuilder>[]): void => {
+  references.forEach((ref) => ref.addImport(builder));
+};
+
+export const ktReference: typeof createReference & {
+  factory: typeof createFactory;
+  genericFactory: typeof createGenericFactory;
+  write: typeof writeKtNodes;
+  import: typeof importRefs;
+} = Object.assign(createReference, {
+  factory: createFactory,
+  genericFactory: createGenericFactory,
+  write: writeKtNodes,
+  import: importRefs,
+});

package/src/src/ast/nodes/string.ts

@@ -0,0 +1,114 @@
+import { type AstNodeOptions, type Nullable, type Prettify, type SourceBuilder, spliceString } from '@goast/core';
+
+import { KtNode } from '../node.js';
+import { writeKtNodes } from '../utils/write-kt-node.js';
+import { ktArgument } from './argument.js';
+
+type Injects = never;
+
+type Options<TBuilder extends SourceBuilder, TInjects extends string = never> = AstNodeOptions<
+  typeof KtNode<TBuilder, TInjects | Injects>,
+  {
+    value?: Nullable<string>;
+    template?: Nullable<boolean>;
+    multiline?: Nullable<boolean>;
+    trimMargin?: Nullable<boolean>;
+    marginPrefix?: Nullable<string>;
+    autoAddMarginPrefix?: Nullable<boolean>;
+  }
+>;
+
+export class KtString<TBuilder extends SourceBuilder, TInjects extends string = never> extends KtNode<
+  TBuilder,
+  TInjects | Injects
+> {
+  public value: string | null;
+  public template: boolean;
+  public multiline: boolean;
+  public trimMargin: boolean;
+  public marginPrefix: string | null;
+  public autoAddMarginPrefix: boolean;
+
+  constructor(options: Options<TBuilder, TInjects>) {
+    super(options);
+    this.value = options?.value ?? null;
+    this.template = options?.template ?? false;
+    this.multiline = options?.multiline ?? false;
+    this.trimMargin = options?.trimMargin ?? true;
+    this.marginPrefix = options?.marginPrefix ?? null;
+    this.autoAddMarginPrefix = options?.autoAddMarginPrefix ?? true;
+  }
+
+  protected override onWrite(builder: TBuilder): void {
+    if (this.value === null) {
+      builder.append('null');
+      return;
+    }
+
+    let value = JSON.stringify(this.value).slice(1, -1);
+    if (this.multiline) {
+      value = value.replace(/\\n/g, '\n').replace(/\\r/g, '\r');
+    }
+
+    if (!this.template) {
+      value = value.replace(/\$/g, '\\$');
+    } else {
+      const originalParts = this.findTemplateParts(this.value);
+      const escapedParts = this.findTemplateParts(value);
+      if (originalParts.length !== escapedParts.length) {
+        throw new Error('Template parts count mismatch');
+      }
+      for (let i = originalParts.length - 1; i >= 0; i--) {
+        const original = originalParts[i];
+        const escaped = escapedParts[i];
+        value = spliceString(value, escaped.index, escaped.value.length, original.value);
+      }
+    }
+
+    builder.append(this.multiline ? '"""' + (this.trimMargin ? '\n' : '') : '"');
+
+    if (this.multiline && this.trimMargin) {
+      builder.indent((b) => {
+        if (this.autoAddMarginPrefix) {
+          b.appendWithLinePrefix(this.marginPrefix ?? '|', value);
+        } else {
+          b.append(value);
+        }
+
+        b.append('\n""".trimMargin');
+        ktArgument.write(b, [this.marginPrefix ? new KtString<TBuilder>({ value: this.marginPrefix }) : null]);
+      });
+    } else {
+      builder.append(value, this.multiline ? '"""' : '"');
+    }
+  }
+
+  protected findTemplateParts(value: string): { value: string; index: number }[] {
+    const parts: { value: string; index: number }[] = [];
+    let start: number | undefined = undefined;
+    let bracketCount = 0;
+    for (let i = 0; i < value.length; i++) {
+      if (value[i] === '$' && value[i + 1] === '{') {
+        start = i;
+      } else if (value[i] === '{') {
+        bracketCount++;
+      } else if (value[i] === '}') {
+        bracketCount--;
+        if (bracketCount === 0 && start !== undefined) {
+          parts.push({ value: value.slice(start, i + 1), index: start });
+          start = undefined;
+        }
+      }
+    }
+    return parts;
+  }
+}
+
+const createString = <TBuilder extends SourceBuilder>(
+  value: Options<TBuilder>['value'],
+  options?: Prettify<Omit<Options<TBuilder>, 'value'>>,
+): KtString<TBuilder> => new KtString<TBuilder>({ ...options, value });
+
+export const ktString: typeof createString & { write: typeof writeKtNodes } = Object.assign(createString, {
+  write: writeKtNodes,
+});

package/src/src/ast/nodes/types.ts

@@ -0,0 +1,23 @@
+import type { BasicAppendValue, SourceBuilder } from '@goast/core';
+
+import type { KtCall } from './call.js';
+import type { KtCollectionLiteral } from './collection-literal.js';
+import type { KtLambdaType } from './lambda-type.js';
+import type { KtLambda } from './lambda.js';
+import type { KtObject } from './object.js';
+import type { KtReference } from './reference.js';
+import type { KtString } from './string.js';
+
+export type KtType<TBuilder extends SourceBuilder> =
+  | KtReference<TBuilder>
+  | KtLambdaType<TBuilder>
+  | BasicAppendValue<TBuilder>;
+
+export type KtValue<TBuilder extends SourceBuilder> =
+  | KtReference<TBuilder>
+  | KtString<TBuilder>
+  | KtCall<TBuilder>
+  | KtObject<TBuilder>
+  | KtLambda<TBuilder>
+  | KtCollectionLiteral<TBuilder>
+  | BasicAppendValue<TBuilder>;

package/src/src/ast/references/index.ts

@@ -0,0 +1,10 @@
+export * as jackson from './jackson.js';
+export * as jakarta from './jakarta.js';
+export * as java from './java.js';
+export * from './kotlin.js';
+export * as kotlinx from './kotlinx.js';
+export * as okhttp3 from './okhttp3.js';
+export * as reactor from './reactor.js';
+export * as springReactive from './spring-reactive.js';
+export * as spring from './spring.js';
+export * as swagger from './swagger.js';

package/src/src/ast/references/jackson.ts

@@ -0,0 +1,24 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// com.fasterxml.jackson.annotation
+export const jsonTypeInfo: KtReferenceFactory = ktReference.factory('JsonTypeInfo', 'com.fasterxml.jackson.annotation');
+export const jsonSubTypes: KtReferenceFactory = ktReference.factory('JsonSubTypes', 'com.fasterxml.jackson.annotation');
+export const jsonClassDescription: KtReferenceFactory = ktReference.factory(
+  'JsonClassDescription',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonProperty: KtReferenceFactory = ktReference.factory('JsonProperty', 'com.fasterxml.jackson.annotation');
+export const jsonPropertyDescription: KtReferenceFactory = ktReference.factory(
+  'JsonPropertyDescription',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonInclude: KtReferenceFactory = ktReference.factory('JsonInclude', 'com.fasterxml.jackson.annotation');
+export const jsonIgnore: KtReferenceFactory = ktReference.factory('JsonIgnore', 'com.fasterxml.jackson.annotation');
+export const jsonAnySetter: KtReferenceFactory = ktReference.factory(
+  'JsonAnySetter',
+  'com.fasterxml.jackson.annotation',
+);
+export const jsonAnyGetter: KtReferenceFactory = ktReference.factory(
+  'JsonAnyGetter',
+  'com.fasterxml.jackson.annotation',
+);

package/src/src/ast/references/jakarta.ts

@@ -0,0 +1,14 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// jakarta.annotation
+export const generated: KtReferenceFactory = ktReference.factory('Generated', 'jakarta.annotation');
+
+// jakarta.validation
+export const valid: KtReferenceFactory = ktReference.factory('Valid', 'jakarta.validation');
+
+// jakarta.validation.constraints
+export const pattern: KtReferenceFactory = ktReference.factory('Pattern', 'jakarta.validation.constraints');
+export const min: KtReferenceFactory = ktReference.factory('Min', 'jakarta.validation.constraints');
+export const max: KtReferenceFactory = ktReference.factory('Max', 'jakarta.validation.constraints');
+export const notEmpty: KtReferenceFactory = ktReference.factory('NotEmpty', 'jakarta.validation.constraints');
+export const size: KtReferenceFactory = ktReference.factory('Size', 'jakarta.validation.constraints');

package/src/src/ast/references/java.ts

@@ -0,0 +1,20 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// java.io
+export const file: KtReferenceFactory = ktReference.factory('File', 'java.io');
+export const ioException: KtReferenceFactory = ktReference.factory('IOException', 'java.io');
+
+// java.lang
+export const illegalStateException: KtReferenceFactory = ktReference.factory('IllegalStateException', 'java.lang');
+export const system: KtReferenceFactory = ktReference.factory('System', 'java.lang');
+export const unsupportedOperationException: KtReferenceFactory = ktReference.factory(
+  'UnsupportedOperationException',
+  'java.lang',
+);
+export const void_: KtReferenceFactory = ktReference.factory('Void', 'java.lang');
+
+// java.time
+export const offsetDateTime: KtReferenceFactory = ktReference.factory('OffsetDateTime', 'java.time');
+
+// java.util
+export const optional: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('Optional', 'java.util');

package/src/src/ast/references/kotlin.ts

@@ -0,0 +1,41 @@
+import { type KtGenericReferenceFactory, ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// kotlin
+export const any: KtReferenceFactory = ktReference.factory('Any', 'kotlin');
+export const nothing: KtReferenceFactory = ktReference.factory('Nothing', 'kotlin');
+export const unit: KtReferenceFactory = ktReference.factory('Unit', 'kotlin');
+export const string: KtReferenceFactory = ktReference.factory('String', 'kotlin');
+export const int: KtReferenceFactory = ktReference.factory('Int', 'kotlin');
+export const long: KtReferenceFactory = ktReference.factory('Long', 'kotlin');
+export const float: KtReferenceFactory = ktReference.factory('Float', 'kotlin');
+export const double: KtReferenceFactory = ktReference.factory('Double', 'kotlin');
+export const boolean: KtReferenceFactory = ktReference.factory('Boolean', 'kotlin');
+export const lazyFun: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('lazy', 'kotlin');
+export const throws: KtReferenceFactory = ktReference.factory('Throws', 'kotlin');
+export const deprecated: KtReferenceFactory = ktReference.factory('Deprecated', 'kotlin');
+export const throwable: KtReferenceFactory = ktReference.factory('Throwable', 'kotlin');
+
+// kotlin.collections
+export const list: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('List', 'kotlin.collections');
+export const mutableList: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
+  'MutableList',
+  'kotlin.collections',
+);
+export const map: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>('Map', 'kotlin.collections');
+export const mutableMap: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'MutableMap',
+  'kotlin.collections',
+);
+export const listOf: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>('listOf', 'kotlin.collections');
+export const mutableListOf: KtGenericReferenceFactory<1> = ktReference.genericFactory<1>(
+  'mutableListOf',
+  'kotlin.collections',
+);
+export const mapOf: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>('mapOf', 'kotlin.collections');
+export const mutableMapOf: KtGenericReferenceFactory<2> = ktReference.genericFactory<2>(
+  'mutableMapOf',
+  'kotlin.collections',
+);
+
+// kotlin.jvm
+export const jvmStatic: KtReferenceFactory = ktReference.factory('JvmStatic', 'kotlin.jvm');

package/src/src/ast/references/kotlinx.ts

@@ -0,0 +1,14 @@
+import { type KtGenericReferenceFactory, ktReference } from '../nodes/reference.js';
+
+// kotlinx.coroutines.reactive
+export const awaitFirst: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirst',
+  'kotlinx.coroutines.reactive',
+);
+export const awaitFirstOrNull: KtGenericReferenceFactory<1> = ktReference.genericFactory(
+  'awaitFirstOrNull',
+  'kotlinx.coroutines.reactive',
+);
+
+// kotlinx.coroutines.reactor
+export const mono: KtGenericReferenceFactory<1> = ktReference.genericFactory('mono', 'kotlinx.coroutines.reactor');

package/src/src/ast/references/okhttp3.ts

@@ -0,0 +1,5 @@
+import { ktReference, type KtReferenceFactory } from '../nodes/reference.js';
+
+// okhttp3
+export const okHttpClient: KtReferenceFactory = ktReference.factory('Factory', 'okhttp3.Call');
+export const httpUrl: KtReferenceFactory = ktReference.factory('HttpUrl', 'okhttp3');