does kapt will be deprecated in future and replace completly by ksp ?

Hey there, after googling for a bit I didn’t find the answer to my question so I came here: Is there a way to identify a delegated property (by lazy, by inject()) etc by KSP ?

Hi how concerned should i be about this appearing in my android build output

Configuration 'kspProductionDebugKotlinProcessorClasspath' was resolved during configuration time.

This is a build performance and scalability issue.

See <https://github.com/gradle/gradle/issues/2298>

Just reported an kotlin IC issue here where incremental compilation of unit test fails when the processor takes code generated by another plugin as input. I’m not 100% sure it’s a KSP bug as it doesn’t happen with

kotlin.incremental=false

so please let me know if I should report on YouTrack instead.

I think ksp has regressed with the latest release. Is there a workaround for this? https://github.com/google/ksp/issues/367#issuecomment-1416879144

Hi , hope i'm at the right channel Using

KSClassDeclaration

for type

ClassKind.ENUM_CLASS

is it possible to get the names of the enums ?

Hi, in a multi-module kotlin multiplatform project, if you set a processor with kspCommonMainMetadata in one module, ksp fails if asked to resolve any type that is declared in any of the other local modules.

How do I add a dependency to the module

generatedByKspCommonMainKotlinMetadata

? When I use the automatic import from IntelliJ, it adds

implementation(project(mapOf("path" to ":")))

which doesn’t work

FYI: I found an interesting interaction loop between KSP and NAPT https://github.com/google/ksp/issues/1321 Reproduction of it is in a PR against the NAPT project. Blocks me from bumping kotlin/ksp up to latest and I can't drop NAPT until dagger ships the ksp processor 😕

Hi All 👋 , how do I print a log out for debugging purpose for KSP? https://stackoverflow.com/questions/75436055/how-to-print-a-log-in-kotlin-ksp-processor

FYI, it looks like AGP/Gradle 8 have a bug around KSP that fails builds in gradle 8. https://issuetracker.google.com/issues/269089135

This message was deleted.

Hello, there is a way to use KSP with Lombok and Mapstruct?

Hello, Is it possible to use KSP to replicate what is done by derive in Rust? With editor support. For instance, with

data class

, compiler will generate some standard code. With

suspend

it will perform some transformation as well. Same with

inline

. That’s for keywords, but there are also

@Compose

for Jetpack Compose and

@Serializable

for Kotlinx.serialization. The last one is really cool. It will generate all of what is needed for de/serialization, and methods such as

Json.decodeFromString<Person>(string)

are showing errors right away in the IDE if Person is not annotated with

Serializable

. This does not use KSP (I think), but a compiler plugin. Would KSP be able to reproduce the same experience before execution?

import com.me.WithMyFeature
import com.me.useFeature

@WithMyFeature
class Dog

class Person

val dog = Dog()
val person = Person()

dog.useFeature() // No issue

person.useFeature() // Issue

I saw this kind of solution, but that would only work at runtime :/

@Suppress("UNUSED_PARAMETER")
fun Any.useFeature() {
  throw NotImplementedError("missing implementation")
}

Hi! We moved from javac based annotation processors to everything written with KSP and we are seeing ridiculously big difference in memory footprint. At the first glance it seems like a memory leak in either KSP or kotlinc. Our processor doesn’t have any fields, top-level fields, objects, companion objects or anything static involved. Everything we reference has a scope of

process

function and should be freed after exiting. So it is highly unlikely that there is a memory leak on our side 😞 We are comparing Kotlin + javac annotation processing with Kotlin + KSP annotation processing and the difference in peak memory consumption for the whole build is: • For Kotlin+Javac: 39.5 Gb • For Kotlin+KSP: 62.5 Gb Both setups are using

Bazel

workers, to verify that it is a memory leak we changed strategy to

local

(which is basically starts new instance of kotlinc for every module instead of using long running daemons) and the memory usage felt back to normal values (still slightly more with KSP but tolerable) Can someone help me with triaging this issue and give me a clue how to run some diagnostics so I’ll be able to create a proper bug report? Was fixed by: https://github.com/google/ksp/pull/1067

It seems that there is not going to be support for databinding with ksp. Is there a community effort to make a ksp compliant version? We have a large app with a few modules that are in databinding and won’t be redone or removed for quite some time. We want to use Anvil for its ability to skip kapt and generate dagger factories purely through kotlinc. However, we lose that ability to do (and must go back on KAPT) when our modules include the databinding compiler (and actually use it more than converting to viewbinding).

I’m profiling my KSP processor and seeing that KSP spends a lot of time visiting classes’ props and funs declarations. The annotation I’m using is only applicable to types, so it is waste of time to scan props and funs. I understand that current processor’s API doesn’t help to avoid that since there is no way to know which annotations are used by the processor and configure

CollectAnnotatedSymbolsVisitor

appropriately. But maybe you think it is a good idea to introduce an

annotations()

fun like javac processors have and infer what exactly should be visited with given set of KSP processors and all annotations they aim to use?

KSP 2 landed in the EAP channel today! (😉 have a great weekend everybody) https://store.steampowered.com/app/954850/Kerbal_Space_Program_2/

