CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-squareup--kotlinpoet

Kotlin and Java API for generating Kotlin source files (.kt) with type-safe, fluent builder patterns

—

Pending
Overview
Eval results
Files

function-and-property-generation.mddocs/

Function and Property Generation

Comprehensive support for generating functions, constructors, properties, and parameters with full Kotlin language feature support including modifiers, annotations, and documentation.

Capabilities

Function Specification

Creates function declarations including regular functions, constructors, getters, setters, and operator functions with full Kotlin language support.

/**
 * Specification for generating functions and constructors
 */
class FunSpec private constructor() {
    companion object {
        /** Creates a builder for a regular function */
        fun builder(name: String): Builder
        
        /** Creates a builder for a function from a MemberName */
        fun builder(memberName: MemberName): Builder
        
        /** Creates a builder for a constructor */
        fun constructorBuilder(): Builder
        
        /** Creates a builder for a property getter */
        fun getterBuilder(): Builder
        
        /** Creates a builder for a property setter */
        fun setterBuilder(): Builder
    }
    
    /** Builder for constructing FunSpec instances */
    class Builder {
        /** Adds modifiers to the function */
        fun addModifiers(vararg modifiers: KModifier): Builder
        fun addModifiers(modifiers: Iterable<KModifier>): Builder
        
        /** Adds type parameters (generics) */
        fun addTypeVariable(typeVariable: TypeVariableName): Builder
        fun addTypeVariables(typeVariables: Iterable<TypeVariableName>): Builder
        
        /** Sets the receiver type for extension functions */
        fun receiver(receiverType: TypeName): Builder
        fun receiver(receiverType: KClass<*>): Builder
        
        /** Sets the return type */
        fun returns(returnType: TypeName): Builder
        fun returns(returnType: KClass<*>): Builder
        
        /** Adds parameters */
        fun addParameter(parameterSpec: ParameterSpec): Builder
        fun addParameter(name: String, type: TypeName, vararg modifiers: KModifier): Builder
        fun addParameter(name: String, type: KClass<*>, vararg modifiers: KModifier): Builder
        fun addParameters(parameterSpecs: Iterable<ParameterSpec>): Builder
        
        /** Adds context parameters for context receivers */
        fun contextReceivers(receiverTypes: Iterable<TypeName>): Builder
        fun contextReceivers(vararg receiverTypes: TypeName): Builder
        
        /** Adds code statements to the function body */
        fun addStatement(format: String, vararg args: Any?): Builder
        fun addNamedCode(format: String, args: Map<String, *>): Builder
        fun addCode(codeBlock: CodeBlock): Builder
        fun addComment(format: String, vararg args: Any?): Builder
        
        /** Sets the function body as a single expression */
        fun addCode(format: String, vararg args: Any?): Builder
        
        /** Adds annotations */
        fun addAnnotation(annotationSpec: AnnotationSpec): Builder
        fun addAnnotation(annotation: ClassName): Builder
        fun addAnnotation(annotation: Class<*>): Builder
        fun addAnnotation(annotation: KClass<*>): Builder
        
        /** Adds KDoc documentation */
        fun addKdoc(format: String, vararg args: Any?): Builder
        fun addKdoc(block: CodeBlock): Builder
        
        /** Builds the FunSpec */
        fun build(): FunSpec
    }
}

Usage Examples:

import com.squareup.kotlinpoet.*

// Simple function
val greetFunction = FunSpec.builder("greet")
    .addParameter("name", String::class)
    .returns(String::class)
    .addStatement("return %S + name", "Hello, ")
    .build()

// Function with multiple parameters and modifiers
val calculateFunction = FunSpec.builder("calculate")
    .addModifiers(KModifier.INLINE)
    .addParameter("x", Int::class)
    .addParameter("y", Int::class)
    .addParameter(
        ParameterSpec.builder("operation", LambdaTypeName.get(
            parameters = listOf(
                ParameterSpec.unnamed(Int::class.asTypeName()),
                ParameterSpec.unnamed(Int::class.asTypeName())
            ),
            returnType = Int::class.asTypeName()
        )).build()
    )
    .returns(Int::class)
    .addStatement("return operation(x, y)")
    .build()

// Extension function
val stringExtension = FunSpec.builder("isPalindrome")
    .receiver(String::class)
    .returns(Boolean::class)
    .addStatement("return this == this.reversed()")
    .build()

// Generic function with constraints
val swapFunction = FunSpec.builder("swap")
    .addTypeVariable(TypeVariableName("T"))
    .addParameter("list", List::class.asClassName().parameterizedBy(TypeVariableName("T")).copy(nullable = false))
    .addParameter("i", Int::class)
    .addParameter("j", Int::class)
    .returns(UNIT)
    .addStatement("val temp = list[i]")
    .addStatement("list[i] = list[j]")
    .addStatement("list[j] = temp")
    .build()

// Suspend function
val fetchDataFunction = FunSpec.builder("fetchData")
    .addModifiers(KModifier.SUSPEND)
    .addParameter("url", String::class)
    .returns(String::class)
    .addStatement("// Implementation would use coroutines")
    .addStatement("return %S", "mock data")
    .build()

// Operator function
val plusOperator = FunSpec.builder("plus")
    .addModifiers(KModifier.OPERATOR)
    .receiver(ClassName("", "Vector"))
    .addParameter("other", ClassName("", "Vector"))
    .returns(ClassName("", "Vector"))
    .addStatement("return Vector(x + other.x, y + other.y)")
    .build()

Constructor Specification

Creates primary and secondary constructors with parameter handling and initialization code.

// Constructors use FunSpec.constructorBuilder()

Usage Examples:

// Primary constructor
val primaryConstructor = FunSpec.constructorBuilder()
    .addParameter("name", String::class)
    .addParameter("age", Int::class)
    .build()

// Secondary constructor with delegation
val secondaryConstructor = FunSpec.constructorBuilder()
    .addParameter("name", String::class)
    .callThisConstructor("name", "0")
    .build()

// Constructor with validation
val validatingConstructor = FunSpec.constructorBuilder()
    .addParameter("email", String::class)
    .addStatement("require(email.contains('@')) { %S }", "Invalid email format")
    .build()

Property Specification

Creates property declarations including val/var properties, getters, setters, backing fields, and delegated properties.

/**
 * Specification for generating properties
 */
class PropertySpec private constructor() {
    companion object {
        /** Creates a builder for a val property */
        fun builder(name: String, type: TypeName, vararg modifiers: KModifier): Builder
        fun builder(name: String, type: KClass<*>, vararg modifiers: KModifier): Builder
        
        /** Creates a builder for a var property */
        fun varBuilder(name: String, type: TypeName, vararg modifiers: KModifier): Builder
        fun varBuilder(name: String, type: KClass<*>, vararg modifiers: KModifier): Builder
    }
    
    /** Builder for constructing PropertySpec instances */
    class Builder {
        /** Sets whether the property is mutable (var) */
        fun mutable(mutable: Boolean = true): Builder
        
        /** Adds modifiers to the property */
        fun addModifiers(vararg modifiers: KModifier): Builder
        fun addModifiers(modifiers: Iterable<KModifier>): Builder
        
        /** Sets the property initializer */
        fun initializer(format: String, vararg args: Any?): Builder
        fun initializer(codeBlock: CodeBlock): Builder
        
        /** Sets a delegated property */
        fun delegate(format: String, vararg args: Any?): Builder
        fun delegate(codeBlock: CodeBlock): Builder
        
        /** Sets a custom getter */
        fun getter(funSpec: FunSpec): Builder
        
        /** Sets a custom setter */
        fun setter(funSpec: FunSpec): Builder
        
        /** Sets the receiver type for extension properties */
        fun receiver(receiverType: TypeName): Builder
        fun receiver(receiverType: KClass<*>): Builder
        
        /** Adds annotations */
        fun addAnnotation(annotationSpec: AnnotationSpec): Builder
        fun addAnnotation(annotation: ClassName): Builder
        fun addAnnotation(annotation: Class<*>): Builder
        fun addAnnotation(annotation: KClass<*>): Builder
        
        /** Adds KDoc documentation */
        fun addKdoc(format: String, vararg args: Any?): Builder
        fun addKdoc(block: CodeBlock): Builder
        
        /** Adds context receivers */
        fun contextReceivers(receiverTypes: Iterable<TypeName>): Builder
        fun contextReceivers(vararg receiverTypes: TypeName): Builder
        
        /** Builds the PropertySpec */
        fun build(): PropertySpec
    }
}

Usage Examples:

// Simple val property with initializer
val nameProperty = PropertySpec.builder("name", String::class)
    .initializer("%S", "Unknown")
    .build()

// Mutable property with custom getter and setter
val temperatureProperty = PropertySpec.builder("temperatureCelsius", Double::class)
    .mutable(true)
    .addModifiers(KModifier.PRIVATE)
    .initializer("0.0")
    .build()

val temperatureFahrenheit = PropertySpec.builder("temperatureFahrenheit", Double::class)
    .getter(
        FunSpec.getterBuilder()
            .addStatement("return temperatureCelsius * 9.0 / 5.0 + 32.0")
            .build()
    )
    .setter(
        FunSpec.setterBuilder()
            .addParameter("value", Double::class)
            .addStatement("temperatureCelsius = (value - 32.0) * 5.0 / 9.0")
            .build()
    )
    .build()

// Const property
val maxRetries = PropertySpec.builder("MAX_RETRIES", Int::class)
    .addModifiers(KModifier.CONST)
    .initializer("3")
    .build()

// Lazy delegated property
val expensiveValue = PropertySpec.builder("expensiveValue", String::class)
    .delegate(CodeBlock.of("lazy { computeExpensiveValue() }"))
    .build()

// Extension property
val stringLength = PropertySpec.builder("lastChar", Char::class.copy(nullable = true))
    .receiver(String::class)
    .getter(
        FunSpec.getterBuilder()
            .addStatement("return if (isEmpty()) null else this[length - 1]")
            .build()
    )
    .build()

// Property with backing field
val counter = PropertySpec.varBuilder("counter", Int::class)
    .addModifiers(KModifier.PRIVATE)
    .initializer("0")
    .getter(
        FunSpec.getterBuilder()
            .addStatement("return field")
            .build()
    )
    .setter(
        FunSpec.setterBuilder()
            .addParameter("value", Int::class)
            .addStatement("require(value >= 0) { %S }", "Counter cannot be negative")
            .addStatement("field = value")
            .build()
    )
    .build()

Parameter Specification

Creates function and constructor parameters with support for default values, vararg, and parameter modifiers.

/**
 * Specification for function and constructor parameters
 */
class ParameterSpec private constructor() {
    companion object {
        /** Creates a builder for a named parameter */
        fun builder(name: String, type: TypeName, vararg modifiers: KModifier): Builder
        fun builder(name: String, type: KClass<*>, vararg modifiers: KModifier): Builder
        
        /** Creates an unnamed parameter (for lambda types) */
        fun unnamed(type: TypeName): ParameterSpec
        fun unnamed(type: KClass<*>): ParameterSpec
    }
    
    /** Builder for constructing ParameterSpec instances */
    class Builder {
        /** Adds modifiers to the parameter */
        fun addModifiers(vararg modifiers: KModifier): Builder
        fun addModifiers(modifiers: Iterable<KModifier>): Builder
        
        /** Sets the default value for the parameter */
        fun defaultValue(format: String, vararg args: Any?): Builder
        fun defaultValue(codeBlock: CodeBlock): Builder
        
        /** Adds annotations */
        fun addAnnotation(annotationSpec: AnnotationSpec): Builder
        fun addAnnotation(annotation: ClassName): Builder
        fun addAnnotation(annotation: Class<*>): Builder
        fun addAnnotation(annotation: KClass<*>): Builder
        
        /** Adds KDoc documentation */
        fun addKdoc(format: String, vararg args: Any?): Builder
        fun addKdoc(block: CodeBlock): Builder
        
        /** Builds the ParameterSpec */
        fun build(): ParameterSpec
    }
}

Usage Examples:

// Simple parameter
val nameParam = ParameterSpec.builder("name", String::class).build()

// Parameter with default value
val ageParam = ParameterSpec.builder("age", Int::class)
    .defaultValue("0")
    .build()

// Vararg parameter
val itemsParam = ParameterSpec.builder("items", String::class)
    .addModifiers(KModifier.VARARG)
    .build()

// Parameter with annotation
val validatedParam = ParameterSpec.builder("email", String::class)
    .addAnnotation(ClassName("javax.validation.constraints", "Email"))
    .build()

// Crossinline lambda parameter  
val lambdaParam = ParameterSpec.builder("block", LambdaTypeName.get(returnType = UNIT))
    .addModifiers(KModifier.CROSSINLINE)
    .build()

// Reified type parameter
val typeParam = ParameterSpec.builder("clazz", Class::class.asClassName().parameterizedBy(TypeVariableName("T")))
    .build()

Context Parameters and Receivers

Support for Kotlin's context receivers and extension function receivers.

// Context receivers are set on FunSpec and PropertySpec builders
// Extension receivers are set using receiver() method

Usage Examples:

// Extension function with receiver
val stringExtension = FunSpec.builder("truncate")
    .receiver(String::class)
    .addParameter("maxLength", Int::class)
    .returns(String::class)
    .addStatement("return if (length <= maxLength) this else substring(0, maxLength) + %S", "...")
    .build()

// Function with context receivers (experimental feature)
val contextFunction = FunSpec.builder("processWithContext")
    .contextReceivers(
        ClassName("", "Logger"),
        ClassName("", "Database")
    )
    .addParameter("data", String::class)
    .returns(UNIT)
    .addStatement("log(%S)", "Processing data")
    .addStatement("save(data)")
    .build()

Install with Tessl CLI

npx tessl i tessl/maven-com-squareup--kotlinpoet

docs

annotations-and-metadata.md

code-generation.md

file-and-type-generation.md

function-and-property-generation.md

index.md

type-system.md

utilities.md

tile.json