rules_kotlin

Public Kotlin/JVM rule API.

kt_javac_options

load("@rules_kotlin//kotlin:jvm.bzl", "kt_javac_options")

kt_javac_options(name, add_exports, no_proc, release, warn, x_ep_disable_all_checks,
                 x_explicit_api_mode, x_lint, xd_suppress_notes)

Define java compiler options for kt_jvm_* rules with java sources.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
add_exports	Export internal jdk apis	List of strings	optional	`[]`
no_proc	Disable java annotation processing (javac -proc:none). The Java half of a target with Kotlin sources is always compiled with -proc:none (Kotlin owns annotation processing there); this option extends that to Java-only kt_jvm_* targets.	Boolean	optional	`False`
release	Compile for the specified Java SE release	String	optional	`"default"`
warn	Control warning behaviour.	String	optional	`"report"`
x_ep_disable_all_checks	See javac -XepDisableAllChecks documentation	Boolean	optional	`False`
x_explicit_api_mode	Enable explicit API mode for Kotlin libraries.	String	optional	`"off"`
x_lint	See javac -Xlint: documentation	List of strings	optional	`[]`
xd_suppress_notes	See javac -XDsuppressNotes documentation	Boolean	optional	`False`

kt_jvm_binary

load("@rules_kotlin//kotlin:jvm.bzl", "kt_jvm_binary")

kt_jvm_binary(name, deps, srcs, data, resources, associates, env, env_inherit, java_stub_template,
              javac_opts, jvm_flags, kotlinc_opts, main_class, manifest_lines, module_name, plugins,
              resource_jars, resource_strip_prefix, runtime_deps)

Builds a Java archive (“jar file”), plus a wrapper shell script with the same name as the rule. The wrapper shell script uses a classpath that includes, among other things, a jar file for each library on which the binary depends.

Note: This rule does not have all of the features found in java_binary. It is appropriate for building workspace utilities. java_binary should be preferred for release artefacts.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	A list of dependencies of this rule.See general comments about `deps` at Attributes common to all build rules.	List of labels	optional	`[]`
srcs	The list of source files that are processed to create the target, this can contain both Java and Kotlin files. Java analysis occurs first so Kotlin classes may depend on Java classes in the same compilation unit.	List of labels	optional	`[]`
data	The list of files needed by this rule at runtime. See general comments about `data` at Attributes common to all build rules.	List of labels	optional	`[]`
resources	A list of files that should be include in a Java jar.	List of labels	optional	`[]`
associates	Kotlin deps who should be considered part of the same module/compilation-unit for the purposes of “internal” access. Such deps must all share the same module space and so a target cannot associate to two deps from two different modules.	List of labels	optional	`[]`
env	Environment variables to set when this binary is executed with `bazel run`. Subject to $(location) and “Make variable” substitution.	Dictionary: String -> String	optional	`{}`
env_inherit	Names of environment variables to inherit from the shell when executed with `bazel run`.	List of strings	optional	`[]`
java_stub_template	-	Label	optional	`"@rules_kotlin//third_party:java_stub_template.txt"`
javac_opts	Javac options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
jvm_flags	A list of flags to embed in the wrapper script generated for running this binary. Note: does not yet support make variable substitution.	List of strings	optional	`[]`
kotlinc_opts	Kotlinc options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
main_class	Name of class with main() method to use as entry point.	String	required
manifest_lines	Lines to add to the main section of the manifest of the output jar, each in the form `Name: value`. They follow the `Target-Label` and `Injecting-Rule-Kind` attributes the rules write. A line that repeats them, `Manifest-Version` or `Created-By` is rejected. As in the `deploy_manifest_lines` attribute of `java_binary`, `Multi-Release`, `Add-Exports` and `Add-Opens` lines are not copied as they are: singlejar merges them and writes them in its normalized form, and `Multi-Release` takes `true` or `false`. A target without `srcs` and `resources` has no jar of its own and rejects the attribute.	List of strings	optional	`[]`
module_name	The name of the module, if not provided the module name is derived from the label. –e.g., `//some/package/path:label_name` is translated to `some_package_path-label_name`.	String	optional	`""`
plugins	-	List of labels	optional	`[]`
resource_jars	Set of archives containing Java resources. If specified, the contents of these jars are merged into the output jar.	List of labels	optional	`[]`
resource_strip_prefix	The path prefix to strip from Java resources. Should be a label pointing to a directory. Files residing under common prefix such as `src/main/resources` or `src/test/resources` or `kotlin` will have stripping applied by convention if this is not specified.	Label	optional	`None`
runtime_deps	Libraries to make available to the final binary or test at runtime only. Like ordinary deps, these will appear on the runtime classpath, but unlike them, not on the compile-time classpath.	List of labels	optional	`[]`

kt_jvm_import

load("@rules_kotlin//kotlin:jvm.bzl", "kt_jvm_import")

