A smaller sample that reads but does not manipulate IR. This isn't the best Gradle structure though. https://github.com/jisungbin/KotlinCompilerPluginSample?source=post_page-----f4e857be9a1--------------------------------

Arrow project has both Meta and Reflection (FIR) plugins that are aiming at making some things easier such as quick macros in FIR. But these were stalled when the compiler extension API's were changing rapidly, and will likely be picked up and continued soon. They do show some use of various extension points. Although this is obfuscated a bit by using their meta library to abstract the extensiono points, you can see them working on FIR with code generation and swapping code (not all implemented but some is): https://github.com/arrow-kt/arrow-reflection/tree/main/arrow-reflect-compiler-plugin/src/main/kotlin/arrow/reflect/compiler/plugin

The Gradle setup is a little sensitive for making things work, I'll know more about it soon as I go through that myself.

I’d like to elaborate on what defines the lever at which an extension is acting, though. Is this something declared in the

build.gradle.kts

file?

no

the registrar decides the extension points

And most of the repos linked above have simple plugins for Gradle. • compiler plugin • gradle compiler plugin (using the helpers given by Kotlin team) • use your compiler plugin in another project via Gradle and for FIR • test in Intellij by running custom build, with the property set allowing loading non bundled (official) plugins

The Gradle part you need to care about is how to make sure you can do integration tests, and what is required to tie the module builds together to do that.

Integration testing is mentioned in the links above (the 6 part series, ending here: https://blog.bnorm.dev/writing-your-second-compiler-plugin-part-6) and this glosses over the topic of

includeBuild

but you can see that in other plugin examples, including some linked above, or checking ones like Cite (J Wharton)

I think the "Redacted" plugin above is the best example for integration testing and

includeBuild

but I haven't dug in a lot to it, It just has a nice package of things you probably need to see.

It likely covers everything you need as an example

Screenshot 2023-09-23 at 5.37.16 AM.png

This last screenshot seems to be the short answer my first question, it makes it clear that there are extensions at both levels and how to declare them

it is medium scope, covers the bases.

not too big, not too small.

Arrow has good information in there, but it is abstracted away from the compiler. It would be a good place for mini-extensions, but not when it is stalled and not being worked on for the moment (they mentioned it "might be a good time to pick it up again", but here we are....)

I'm newer too, so mostly I've just collected the information above and checked out what works and doesn't. So we will both be here asking questions!

KotlinConf

I hope to make it this year!

Oh, this template is pointed to from some threads here: https://github.com/demiurg906/kotlin-compiler-plugin-template/tree/master But, I don't think it has the full Gradle setup for integration testing. It does show FIR vs. backend registration as well.

(that Gradle setup is not going to serve you well, but the other information in this template might be useful)

summary: • Redacted plugin is a good Gradle setup, does FIR • Cite is a good plugin to see someone testing Kotlin KMP with a plugin (non-FIR) • Arrow Reflection / Meta is a good sample of more advanced things, but the abstractions might slow you down • The other templates and other samples usually only have part of the puzzle and not really the "full gradle" setup

There are threads about it here you can search for.

I'm going to go now and actually start pulling together a base plugin sample that does very little FIR but works in all the cases mentioned above, and can load into intellij-community custom build and show that FIR is working in the IDE as well.