@goast/kotlin 0.1.18 → 0.2.0

package/esm/lib/ast/nodes/function.js

@@ -0,0 +1,101 @@
+import { notNullish, } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktDoc } from './doc';
+import { ktGenericParameter } from './generic-parameter';
+import { ktParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtFunction extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
+        super(options);
+        this.name = options.name;
+        this.generics = (_b = (_a = options.generics) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.parameters = (_d = (_c = options.parameters) === null || _c === void 0 ? void 0 : _c.filter(notNullish)) !== null && _d !== void 0 ? _d : [];
+        this.doc = (_e = options.doc) !== null && _e !== void 0 ? _e : null;
+        this.returnType = (_f = options.returnType) !== null && _f !== void 0 ? _f : null;
+        this.body = (_g = options.body) !== null && _g !== void 0 ? _g : null;
+        this.accessModifier = (_h = options.accessModifier) !== null && _h !== void 0 ? _h : null;
+        this.annotations = (_k = (_j = options.annotations) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.receiverType = (_l = options.receiverType) !== null && _l !== void 0 ? _l : null;
+        this.receiverAnnotations = (_o = (_m = options.receiverAnnotations) === null || _m === void 0 ? void 0 : _m.filter(notNullish)) !== null && _o !== void 0 ? _o : [];
+        this.singleExpression = (_p = options.singleExpression) !== null && _p !== void 0 ? _p : false;
+        this.open = (_q = options.open) !== null && _q !== void 0 ? _q : false;
+        this.inline = (_r = options.inline) !== null && _r !== void 0 ? _r : false;
+        this.infix = (_s = options.infix) !== null && _s !== void 0 ? _s : false;
+        this.tailrec = (_t = options.tailrec) !== null && _t !== void 0 ? _t : false;
+        this.suspend = (_u = options.suspend) !== null && _u !== void 0 ? _u : false;
+        this.operator = (_v = options.operator) !== null && _v !== void 0 ? _v : false;
+        this.override = (_w = options.override) !== null && _w !== void 0 ? _w : false;
+        this.abstract = (_x = options.abstract) !== null && _x !== void 0 ? _x : false;
+    }
+    onWrite(builder) {
+        var _a;
+        builder.append(this.inject.beforeDoc);
+        (_a = ktDoc.get(this.doc, { generics: this.generics, parameters: this.parameters })) === null || _a === void 0 ? void 0 : _a.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.inline)
+            builder.append('inline ');
+        if (this.infix)
+            builder.append('infix ');
+        if (this.tailrec)
+            builder.append('tailrec ');
+        if (this.suspend)
+            builder.append('suspend ');
+        if (this.open)
+            builder.append('open ');
+        if (this.override)
+            builder.append('override ');
+        if (this.abstract)
+            builder.append('abstract ');
+        if (this.operator)
+            builder.append('operator ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('fun ');
+        builder.append(this.inject.beforeGenerics);
+        ktGenericParameter.write(builder, this.generics);
+        builder.append(this.inject.afterGenerics);
+        if (this.generics.length > 0)
+            builder.append(' ');
+        if (this.receiverType) {
+            builder.append(this.inject.beforeReceiverAnnotations);
+            ktAnnotation.write(builder, this.receiverAnnotations, { multiline: false });
+            builder.append(this.inject.afterReceiverAnnotations);
+            builder.append(this.inject.beforeReceiverType);
+            writeKtNode(builder, this.receiverType);
+            builder.append(this.inject.afterReceiverType);
+            builder.append('.');
+        }
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        builder.append(this.inject.beforeParameters);
+        ktParameter.write(builder, this.parameters);
+        builder.append(this.inject.afterParameters);
+        if (this.returnType) {
+            builder.append(': ');
+            builder.append(this.inject.beforeReturnType);
+            writeKtNode(builder, this.returnType);
+            builder.append(this.inject.afterReturnType);
+        }
+        if (!this.abstract) {
+            builder.append(' ');
+            if (this.singleExpression && this.body) {
+                builder.append('= ');
+                builder.indent(this.body);
+            }
+            else {
+                builder.parenthesize('{}', this.body, { multiline: !!this.body });
+            }
+        }
+        builder.appendLine();
+    }
+}
+const createFunction = (name, options) => new KtFunction(Object.assign(Object.assign({}, options), { name }));
+export const ktFunction = Object.assign(createFunction, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/generic-parameter.js

@@ -0,0 +1,25 @@
+import { KtNode } from '../node';
+import { writeKtGenericParameters } from '../utils/write-kt-generic-parameters';
+import { writeKtNode } from '../utils/write-kt-node';
+export class KtGenericParameter extends KtNode {
+    constructor(options) {
+        var _a, _b;
+        super(options);
+        this.name = options.name;
+        this.description = (_a = options.description) !== null && _a !== void 0 ? _a : null;
+        this.constraint = (_b = options.constraint) !== null && _b !== void 0 ? _b : null;
+    }
+    onWrite(builder) {
+        builder.append(this.inject.beforeName, this.name, this.inject.afterName);
+        if (this.constraint) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeConstraint);
+            writeKtNode(builder, this.constraint);
+            builder.append(this.inject.afterConstraint);
+        }
+    }
+}
+const createGenericParameter = (name, options) => new KtGenericParameter(Object.assign(Object.assign({}, options), { name }));
+export const ktGenericParameter = Object.assign(createGenericParameter, {
+    write: writeKtGenericParameters,
+});

