Hello, where can I find the logs created by using

environment.logger

?

Hi, I was wondering how can I generate the

symbol-processing-cmdline

artifact locally? I see it's only created to be published in Maven (https://github.com/google/ksp/pull/541), but I don't see a way to generate it myself in case I want to test the 1.5.30 branch for example. It's also unclear to me what is the difference between that and the regular

symbol-processing

artifact. I know the cmdline variant is necessary for Kotlin Native and command line, but why is that?

Hi, I'm trying to use KSP from command line and while I do get the generated classes in the kotlinOutputDir, the

kotlinc

command doesn't compile the project's classes and places them in the output folder. As a repro example using the playground project, after running the following command I don't see anything in the

build2/classes

folder. I do however see the generated

AClassBuilder

class inside

build2/generated/ksp/main/kotlin

.

kotlinc \
-d /Users/udinic/projects/ksp-playground4/workload/build2/classes \
-verbose \
-cp /Users/udinic/projects/ksp-playground4/test-processor/build/libs/test-processor-1.0-SNAPSHOT.jar \
-Xplugin=/Users/udinic/tmp/ksp-stuff/symbol-processing-api-1.5.21-1.0.0-beta07.jar \
-Xplugin=/Users/udinic/tmp/ksp-stuff/symbol-processing-cmdline-1.5.21-1.0.0-beta07.jar \
-P plugin:com.google.devtools.ksp.symbol-processing:apclasspath=/Users/udinic/projects/ksp-playground4/test-processor/build/libs/test-processor-1.0-SNAPSHOT.jar \
-P plugin:com.google.devtools.ksp.symbol-processing:projectBaseDir=/Users/udinic/projects/ksp-playground4/workload/src/main/java \
-P plugin:com.google.devtools.ksp.symbol-processing:classOutputDir=/Users/udinic/projects/ksp-playground4/workload/build2/classes/kotlin/main \
-P plugin:com.google.devtools.ksp.symbol-processing:kotlinOutputDir=/Users/udinic/projects/ksp-playground4/workload/build2/generated/ksp/main/kotlin \
-P plugin:com.google.devtools.ksp.symbol-processing:javaOutputDir=/Users/udinic/projects/ksp-playground4/workload/build2/generated/ksp/main/java \
-P plugin:com.google.devtools.ksp.symbol-processing:resourceOutputDir=/Users/udinic/projects/ksp-playground4/workload/build2/generated/ksp/main/resources \
-P plugin:com.google.devtools.ksp.symbol-processing:cachesDir=/Users/udinic/projects/ksp-playground4/workload/build2/generated/ksp/main/cache \
-P plugin:com.google.devtools.ksp.symbol-processing:kspOutputDir=/Users/udinic/projects/ksp-playground4/workload/build2/ksp \
/Users/udinic/projects/ksp-playground4/workload/build2/generated/ksp/main/kotlin/ /Users/udinic/projects/ksp-playground4/workload/src/main/java

If I disable KSP, by removing the

-Xplugin

params, I will see the compiled classes in the classes folder, but without any new generated classes of course. Is there something missing in my command?

Hi guys, is it possible with KSP to get the default value of a function parameter which function is annotated? I am able to check if there is a default value for that parameter (using

KSValueParameter.hasDefault

), but not what that value is..

Hey folks. I'm writing a KSP processor for a multiplatform project where I want to scan annotated JVM code and generate both JVM + JS code, however the current

CodeGeneration

API does not seem to support writing to a different source set rather than the one being processed. My workaround is to pass

fileName = "../../(a lot more "../")/jsMain/OutputFileName"

. Is there any other way to achieve this?

I am running into an issue where an annotation argument is missing during processing (KSP beta8, kotlin 1.5.30) - I’m not sure if it’s a KSP or Kotlin bug. I know there have been several bugs with values in annotations not working correctly in some edge cases, but this one seems different. I am seeing this when using an Android resource value (Int) as an annotation argument

@Attr(R2.layout.my_layout)
class MyClass

Where the resource is defined in a class like this

public final class R2 {
    public static final class layout {
        public static final int my_layout = 1616;
    }
}

We borrowed this pattern from Butterknife, and the R2 class comes from the Butterknife gradle plugin to make the resource values final. When a resource value is used as the annotation argument like this, KSP and the kotlin compiler don’t seem to recognize it. I’ve done some debugging and the whole argument is just absent in the compiler representation of the arguments list. However, if I use a constant Int directly the argument is available. Does anyone know why KSP/Kotlin can’t recognize a value defined this way?

seems like the evaluation is not handling it properly

@Ting-Yuan Huang You brought up non-JVM support for the PR I submitted. I thought it might be useful to discuss ideas about the non-JVM support for https://github.com/google/ksp/pull/508 which adds the getAnnotationsByType and isAnnotationPresent experimental methods. I saw that the latest version of Kotlin 1.5.30 provides the ability to instantiate. I am not sure if this provides a better integration into just utilizing Kotlin reflection and isolating away from using JVM specific calls. This KEEP discusses “3. Better multiplatform support”. What are your thoughts, as I am just scratching the surface of the JVM vs Multiplatform understanding here.

