Solution: Annotation Processing execution measurement wrapper

Here is an example solution code:

package academy.kt

import com.squareup.javapoet.*
import javax.annotation.processing.AbstractProcessor
import javax.annotation.processing.RoundEnvironment
import javax.lang.model.AnnotatedConstruct
import javax.lang.model.SourceVersion
import javax.lang.model.element.*
import javax.lang.model.type.TypeMirror

class GenerateMeasuredWrapperProcessor : AbstractProcessor() {

    override fun getSupportedAnnotationTypes(): Set<String> =
        setOf(Measured::class.qualifiedName!!)

    override fun getSupportedSourceVersion(): SourceVersion =
        SourceVersion.latestSupported()

    override fun process(
        annotations: Set<TypeElement>,
        roundEnv: RoundEnvironment
    ): Boolean {
        roundEnv.getElementsAnnotatedWith(Measured::class.java)
            .filterIsInstance<ExecutableElement>()
            .groupBy { it.enclosingElement!! }
            .forEach { (clazz) -> generateMeasuredClass(clazz) }
        return true
    }

    private fun generateMeasuredClass(classElement: Element) {
        val className = classElement.simpleName.toString()
        val measuredName = "Measured$className"
        val measuredPackage = processingEnv.elementUtils
            .getPackageOf(classElement)
            .qualifiedName
            .toString()
        val publicMethods = classElement.enclosedElements
            .filter { it.kind == ElementKind.METHOD }
            .filter { it.modifiers.contains(Modifier.PUBLIC) }
            .filterIsInstance<ExecutableElement>()
        val constructorParameters = classElement.enclosedElements
            .filter { it.kind == ElementKind.CONSTRUCTOR }
            .filterIsInstance<ExecutableElement>()
            .flatMap { it.parameters }

        JavaFile.builder(
            measuredPackage,
            TypeSpec
                .classBuilder(measuredName)
                .addField(
                    FieldSpec.builder(
                        classElement.asType().toTypeSpec(),
                        "wrapper",
                        Modifier.PRIVATE
                    ).build()
                )
                .addMethod(
                    MethodSpec.constructorBuilder()
                        .addParameter(
                            classElement.asType().toTypeSpec(),
                            "wrapper"
                        )
                        .addStatement("this.wrapper = wrapper")
                        .build()
                )
                .addMethod(
                    MethodSpec.constructorBuilder()
                        .addParameters(constructorParameters
                            .filterIsInstance<VariableElement>()
                            .map {
                                buildMethodParameter(it)
                            })
                        .addStatement(
                            "this.wrapper = new ${
                                classElement.simpleName
                            }(${
                                constructorParameters
                                    .joinToString { it.simpleName.toString() }
                            })"
                        )
                        .build()
                )
                .addMethods(publicMethods.map {
                    buildInterfaceMethod(className, it)
                }
                )
                .build()
        ).build()
            .writeTo(processingEnv.filer)
    }

    private fun buildInterfaceMethod(
        className: String,
        method: ExecutableElement
    ): MethodSpec {
        val methodName = method.simpleName.toString()
        return MethodSpec
            .methodBuilder(methodName)
            .addModifiers(method.modifiers)
            .addParameters(
                method.parameters
                    .map(::buildMethodParameter)
            )
            .returns(
                TypeName.get(method.returnType)
                    .annotated(
                        method.returnType.getAnnotationSpecs()
                    )
            )
            .addAnnotations(method
                .annotationMirrors
                .filter { !isMeasured(it) }
                .map(AnnotationSpec::get))
            .addCode(run {
                val params = method.parameters
                    .joinToString { it.simpleName }

                if (method.annotationMirrors.none(::isMeasured))
                    "return wrapper.$methodName($params);"
                else {
                    val retType = method.returnType
                    """
                    long before = System.currentTimeMillis();
                    $retType value = wrapper.$methodName($params);
                    long after = System.currentTimeMillis();
                    System.out.println("$methodName from $className took " + (after - before) + " ms");
                    return value;
                    """.trimIndent()
                }
            })
            .build()
    }

    private fun isMeasured(it: AnnotationMirror) =
        (it.annotationType.asElement() as TypeElement)
            .qualifiedName
            ?.toString() == Measured::class.qualifiedName

    private fun buildMethodParameter(
        variableElement: VariableElement
    ): ParameterSpec {
        val asType = variableElement.asType()
        return ParameterSpec
            .builder(
                TypeName.get(asType)
                    .annotated(asType.getAnnotationSpecs()),
                variableElement.simpleName.toString()
            )
            .addAnnotations(variableElement.getAnnotationSpecs())
            .build()
    }
}

private fun TypeMirror.toTypeSpec() = TypeName.get(this)
    .annotated(this.getAnnotationSpecs())

private fun AnnotatedConstruct.getAnnotationSpecs() =
    annotationMirrors.map(AnnotationSpec::get)