[kapt] allow options to be passed to kapt and javac annotation processing. (#1354)

* [kapt] allow options to be passed to kapt and javac annotation processing.

java annotatin processing options can be passed like this:
```

kt_plugin_cfg(
    name = "autovalue_no_identifiers",
    options = {
        "com.google.auto.value.OmitIdentifiers": ["true"],
    },
    plugin = "//kotlin/compiler:kapt",
    deps = [
        ":autovalue",
    ],
)
```

* Fix lint errors

Author: restingbull

kotlin/compiler/BUILD

@@ -14,6 +14,7 @@ load("//src/main/starlark/release:packager.bzl", "release_archive")
 # See the License for the specific language governing permissions and
 # limitations under the License.
 load(":compiler.bzl", "kt_configure_compiler")
+load(":kapt.bzl", "kapt_compiler_plugin")
 load(":ksp.bzl", "kt_configure_ksp")
 
 package(default_visibility = ["//visibility:public"])
@@ -31,3 +32,8 @@ release_archive(
         "BUILD.release.bazel": "BUILD.bazel",
     },
 )
+
+kapt_compiler_plugin(
+    name = "kapt",
+    id = "org.jetbrains.kotlin.kapt3",
+)

kotlin/compiler/BUILD.release.bazel

@@ -14,6 +14,7 @@
 
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
 load(":compiler.bzl", "kt_configure_compiler")
+load(":kapt.bzl", "kapt_compiler_plugin")
 load(":ksp.bzl", "kt_configure_ksp")
 
 package(default_visibility = ["//visibility:public"])
@@ -28,3 +29,8 @@ bzl_library(
     name = "compiler",
     srcs = glob(["*.bzl"]),
 )
+
+kapt_compiler_plugin(
+    name = "kapt",
+    id = "org.jetbrains.kotlin.kapt3",
+)

kotlin/compiler/kapt.bzl

@@ -0,0 +1,87 @@
+load("@rules_java//java/common:java_common.bzl", "java_common")
+load("@rules_java//java/common:java_info.bzl", "JavaInfo")
+load("@rules_java//java/common:java_plugin_info.bzl", "JavaPluginInfo")
+load("//src/main/starlark/core/options:opts.javac.bzl", "JavacOptions")
+load("//src/main/starlark/core/plugin:common.bzl", "plugin_common")
+load(
+    "//src/main/starlark/core/plugin:providers.bzl",
+    "KtCompilerPluginInfo",
+    "KtCompilerPluginOption",
+    "KtPluginConfiguration",
+)
+
+def _resolve_kapt_cfg(
+        info,
+        option_string_list_dict,
+        deps,
+        expand_location):  # @unused Needed for lambda contract.
+    infos = []
+    plugins = []
+    for d in deps:
+        if JavaInfo in d:
+            infos.append(d[JavaInfo])
+        if JavaPluginInfo in d:
+            # mild chicanary to turn a JavaPluginInfo in to a JavaInfo.
+            # This is necessary to merge all the java related things into a single JavaInfo
+            # that exports all plugins. It would be easier if there was a way to
+            # generate JavaInfo without an output_jar.
+            jpi = d[JavaPluginInfo]
+            for o in jpi.java_outputs:
+                infos.append(
+                    JavaInfo(
+                        output_jar = o.class_jar,
+                        compile_jar = o.compile_jar,
+                        exported_plugins = [jpi],
+                    ),
+                )
+
+    ji = java_common.merge(infos)
+    classpath = depset(ji.runtime_output_jars, transitive = [ji.transitive_runtime_jars])
+    data = None
+    data_runfiles = [d[DefaultInfo].default_runfiles for d in deps if d[DefaultInfo]]
+    if data_runfiles:
+        data = data_runfiles[0].merge_all(data_runfiles[1:])
+    return [
+        ji,  # allows java compilation to pick up the annotation processor.
+        JavacOptions(
+            annotation_processor_options = {
+                k: v
+                for (k, vs) in option_string_list_dict.items()
+                for v in vs
+            },
+        ),
+        KtPluginConfiguration(
+            id = info.id,
+            options = [
+                KtCompilerPluginOption(
+                    id = info.id,
+                    value = "apoption=%s:%s" % (k, v),
+                )
+                for (k, vs) in option_string_list_dict.items()
+                for v in vs
+            ],
+            classpath = classpath,
+            data = data,
+        ),
+    ] + plugins
+
+def _kapt_compiler_plugin_impl(ctx):
+    plugin_id = ctx.attr.id
+    return [
+        KtCompilerPluginInfo(
+            id = plugin_id,
+            classpath = depset(),
+            options = [],
+            stubs = True,
+            compile = False,
+            resolve_cfg = _resolve_kapt_cfg,
+            merge_cfgs = plugin_common.merge_cfgs,
+        ),
+    ]
+
+kapt_compiler_plugin = rule(
+    implementation = _kapt_compiler_plugin_impl,
+    attrs = {
+        "id": attr.string(default = "org.jetbrains.kotlin.kapt3"),
+    },
+)

kotlin/internal/jvm/compile.bzl

@@ -197,7 +197,7 @@ def _new_plugins_from(targets):
         plugin = t[_KtCompilerPluginInfo]
         if not (plugin.stubs or plugin.compile):
             plugins_without_phase.append("%s: %s" % (t.label, plugin.id))
-        if plugin.id in all_plugins:
+        if plugin.id in all_plugins and all_plugins[plugin.id] != plugin:
             # This need a more robust error messaging.
             fail("has multiple plugins with the same id: %s." % plugin.id)
         all_plugins[plugin.id] = plugin