Has anyone encountered this issue with native targets?

> Task :an-sample:kspTestKotlinAndroidNativeArm64 FAILED
e: Could not find "/Users/natario/Projects/ccc/ppp/an-sample/build/generated/ksp/androidNativeArm64Main/classes" in [/Users/natario/Projects/ccc/ppp, /Users/natario/.konan/klib, /Users/natario/.konan/kotlin-native-prebuilt-macos-x86_64-1.5.30/klib/common, /Users/natario/.konan/kotlin-native-prebuilt-macos-x86_64-1.5.30/klib/platform/android_arm64]

Trying to run processor on the

test

compilation, gives the error above about missing class file in the

main

compilation path. Indeed that "generated/ksp/classes" directory is empty, not sure what it's expecting to find there. The error wording also seems suspicious, in

Could not find "XXX" in [list of paths]

I'd expect XXX to be a filename, not a resolved path.

I noticed that kotlin sources generated in android debug unit tests don’t seem to be visible to the java compiler, which causes the java compilation to fail.

I'd like to tackle https://github.com/google/ksp/issues/277 if team is not working on it. I have it working actually, but I need to take some decisions which I'd like to discuss: 1. Right now I'm creating a configuration per

KotlinTarget

, named

ksp<TargetName>

. For single-platform projects though, it might make sense to skip this step - when kotlin-jvm plugin is used for example, there's no point in having to write

kspJvm

as it would be identical to root

ksp

. What do you think? 2. Within each target, I create a configuration per

KotlinCompilation

, named

ksp<TargetName><CompilationName>

, extending the target configuration. As above, target name is omitted in single-platform. We could avoid creating this configuration for the main compilation, but after playing with it I think it's very nice to have fine grained control over main vs. test vs. both. 3. Within each compilation, I create a configuration per

KotlinSourceSet

, named

ksp<SourceSetName>

, but only if the source set is not the default one for that compilation. Basically this will be skipped 99% of the times? 4. Intermediate source sets do not have their own configuration. May be introduced in a future PR/version? 5. Android needs special handling. The KotlinSourceSet names are very confusing:

compilation=debug sourceSets=[androidDebug, androidMain]
compilation=debugAndroidTest sourceSets=[androidDebugAndroidTest, androidAndroidTest, androidAndroidTestDebug]
compilation=debugUnitTest sourceSets=[androidDebugUnitTest, androidTest, androidTestDebug]
compilation=release sourceSets=[androidRelease, androidMain]
compilation=releaseUnitTest sourceSets=[androidReleaseUnitTest, androidTest, androidTestRelease]

Looks to me that compilations == AGP variants, so one option is to create one config per variant named

ksp<TargetName><VariantName>

. Another option is to read the `AndroidSourceSet`s from AGP (main, debug, release, test, testDebug, testRelease, androidTest, androidTestDebug, androidTestRelease). This gives more fine grained control, but it's harder to do (testDebug should extend both debug and test... Also not clear how to retrieve the correct configurations later in

applyToCompilation()

).

I was surprised to see the

KSDeclaration.getVisibility()

returns the visibility of the original declaration by looking up the overridee if the declaration is an override. I was expecting, and hoping, to get the visibility of an overridden function and was pretty confused by this behavior. Why was this approach chosen? It seems like a strange default. I suppose we can check modifiers directly to get visibility of a overridden declaration but it’s not ideal imo

I think a missing API that we can get from Metadata today but not in KSP is the target language information.

jvmTarget

,

languageVersion

, and

apiVersion

in particular. Worth filing an issue?

Hello there, Whenever I add the JS target to my multiplatform build, I get the error below. Removing JS target causes code to be generated on all other platforms but commonMain.

> Failed to calculate the value of task ':compileTestDevelopmentExecutableKotlinJs' property 'entryModule$kotlin_gradle_plugin'.
   > Collection has more than one element.

Asking here to know if it is an unknown bug, or I don't know how to configure this yet. N.B: I am new to ksp