kt_jvm_import(name, deps, exported_compiler_plugins, exports, jar, jars, neverlink, runtime_deps,
              srcjar)

Import Kotlin jars.

examples

# Old style usage -- reference file groups, do not used this.
kt_jvm_import(
    name = "kodein",
    jars = [
        "@com_github_salomonbrys_kodein_kodein//jar:file",
        "@com_github_salomonbrys_kodein_kodein_core//jar:file"
    ]
)

# This style will pull in the transitive runtime dependencies of the targets as well.
kt_jvm_import(
    name = "kodein",
    jars = [
        "@com_github_salomonbrys_kodein_kodein//jar",
        "@com_github_salomonbrys_kodein_kodein_core//jar"
    ]
)

# Import a single kotlin jar.
kt_jvm_import(
    name = "kotlin-stdlib",
    jars = ["lib/kotlin-stdlib.jar"],
    srcjar = "lib/kotlin-stdlib-sources.jar"
)

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	Compile and runtime dependencies	List of labels	optional	`[]`
exported_compiler_plugins	Exported compiler plugins. Compiler plugins listed here will be treated as if they were added in the plugins attribute of any targets that directly depend on this target. Like java_plugins’ exported_plugins, this is not transitive	List of labels	optional	`[]`
exports	Exported libraries. Deps listed here will be made available to other rules, as if the parents explicitly depended on these deps. This is not true for regular (non-exported) deps.	List of labels	optional	`[]`
jar	The jar listed here is equivalent to an export attribute.	Label	optional	`None`
jars	The jars listed here are equavalent to an export attribute. The label should be either to a single class jar, or one or more filegroup labels. The filegroups, when resolved, must contain only one jar containing classes, and (optionally) one peer file containing sources, named `<jarname>-sources.jar`. DEPRECATED - please use `jar` and `srcjar` attributes.	List of labels	optional	`[]`
neverlink	If true only use this library for compilation and not at runtime.	Boolean	optional	`False`
runtime_deps	Additional runtime deps.	List of labels	optional	`[]`
srcjar	The sources for the class jar.	Label	optional	`"@rules_kotlin//third_party:empty.jar"`

kt_jvm_library

load("@rules_kotlin//kotlin:jvm.bzl", "kt_jvm_library")

kt_jvm_library(name, deps, srcs, data, resources, associates, exported_compiler_plugins, exports,
               java_stub_template, javac_opts, kotlinc_opts, manifest_lines, module_name, neverlink,
               plugins, resource_jars, resource_strip_prefix, runtime_deps)

This rule compiles and links Kotlin and Java sources into a .jar file.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	A list of dependencies of this rule.See general comments about `deps` at Attributes common to all build rules.	List of labels	optional	`[]`
srcs	The list of source files that are processed to create the target, this can contain both Java and Kotlin files. Java analysis occurs first so Kotlin classes may depend on Java classes in the same compilation unit.	List of labels	optional	`[]`
data	The list of files needed by this rule at runtime. See general comments about `data` at Attributes common to all build rules.	List of labels	optional	`[]`
resources	A list of files that should be include in a Java jar.	List of labels	optional	`[]`
associates	Kotlin deps who should be considered part of the same module/compilation-unit for the purposes of “internal” access. Such deps must all share the same module space and so a target cannot associate to two deps from two different modules.	List of labels	optional	`[]`
exported_compiler_plugins	Exported compiler plugins. Compiler plugins listed here will be treated as if they were added in the plugins attribute of any targets that directly depend on this target. Like `java_plugin`s exported_plugins, this is not transitive	List of labels	optional	`[]`
exports	Exported libraries. Deps listed here will be made available to other rules, as if the parents explicitly depended on these deps. This is not true for regular (non-exported) deps.	List of labels	optional	`[]`
java_stub_template	-	Label	optional	`"@rules_kotlin//third_party:java_stub_template.txt"`
javac_opts	Javac options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
kotlinc_opts	Kotlinc options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
manifest_lines	Lines to add to the main section of the manifest of the output jar, each in the form `Name: value`. They follow the `Target-Label` and `Injecting-Rule-Kind` attributes the rules write. A line that repeats them, `Manifest-Version` or `Created-By` is rejected. As in the `deploy_manifest_lines` attribute of `java_binary`, `Multi-Release`, `Add-Exports` and `Add-Opens` lines are not copied as they are: singlejar merges them and writes them in its normalized form, and `Multi-Release` takes `true` or `false`. A target without `srcs` and `resources` has no jar of its own and rejects the attribute.	List of strings	optional	`[]`
module_name	The name of the module, if not provided the module name is derived from the label. –e.g., `//some/package/path:label_name` is translated to `some_package_path-label_name`.	String	optional	`""`
neverlink	If true only use this library for compilation and not at runtime.	Boolean	optional	`False`
plugins	-	List of labels	optional	`[]`
resource_jars	Set of archives containing Java resources. If specified, the contents of these jars are merged into the output jar.	List of labels	optional	`[]`
resource_strip_prefix	The path prefix to strip from Java resources. Should be a label pointing to a directory. Files residing under common prefix such as `src/main/resources` or `src/test/resources` or `kotlin` will have stripping applied by convention if this is not specified.	Label	optional	`None`
runtime_deps	Libraries to make available to the final binary or test at runtime only. Like ordinary deps, these will appear on the runtime classpath, but unlike them, not on the compile-time classpath.	List of labels	optional	`[]`

