For two cases:

    val smartClasses = SmartReflekt.classes<BInterface>().filter { it.isData() }.resolve()
    println(smartClasses)

    val smartObjects = SmartReflekt.objects<BInterface>().filter { it.isCompanion() }.resolve()
    println(smartObjects)

we got this error:
class io.reflekt.example.TestFunctions$Companion cannot be cast to class io.reflekt.example.BInterface

But we should not consider this class

The idea is that WithX.toList should return not a KClass, which assumes further runtime reflection, but an information class storing all the information about the class available to Reflekt plus the old KClass reference.

This is particularly useful to implement #71, because actually KClass has the sealedSubclasses property that does that thing; however, this data can be collected at compile time, and it's helpful in cases where run-time reflection isn't available or too slow.

Rough API:

class ReflektClass<T> {
  val kotlin: KClass<T>
  val qualifiledName: String
  val simpleName: String
  val sealedSubclasses: List<ReflektClass<*>>
  val isOpen: Boolean
  ...
}

Possible usage:

Reflekt.classes().withSuperType<B1>().toList().map { /* it: ReflektClass<B1> */ it.qualifiedName }.forEach { println(it) }

Also, to not bloat the ReflektImpl file, there must be a registry of such classes to have them available in many DSL calls simultaneously (basically, val classData: HashMap<String, ReflektClass<*>>).

Hi, I've been looking at using this project and I see that the Gradle config could be improved. I like fixing Gradle, so I'm happy to make a PR.

Here's a non-complete list:

1. remove unused or unrequired plugins & dependencies

• com.github.gmazzo.buildconfig, unused

I'll look into making some additional improvements, like using the Kover for code coverage.

Write a guide for external contributors how they can help us

Since these are known at compile-time, it would be quite helpful to be able to generate that information.

Tests of ReflektImpl generation don't check if generated files compile successfully.

Add tests for code generation for ReflektImpl file

Create an Intellij IDEA plugin to make it easier to use the Reflekt plugin: add an inspection for searching the Reflekt and SmartReflekt calls and describe what of the part will be replaced at the compile time.

The main reason for it: it can be difficult for users to understand clearly what of the part from the query will be run at the run-time in the composite queries, e.g.:

SmartReflekt.functions<() -> Boolean>().filter { it.isTopLevel && it.name == "fooBoolean" }.resolve().onEach { it() }
        .map { it.toString() }.toSet()

This example will be replaced into something like this:

listOf(list_of_functions).onEach { it() }.map { it.toString() }.toSet()

And the last part will be executed at the run-time

Couldn't run readme example with kotless dependency due to the error "Could not resolve io.kotless:kotless-dsl:0.1.6"

A problem occurred configuring root project 'reflekt-example'.
> Failed to notify project evaluation listener.
   > Could not resolve all files for configuration ':compileClasspath'.
      > Could not find io.kotless:kotless-dsl:0.1.6.
        Searched in the following locations:
          - https://repo.maven.apache.org/maven2/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://jcenter.bintray.com/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://plugins.gradle.org/m2/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://packages.jetbrains.team/maven/p/reflekt/reflekt/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
        Required by:
            project :
   > Could not resolve all files for configuration ':compileClasspath'.
      > Could not find io.kotless:kotless-dsl:0.1.6.
        Searched in the following locations:
          - https://repo.maven.apache.org/maven2/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://jcenter.bintray.com/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://plugins.gradle.org/m2/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
          - https://packages.jetbrains.team/maven/p/reflekt/reflekt/io/kotless/kotless-dsl/0.1.6/kotless-dsl-0.1.6.pom
        Required by:
            project :

Possible solution:
 - Declare repository providing the artifact, see the documentation at https://docs.gradle.org/current/userguide/declaring_repositories.html

Currently, Reflekt searches for entities (classes/objects/functions) be their annotations and returns as a list or a set.

Sometimes, e.g. in Kotless, users want to use not only the lists with results, but use the information from annotations. In this case, we can find entities, but to get the annotations from them we should use run-time reflection.

Thus, we should add an able of storing not only the list/set of the entities but and additional info (from the query params)

Currently, Reflekt does not support the incremental compilation process. We have to get all compiled instances per module and merge old results with new ones

This is very similar to a project I started a while back.

https://github.com/dhakehurst/net.akehurst.kotlinx/tree/master/net.akehurst.kotlinx

