diff options
Diffstat (limited to 'kotlin/internal/toolchains.bzl')
| -rw-r--r-- | kotlin/internal/toolchains.bzl | 200 |
1 files changed, 200 insertions, 0 deletions
diff --git a/kotlin/internal/toolchains.bzl b/kotlin/internal/toolchains.bzl new file mode 100644 index 0000000..01e07bf --- /dev/null +++ b/kotlin/internal/toolchains.bzl @@ -0,0 +1,200 @@ +# Copyright 2018 The Bazel Authors. 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. + +load("//kotlin/internal/common:common.bzl", _common="common") +load("//kotlin/internal:defs.bzl", _TOOLCHAIN_TYPE="TOOLCHAIN_TYPE", _KT_COMPILER_REPO="KT_COMPILER_REPO") + +"""Kotlin Toolchains + +This file contains macros for defining and registering specific toolchains. + +### Examples + +To override a tool chain use the appropriate macro in a `BUILD` file to declare the toolchain: + +```bzl +load("@io_bazel_rules_kotlin//kotlin:toolchains.bzl", "define_kt_toolchain") + +define_kt_toolchain( + name= "custom_toolchain", + api_version = "1.1", + language_version = "1.1", +) +``` +and then register it in the `WORKSPACE`: +```bzl +register_toolchains("//:custom_toolchain") +``` +""" + + + +# The toolchain rules are not made private, at least the jvm ones so that they may be introspected in Intelij. +_common_attrs = { + "kotlin_home": attr.label( + default = Label("@" + _KT_COMPILER_REPO + "//:home"), + allow_files = True, + ), + "kotlinbuilder": attr.label( + default = Label("//kotlin/builder"), + executable = True, + allow_files = True, + cfg = "host", + ), + "language_version": attr.string( + default = "1.2", + values = [ + "1.1", + "1.2", + ], + ), + "api_version": attr.string( + default = "1.2", + values = [ + "1.1", + "1.2", + ], + ), + "debug": attr.string_list( + allow_empty=True, + doc="""Debugging tags passed to the builder. Two tags are supported. `timings` will cause the builder to print +timing information. `trace` will cause the builder to print tracing messages. These tags can be enabled via the default +toolchain via the defines `kt_timings=1` and `kt_trace=1`. The tags may also be picked up via the `tags` attribute +defined directly on the rules.""" + ), + "coroutines": attr.string( + default = "enable", + values = [ + "enable", + "warn", + "error", + ], + ), +} + +_kt_jvm_attrs = dict(_common_attrs.items() + { + "jvm_runtime": attr.label( + default = Label("@" + _KT_COMPILER_REPO + "//:kotlin-runtime"), + providers = [JavaInfo], + cfg = "target", + ), + "jvm_stdlibs": attr.label_list( + default = [ + Label("@" + _KT_COMPILER_REPO + "//:kotlin-stdlib"), + Label("@" + _KT_COMPILER_REPO + "//:kotlin-stdlib-jdk7"), + Label("@" + _KT_COMPILER_REPO + "//:kotlin-stdlib-jdk8"), + ], + providers = [JavaInfo], + cfg = "target", + ), + "jvm_target": attr.string( + default = "1.8", + values = [ + "1.6", + "1.8", + ], + ), +}.items()) + +def _kotlin_toolchain_impl(ctx): + toolchain = dict( + label = _common.restore_label(ctx.label), + language_version = ctx.attr.language_version, + api_version = ctx.attr.api_version, + coroutines = ctx.attr.coroutines, + debug = ctx.attr.debug, + + jvm_target = ctx.attr.jvm_target, + + kotlinbuilder = ctx.attr.kotlinbuilder, + kotlin_home = ctx.files.kotlin_home, + + jvm_stdlibs = java_common.create_provider( + compile_time_jars = ctx.files.jvm_stdlibs, + runtime_jars = ctx.files.jvm_runtime, + use_ijar = False, + ), + ) + return [ + platform_common.ToolchainInfo(**toolchain) + ] + +kt_toolchain = rule( + attrs = _kt_jvm_attrs, + implementation = _kotlin_toolchain_impl, + provides = [platform_common.ToolchainInfo], +) + +"""The kotlin jvm toolchain +Args: + language_version: the -languag_version flag [see](https://kotlinlang.org/docs/reference/compatibility.html). + api_version: the -api_version flag [see](https://kotlinlang.org/docs/reference/compatibility.html). + jvm_target: the -jvm_target flag. + coroutines: the -Xcoroutines flag, enabled by default as it's considered production ready 1.2.0 onward. +""" + +def kt_register_toolchains(): + """This macro registers all of the default toolchains.""" + native.register_toolchains("@io_bazel_rules_kotlin//kotlin/internal:default_toolchain") + +def define_kt_toolchain( + name, + language_version=None, + api_version=None, + jvm_target=None, + coroutines=None, + debug=[] +): + """Define a Kotlin JVM Toolchain, the name is used in the `toolchain` rule so can be used to register the toolchain + in the WORKSPACE file. + """ + impl_name = name + "_impl" + kt_toolchain( + name = impl_name, + language_version = language_version, + api_version = api_version, + jvm_target = jvm_target, + coroutines = coroutines, + debug = debug, + visibility = ["//visibility:public"] + ) + native.toolchain( + name = name, + toolchain_type = _TOOLCHAIN_TYPE, + toolchain = impl_name, + visibility = ["//visibility:public"] + ) + +def _kt_toolchain_ide_info_impl(ctx): + tc=ctx.toolchains[_TOOLCHAIN_TYPE] + info = struct( + label = tc.label, + common = struct( + language_version = tc.language_version, + api_version = tc.api_version, + coroutines = tc.coroutines + ), + jvm = struct( + jvm_target = tc.jvm_target, + ) + ) + ctx.actions.write(ctx.outputs.ide_info, info.to_json()) + return [DefaultInfo(files=depset([ctx.outputs.ide_info]))] + +kt_toolchain_ide_info = rule( + outputs = {"ide_info": "kt_toolchain_ide_info.json"}, + toolchains = [_TOOLCHAIN_TYPE], + implementation = _kt_toolchain_ide_info_impl, +) + |