kt_jvm_test

load("@rules_kotlin//kotlin:jvm.bzl", "kt_jvm_test")

kt_jvm_test(name, deps, srcs, data, resources, associates, env, env_inherit, java_stub_template,
            javac_opts, jvm_flags, kotlinc_opts, main_class, manifest_lines, module_name, plugins,
            resource_jars, resource_strip_prefix, runtime_deps, test_class)

Setup a simple kotlin_test.

Notes:

The kotlin test library is not added implicitly, it is available with the label @rules_kotlin//kotlin/compiler:kotlin-test.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	A list of dependencies of this rule.See general comments about `deps` at Attributes common to all build rules.	List of labels	optional	`[]`
srcs	The list of source files that are processed to create the target, this can contain both Java and Kotlin files. Java analysis occurs first so Kotlin classes may depend on Java classes in the same compilation unit.	List of labels	optional	`[]`
data	The list of files needed by this rule at runtime. See general comments about `data` at Attributes common to all build rules.	List of labels	optional	`[]`
resources	A list of files that should be include in a Java jar.	List of labels	optional	`[]`
associates	Kotlin deps who should be considered part of the same module/compilation-unit for the purposes of “internal” access. Such deps must all share the same module space and so a target cannot associate to two deps from two different modules.	List of labels	optional	`[]`
env	Specifies additional environment variables to set when the target is executed by bazel test. Subject to $(location) and “Make variable” substitution.	Dictionary: String -> String	optional	`{}`
env_inherit	Environment variables to inherit from the external environment.	List of strings	optional	`[]`
java_stub_template	-	Label	optional	`"@rules_kotlin//third_party:java_stub_template.txt"`
javac_opts	Javac options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
jvm_flags	A list of flags to embed in the wrapper script generated for running this binary. Note: does not yet support make variable substitution.	List of strings	optional	`[]`
kotlinc_opts	Kotlinc options to be used when compiling this target. These opts if provided will be used instead of the ones provided to the toolchain.	Label	optional	`None`
main_class	-	String	optional	`"com.google.testing.junit.runner.BazelTestRunner"`
manifest_lines	Lines to add to the main section of the manifest of the output jar, each in the form `Name: value`. They follow the `Target-Label` and `Injecting-Rule-Kind` attributes the rules write. A line that repeats them, `Manifest-Version` or `Created-By` is rejected. As in the `deploy_manifest_lines` attribute of `java_binary`, `Multi-Release`, `Add-Exports` and `Add-Opens` lines are not copied as they are: singlejar merges them and writes them in its normalized form, and `Multi-Release` takes `true` or `false`. A target without `srcs` and `resources` has no jar of its own and rejects the attribute.	List of strings	optional	`[]`
module_name	The name of the module, if not provided the module name is derived from the label. –e.g., `//some/package/path:label_name` is translated to `some_package_path-label_name`.	String	optional	`""`
plugins	-	List of labels	optional	`[]`
resource_jars	Set of archives containing Java resources. If specified, the contents of these jars are merged into the output jar.	List of labels	optional	`[]`
resource_strip_prefix	The path prefix to strip from Java resources. Should be a label pointing to a directory. Files residing under common prefix such as `src/main/resources` or `src/test/resources` or `kotlin` will have stripping applied by convention if this is not specified.	Label	optional	`None`
runtime_deps	Libraries to make available to the final binary or test at runtime only. Like ordinary deps, these will appear on the runtime classpath, but unlike them, not on the compile-time classpath.	List of labels	optional	`[]`
test_class	The Java class to be loaded by the test runner.	String	optional	`""`

Public ktlint rules.

ktlint_config

load("@rules_kotlin//kotlin:lint.bzl", "ktlint_config")

ktlint_config(name, android_rules_enabled, editorconfig, experimental_rules_enabled)

Used to configure ktlint.

ktlint can be configured to use a .editorconfig, as documented at https://github.com/pinterest/ktlint/#editorconfig

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
android_rules_enabled	Turn on Android Kotlin Style Guide compatibility	Boolean	optional	`False`
editorconfig	Editor config file to use	Label	optional	`None`
experimental_rules_enabled	Turn on experimental rules (ktlint-ruleset-experimental)	Boolean	optional	`False`