I have been trying to build a native project that depends on a library that makes use of ksp. Apart from the issue regarding test builds (context: https://kotlinlang.slack.com/archives/C013BA8EQSE/p1630246449011600), now the library looks like it builds. However when I'm building the app part, it results in

undefined reference to (my type)

. Any idea why this happens?

How can I create a KType from a string (the fully qualified name of a class) ?

Hello everyone, here is the KSP 1.0.0 stable release! We want to thank you for being KSP's early adopters and giving us so many invaluable feedback / contributions. With all your help we finally are able to make the first stable release of KSP. The next steps of KSP will be supporting new Kotlin compiler, better multiplatform support, performance and bug fixing. We'd also like to spend more time working with you to bring KSP to everyone. Of course, please feel free to let us know if you have any ideas on what can be done next. Again, please give it a try and let us know what you think! P.S. The version convention is unchanged; The exact version number is 1.5.30-1.0.0 to match the compiler version.

Hello, everyone! 👋 I’m trying to update Room from KAPT to KSP in my project but I’m facing

Plugin with id 'com.google.devtools.ksp' not found.

. I followed this article where it states that only by adding

apply plugin: 'com.google.devtools.ksp'

and replacing

kapt

with

ksp

in the dependency it is good to go. Am I missing something? Thanks a lot! ❤️

I don't think it's on the gradle plugin portal? Try adding

pluginManagement {
    repositories {
        gradlePluginPortal()
        mavenCentral()
    }
}

To your settings.gradle

What's the compatibility story for KSP now that it's 1.0? Since there's still a Kotlin version in the version number, does that mean consumers are still tied to using that same version for the foreseeable future while we wait for compiler plugins to stabilize?

I'm working on upstreaming the KSP implementation of moshi codegen here but running into what looks like a bug with processing. When I breakpoint it in the

JsonClassSymbolProcessorTest#disableProguardGeneration()

test, it runs successfully the first time and then is called a second time, upon which it throws an exception internally (in thread) that appears to originate from parsing the file generated by the first pass. I think it's a bug, but I don't really know what exactly to file as I'm not sure where it's going wrong. Doing a second round makes sense to me, but I don't understand why it fails in this particular test case (and two others, but the rest are fine). The test runs fine in the moshix repo with no changes, but falls over in this repo and suggests something is up with the build. Let me know if there's somewhere specific I should dig!

In the announcement blog post it says

We have also updated a number of Android specific libraries which are ready for you to try today and offer significant performance improvements.

Is there any hint to a list or something?

Working on a KSP interop artifact for KotlinPoet, if KSP folks have some time I'd love extra eyes on this! https://github.com/square/kotlinpoet/pull/1146

Hi, after upgrading from beta08 to the stable version my processor got broken due to a change in KSTypeImpl, and I'm no sure why is that. In 1.0.0 stable, there's an additional check when resolving a KSType, where the constractor's declaration is compared to NotFoundClasses.MockClassDescriptor (See commit https://github.com/google/ksp/commit/4ac387a98c8acfcefb5e46a795a5ffcd2dbf1af9). One of my annotations is found to be this way, which means its KSType is resolved to "<Error>". I'm not sure why is that and I was hoping for some clarification on this check, and what does it mean if the constractor is of type NotFoundClasses.MockClassDescriptor. For reference, my annotation is a meta-annotation, in Java, that's declared something like this: @Retention(RetentionPolicy.CLASS) @Target(ElementType.ANNOTATION_TYPE) public @interface UdinicMetaAnnotation { String GENERATOR = "generator"; String generator() default ""; Target[] targets(); Class<?>[] nestedAnnotations() default {}; // .... } BTW in beta08, before this change, I didn't notice any issues related to this annotation's problematic constractor type.

This is for determining if the method for example is accessible if it has the internal modifier

KSType has

arguments

but I don’t see a way to know what the source type is

Is it possible to get start and end line number of the KSFunctionDeclaration's source code? There is FileLocation.lineNumber, but, as I understand, is indicates only first line of the function's source code

Does KSP supports loading resource files from the classpath? In a Java annotation processor, I could use the Filer's method getResource() (see https://javadoc.io/static/org.jvnet.sorcerer/sorcerer-javac/0.8/index.html?com/sun/tools/javac/processing/JavacFiler.html), which supports loading resources from CLASS_OUTPUT, CLASS_PATH and ANNOTATION_PROCESSOR_PATH. For context, I have a KSP processor that loads a template for the sources it generates, which is located in one of the jars in its classpath.

I’m having an issue with incremental compilation. I’ve read the docs and used

ksp.incremental.log=true

(very helpful, btw!) so I think I understand what is going on. My generated file (aggregating) relies on both a symbol in sources acquired with

getSymbolsWithAnnotation

and a set of classes on the classpath (via

getDeclarationsFromPackage

). The file’s originating elements reflect this, as do the ksp incremental logs, so the dependencies seem correctly understood by KSP. My problem is that when there are classpath changes and the processor incrementally runs, KSP sees that only the classpath files changed and does not consider my source file as dirty, so my call to

getSymbolsWithAnnotation

does not return anything. This is problematic because I need both the symbol in source as well as the classpath files to generate my output file, and this fails when I cannot get the source symbol with

getSymbolsWithAnnotation

. I understand why KSP does this, and it is optimal for some cases, but it makes generating a file that depends on both sources and classpath difficult - I think I would have to work around this by manually getting all files and parsing them. Would it be reasonable instead for KSP to look at the set of inputs to a generated file, and if any one of those input is a classpath change then consider the rest of the inputs as dirty as well? according to the docs this is already done with sources, but maybe not for classpath changes?

Propagation by input-output correspondence: If a source file is changed or affected, all other source files having some output in common with that file are affected.