there may also be other people who have done similar things.

We should try to combine our approaches and resources, to make better progress.

Support search entities in Java files from the project and the libraries. We can use special JavaDescriptors to search the entities (only for Reflekt part, since for SmartReflekt we have to adapt all Kotlin-specific properties to Java)

In this case, we also can support the usage of the Reflekt queries in Java files, but we can not replace IR since we don't have IR in Java. To keep our approach multiplatform, we can use ReflektImpl approach -- generate ReflektImpl implementation not only for the libraries but and for the current project (only for Java queries)

I've checked out master and when I run the tests I get failures due to mismatched line endings.

"Contents have differences only in line separators".

I've tried implementing a function to normalize the line endings to \n

/**
 * Read all lines in a file, with line-endings normalized to `\n`. The result is [trim]-ed.
 *
 * This helps ensure consistent test results across Windows and Unix platforms.
 */
fun File.readTextNormalized(): String = useLines(Charsets.UTF_8) { it.joinToString("\n").trim() }

However this doesn't resolve the issue, and for some reason the 'actual' isn't loaded correctly

I see that in .editorconfig the line endings are specified as lf, but because there's no .gitattributes file, very few of the files are formatted as lf.

The fix is probably to add .gitattributes and reformat all files to have lf endings.

Hello,

Can we use this lib with Maven or without Gradle?

Thanks in advance.

All links in readme to the limited Reflekt DSL or the extended SmartReflekt DSL are leading to 404

Currently, the user should do a lot of work to get the plugin into a Gradle build with all the configuration fiddling. Can we make it easier?

Describe all invariants in the documentation, e.g. what we consider as a subtype for the functions signatures, how we handle extension functions, what entities we are looking for (e.g. entities with the public modifier, top-level functions)

Instead of having storage for metadata, we can store each query result and avoid whens in ReflektImpl that cause O(n) time complexity for each invocation.

These cases have errors for the current version with bytecode. We need to check them in the current version, also add tests for them

1. Function:

fun foo(): Boolean {
    println("public second example foo")
    return true
}

Query:

SmartReflekt.functions<() -> Boolean>().filter { it.isTopLevel && it.name == "foo" }.resolve()

2. Function:

fun <T> foo(): List<T>

Query:

SmartReflekt.functions<Function0<List<*>>>().filter { it.isTopLevel && it.name == "foo" }.resolve()

3. Enum case

Hi, I saw this note in the source code about marking which dependencies should be introspected.

I think a better way would be to use Gradle variant attributes.

The end result would, to users, look something like this:

    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.6.10")  {
        reflekt(introspect = true)
    }

And in the plugin, it would require less config, and leverage Gradle task-avoidance more (faster, less unncessary work).

The steps would be

1. Create a custom Attribute https://docs.gradle.org/current/userguide/variant_attributes.html#sec:declaring_attributes
2. Create a helper extension function, to apply the attribute to dependencies
3. Create a Configuration for gathering the dependencies https://docs.gradle.org/current/userguide/cross_project_publications.html#sec:variant-aware-sharing
4. Update ReflektSubPlugin.kt to resolve the location of the libraries using the Configuration

Create a custom attribute

// ReflektSubPlugin.kt
    companion object {
        val REFLEKT_INTROSPECTION_ATTRIBUTE = Attribute.of("org.jetbrains.reflekt.introspect", Boolean::class.javaObjectType)
    }

Manually this attribute could be applied

// build.gradle.kts
dependencies {
    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.6.10")  {
        attributes {
            attributes.attribute(Attribute.of("org.jetbrains.reflekt.introspect", Boolean::class.javaObjectType), true)
        }
    }
}

Create 'apply introspect Attribute' extension

But that's a little clunky. I think an extension function, in reflekt-gradle-plugin, like this would work

// ReflektGradleExtension.kt
/** Designate this dependency as one Reflekt will analyse. */
fun ModuleDependency.reflekt(introspect: Boolean = true) {
    attributes.attribute(REFLEKT_INTROSPECTION_ATTRIBUTE, introspect)
}

// build.gradle.kts
dependencies {
    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.6.10")  {
        reflekt(introspect = true)
    }
}

Create a Configuration