@@ -884,6 +884,12 @@ def _run_kt_java_builder_actions(
     ksp_generated_java_src_jars = generated_ksp_src_jars and is_ksp_processor_generating_java(ctx.attr.plugins)
     if srcs.java or generated_kapt_src_jars or srcs.src_jars or ksp_generated_java_src_jars:
         javac_opts = javac_options_to_flags(ctx.attr.javac_opts[JavacOptions] if ctx.attr.javac_opts else toolchains.kt.javac_options)
+        javac_opts.extend([
+            flag
+            for plugin in ctx.attr.plugins
+            if JavacOptions in plugin
+            for flag in javac_options_to_flags(plugin[JavacOptions])
+        ])
 
         # Kotlin takes care of annotation processing. Note that JavaBuilder "discovers"
         # annotation processors in `deps` also.
@@ -894,7 +900,7 @@ def _run_kt_java_builder_actions(
             source_files = srcs.java,
             source_jars = generated_kapt_src_jars + srcs.src_jars + generated_ksp_src_jars,
             output = ctx.actions.declare_file(ctx.label.name + "-java.jar"),
-            deps = compile_deps.deps + kt_stubs_for_java,
+            deps = compile_deps.deps + kt_stubs_for_java + [p[JavaInfo] for p in ctx.attr.plugins if JavaInfo in p],
             java_toolchain = toolchains.java,
             plugins = _plugin_mappers.targets_to_annotation_processors_java_plugin_info(ctx.attr.plugins),
             javac_opts = javac_opts,

kotlin/internal/jvm/impl.bzl

@@ -429,7 +429,9 @@ def kt_compiler_plugin_impl(ctx):
 
 def kt_plugin_cfg_impl(ctx):
     plugin = ctx.attr.plugin[_KtCompilerPluginInfo]
-    return plugin.resolve_cfg(plugin, ctx.attr.options, ctx.attr.deps, ctx.expand_location)
+    return [
+        plugin,
+    ] + plugin.resolve_cfg(plugin, ctx.attr.options, ctx.attr.deps, ctx.expand_location)
 
 def kt_ksp_plugin_impl(ctx):
     deps = ctx.attr.deps

kotlin/internal/jvm/jvm.bzl

@@ -661,6 +661,7 @@ kt_plugin_cfg = rule(
                 [JavaInfo],
                 [JavaPluginInfo],
             ],
+            cfg = "exec",
         ),
     },
 )

kotlin/internal/jvm/plugins.bzl

@@ -46,7 +46,8 @@ def _targets_to_annotation_processors(targets):
             p = t[JavaInfo].plugins
             if p.processor_jars:
                 plugins.append(p)
-    return depset(plugins)
+
+    return plugins
 
 def _targets_to_ksp_annotation_processors(targets):
     plugins = []

src/main/kotlin/io/bazel/kotlin/builder/tasks/jvm/CompilationArgs.kt

@@ -201,9 +201,13 @@ class CompilationArgs(
     for ((k, vs) in values) {
       oos.writeUTF(k)
 
-      oos.writeInt(vs.size)
-      for (v in vs) {
-        oos.writeUTF(v)
+      if (vs.size == 1) {
+        oos.writeUTF(vs[0])
+      } else {
+        oos.writeInt(vs.size)
+        for (v in vs) {
+          oos.writeUTF(v)
+        }
       }
     }
 

src/main/kotlin/io/bazel/kotlin/builder/tasks/jvm/CompilationTask.kt

@@ -167,6 +167,7 @@ internal fun JvmCompilationTask.kaptArgs(
     val version =
       info.toolchainInfo.common.apiVersion
         .toFloat()
+
     when {
       version < 1.5 ->
         base64Encode(
@@ -181,6 +182,20 @@ internal fun JvmCompilationTask.kaptArgs(
           "plugin:${plugins.kapt.id}:$option=$value"
         }
     }
+    // Read kapt options from the plugin options
+    val optionPrefix = plugins.kapt.id + ":apoption="
+    val options =
+      (inputs.compilerPluginOptionsList + inputs.stubsPluginOptionsList)
+        .filter { o -> o.startsWith(optionPrefix) }
+        .map { o -> o.substring(optionPrefix.length).split(":", limit = 2) }
+        .map { kv -> kv[0] to listOf(kv[1]) }
+        .toTypedArray()
+
+    if (options.isNotEmpty()) {
+      base64Encode("-P", *options) { enc ->
+        "plugin:${plugins.kapt.id}:apoptions=$enc"
+      }
+    }
   }
 }
 
@@ -265,7 +280,7 @@ private fun JvmCompilationTask.runKaptPlugin(
     baseArgs()
       .plus(
         plugins(
-          options = inputs.stubsPluginOptionsList,
+          options = inputs.stubsPluginOptionsList.filterNot { o -> o.startsWith(plugins.kapt.id) },
           classpath = inputs.stubsPluginClasspathList,
         ),
       ).plus(
@@ -278,7 +293,7 @@ private fun JvmCompilationTask.runKaptPlugin(
         context.executeCompilerTask(
           args,
           compiler::compile,
-          printOnSuccess = context.whenTracing { true } ?: false,
+          printOnSuccess = context.whenTracing { true } == true,
         )
       }.let { outputLines ->
         // if tracing is enabled the output should be formatted in a special way, if we aren't

src/main/starlark/core/options/convert.bzl

@@ -17,7 +17,7 @@ def _to_flags(opts, attr_provider):
         value = getattr(attr_provider, n, None)
         if o.value_to_flag and o.value_to_flag.get(derive.info, None):
             info = o.value_to_flag[derive.info]
-            flag = info.derive(info.ctx, value)
+            flag = info.derive(info.ctx, value or o.args.get("default", None))
         elif o.value_to_flag:
             flag = o.value_to_flag.get(value, None)
         else: