kotlin_library
name
def name(
*,
name: str,
default_target_platform: None | str = ...,
target_compatible_with: list[str] = ...,
compatible_with: list[str] = ...,
exec_compatible_with: list[str] = ...,
visibility: list[str] = ...,
within_view: list[str] = ...,
metadata: OpaqueMetadata = ...,
tests: list[str] = ...,
modifiers: OpaqueMetadata = ...,
_apple_platforms: dict[str, str] = ...,
_build_only_native_code: bool = ...,
_dex_min_sdk_version: None | int = ...,
_dex_toolchain: str = ...,
_exec_os_type: str = ...,
_is_building_android_binary: bool = ...,
_java_toolchain: str = ...,
_kotlin_toolchain: str = ...,
abi_generation_mode: None | str = ...,
annotation_processing_tool: None | str = ...,
annotation_processor_deps: list[str] = ...,
annotation_processor_params: list[str] = ...,
annotation_processors: list[str] = ...,
attrs_validators: None | list[str] = ...,
contacts: list[str] = ...,
default_host_platform: None | str = ...,
deps: list[str] = ...,
enable_used_classes: bool = ...,
exported_deps: list[str] = ...,
exported_provided_deps: list[str] = ...,
extra_arguments: list[str] = ...,
extra_kotlinc_arguments: list[str] = ...,
friend_paths: list[str] = ...,
incremental: bool = ...,
jar_postprocessor: None | str = ...,
java_version: None | str = ...,
javac: None | str = ...,
k2: bool = ...,
keep_synthetics_in_class_abi: None | bool = ...,
kotlin_compiler_plugins: dict[str, dict[str, str]] = ...,
labels: list[str] = ...,
licenses: list[str] = ...,
manifest_file: None | str = ...,
maven_coords: None | str = ...,
never_mark_as_unused_dependency: None | bool = ...,
on_unused_dependencies: None | str = ...,
plugins: list[str | (str, list[str])] = ...,
proguard_config: None | str = ...,
provided_deps: list[str] = ...,
remove_classes: list[str] = ...,
required_for_source_only_abi: bool = ...,
resources: list[str] = ...,
resources_root: None | str = ...,
runtime_deps: list[str] = ...,
source: None | str = ...,
source_abi_verification_mode: None | str = ...,
source_only_abi_deps: list[str] = ...,
srcs: list[str] = ...,
target: None | str = ...,
use_jvm_abi_gen: None | bool = ...,
validation_deps: list[str] = ...,
) -> None
A kotlin_library()
rule is used to define a set of Kotlin files that can be compiled together. The main output of a kotlin_library()
rule is a single JAR file containing all of the compiled class files, as well as the static files specified in the resources
argument.
Parameters
-
name
: name of the target -
default_target_platform
: specifies the default target platform, used when no platforms are specified on the command line -
target_compatible_with
: a list of constraints that are required to be satisfied for this target to be compatible with a configuration -
compatible_with
: a list of constraints that are required to be satisfied for this target to be compatible with a configuration -
exec_compatible_with
: a list of constraints that are required to be satisfied for this target to be compatible with an execution platform -
visibility
: a list of visibility patterns restricting what targets can depend on this one -
within_view
: a list of visibility patterns restricting what this target can depend on -
metadata
: a key-value map of metadata associated with this target -
tests
: a list of targets that provide tests for this one -
modifiers
: an array of modifiers associated with this target -
annotation_processing_tool
: Specifies the tool to use for annotation processing. Possible values: "kapt" or "javac". "kapt" allows running Java annotation processors against Kotlin sources while backporting it for Java sources too. "javac" works only against Java sources, Kotlin sources won't have access to generated classes at compile time. -
deps
: Rules (usually otherkotlin_library
rules) that are used to generate the classpath required to compile thiskotlin_library
. -
enable_used_classes
: Deprecated: for an experiment only, will be removed -
exported_deps
: Other rules that depend on this rule will also include itsexported_deps
in their classpaths. This is useful when the public API of a rule has return types or checked exceptions that are defined in another rule, which would otherwise require callers to add an extra dependency. It's also useful for exposing e.g. a collection ofprebuilt_jar
rules as a single target for callers to depend on. Targets inexported_deps
are implicitly included in thedeps
of this rule, so they don't need to be repeated there. -
exported_provided_deps
: This is a combination ofprovided_deps
andexported_deps
. Rules listed in this parameter will be added to classpath of rules that depend on this rule, but they will not be included in a binary if binary depends on a such target. -
extra_kotlinc_arguments
: List of additional arguments to pass into the Kotlin compiler. -
friend_paths
: List of source paths to pass into the Kotlin compiler as friend-paths, that is, modules you can have access to internal methods. -
incremental
: Enables Kotlin incremental compilation. -
javac
: Specifies the Java compiler program to use for this rule. The value is a source path or an execution dep (e.g., //foo/bar:bar). Overrides the value in "javac" in the "tools" section of.buckconfig
. -
k2
: Enables the Kotlin K2 compiler. -
kotlin_compiler_plugins
: Use this to specify Kotlin compiler plugins to use when compiling this library. This takes a map, with each entry specify one plugin. Entry's key is plugin source path, and value is a map of plugin option key value pair. Unlikeextra_kotlinc_arguments
, these can be source paths, not just strings.A special option value is
__codegen_dir__
, in which case Buck will provide a default codegen folder's path as option value instead. E.g.fbcode/buck2/prelude/decls/jvm_common.bzl
kotlin_compiler_plugins = {
"somePluginSourcePath": {
"plugin:somePluginId:somePluginOptionKey": "somePluginOptionValue",
"plugin:somePluginId:someDirectoryRelatedOptionKey": "__codegen_dir__",
},
},Each plugin source path will be prefixed with
-Xplugin=
and passed as extra arguments to the compiler. Plugin options will be appended after its plugin with-P
.A specific example is, if you want to use kotlinx.serialization with
kotlin_library()
, you need to specifykotlinx-serialization-compiler-plugin.jar
underkotlin_compiler_plugins
andkotlinx-serialization-runtime.jar
(which you may have to fetch from Maven) in yourdeps
:
kotlin_library(
name = "example",
srcs = glob(["*.kt"]),
deps = [
":kotlinx-serialization-runtime",
],
kotlin_compiler_plugins = {
# Likely copied from your $KOTLIN_HOME directory.
"kotlinx-serialization-compiler-plugin.jar": {},
},
)
prebuilt_jar(
name = "kotlinx-serialization-runtime",
binary_jar = ":kotlinx-serialization-runtime-0.10.0",
)
# Note you probably want to set
# maven_repo=http://jcenter.bintray.com/ in your .buckconfig until
# https://github.com/Kotlin/kotlinx.serialization/issues/64
# is closed.
remote_file(
name = "kotlinx-serialization-runtime-0.10.0",
out = "kotlinx-serialization-runtime-0.10.0.jar",
url = "mvn:org.jetbrains.kotlinx:kotlinx-serialization-runtime:jar:0.10.0",
sha1 = "23d777a5282c1957c7ce35946374fff0adab114c"
) -
labels
: Set of arbitrary strings which allow you to annotate abuild rule
with tags that can be searched for over an entire dependency tree usingbuck query()
. -
provided_deps
: These represent dependencies that are known to be provided at run time, but are required in order for the code to compile. Examples ofprovided_deps
include the JEE servlet APIs. When this rule is included in a , theprovided_deps
will not be packaged into the output. -
remove_classes
: Specifies a list ofPatterns
that are used to excludeclasses
from theJAR
. The pattern matching is based on the name of the class. This can be used to exclude a member class or delete a local view of a class that will be replaced during a later stage of the build. -
resources
: Static files to include with the compiled.class
files. These files can be loaded via Class.getResource().Note: If
resources_root
isn't set, Buck uses the.buckconfig
property in.buckconfig
to determine where resources should be placed within the generated JAR file. -
srcs
: The set of.kt
,.java
or.kts
files to compile for this rule. If any of the files in this list end in.src.zip
, then the entries in the ZIP file that end in.java
or.kt
will be included as ordinary inputs to compilation.
Details
Examples:
# A rule that compiles a single .kt file.
kotlin_library(
name = 'JsonUtil',
srcs = ['JsonUtil.kt'],
deps = [
'//third_party/guava:guava',
'//third_party/jackson:jackson',
],
)
# A rule that compiles all of the .kt files under the directory in
# which the rule is defined using glob(). It also excludes an
# individual file that may have additional dependencies, so it is
# compiled by a separate rule.
kotlin_library(
name = 'messenger',
srcs = glob(['**/*.kt'], excludes = ['MessengerModule.kt']),
deps = [
'//src/com/facebook/base:base',
'//third_party/guava:guava',
],
)
kotlin_library(
name = 'MessengerModule',
srcs = ['MessengerModule.kt'],
deps = [
'//src/com/facebook/base:base',
'//src/com/google/inject:inject',
'//third_party/guava:guava',
'//third_party/jsr-330:jsr-330',
],
)
# A rule that builds a library with both relative and
# fully-qualified deps.
kotlin_library(
name = 'testutil',
srcs = glob(['tests/**/*.kt'], excludes = 'tests/**/*Test.kt'),
deps = [
':lib-fb4a',
'//java/com/facebook/base:base',
],
)