kotlin/jvm_compile.bzl

# Copyright 2022 Google LLC. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the License);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""Compile method that can compile kotlin or java sources"""

load("//:visibility.bzl", "RULES_DEFS_THAT_COMPILE_KOTLIN")
load("//bazel:stubs.bzl", "lint_actions")
load(":common.bzl", "common")
load(":compiler_plugin.bzl", "KtCompilerPluginInfo")
load(":traverse_exports.bzl", "kt_traverse_exports")

visibility(RULES_DEFS_THAT_COMPILE_KOTLIN)

_RULE_FAMILY = common.RULE_FAMILY

def kt_jvm_compile(
        ctx,
        output,
        srcs,
        common_srcs,
        deps,
        plugins,
        runtime_deps,
        exports,
        javacopts,
        kotlincopts,
        neverlink,
        testonly,
        android_lint_plugins,
        resource_files,
        exported_plugins,
        java_android_lint_config = None,
        manifest = None,
        merged_manifest = None,
        classpath_resources = [],
        kt_toolchain = None,
        java_toolchain = None,
        android_lint_rules_jars = depset(),
        disable_lint_checks = [],
        r_java = None,
        output_srcjar = None,
        rule_family = _RULE_FAMILY.UNKNOWN,
        annotation_processor_additional_outputs = [],
        annotation_processor_additional_inputs = [],
        coverage_srcs = [],
        **_kwargs):
    """
    The Kotlin JVM Compile method.

    Args:
      ctx: The context.
      output: A File. The output jar.
      srcs: List of Files. The Kotlin and Java sources.
      common_srcs: List of common source files.
      deps: List of targets. A list of dependencies.
      plugins: List of targets. A list of jvm plugins.
      runtime_deps: List of targets. A list of runtime deps.
      exports: List of targets. A list of exports.
      javacopts: List of strings. A list of Java compile options.
      kotlincopts: List of strings. A list of Kotlin compile options.
      neverlink: A bool. Signifies whether the target is only used for compile-time.
      testonly: A bool. Signifies whether the target is only used for testing only.
      android_lint_plugins: List of targets. An list of android lint plugins to
        execute as a part of linting.
      resource_files: List of Files. The list of Android Resource files.
      exported_plugins: List of exported javac/kotlinc plugins
      java_android_lint_config: Android Lint XML config file to use if there are no Kotlin srcs
      manifest: A File. The raw Android manifest. Optional.
      merged_manifest: A File. The merged Android manifest. Optional.
      classpath_resources: List of Files. The list of classpath resources (kt_jvm_library only).
      kt_toolchain: The Kotlin toolchain.
      java_toolchain: The Java toolchain.
      android_lint_rules_jars: Depset of Files. Standalone Android Lint rule Jar artifacts.
      disable_lint_checks: Whether to disable link checks.
        NOTE: This field should only be used when the provider is not produced
        by a target. For example, the JavaInfo created for the Android R.java
        within an android_library rule.
      r_java: A JavaInfo provider. The JavaInfo provider for the Android R.java
        which is both depended on and propagated as an export.
        NOTE: This field accepts a JavaInfo, but should only be used for the
        Android R.java within an android_library rule.
      output_srcjar: Target output file for generated source jar. Default filename used if None.
      rule_family: The family of the rule calling this function. Element of common.RULE_FAMILY.
        May be used to enable/disable some features.
      annotation_processor_additional_outputs: sequence of Files. A list of
        files produced by an annotation processor.
      annotation_processor_additional_inputs: sequence of Files. A list of
        files consumed by an annotation processor.
      coverage_srcs: Files to use as the basis when computing code coverage. These are typically
        handwritten files that were inputs to generated `srcs`. Should be disjoint with `srcs`.
      **_kwargs: Unused kwargs so that parameters are easy to add and remove.

    Returns:
      A struct that carries the following fields: java_info and validations.
    """
    if rule_family != _RULE_FAMILY.ANDROID_LIBRARY and not (srcs + common_srcs + exports):
        # Demands either of the following to be present.
        # - Source-type artifacts, srcs or common_srcs, including an empty
        #   tree-artifact (a directory) or a srcjar without jar entries.
        # - Exporting targets, exports. It is typically used by a library author
        #   to publish one user-facing target with direct exposure to its
        # dependent libraries.
        fail("Expected one of (srcs, common_srcs, exports) is not empty for kotlin/jvm_compile on target: {}".format(ctx.label))

    if classpath_resources and rule_family != _RULE_FAMILY.JVM_LIBRARY:
        fail("resources attribute only allowed for jvm libraries")

    if type(java_toolchain) == "Target":
        # Allow passing either a target or a provider until all callers are updated
        java_toolchain = java_toolchain[java_common.JavaToolchainInfo]

    java_infos = []

    # The r_java field only support Android resources Jar files. For now, verify
    # that the name of the jar matches "_resources.jar". This check does not to
    # prevent malicious use, the intent is to prevent accidental usage.
    r_java_infos = []
    if r_java:
        for jar in r_java.outputs.jars:
            if not jar.class_jar.path.endswith("_resources.jar"):
                fail("Error, illegal dependency provided for r_java. This " +
                     "only supports Android resource Jar files, " +
                     "'*_resources.jar'.")
        r_java_infos.append(r_java)

    # Skip deps validation check for any android_library target with no kotlin sources: b/239721906
    has_kt_srcs = any([common.is_kt_src(src) for src in srcs])
    if rule_family != _RULE_FAMILY.ANDROID_LIBRARY or has_kt_srcs:
        kt_traverse_exports.expand_forbidden_deps(deps + runtime_deps + exports)

    for dep in deps:
        if JavaInfo in dep:
            java_infos.append(dep[JavaInfo])
        else:
            fail("Unexpected dependency (must provide JavaInfo): %s" % dep.label)

    if kotlincopts != None and "-Werror" in kotlincopts:
        fail("Flag -Werror is not permitted")

    return common.kt_jvm_library(
        ctx,
        classpath_resources = classpath_resources,
        common_srcs = common_srcs,
        coverage_srcs = coverage_srcs,
                deps = r_java_infos + java_infos,
        disable_lint_checks = disable_lint_checks,
        exported_plugins = common.kt_plugins_map(
            java_plugin_infos = common.collect_providers(JavaPluginInfo, exported_plugins),
            android_lint_rulesets = common.collect_providers(lint_actions.AndroidLintRulesetInfo, exported_plugins),
        ),
        # Not all exported targets contain a JavaInfo (e.g. some only have CcInfo)
        exports = r_java_infos + [e[JavaInfo] for e in exports if JavaInfo in e],
        friend_jars = kt_traverse_exports.expand_friend_jars(deps, root = ctx),
        java_toolchain = java_toolchain,
        javacopts = javacopts,
        kotlincopts = kotlincopts,
        compile_jdeps = kt_traverse_exports.expand_direct_jdeps(deps),
        kt_toolchain = kt_toolchain,
        manifest = manifest,
        merged_manifest = merged_manifest,
        native_libraries = [p[CcInfo] for p in deps + runtime_deps + exports if CcInfo in p],
        neverlink = neverlink,
        output = output,
        output_srcjar = output_srcjar,
        plugins = common.kt_plugins_map(
            android_lint_rulesets = (
                common.collect_providers(lint_actions.AndroidLintRulesetInfo, android_lint_plugins) +
                common.collect_providers(lint_actions.AndroidLintRulesetInfo, plugins)
            ) + [
                lint_actions.AndroidLintRulesetInfo(singlejars = android_lint_rules_jars),
            ],
            java_plugin_infos = common.collect_providers(JavaPluginInfo, plugins),
            kt_compiler_plugin_infos = (
                kt_traverse_exports.expand_compiler_plugins(deps).to_list() +
                common.collect_providers(KtCompilerPluginInfo, plugins)
            ),
        ),
        java_android_lint_config = java_android_lint_config,
        resource_files = resource_files,
        runtime_deps = [d[JavaInfo] for d in runtime_deps if JavaInfo in d],
        srcs = srcs,
        testonly = testonly,
        rule_family = rule_family,
        annotation_processor_additional_outputs = annotation_processor_additional_outputs,
        annotation_processor_additional_inputs = annotation_processor_additional_inputs,
    )