Do you have plans to support unstructured code blocks? Like property initializers. For example given the class,

class Foo : Bar {
    val foo by bar()
}

It would be nice, from

foo

property, to retrieve the initializer

"by bar()"

as a code block / string that can be analyzed.

That's an interesting idea. Can you give some example of how those code blocks can be analyzed / from which what information can be extracted and used?

By analyzed I mean purely with string manipulation like regexes. Kind of what you can do in KotlinPoet with

PropertySpec.initializer.toString()

. If you want a concrete example, I have a library that lets you model Firestore database objects like this:

@FirestoreClass
class User {
    val firstName: String by this
    val lastName: String by this
}

A processor cycles over the properties to store their names, however sometimes the server field name is slightly different. It would be powerful to be able to write

val firstName: String by this("first_name")

and retrieve "first_name" in the processor, without adding verbose annotations to each field.

Generally, expressions are not available at the moment. The only available expression right now is within annotations, which are required to be compile time constants. In the example

val firstName: String by this("first_name")

, we would need to model function call and delegation before

"first_name"

can be retrieved. That (supporting expressions / statements) is beyond our current plan.

To be clear, I mean to expose an unstructured string, so that I could do:

val property: KSPropertyDeclaration = ...
val initializer: String = property.initializer 
// initializer is a string equal to "by this(\"first_name\")"
require(initializer.startsWith("by this")) { 
    "DB properties must be delegated to this!" 
}
val fieldName = initializer.substring(9, initializer.lastIndexOf("\""))

So you don't really need models for functions and delegation, it's just an opaque string, saying nothing about its contents, like KotlinPoet's CodeBlock . This example is a bit convoluted but, for instance, for literals

const val foo = 0L

this string would be equal to "0L" which one could transform to Long. And just like KSPropertyDeclaration.initializer one could have KSFunctionDeclaration.body and so on. I understand if you think this is out of scope, I just wanted to be clear

Thanks for the explanation. That sounds somewhat feasible and useful. Please allow us to think more about it before making any commitments.

Sure - thanks!