ktlint_fix

load("@rules_kotlin//kotlin:lint.bzl", "ktlint_fix")

ktlint_fix(name, srcs, config)

Lint Kotlin files and automatically fix them as needed

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
srcs	Source files to review and fix	List of labels	required
config	ktlint_config to use	Label	optional	`None`

ktlint_test

load("@rules_kotlin//kotlin:lint.bzl", "ktlint_test")

ktlint_test(name, srcs, config)

Lint Kotlin files, and fail if the linter raises errors.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
srcs	Source files to lint	List of labels	required
config	ktlint_config to use	Label	optional	`None`

Core Kotlin rule and providers.

kt_btapi_runtime

load("@rules_kotlin//kotlin:core.bzl", "kt_btapi_runtime")

kt_btapi_runtime(name, base, build_tools_impl, compiler, jdeps_gen, jvm_abi_gen, kapt, libraries,
                 skip_code_gen)

The Build Tools API compilation runtime: the jars the worker loads into the Build Tools API classloader, and the internal compiler plugins it passes to the compiler. Every jar is the embeddable compiler dialect (the Maven-published form of the compiler and its plugins), because the Build Tools implementation is published in that dialect only.

An artifact that is not set is inherited from base, so a runtime that replaces one artifact states only that artifact. The default runtime, //kotlin/compiler:btapi_runtime, takes every artifact from the configured Kotlin release.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
base	The runtime that provides every artifact this target does not set.	Label	optional	`None`
build_tools_impl	The Build Tools implementation.	List of labels	optional	`[]`
compiler	The compiler, embeddable dialect.	List of labels	optional	`[]`
jdeps_gen	The jdeps-gen compiler plugin, embeddable dialect.	List of labels	optional	`[]`
jvm_abi_gen	The jvm-abi-gen compiler plugin, embeddable dialect.	List of labels	optional	`[]`
kapt	The kapt compiler plugin, embeddable dialect.	List of labels	optional	`[]`
libraries	The libraries the implementation and the compiler need.	List of labels	optional	`[]`
skip_code_gen	The skip-code-gen compiler plugin, embeddable dialect.	List of labels	optional	`[]`

kt_compiler_plugin

load("@rules_kotlin//kotlin:core.bzl", "kt_compiler_plugin")

kt_compiler_plugin(name, deps, data, compile_phase, id, options, stubs_phase,
                   target_embedded_compiler)

Define a plugin for the Kotlin compiler to run. The plugin can then be referenced in the plugins attribute of the kt_jvm_* rules.

An example can be found under //examples/plugin:

kt_compiler_plugin(
    name = "open_for_testing_plugin",
    id = "org.jetbrains.kotlin.allopen",
    options = {
        "annotation": ["plugin.OpenForTesting"],
    },
    deps = [
        "//kotlin/compiler:allopen-compiler-plugin",
    ],
)

kt_jvm_library(
    name = "open_for_testing",
    srcs = ["OpenForTesting.kt"],
)

kt_jvm_library(
    name = "user",
    srcs = ["User.kt"],
    plugins = [":open_for_testing_plugin"],
    deps = [
        ":open_for_testing",
    ],
)

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	The list of libraries to be added to the compiler’s plugin classpath	List of labels	optional	`[]`
data	The list of data files to be used by compiler’s plugin	List of labels	optional	`[]`
compile_phase	Runs the compiler plugin during kotlin compilation. Known examples: `allopen`, `sam_with_reciever`	Boolean	optional	`True`
id	The ID of the plugin	String	required
options	Dictionary of options to be passed to the plugin. Each option key can have multiple values. Supports the following template values: - `{generatedClasses}`: directory for generated class output - `{temp}`: temporary directory, discarded between invocations - `{generatedSources}`: directory for generated source output - `{classpath}` : replaced with a list of jars separated by the filesystem appropriate separator.	Dictionary: String -> List of strings	optional	`{}`
stubs_phase	Runs the compiler plugin in kapt stub generation.	Boolean	optional	`True`
target_embedded_compiler	Plugin was compiled against the embeddable kotlin compiler. The plugin classpath is reshaded when this dialect differs from the dialect of the compiler that the toolchain runs.	Boolean	optional	`False`

kt_javac_options

load("@rules_kotlin//kotlin:core.bzl", "kt_javac_options")

kt_javac_options(name, add_exports, no_proc, release, warn, x_ep_disable_all_checks,
                 x_explicit_api_mode, x_lint, xd_suppress_notes)

Define java compiler options for kt_jvm_* rules with java sources.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
add_exports	Export internal jdk apis	List of strings	optional	`[]`
no_proc	Disable java annotation processing (javac -proc:none). The Java half of a target with Kotlin sources is always compiled with -proc:none (Kotlin owns annotation processing there); this option extends that to Java-only kt_jvm_* targets.	Boolean	optional	`False`
release	Compile for the specified Java SE release	String	optional	`"default"`
warn	Control warning behaviour.	String	optional	`"report"`
x_ep_disable_all_checks	See javac -XepDisableAllChecks documentation	Boolean	optional	`False`
x_explicit_api_mode	Enable explicit API mode for Kotlin libraries.	String	optional	`"off"`
x_lint	See javac -Xlint: documentation	List of strings	optional	`[]`
xd_suppress_notes	See javac -XDsuppressNotes documentation	Boolean	optional	`False`

kt_kotlinc_options

load("@rules_kotlin//kotlin:core.bzl", "kt_kotlinc_options")

kt_kotlinc_options(name, api_version, include_stdlibs, java_parameters, jvm_default, jvm_target,
                   language_version, progressive, warn, x_allow_kotlin_package,
                   x_allow_unstable_dependencies, x_annotation_default_target, x_assertions,
                   x_backend_threads, x_compiler_plugin_order,
                   x_consistent_data_class_copy_visibility, x_context_parameters, x_context_receivers,
                   x_emit_jvm_type_annotations, x_enable_incremental_compilation, x_explicit_api_mode,
                   x_inline_classes, x_jdk_release, x_jspecify_annotations, x_jsr_305, x_jvm_default,
                   x_lambdas, x_multi_platform, x_no_call_assertions, x_no_optimize,
                   x_no_param_assertions, x_no_receiver_assertions, x_no_source_debug_extension,
                   x_nullability_annotations, x_optin, x_render_internal_diagnostic_names,
                   x_report_all_warnings, x_report_perf, x_sam_conversions, x_skip_prerelease_check,
                   x_suppress_version_warnings, x_suppress_warning,
                   x_type_enhancement_improvements_strict_mode, x_use_fir_lt, x_use_k2,
                   x_warning_level, x_when_guards, x_xlanguage)

