@goast/kotlin 0.4.2-beta1 → 0.4.3

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

@@ -0,0 +1,253 @@
+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 { ktDoc } from './doc.js';
+import { ktProperty } from './property.js';
+
+describe('ktProperty', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write a property', () => {
+    builder.append(ktProperty('x'));
+    expect(builder.toString(false)).toBe(`val x: Any?${EOL}`);
+  });
+
+  it('should write a property with a default value', () => {
+    builder.append(ktProperty('x', { default: '42' }));
+    expect(builder.toString(false)).toBe(`val x = 42${EOL}`);
+  });
+
+  it('should write a mutable property', () => {
+    builder.append(ktProperty('x', { mutable: true }));
+    expect(builder.toString(false)).toBe(`var x: Any?${EOL}`);
+  });
+
+  it('should write a property with a type', () => {
+    builder.append(ktProperty('x', { type: 'Int' }));
+    expect(builder.toString(false)).toBe(`val x: Int${EOL}`);
+  });
+
+  it('should write all annotations', () => {
+    builder.append(ktProperty('x', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
+    expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}val x: Any?${EOL}`);
+  });
+
+  it('should write the const keyword if configured', () => {
+    builder.append(ktProperty('x', { const: true }));
+    expect(builder.toString(false)).toBe(`const val x: Any?${EOL}`);
+  });
+
+  it('should write the lateinit keyword if configured', () => {
+    builder.append(ktProperty('x', { lateinit: true }));
+    expect(builder.toString(false)).toBe(`lateinit val x: Any?${EOL}`);
+  });
+
+  it('should write the open keyword if configured', () => {
+    builder.append(ktProperty('x', { open: true }));
+    expect(builder.toString(false)).toBe(`open val x: Any?${EOL}`);
+  });
+
+  it('should write the override keyword if configured', () => {
+    builder.append(ktProperty('x', { override: true }));
+    expect(builder.toString(false)).toBe(`override val x: Any?${EOL}`);
+  });
+
+  it('should write the abstract keyword if configured', () => {
+    builder.append(ktProperty('x', { abstract: true }));
+    expect(builder.toString(false)).toBe(`abstract val x: Any?${EOL}`);
+  });
+
+  it('should write the delegate if it exists', () => {
+    builder.append(ktProperty('x', { delegate: 'lazy' }));
+    expect(builder.toString(false)).toBe(`val x: Any? by lazy${EOL}`);
+  });
+
+  it('should write the delegate with arguments if they exist', () => {
+    builder.append(ktProperty('x', { delegate: 'lazy', delegateArguments: ['42', 'true'] }));
+    expect(builder.toString(false)).toBe(`val x: Any? by lazy(42, true)${EOL}`);
+  });
+
+  it('should write the getter if it exists', () => {
+    builder.append(ktProperty('x', { getter: ktProperty.getter() }));
+    expect(builder.toString(false)).toBe(`val x: Any?${EOL}    get${EOL}`);
+  });
+
+  it('should write the setter if it exists', () => {
+    builder.append(ktProperty('x', { setter: ktProperty.setter() }));
+    expect(builder.toString(false)).toBe(`var x: Any?${EOL}    set${EOL}`);
+  });
+
+  it('should write documentation if it exists', () => {
+    builder.append(ktProperty('x', { doc: ktDoc('Hello') }));
+    expect(builder.toString(false)).toBe(`/**${EOL} * Hello${EOL} */${EOL}val x: Any?${EOL}`);
+  });
+
+  it('should write all the parts of the property', () => {
+    builder.append(
+      ktProperty('x', {
+        doc: ktDoc('Hello'),
+        default: '42',
+        mutable: true,
+        type: 'Int',
+        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+        const: true,
+        lateinit: true,
+        open: true,
+        override: true,
+        abstract: true,
+        delegate: 'lazy',
+        delegateArguments: ['42', 'true'],
+        getter: ktProperty.getter(),
+        setter: ktProperty.setter(),
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      `/**${EOL} * Hello${EOL} */${EOL}@Inject${EOL}@Optional${EOL}const lateinit abstract override open var x: Int = 42 by lazy(42, true)${EOL}    get${EOL}    set${EOL}`,
+    );
+  });
+
+  it('should render injections', () => {
+    builder.append(
+      ktProperty('x', {
+        doc: ktDoc('Hello'),
+        default: '42',
+        mutable: true,
+        type: 'Int',
+        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+        const: true,
+        lateinit: true,
+        open: true,
+        override: true,
+        abstract: true,
+        delegate: 'lazy',
+        delegateArguments: ['42', 'true'],
+        getter: ktProperty.getter(),
+        setter: ktProperty.setter(),
+        inject: {
+          before: '║b║',
+          after: '║a║',
+          beforeDoc: '║bd║',
+          afterDoc: '║ad║',
+          beforeAnnotations: '║ba║',
+          afterAnnotations: '║aa║',
+          beforeModifiers: '║bm║',
+          afterModifiers: '║am║',
+          beforeName: '║bn║',
+          afterName: '║an║',
+          beforeType: '║bt║',
+          afterType: '║at║',
+          beforeDefault: '║bdf║',
+          afterDefault: '║adf║',
+          beforeDelegate: '║bdg║',
+          afterDelegate: '║adg║',
+        },
+      }),
+    );
+    expect(builder.toString(false)).toBe(
+      normalizeEOL(8)(
+        `║b║║bd║
+        /**
+         * Hello
+         */
+        ║ad║║ba║@Inject
+        @Optional
+        ║aa║║bm║const lateinit abstract override open ║am║var ║bn║x║an║: ║bt║Int║at║ = ║bdf║42║adf║ by ║bdg║lazy(42, true)║adg║
+            get
+            set
+        ║a║`,
+      ),
+    );
+  });
+});
+
+describe('ktPropertyAccessor', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write the kind of the accessor', () => {
+    ktProperty.getter().write(builder);
+    expect(builder.toString(false)).toBe(`get${EOL}`);
+  });
+
+  it('should write the get body if it exists', () => {
+    ktProperty.getter({ body: 'println("Hello")' }).write(builder);
+    expect(builder.toString(false)).toBe(`get() {${EOL}    println("Hello")${EOL}}${EOL}`);
+  });
+
+  it('should write the get body with a single expression', () => {
+    ktProperty.getter({ body: '42', singleExpression: true }).write(builder);
+    expect(builder.toString(false)).toBe(`get() = 42${EOL}`);
+  });
+
+  it('should write the set body if it exists', () => {
+    ktProperty.setter({ body: 'println("Hello")' }).write(builder);
+    expect(builder.toString(false)).toBe(`set(value) {${EOL}    println("Hello")${EOL}}${EOL}`);
+  });
+
+  it('should write the set body with a single expression', () => {
+    ktProperty.setter({ body: '42', singleExpression: true }).write(builder);
+    expect(builder.toString(false)).toBe(`set(value) = 42${EOL}`);
+  });
+
+  it('should write all annotations', () => {
+    ktProperty.getter({ annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }).write(builder);
+    expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}get${EOL}`);
+  });
+
+  it('should write the accessModifier if it exists', () => {
+    ktProperty.getter({ accessModifier: 'private' }).write(builder);
+    expect(builder.toString(false)).toBe(`private get${EOL}`);
+  });
+
+  it('should write all the parts of the accessor', () => {
+    ktProperty
+      .getter({
+        body: 'println("Hello")',
+        accessModifier: 'private',
+        annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+      })
+      .write(builder);
+    expect(builder.toString(false)).toBe(
+      `@Inject${EOL}@Optional${EOL}private get() {${EOL}    println("Hello")${EOL}}${EOL}`,
+    );
+  });
+
+  it('should render injections', () => {
+    ktProperty
+      .getter({
+        body: '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║',
+          beforeBody: '║bb║',
+          afterBody: '║ab║',
+        },
+      })
+      .write(builder);
+    expect(builder.toString(false)).toBe(
+      `║b║║ba║@Inject${EOL}@Optional${EOL}║aa║║bm║private ║am║get║bp║()║ap║ ║bb║{${EOL}    println("Hello")${EOL}}║ab║${EOL}║a║`,
+    );
+  });
+});

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

