Awesome

<h1 align="center">MpApt - Kotlin (Native/JS/JVM) Annotation Processor library</h1>

Introduction 🙋‍♂️ 🙋‍

Note This project is deprecated, when you are looking for a multiplatform annotation processor, please take a look at KSP

I wrote an annotation processing libary that can detect annotations in Kotlin Native/JS and Jvm projects, because Kapt is only working with KotlinJvm. The library can be used in Kotlin Compiler plugins. Tested with Kotlin 1.4.0,1.5.10

It can detect annotations with following targets:

(CLASS,FUNCTION,PROPERTY,VALUE_PARAMETER,PROPERTY_GETTER,PROPERTY_GETTER,CONSTRUCTOR)
(ANNOTATION_CLASS,TYPE_PARAMETER,FIELD,FILE,LocalVariable)

<p align="left"> Example output of my example plugin on Kotlin Native: <img src ="https://raw.githubusercontent.com/Foso/MpApt/master/docs/images/logNative.png" /> </p>

Show some :heart: and star the repo to support the project

Projects that use MpApt:

Usage

These are the instructions for v0.8.7, check Changelog for changes on the active development branch

Inside your compiler plugin, add the dependency from MavenCentral

repositories {
    mavenCentral()
}

dependencies {
   compile 'de.jensklingenberg:mpapt-runtime:0.8.7'
}

Create a class that extends de.jensklingenberg.mpapt.model.AbstractProcessor

class MpAptTestProcessor() : AbstractProcessor() {

Add the names of your annotations that you want to detect:

override fun getSupportedAnnotationTypes(): Set<String> = setOf(TestClass::class.java.name, TestFunction::class.java.name)

Do something with detected annotations:

override fun process(roundEnvironment: RoundEnvironment) {
roundEnvironment.getElementsAnnotatedWith(TestClass::class.java.name).forEach {
            when (it) {
                is Element.ClassElement -> {
                    log("Found Class: " + it.classDescriptor.name + " Module: " + it.classDescriptor.module.simpleName() + " platform   " + activeTargetPlatform.first().platformName)
                }
            }
        }

        roundEnvironment.getElementsAnnotatedWith(TestFunction::class.java.name).forEach {
            when (it) {
                is Element.FunctionElement -> {
                    log("Found Function: " + it.func.name + " Module: " + it.func.module.simpleName() + " platform   " + activeTargetPlatform.first().platformName)
                }
            }
        }
}

Init MpApt inside your ComponentRegistrar:

Pass an instance of your processor and the CompilerConfiguration into MpAptProject
Then add an instance of MpAptProject to the following extension classes:

Inside a Kotlin Native Compiler Plugin:

override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) {
        val processor = MpAptTestProcessor()
        val mpapt = MpAptProject(processor,configuration)

        StorageComponentContainerContributor.registerExtension(project,mpapt)
        IrGenerationExtension.registerExtension(project,mpapt)
    }

Inside a Kotlin JVM/JS Compiler Plugin:

 override fun registerProjectComponents(
            project: MockProject,
            configuration: CompilerConfiguration
    ) {
        val processor = MpAptTestProcessor()
        val mpapt = MpAptProject(processor,configuration)
        StorageComponentContainerContributor.registerExtension(project,mpapt)
        ClassBuilderInterceptorExtension.registerExtension(project,mpapt)
        JsSyntheticTranslateExtension.registerExtension(project,mpapt)
    }

That's it

Choose supported target platforms

By default your processor is enabled for every target. You can override

isTargetPlatformSupported(platform: TargetPlatform): Boolean

and return "true" if you want to support the target or "false" you don't.

   override fun isTargetPlatformSupported(platform: TargetPlatform): Boolean {
         val targetName = platform.first().platformName
 
         return when (targetName) {
             KotlinPlatformValues.JS -> true
             KotlinPlatformValues.JVM -> true
             KotlinPlatformValues.NATIVE -> {
                 return when (configuration.nativeTargetPlatformName()) {
                     KonanTargetValues.LINUX_X64, KonanTargetValues.MACOS_X64 -> {
                         true
                     }
                     else -> {
                         true
                     }
                 }
             }
             else -> {
                 log(targetName)
                 true
             }
         }
 
     }

You can distinguish between the native target platforms you want to support.

configuration.nativeTargetPlatformName() will get you the names of the Native Targets(macos_x64,linux_x64,etc). The values are defined in KonanTargetValues. It needs to be used only on Kotlin Native otherwise it will return an empty string

✍️ Feedback

Feel free to send feedback on Twitter or file an issue or join the Kotlin Slack and the channel. Feature requests are always welcome. If you wish to contribute, please take a quick look at How to develop?

👷 Development Project Structure

<kbd>demoProject</kbd> - An example project that is using MpApt+KotlinPoet to generate code on KotlinJS
<kbd>annotations</kbd> - A Kotlin Multiplatform project which contains test annotations
<kbd>example</kbd> - A Kotlin Multiplatform project which applies a gradle plugin(de.jensklingenberg.mpapt) whichs triggers the compiler plugin.
<kbd>buildSrc</kbd> - This module contains the gradle plugin which trigger the compiler plugin
<kbd>kotlin-plugin</kbd> - This module contains the Kotlin Compiler Plugin for JVM/JS targets, it implements the <kbd>kotlin-plugin-shared</kbd>-module
<kbd>kotlin-compiler-native-plugin</kbd> - This module contains the Kotlin Compiler Plugin for Native targets, it implements the <kbd>kotlin-plugin-shared</kbd>-module
<kbd>kotlin-plugin-shared</kbd> Contains an implementation of MpApt

Testing

The CompileTest shows you, how you can use Kotlin Compile Testing to test your Processor/Compiler Plugin