Define kotlin compiler options.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
api_version	Allow using declarations from only the specified version of bundled libraries. Overrides the toolchain’s api_version when set.	String	optional	`""`
include_stdlibs	Don’t automatically include the Kotlin standard libraries into the classpath (stdlib and reflect).	String	optional	`"all"`
java_parameters	Generate metadata for Java 1.8+ reflection on method parameters.	Boolean	optional	`False`
jvm_default	Specifies how to generate JVM default methods for interface declarations with bodies. This is the stable replacement for x_jvm_default (-Xjvm-default). Available from Kotlin 2.2. Options: - ‘off’: Don’t pass the flag (uses compiler default, which is ‘enable’ in Kotlin 2.2+). - ‘enable’: Generate default methods and DefaultImpls for compatibility. - ‘no-compatibility’: Generate default methods without DefaultImpls classes. - ‘disable’: Do not generate JVM default methods (was the default up to Kotlin 2.1).	String	optional	`"off"`
jvm_target	The target version of the generated JVM bytecode	String	optional	`""`
language_version	Provide source compatibility with the specified version of Kotlin. Overrides the toolchain’s language_version when set.	String	optional	`""`
progressive	Enable progressive compiler mode. In this mode, deprecations and bug fixes for unstable code take effect immediately instead of going through a graceful migration cycle.	Boolean	optional	`False`
warn	Control warning behaviour.	String	optional	`"report"`
x_allow_kotlin_package	Allow compiling code in the ‘kotlin’ package, and allow not requiring ‘kotlin.stdlib’ in ‘module-info’.	Boolean	optional	`False`
x_allow_unstable_dependencies	Do not report errors on classes in dependencies that were compiled by an unstable version of the Kotlin compiler.	Boolean	optional	`False`
x_annotation_default_target	Change the default annotation targets for constructor properties: -Xannotation-default-target=first-only: use the first of the following allowed targets: ‘@param:’, ‘@property:’, ‘@field:’; -Xannotation-default-target=first-only-warn: same as first-only, and raise warnings when both ‘@param:’ and either ‘@property:’ or ‘@field:’ are allowed; -Xannotation-default-target=param-property: use ‘@param:’ target if applicable, and also use the first of either ‘@property:’ or ‘@field:’; default: ‘first-only-warn’ in language version 2.2+, ‘first-only’ in version 2.1 and before.	String	optional	`"off"`
x_assertions	Configures how assertions are handled. The ‘jvm’ option enables assertions in JVM code.	String	optional	`""`
x_backend_threads	When using the IR backend, run lowerings by file in N parallel threads. 0 means use a thread per processor core. Default value is 1.	Integer	optional	`1`
x_compiler_plugin_order	Execution order constraints for compiler plugins. Each constraint has the form `<pluginId1>><pluginId2>`: the first plugin runs before the second.	List of strings	optional	`[]`
x_consistent_data_class_copy_visibility	The effect of this compiler flag is the same as applying @ConsistentCopyVisibility annotation to all data classes in the module. See https://youtrack.jetbrains.com/issue/KT-11914	Boolean	optional	`False`
x_context_parameters	Enable experimental context parameters (Kotlin 2.2+).	Boolean	optional	`False`
x_context_receivers	Enable experimental context receivers.	Boolean	optional	`False`
x_emit_jvm_type_annotations	Basic support for type annotations in JVM bytecode.	Boolean	optional	`False`
x_enable_incremental_compilation	Enable incremental compilation	Boolean	optional	`False`
x_explicit_api_mode	Enable explicit API mode for Kotlin libraries.	String	optional	`"off"`
x_inline_classes	Enable experimental inline classes	Boolean	optional	`False`
x_jdk_release	Compile against the specified JDK API version, similarly to javac’s ‘-release’. This requires JDK 9 or newer. The supported versions depend on the JDK used; for JDK 25+, the supported versions are 1.8 and 9-25. This also sets the value of ‘-jvm-target’ to be equal to the selected JDK version.	String	optional	`""`
x_jspecify_annotations	Controls how JSpecify annotations are treated. Options are ‘default’, ‘ignore’, ‘warn’, and ‘strict’.	String	optional	`""`
x_jsr_305	Specifies how to handle JSR-305 annotations in Kotlin code. Options are ‘default’, ‘ignore’, ‘warn’, and ‘strict’.	String	optional	`""`
x_jvm_default	DEPRECATED: Use jvm_default instead for Kotlin 2.2+. Specifies that a JVM default method should be generated for non-abstract Kotlin interface member. Migration to jvm_default: - x_jvm_default=all -> jvm_default=no-compatibility - x_jvm_default=all-compatibility -> jvm_default=enable - x_jvm_default=disable -> jvm_default=disable	String	optional	`"off"`
x_lambdas	Change codegen behavior of lambdas. Defaults to “class” (anonymous inner classes), which differs from Kotlin 2.x/Gradle default of “indy” (invokedynamic). Set to “indy” for Gradle-compatible bytecode.	String	optional	`"class"`
x_multi_platform	Enable experimental language support for multi-platform projects	Boolean	optional	`False`
x_no_call_assertions	Don’t generate not-null assertions for arguments of platform types	Boolean	optional	`False`
x_no_optimize	Disable optimizations	Boolean	optional	`False`
x_no_param_assertions	Don’t generate not-null assertions on parameters of methods accessible from Java	Boolean	optional	`False`
x_no_receiver_assertions	Don’t generate not-null assertion for extension receiver arguments of platform types	Boolean	optional	`False`
x_no_source_debug_extension	Do not generate @kotlin.jvm.internal.SourceDebugExtension annotation on a class with the copy of SMAP	Boolean	optional	`False`
x_nullability_annotations	Configure how Kotlin treats nullability annotations on Java types, per annotation class. Map the fully-qualified annotation class name (prefixed with ‘@’) to a mode: ‘ignore’, ‘warn’, or ‘strict’. Ex: {‘@jakarta.annotation.Nullable’: ‘strict’, ‘@jakarta.annotation.Nonnull’: ‘strict’}. Use x_jsr305 for javax.annotation (JSR-305) and x_jspecify_annotations for org.jspecify.	Dictionary: String -> String	optional	`{}`
x_optin	Define APIs to opt-in to.	List of strings	optional	`[]`
x_render_internal_diagnostic_names	Render the internal names of warnings and errors.	Boolean	optional	`False`
x_report_all_warnings	Report all warnings even if errors are found.	Boolean	optional	`False`
x_report_perf	Report detailed performance statistics	Boolean	optional	`False`
x_sam_conversions	Change codegen behavior of SAM/functional interfaces. Defaults to “indy” (invokedynamic via LambdaMetafactory), matching Kotlin compiler’s own default since 1.5. Set to “class” for legacy anonymous-class codegen.	String	optional	`"indy"`
x_skip_prerelease_check	Suppress errors thrown when using pre-release classes.	Boolean	optional	`False`
x_suppress_version_warnings	Suppress warnings about outdated, inconsistent, or experimental language or API versions.	Boolean	optional	`False`
x_suppress_warning	Suppress specific warnings globally	List of strings	optional	`[]`
x_type_enhancement_improvements_strict_mode	Enables strict mode for type enhancement improvements, enforcing stricter type checking and enhancements.	Boolean	optional	`False`
x_use_fir_lt	Compile using LightTree parser with Front-end IR. Warning: this feature is far from being production-ready	Boolean	optional	`False`
x_use_k2	Compile using experimental K2. K2 is a new compiler pipeline, no compatibility guarantees are yet provided	Boolean	optional	`False`
x_warning_level	Suppress specific warnings globally. Ex: ‘OPTION’: ‘(error\|warning\|disabled)’	Dictionary: String -> String	optional	`{}`
x_when_guards	Enable experimental language support for when guards.	Boolean	optional	`False`
x_xlanguage	Enable or disable the specified language feature. Not intended for production use; prefer language_version or the dedicated feature flags.	List of strings	optional	`[]`

