The Kotlin compilation process works in several stages: - First the compiler is called with the kapt plugin which generates Java stub files from the Kotlin files and then calls apt with that. AFAIK the kapt plugin "shortwires" the rest of the compilation, so that no actual compilation of Kotlin sources takes place in this stage - Then the Kotlin compiler is called regularly to compile the Kotlin sources - Finally the Java compiler is called to compile all Java sources, with the compiled Kotlin class-files from the previous step on the classpath. My question is: Do third-party compiler plugins get passed to both the first 2 stages or just in the 2nd stage? Does the kapt plugin prevent the execution of further compiler plugins as well, like it shortwires the regular compilation?

Compiler plugins get called when kt files are ready

I think we are talking about different phases. The "phases" I mean are decided by the Kotlin Gradle and Kapt Gradle plugins and make distinct calls to the actual Kotlin compiler (afaik).

Yes but those phases are not calling the ComponentRegistrar ,the Kotlin compiler calls registerProjectComponents which plugins override.

An AdditionalTypeChecker would be an example for the latter, right @raulraja?

Yes, though typechecking is not a compiler extension so more of a hack in which you use an early phase to change a compiler service.

Thanks @tschuchort for the lib💪🏽👏🏽

The gradle plugin calls the Kotlin compiler twice, once with the kapt plugin and once without. When the compiler gets to

KaptComponentRegistrar::registerProjectComponents

it does its thing and registers the

AbortAnalysisHandlerExtension

which just says "yes we're finished, do nothing else", effectively preventing all the following extensions like code generation to be run. Then the compiler terminates and the Gradle plugin calls the compiler again, this time without the kapt plugin. Now what I'd like to know is if the Gradle plugin also passes all other third-party plugins via the pluginClasspath in both invocations of the compiler. Because this could lead to some third-party plugins being executed twice. Or perhaps it makes no difference if they are executed twice if they only register extensions for the later extensions that don't get executed due to kapt's short-circuiting.

The compiler may be in daemon state

in whichever case it would always be invoked with the plugin directive and plugin classpath

How can the pluginClasspath be the same when the kapt plugin is only used in the first call? If it were used always, it would never compile anything because kapt always aborts the compilation before the codegen phase

You could potentially append in two places user overrides in the test? I guess I don't understand the issue because in both cases we could load env bars and system properties which is also how we pass them today to the compiler

Hi @tschuchort, thanks again for your time and your kind attention with this issue

I'm not convinced that this is the correct way to do it, but if you say that it works with arrow at least, I will merge the PR and we can fix it later if problems arise.

Thanks @tschuchort!! I can promise that I will be available to fix those problems

Well, it's not really a bug with your code. We simply don't know what the desired behaviour should be. But if you find out any more information about this, feel free to make another PR.

Ok @tschuchort, let's keep in contact!