Now Reflekt can create its own bucket of dependencies, called reflektIntrospect.

    // RefelktSubPlugin.kt
    companion object {
        const val REFLEKT_INTROSPECT_CONFIGURATION_NAME = "reflektIntrospect"
        val REFLEKT_INTROSPECTION_ATTRIBUTE = Attribute.of("org.jetbrains.reflekt.introspect", Boolean::class.javaObjectType)
    }

    private fun Project.createReflektIntrospectConfiguration(): Configuration {
        return configurations.create(REFLEKT_INTROSPECT_CONFIGURATION_NAME).apply {
            description = "These dependencies will be introspected by Reflekt. "

            // mark this as an 'inbound' collector. It is not a provider of dependencies.
            isCanBeResolved = true
            isCanBeConsumed = false

            // filter to only include dependencies that are explicitly marked
            attributes.attribute(REFLEKT_INTROSPECTION_ATTRIBUTE, true)
            isTransitive = false

            // extending from compileClasspath means this 'reflekt' configuration will also receive 
            // any dependencies that 'compileClasspath' receives.
            // https://docs.gradle.org/current/userguide/java_plugin.html#tab:configurations
            extendsFrom(configurations[JavaPlugin.COMPILE_CLASSPATH_CONFIGURATION_NAME])
        }
    }

This configuration will be available for customisation in any project where the Reflekt Gradle Plugin is applied, so users can customise it. (For example, including testCompileClasspath, or files from a local directory.)

Create the Configuration in ReflektSubPlugin

I think that this new configuration should be applied ASAP, and creating it in override fun applyToCompilation(...) might be too late? But I'm not sure.

// ReflektSubPlugin.kt
    override fun apply(target: Project) {
        target.createReflektIntrospectConfiguration()
    }

Resolve the Configuration in ReflektSubPlugin

And then in applyToCompilation the configuration can be resolved. This will trigger Gradle tasks - so it's best to either use the correct Gradle methods that will return and map providers...

// get a provider for the config
val introspectConfigurationProvider: NamedDomainObjectProvider<Configuration> =
            project.configurations.named(REFLEKT_INTROSPECT_CONFIGURATION_NAME)

val librariesToIntrospect: Provider<List<SubpluginOption>> =
    introspectConfigurationProvider
        .map { introspectLibs: Configuration ->
            introspectLibs
                .incoming
                .artifactView { it.lenient(true) }
                .files
                .map { lib: File ->
                    SubpluginOption(key = LIBRARY_TO_INTROSPECT.name, value = lib.canonicalPath)
                }
        }
// (note: Provider.map is different to List<>.map)

Or do all the work inside a provider

return project.provider {

            val introspectConfiguration: Configuration = project.configurations[REFLEKT_INTROSPECT_CONFIGURATION_NAME]
            val librariesToIntrospect = introspectConfiguration.incoming
                .artifactView { it.lenient(true) }
                .files
                .map { lib: File ->
                    SubpluginOption(key = LIBRARY_TO_INTROSPECT.name, value = lib.canonicalPath)
                }

            librariesToIntrospect + reflektMetaFilesOptions + dependencyJars +
                SubpluginOption(key = ENABLED_OPTION_INFO.name, value = extension.enabled.toString()) +
                SubpluginOption(key = OUTPUT_DIR_OPTION_INFO.name, value = generationPath) +
                SubpluginOption(key = SAVE_METADATA_OPTION_INFO.name, value = extension.toSaveMetadata.toString()) +
                SubpluginOption(key = REFLEKT_META_FILE_PATH.name, value = createReflektMeta(project.getResourcesPath()).absolutePath)
        }

Implement code-generation of SmartReflektImpl file to add an ability to use SmartReflekt in external libraries.

Add the ability to search for functions without specified signature based on given annotations.

ie:

Reflekt.functions().withAnnotation<Function<*>>(Annotation::class)

Possible algorithm of implementation:

1. To interface ReflektClass<T> add val objectInstance: T?
2. Add interface ReflektObject<T : Any> : ReflektClass<T> where objectInstance is overriden by type T
3. Add value class ReflektObjectDelegate(val reflektClass: ReflektClass<T>) : ReflektObject<T> { ... }
4. In objects DSL results resulting ReflektClass for objects should be converted to ReflektObjectDelegate

Maybe the interface ReflektObject isn't necessary at all.

Shocked to see Kotlin 1.7 (& 1.5) everywhere in the readmes 😅

Add VERSION.md file and replace gathering version in the project everywhere

Add ktlint and fix all code quality issues if it is necessary