kt_ksp_plugin

load("@rules_kotlin//kotlin:core.bzl", "kt_ksp_plugin")

kt_ksp_plugin(name, deps, generates_java, options, processor_class, target_embedded_compiler)

Define a KSP plugin for the Kotlin compiler to run. The plugin can then be referenced in the plugins attribute of the kt_jvm_* and kt_android_* rules.

An example can be found under //examples/ksp:

kt_ksp_plugin(
    name = "moshi-kotlin-codegen",
    processor_class = "com.squareup.moshi.kotlin.codegen.ksp.JsonClassSymbolProcessorProvider",
    deps = [
        "@maven//:com_squareup_moshi_moshi",
        "@maven//:com_squareup_moshi_moshi_kotlin",
        "@maven//:com_squareup_moshi_moshi_kotlin_codegen",
    ],
)

kt_jvm_library(
    name = "lib",
    srcs = glob(["*.kt"]),
    plugins = ["//:moshi-kotlin-codegen"],
)

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	The list of libraries to be added to the compiler’s plugin classpath	List of labels	optional	`[]`
generates_java	Runs Java compilation action for plugin generating Java output.	Boolean	optional	`False`
options	Processor options passed to the KSP processor via SymbolProcessorEnvironment.options. Each entry is a key-value pair available to the processor at processing time.	Dictionary: String -> String	optional	`{}`
processor_class	The fully qualified class name that the Java compiler uses as an entry point to the annotation processor.	String	required
target_embedded_compiler	Plugin was compiled against the embeddable kotlin compiler. These plugins expect shaded kotlinc dependencies, and will fail when running against a non-embeddable compiler.	Boolean	optional	`False`

kt_plugin_cfg

load("@rules_kotlin//kotlin:core.bzl", "kt_plugin_cfg")

kt_plugin_cfg(name, deps, data, options, plugin)

Configurations for kt_compiler_plugin, ksp_plugin, and java_plugin.

This allows setting options and dependencies independently from the initial plugin definition.

ATTRIBUTES

Name	Description	Type	Mandatory	Default
name	A unique name for this target.	Name	required
deps	Dependencies for this configuration.	List of labels	optional	`[]`
data	The list of data files to be used by compiler’s plugin	List of labels	optional	`[]`
options	A dictionary of flag to values to be used as plugin configuration options.	Dictionary: String -> List of strings	optional	`{}`
plugin	The plugin to associate with this configuration	Label	required

BtapiRuntimeInfo

load("@rules_kotlin//kotlin:core.bzl", "BtapiRuntimeInfo")

BtapiRuntimeInfo(build_tools_impl, compiler, jdeps_gen, jvm_abi_gen, kapt, libraries, skip_code_gen)

The complete Build Tools API compilation runtime: the classloader group and the internal compiler plugins. Every jar is the embeddable compiler dialect.

FIELDS

Name	Description
build_tools_impl	list of File: the Build Tools implementation.
compiler	list of File: the compiler, embeddable dialect.
jdeps_gen	list of File: the jdeps-gen compiler plugin, embeddable dialect.
jvm_abi_gen	list of File: the jvm-abi-gen compiler plugin, embeddable dialect.
kapt	list of File: the kapt compiler plugin, embeddable dialect.
libraries	list of File: the libraries the implementation and the compiler need.
skip_code_gen	list of File: the skip-code-gen compiler plugin, embeddable dialect.

define_kt_toolchain

load("@rules_kotlin//kotlin:core.bzl", "define_kt_toolchain")

define_kt_toolchain(name, language_version, api_version, jvm_target, experimental_use_abi_jars,
                    experimental_treat_internal_as_private_in_abi_jars,
                    experimental_remove_private_classes_in_abi_jars,
                    experimental_remove_debug_info_in_abi_jars,
                    experimental_preserve_declaration_order,
                    experimental_remove_data_class_copy_if_constructor_is_private,
                    experimental_strict_kotlin_deps, experimental_report_unused_deps,
                    experimental_reduce_classpath_mode, experimental_multiplex_workers,
                    experimental_multiplex_sandboxing, supports_path_mapping,
                    experimental_build_tools_api, btapi_runtime, javac_options, kotlinc_options,
                    jvm_stdlibs, jvm_runtime, jacocorunner, exec_compatible_with,
                    target_compatible_with, target_settings)

Define the Kotlin toolchain.

The legacy invocation runs the compiler of the bundled CLI distribution. When the Build Tools API compilation is enabled, through experimental_build_tools_api, through btapi_runtime, or through the build setting //kotlin/settings:experimental_build_tools_api, the toolchain runs a Build Tools API runtime: the Build Tools implementation, the embeddable compiler, the libraries they need, and the internal compiler plugins in the embeddable dialect.