package/esm/lib/ast/nodes/init-block.js

@@ -0,0 +1,15 @@
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtInitBlock extends KtNode {
+    constructor(options) {
+        super(options);
+        this.body = options.body;
+    }
+    onWrite(builder) {
+        builder.append('init ').parenthesize('{}', this.body, { multiline: !!this.body }).appendLine();
+    }
+}
+const createInitBlock = (body, options) => new KtInitBlock(Object.assign(Object.assign({}, options), { body }));
+export const ktInitBlock = Object.assign(createInitBlock, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/interface.js

@@ -0,0 +1,64 @@
+import { notNullish, createOverwriteProxy, } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktDoc } from './doc';
+import { ktGenericParameter } from './generic-parameter';
+import { KtNode } from '../node';
+import { writeKtMembers } from '../utils/write-kt-members';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtInterface extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.accessModifier = (_d = options.accessModifier) !== null && _d !== void 0 ? _d : null;
+        this.name = options.name;
+        this.generics = (_f = (_e = options.generics) === null || _e === void 0 ? void 0 : _e.filter(notNullish)) !== null && _f !== void 0 ? _f : [];
+        this.extends = (_h = (_g = options.extends) === null || _g === void 0 ? void 0 : _g.filter(notNullish)) !== null && _h !== void 0 ? _h : [];
+        this.members = (_k = (_j = options.members) === null || _j === void 0 ? void 0 : _j.filter(notNullish)) !== null && _k !== void 0 ? _k : [];
+        this.companionObject = (_l = options.companionObject) !== null && _l !== void 0 ? _l : null;
+    }
+    onWrite(builder) {
+        var _a;
+        builder.append(this.inject.beforeDoc);
+        (_a = ktDoc.get(this.doc, { generics: this.generics })) === null || _a === void 0 ? void 0 : _a.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, ' ');
+        builder.append(this.inject.afterModifiers);
+        builder.append('interface ');
+        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.extends.length > 0) {
+            builder.append(' : ');
+            builder.append(this.inject.beforeExtends);
+            writeKtNodes(builder, this.extends, { separator: ', ' });
+            builder.append(this.inject.afterExtends);
+        }
+        const allMembers = [
+            this.companionObject ? createOverwriteProxy(this.companionObject, { companion: true }) : null,
+            ...this.members,
+        ].filter(notNullish);
+        if (allMembers.length > 0) {
+            builder.append(' ');
+            builder.append(this.inject.beforeBody);
+            builder.parenthesize('{}', (b) => {
+                b.append(this.inject.beforeMembers);
+                writeKtMembers(b, allMembers);
+                b.append(this.inject.afterMembers);
+            }, { multiline: true });
+            builder.append(this.inject.afterBody);
+        }
+        builder.appendLine();
+    }
+}
+const createInterface = (name, options) => new KtInterface(Object.assign(Object.assign({}, options), { name }));
+export const ktInterface = Object.assign(createInterface, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/lambda-type.js

@@ -0,0 +1,40 @@
+import { notNullish } from '@goast/core';
+import { ktParameter } from './parameter';
+import { KtNode } from '../node';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtLambdaType extends KtNode {
+    constructor(options) {
+        var _a, _b, _c;
+        super(options);
+        this.extensionFor = (_a = options.extensionFor) !== null && _a !== void 0 ? _a : null;
+        this.parameters = (_c = (_b = options.parameters) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.returnType = options.returnType;
+    }
+    onWrite(builder) {
+        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 = (parameters, returnType, options) => new KtLambdaType(Object.assign(Object.assign({}, options), { parameters, returnType }));
+export const ktLambdaType = Object.assign(createLambdaType, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/lambda.js

@@ -0,0 +1,32 @@
+import { notNullish } from '@goast/core';
+import { KtNode } from '../node';
+import { writeKtNodes } from '../utils/write-kt-node';
+export class KtLambda extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super(options);
+        this.arguments = (_b = (_a = options.arguments) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.body = (_c = options.body) !== null && _c !== void 0 ? _c : null;
+        this.singleline = (_d = options.singleline) !== null && _d !== void 0 ? _d : false;
+    }
+    onWrite(builder) {
+        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 = (args, body, options) => new KtLambda(Object.assign(Object.assign({}, options), { arguments: args, body }));
+export const ktLambda = Object.assign(createLambda, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/object.js

@@ -0,0 +1,54 @@
+import { notNullish } from '@goast/core';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtMembers } from '../utils/write-kt-members';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtObject extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        super(options);
+        this.data = (_a = options.data) !== null && _a !== void 0 ? _a : false;
+        this.name = (_b = options.name) !== null && _b !== void 0 ? _b : null;
+        this.class = (_c = options.class) !== null && _c !== void 0 ? _c : null;
+        this.classArguments = (_e = (_d = options.classArguments) === null || _d === void 0 ? void 0 : _d.filter(notNullish)) !== null && _e !== void 0 ? _e : [];
+        this.implements = (_g = (_f = options.implements) === null || _f === void 0 ? void 0 : _f.filter(notNullish)) !== null && _g !== void 0 ? _g : [];
+        this.members = (_j = (_h = options.members) === null || _h === void 0 ? void 0 : _h.filter(notNullish)) !== null && _j !== void 0 ? _j : [];
+        this.companion = (_k = options.companion) !== null && _k !== void 0 ? _k : false;
+    }
+    onWrite(builder) {
+        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 = (options) => new KtObject(options !== null && options !== void 0 ? options : {});
+export const ktObject = Object.assign(createObject, {
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/parameter.js

@@ -0,0 +1,53 @@
+import { notNullish } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { KtNode } from '../node';
+import { writeKtNode } from '../utils/write-kt-node';
+import { writeKtParameters } from '../utils/write-kt-parameters';
+export class KtParameter extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        super(options);
+        this.name = options.name;
+        this.type = options.type;
+        this.annotations = (_b = (_a = options.annotations) === null || _a === void 0 ? void 0 : _a.filter(notNullish)) !== null && _b !== void 0 ? _b : [];
+        this.default = (_c = options.default) !== null && _c !== void 0 ? _c : null;
+        this.vararg = (_d = options.vararg) !== null && _d !== void 0 ? _d : false;
+        this.description = (_e = options.description) !== null && _e !== void 0 ? _e : null;
+        this.accessModifier = (_f = options.accessModifier) !== null && _f !== void 0 ? _f : null;
+        this.property = (_g = options.property) !== null && _g !== void 0 ? _g : null;
+        this.propertyDescription = (_h = options.propertyDescription) !== null && _h !== void 0 ? _h : null;
+        this.override = (_j = options.override) !== null && _j !== void 0 ? _j : false;
+    }
+    onWrite(builder) {
+        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 = (name, type, options) => new KtParameter(Object.assign(Object.assign({}, options), { name, type }));
+const createClassParameter = (name, type, options) => new KtParameter(Object.assign(Object.assign({}, options), { name, type }));
+export const ktParameter = Object.assign(createParameter, {
+    class: createClassParameter,
+    write: writeKtParameters,
+});

package/esm/lib/ast/nodes/property.js

@@ -0,0 +1,135 @@
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+import { notNullish } from '@goast/core';
+import { ktAnnotation } from './annotation';
+import { ktArgument } from './argument';
+import { KtNode } from '../node';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtPropertyAccessor extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        super(options);
+        this.accessModifier = (_a = options.accessModifier) !== null && _a !== void 0 ? _a : null;
+        this.annotations = (_c = (_b = options.annotations) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.body = (_d = options.body) !== null && _d !== void 0 ? _d : null;
+        this.singleExpression = (_e = options.singleExpression) !== null && _e !== void 0 ? _e : false;
+    }
+    onWrite(builder) {
+        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 extends KtPropertyAccessor {
+    constructor() {
+        super(...arguments);
+        this.kind = 'get';
+    }
+}
+export class KtPropertySetter extends KtPropertyAccessor {
+    constructor() {
+        super(...arguments);
+        this.kind = 'set';
+    }
+}
+export class KtProperty extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        super(options);
+        this.doc = (_a = options.doc) !== null && _a !== void 0 ? _a : null;
+        this.name = options.name;
+        this.type = (_b = options.type) !== null && _b !== void 0 ? _b : null;
+        this.annotations = (_d = (_c = options.annotations) === null || _c === void 0 ? void 0 : _c.filter(notNullish)) !== null && _d !== void 0 ? _d : [];
+        this.accessModifier = (_e = options.accessModifier) !== null && _e !== void 0 ? _e : null;
+        this.getter = (_f = options.getter) !== null && _f !== void 0 ? _f : null;
+        this.setter = (_g = options.setter) !== null && _g !== void 0 ? _g : null;
+        this.default = (_h = options.default) !== null && _h !== void 0 ? _h : null;
+        this.delegate = (_j = options.delegate) !== null && _j !== void 0 ? _j : null;
+        this.delegateArguments = (_l = (_k = options.delegateArguments) === null || _k === void 0 ? void 0 : _k.filter(notNullish)) !== null && _l !== void 0 ? _l : null;
+        this.mutable = (_m = options.mutable) !== null && _m !== void 0 ? _m : false;
+        this.const = (_o = options.const) !== null && _o !== void 0 ? _o : false;
+        this.lateinit = (_p = options.lateinit) !== null && _p !== void 0 ? _p : false;
+        this.open = (_q = options.open) !== null && _q !== void 0 ? _q : false;
+        this.override = (_r = options.override) !== null && _r !== void 0 ? _r : false;
+        this.abstract = (_s = options.abstract) !== null && _s !== void 0 ? _s : false;
+    }
+    onWrite(builder) {
+        var _a, _b, _c;
+        builder.append(this.inject.beforeDoc);
+        (_a = this.doc) === null || _a === void 0 ? void 0 : _a.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 && !((_b = this.getter) === null || _b === void 0 ? void 0 : _b.body))) {
+            builder.append(': ', this.inject.beforeType);
+            writeKtNode(builder, (_c = this.type) !== null && _c !== void 0 ? _c : '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) => {
+                var _a, _b;
+                (_a = this.getter) === null || _a === void 0 ? void 0 : _a.write(b);
+                (_b = this.setter) === null || _b === void 0 ? void 0 : _b.write(b);
+            });
+        }
+        builder.ensureCurrentLineEmpty();
+    }
+}
+const createPropertyGetter = (options) => new KtPropertyGetter(options !== null && options !== void 0 ? options : {});
+const createPropertySetter = (options) => new KtPropertySetter(options !== null && options !== void 0 ? options : {});
+const createProperty = (name, options) => new KtProperty(Object.assign(Object.assign({}, options), { name }));
+export const ktProperty = Object.assign(createProperty, {
+    getter: createPropertyGetter,
+    setter: createPropertySetter,
+    write: writeKtNodes,
+});

package/esm/lib/ast/nodes/reference.js

@@ -0,0 +1,75 @@
+import { notNullish } from '@goast/core';
+import { ktGenericParameter } from './generic-parameter';
+import { KotlinFileBuilder } from '../../file-builder';
+import { KtNode } from '../node';
+import { writeKtNode, writeKtNodes } from '../utils/write-kt-node';
+export class KtReference extends KtNode {
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        super(options);
+        this.name = options.name;
+        this.packageName = (_a = options.packageName) !== null && _a !== void 0 ? _a : null;
+        this.generics = (_c = (_b = options.generics) === null || _b === void 0 ? void 0 : _b.filter(notNullish)) !== null && _c !== void 0 ? _c : [];
+        this.nullable = (_d = options.nullable) !== null && _d !== void 0 ? _d : false;
+        this.classReference = (_e = options.classReference) !== null && _e !== void 0 ? _e : false;
+        this.subReference = (_f = options.subReference) !== null && _f !== void 0 ? _f : null;
+    }
+    addImport(builder) {
+        if (this.packageName) {
+            const handler = KtReference.addImportHandlers.find((h) => builder instanceof h.builderClass);
+            if (handler) {
+                handler.handler(builder, this);
+            }
+        }
+    }
+    onWrite(builder) {
+        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);
+    }
+    static registerAddImportHandler(builderClass, handler) {
+        KtReference.addImportHandlers.push({ builderClass, handler });
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+KtReference.addImportHandlers = [
+    {
+        builderClass: KotlinFileBuilder,
+        handler: (builder, reference) => builder.addImport(reference.name, reference.packageName),
+    },
+];
+const createReference = (name, packageName, options) => new KtReference(Object.assign(Object.assign({}, options), { name, packageName }));
+const createFactory = (name, packageName) => {
+    return Object.assign((options) => createReference(name, packageName, options), {
+        refName: name,
+        packageName,
+        matches: (value) => value instanceof KtReference && value.name === name && value.packageName === (packageName !== null && packageName !== void 0 ? packageName : null),
+    });
+};
+const createGenericFactory = (name, packageName) => {
+    return Object.assign((generics, options) => createReference(name, packageName, Object.assign(Object.assign({}, options), { generics })), {
+        refName: name,
+        packageName,
+        infer: (options) => createReference(name, packageName, options),
+        matches: (value) => value instanceof KtReference && value.name === name && value.packageName === (packageName !== null && packageName !== void 0 ? packageName : null),
+    });
+};
+const importRefs = (builder, references) => {
+    references.forEach((ref) => ref.addImport(builder));
+};
+export const ktReference = Object.assign(createReference, {
+    factory: createFactory,
+    genericFactory: createGenericFactory,
+    write: writeKtNodes,
+    import: importRefs,
+});