What approach do folks here use to insure against processor crashes due to malformed annotations? ksp runs before kotlinCompile, so annotations may be bad. This can trigger crash in processor without any indication to user about what the malformed element is, and compiler won't get to run to show the offending element, either. Many of the examples below cause various exceptions in ksp while trying to access the annotation and its value.

@MyIntThing(1) // correct
@MyIntThing(1,2) // no
@MyIntThing("nope")
@MyIntThing(1) @MyIntThing(2) //no, it's not repeatable
@MyIntThing(1L) // no, really

Hi Can we use generated classes in original annotated class ?

@MyAnnotatoin
data class A(){
   fun b(): MyAnnotatoinGeneratedClass {
       return MyAnnotatoinGeneratedClass()
   }
}

where

MyAnnotatoinGeneratedClass

is a class that was generated by

@MyAnnotation

Ofc i'm getting not resolved right now

Hi All, If I want to see the Info log info for KSP debugging, where can I set the

--verbose

mode through IntelliJ or Android Studio? I post the question in https://stackoverflow.com/questions/75601653/how-to-set-verbose-in-intellij-android-studio-for-ksp-debugging-purposes too. Thanks 🙏

Anyone here who can suggest how to use ksp in a kscript? Tho, tbh, I'm thinking of just migrating this script to be an executable fatjar instead 😒miling_face_with_tear:

Is it possible to get the value of a property with KSP?

@MyAnnotation
class MyConfig : Config {
    override val configField1: String = "a"
    override val configField2: String = "b"
}

Is it possible to get “a” out of ksClassDeclaration?

Are there any patterns for generating files from a symbol processor that aren't code/resource files while still maintaining support for incremental processing? e.g. I want to write a report to some path so that I can use it in later gradle tasks

If I have an annotated class Foo<T>, and I use the symbol information for the generic type T to create a file, should I tag the file spec with the originatingFile as T or Foo? What if multiple Ts make up a file, should all of them be tagged as the originating file? Any help is much appreciated

I've a multi-module project using KSP version 1.8.10-1.0.9 and it would be helpful if someone can help me with disabling the task of code-generation in the tests sub-directory of the build directory. This is roughly the structure of the project:

myProject
    - api
    - engine
    - methods
        - build.gradle.kts

dependencies { implementation(project(":engine")) implementation(project(":methodsProcessor")) testImplementation(kotlin("test")) testImplementation(testFixtures(project(":engine"))) testImplementation("org.junit.jupiter:junit-jupiter-params:5.8.2") ksp(project(":methodsProcessor")) }

- build
            - generated
                - ksp
                    - main
                        - kotlin
                            - methods
                                - PublicMethods.kt

                    - test   ##  I don't want this directory to be created at all
                        - kotlin
                            - methods
                                - PublicMethods.kt
    - methodsProcessor
        - build.gradle.kts (contents below)

dependencies { implementation(libs.ksp.api) }

- src.main.kotlin.processor.MethodsProcessor
            ## this file has a SymbolProcessor which creates a new file (PublicMethods.kt) in
            ## `methods/build/generated/ksp/main/kotlin/methods` &
            ## `methods/build/generated/ksp/test/kotlin/methods` (THIS I would like not to be created)
    - build.gradle.kts
    - settings.gradle.kts

rootProject.name = "myProject" include("engine") include("methods") include("api") include("methodsProcessor") val kotlinVersion: String by settings val kspVersion: String by settings pluginManagement { plugins { // For some reason the global variables are not accessible here val kotlinVersion: String by settings val kspVersion: String by settings kotlin("jvm") version kotlinVersion kotlin("plugin.jpa") version kotlinVersion kotlin("plugin.spring") version kotlinVersion id("com.google.devtools.ksp") version kspVersion } } dependencyResolutionManagement { repositories { mavenCentral() } versionCatalogs { create("libs") { library("ksp-api", "com.google.devtools.ksp😒ymbol-processing-api:$kspVersion") } } }

```

When I run `./gradlew build` for my project, the output on the terminal looks like:
```> Task :api:openApiGenerate
################################################################################
# Thanks for using OpenAPI Generator.                                          #
# Please consider donation to help us maintain this project :pray:                 #
# <https://opencollective.com/openapi_generator/donate>                          #
################################################################################
Successfully generated code to /Users/gxyd/projects/solver-engine/api/build/generated-src/openapi

> Task :methods:kspKotlin
w: [ksp] hello world

Daemon will be stopped at the end of the build after running out of JVM memory

> Task :methods:kspTestKotlin
w: [ksp] hello world

So, the second task that you see, i.e.

:methods:kspTestKotlin

is something I don't to it to run. I've already tried having the below configuration in `methods.build.gradle.kts`:

ksp {
    tasks.named("kspTestKotlin") {
        enabled = false
    }
}

which raises the error saying, there is no task named "kspTestKotlin", while building my project.

Any chance of a bugfix release with the fix for resolving dependencies at configuration-time? It's quite a noisy log on top of the performance penalty

I have a test which asserts that ksp compilation fails when a certain invariant is broken. The test passes, but the failure I log through to ksp is always printed to stdout. Is there anyway of preventing this? It’s fine for me but for other members of my team they may believe this is a real error when reading CI logs rather than a situation I’m simulating in test.

Is there a deepCopy KSP available? I was thinking to make one 🤓