PARAMETERS

Name	Description	Default Value
name	the toolchain name.	none
language_version	<p align="center"> - </p>	`None`
api_version	<p align="center"> - </p>	`None`
jvm_target	<p align="center"> - </p>	`None`
experimental_use_abi_jars	<p align="center"> - </p>	`False`
experimental_treat_internal_as_private_in_abi_jars	<p align="center"> - </p>	`False`
experimental_remove_private_classes_in_abi_jars	<p align="center"> - </p>	`False`
experimental_remove_debug_info_in_abi_jars	<p align="center"> - </p>	`False`
experimental_preserve_declaration_order	<p align="center"> - </p>	`False`
experimental_remove_data_class_copy_if_constructor_is_private	<p align="center"> - </p>	`False`
experimental_strict_kotlin_deps	<p align="center"> - </p>	`None`
experimental_report_unused_deps	<p align="center"> - </p>	`None`
experimental_reduce_classpath_mode	<p align="center"> - </p>	`None`
experimental_multiplex_workers	<p align="center"> - </p>	`None`
experimental_multiplex_sandboxing	<p align="center"> - </p>	`None`
supports_path_mapping	<p align="center"> - </p>	`None`
experimental_build_tools_api	`True` enables the Build Tools API compilation for the toolchain. Unset, it is `True` when `btapi_runtime` is set and `False` otherwise. `False` keeps the legacy invocation until the build setting turns the Build Tools API on; a `btapi_runtime` then applies to that build only.	`None`
btapi_runtime	a `kt_btapi_runtime` that replaces the default Build Tools API runtime, `//kotlin/compiler:btapi_runtime`, the runtime of the current Kotlin release. The runtime of another release is `@<name>//:runtime` of a repository the module extension tag `btapi_impl_version` declares. A runtime built on either with `base` replaces single artifacts. A runtime is an explicit choice of the Build Tools API compilation, see `experimental_build_tools_api`.	`None`
javac_options	<p align="center"> - </p>	`Label("@rules_kotlin//kotlin/internal:default_javac_options")`
kotlinc_options	<p align="center"> - </p>	`Label("@rules_kotlin//kotlin/internal:default_kotlinc_options")`
jvm_stdlibs	<p align="center"> - </p>	`None`
jvm_runtime	<p align="center"> - </p>	`None`
jacocorunner	<p align="center"> - </p>	`None`
exec_compatible_with	<p align="center"> - </p>	`None`
target_compatible_with	<p align="center"> - </p>	`None`
target_settings	<p align="center"> - </p>	`None`

kt_register_toolchains

load("@rules_kotlin//kotlin:core.bzl", "kt_register_toolchains")

kt_register_toolchains()

This macro registers the kotlin toolchain.

Stubs for stardoc generation.

kotlin_repositories

load("@rules_kotlin//kotlin:repositories.doc.bzl", "kotlin_repositories")

kotlin_repositories(is_bzlmod, compiler_repository_name, ksp_repository_name, compiler_release,
                    ksp_compiler_release, btapi_impl_releases)

Call this in the WORKSPACE file to setup the Kotlin rules.

PARAMETERS

Name	Description	Default Value
is_bzlmod	whether the repositories are being set up under bzlmod.	`False`
compiler_repository_name	for the kotlinc compiler repository.	`"com_github_jetbrains_kotlin"`
ksp_repository_name	for the KSP compiler plugin repository.	`"com_github_google_ksp"`
compiler_release	version provider from versions.bzl.	`struct(sha256 = "59e9ca74c7904ef2c122b12114937673ccce68de820a663f0ed66ccf8799e0b7", url_templates = ["https://github.com/JetBrains/kotlin/releases/download/v{version}/kotlin-compiler-{version}.zip"], version = "2.4.20")`
ksp_compiler_release	(internal) version provider from versions.bzl.	`struct(sha256 = "31e83f087c3e822d16d93b2fd240769872ba1fad26e7f3b5dfb3f71513e7399f", url_templates = ["https://github.com/google/ksp/releases/download/{version}/artifacts.zip"], version = "2.3.12")`
btapi_impl_releases	the Build Tools API implementation records, a dict of repository name to a record built with btapi_impl_version. The record of the current release is always created as @btapi_impl unless the dict replaces it.	`None`

versions.use_repository

load("@rules_kotlin//kotlin:repositories.doc.bzl", "versions")

versions.use_repository(rule, name, version, **kwargs)

PARAMETERS

Name	Description	Default Value
rule	<p align="center"> - </p>	none
name	<p align="center"> - </p>	none
version	<p align="center"> - </p>	none
kwargs	<p align="center"> - </p>	none

This site is open source. Improve this page.