@@ -0,0 +1,47 @@
+import "../../../_dnt.test_polyfills.js";
+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 type { KotlinImport } from '../../common-results.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktReference } from './reference.js';
+
+describe('ktReference', () => {
+  let builder: KotlinFileBuilder;
+
+  beforeEach(() => {
+    builder = new KotlinFileBuilder();
+  });
+
+  it('should write reference', () => {
+    builder.append(ktReference('MyClass'));
+    expect(builder.toString(false)).toBe('MyClass');
+  });
+
+  it('should write reference with generics', () => {
+    builder.append(ktReference('MyClass', null, { generics: [ktReference('String')] }));
+    expect(builder.toString(false)).toBe('MyClass<String>');
+  });
+
+  it('should add import to builder', () => {
+    builder.append(ktReference('MyClass', 'my-package'));
+    expect(builder.imports.imports).toEqual(
+      <KotlinImport[]> [
+        {
+          typeName: 'MyClass',
+          packageName: 'my-package',
+        },
+      ],
+    );
+  });
+
+  it('should render nullable', () => {
+    builder.append(ktReference('MyClass', null, { nullable: true }));
+    expect(builder.toString(false)).toBe('MyClass?');
+  });
+
+  it('should render injections', () => {
+    builder.append(ktReference('MyClass', null, { inject: { before: 'before', after: 'after' } }));
+    expect(builder.toString(false)).toBe('beforeMyClassafter');
+  });
+});