Bazel is still in Beta and new releases may include backward incompatible changes. As we make changes and polish the extension mechanism, old features may be removed and new features that are not backward compatible may be added.
Backward incompatible changes are introduced gradually:
false.true. You can still use the flag to disable the change.To check if your code will be compatible with future releases you can:
--all_incompatible_changes. This flag enables all backward incompatible changes, and so you can ensure your code is compatible with upcoming changes.The following are the backward incompatible changes that are implemented and guarded behind flags in the current release:
We are removing the + operator on dictionaries. This includes the += form where the left-hand side is a dictionary. This is done to improve compatibility with Python. A possible workaround is to use the .update method instead.
--incompatible_disallow_dict_plusfalsePreviously, the load statement could appear anywhere in a .bzl file so long as it was at the top level. With this change, for .bzl files, load must appear at the beginning of the file, i.e. before any other non-load statement.
--incompatible_bzl_disallow_load_after_statementfalseWhen the flag is set to true, depset objects are not treated as iterable. This prohibits directly iterating over depsets in for loops, taking its size via len(), and passing it to many functions such as list, tuple, min, max, sorted, all, and any. It does not prohibit checking for emptiness by converting the depset to a boolean.
The goal of this change is to avoid accidental iteration on depset, which can be expensive. If you really need to iterate over a depset, you can call the .to_list() method to obtain a flattened list of its contents.
deps = depset() [x.path for x in deps] # deprecated [x.path for x in deps.to_list()] # recommended sorted(deps) # deprecated sorted(deps.to_list()) # recommended
--incompatible_depset_is_not_iterablefalseTo merge two sets, the following examples used to be supported, but are now deprecated:
depset1 + depset2 # deprecated depset1 | depset2 # deprecated depset1.union(depset2) # deprecated
The recommended solution is to use the depset constructor:
depset(transtive=[depset1, depset2])
See the depset documentation for more information.
--incompatible_depset_unionfalseWhen the flag is set to true, string objects are not treated as iterable. This affects for loops and many functions, e.g. list, tuple, min, max, sorted, all, and any. String iteration has been a source of errors and confusion, such as this error:
def my_macro(name, srcs): for src in srcs: # do something with src # equivalent to: my_macro("hello", ["f", "o", "o", ".", "c", "c"]) my_macro( name = "hello", srcs = "foo.cc", )
String indexing and len are still allowed. If you need to iterate over a string, you may explicitly use:
my_string = "hello world" for i in range(len(my_string)): char = my_string[i] # do something with char
--incompatible_string_is_not_iterablefalse//Integer division operator is now // instead of /. This aligns with Python 3 and it highlights the fact it is a floor division.
x = 7 / 2 # deprecated x = 7 // 2 # x is 3
--incompatible_disallow_slash_operatorfalseThe current package name should be retrieved by calling package_name() in BUILD files or native.package_name() in .bzl files. The old way of referring to the magic PACKAGE_NAME variable bends the language since it is neither a parameter, local variable, nor global variable.
Likewise, the magic REPOSITORY_NAME variable is replaced by repository_name() and native.repository_name(). Both deprecations use the same flag.
--incompatible_package_name_is_a_functiontrueThe FileType function is going away. The main use-case was as an argument to the rule function. It's no longer needed, you can simply pass a list of strings to restrict the file types the rule accepts.
--incompatible_disallow_filetypefalseThis change removes the old methods for registering actions within rules, and requires that you use the new methods instead. The deprecated methods and their replacements are as follows.
ctx.new_file(...) --> ctx.actions.declare_file(...)ctx.experimental_new_directory(...) --> ctx.actions.declare_directory(...)ctx.action(...) --> either ctx.actions.run(...) or ctx.actions.run_shell(...)ctx.file_action(...) --> ctx.actions.write(...)ctx.empty_action(...) --> ctx.actions.do_nothing(...)ctx.template_action(...) --> ctx.actions.expand_template(...)--incompatible_new_actions_apifalseThe Args object returned by ctx.actions.args() has dedicated methods for appending the contents of a list or depset to the command line. Previously these use cases were lumped into its add() method, resulting in a more cluttered API.
With this flag, add() only works for scalar values, and its deprecated parameters are disabled. To add many arguments at once you must use add_all() or add_joined() instead.
--incompatible_disallow_old_style_args_addfalseWhen set, the result of range(...) function is a lazy range type instead of a list. Because of this repetitions using * operator are no longer supported and range slices are also lazy range instances.
--incompatible_range_typefalseThis flag disables certain deprecated resource fields on ObjcProvider.
--incompatible_objc_provider_resourcesfalseWhen set, the native git_repository and new_git_repository rules are disabled. The Starlark versions
load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository", "new_git_repository")
should be used instead. These are drop-in replacements of the corresponding native rules, however with the additional requirement that all label arguments be provided as a fully qualified label (usually starting with @//), for example: build_file = "@//third_party:repo.BUILD".
--incompatible_remove_native_git_repositoryfalseWhen set, the native http_archive and all related rules are disabled. The Starlark version
load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
should be used instead. This is a drop-in replacement, however with the additional requirement that all label arguments be provided as fully qualified labels (usually starting with @//). The Starlark http_archive is also a drop-in replacement for the native new_http_archive (with the same proviso). http.bzl also provides http_jar and http_file (the latter only supports the urls parameter, not url).
--incompatible_remove_native_http_archivefalseWhen set, java_common.create_provider and certain arguments to JavaInfo are deprecated. The deprecated arguments are: actions, sources, source_jars, use_ijar, java_toolchain, and host_javabase.
Example migration from create_provider:
# Before provider = java_common.create_provider( ctx.actions, compile_time_jars = [output_jar], use_ijar = True, java_toolchain = ctx.attr._java_toolchain, transitive_compile_time_jars = transitive_compile_time, transitive_runtime_jars = transitive_runtime_jars, ) # After compile_jar = java_common.run_ijar( ctx.actions, jar = output_jar, target_label = ctx.label, java_toolchain = ctx.attr._java_toolchain, ) provider = JavaInfo( output_jar = output_jar, compile_jar = compile_jar, deps = deps, runtime_deps = runtime_deps, )
Example migration from deprecated JavaInfo arguments:
# Before provider = JavaInfo( output_jar = my_jar, use_ijar = True, sources = my_sources, deps = my_compile_deps, runtime_deps = my_runtime_deps, actions = ctx.actions, java_toolchain = my_java_toolchain, host_javabase = my_host_javabase, ) # After my_ijar = java_common.run_ijar( ctx.actions, jar = my_jar, target_label = ctx.label, java_toolchain, my_java_toolchain, ) my_source_jar = java_common.pack_sources( ctx.actions, sources = my_sources, java_toolchain = my_java_toolchain, host_javabase = my_host_javabase, ) provider = JavaInfo( output_jar = my_jar, compile_jar = my_ijar, source_jar = my_source_jar, deps = my_compile_deps, runtime_deps = my_runtime_deps, )
A tool is an input coming from an attribute of type label where the attribute has been marked executable = True. In order for an action to run a tool, it needs access to its runfiles.
Under the old API, tools are passed to ctx.actions.run() and ctx.actions.run_shell() via their inputs parameter. Bazel scans this argument (which may be a large depset) to find all the inputs that are tools, and adds their runfiles automatically.
In the new API, tools are instead passed to a dedicated tools parameter. The inputs are not scanned. If a tool is accidentally put in inputs instead of tools, the action will fail during the execution phase with an error due to missing runfiles. This may be somewhat cryptic.
To support a gradual transition, all actions with a tools argument are opted into the new API, while all actions without a tools argument still follow the old one. In the future (when this flag is removed), all actions will use the new API unconditionally.
This flag turns on a safety check that is useful for migrating existing code. The safety check applies to all actions that do not have a tools argument. It scans the inputs looking for tools, and if it finds any, it raises an error during the analysis phase that clearly identifies the offending tools.
In the rare case that your action requires a tool as input, but does not actually run the tool and therefore does not need its runfiles, the safety check will fail even though the action would have succeeded. In this case, you can bypass the check by adding a (possibly empty) tools argument to your action. Note that once an action has been modified to take a tools argument, you will no longer get helpful analysis-time errors for any remaining tools that should have been migrated from inputs.
--incompatible_no_support_tools_in_action_inputsfalsePreviously, directories created by ctx.actions.declare_directory expanded to the path of the directory when added to an Args object.
With this flag enabled, directories are instead replaced by the full file contents of that directory when passed to args.add_all() or args.add_joined(). (Directories may not be passed to args.add().)
If you want the old behavior on a case-by-case basis (perhaps your tool can handle directories on the command line), you can pass expand_directories=False to the args.add_all() or args.add_joined() call.
d = ctx.action.declare_directory(“dir”)
# ... Some action runs and produces [“dir/file1”, “dir/file2”] ...
f = ctx.action.declare_file(“file”)
args = ctx.action.args()
args.add_all([d, f])
-> Used to expand to ["dir", "file"]
Now expands to [“dir/file1”, “dir/file2”, “file”]
--incompatible_expand_directoriesfalseWhen the flag is set, use a saner way to resolve variables. The previous behavior was buggy in a number of subtle ways. See the proposal for background and examples.
The proposal is not fully implemented yet.
--incompatible_static_name_resolutionfalseIf false, Bazel constructs an in-memory //tools/defaults package based on the command line options. If true, //tools/defaults:* is resolved from file system as a regular package.
--incompatible_disable_tools_defaults_packagefalse//tools/default was initially created as virtual in-memory package. It generates content dynamically based on current configuration. There is no need of having //tools/defaults any more as LateBoundAlias can do dynamic configuration-based label resolving. Also, having //tools/default makes negative impact on performance, and introduces unnecessary code complexity.
All references to //tools/defaults:* targets should be removed or replaced to corresponding target in @bazel_tools//tools/jdk: and @bazel_tools//tools/cpp: packages.
Targets in //tools/default will not exist any more. If you have any references inside your BUILD or *.bzl files to any of its, then bazel will fail to resolve.
Please replace all occurrences:
//tools/defaults:jdk@bazel_tools//tools/jdk:current_java_runtime@bazel_tools//tools/jdk:current_host_java_runtime//tools/defaults:java_toolchain@bazel_tools//tools/jdk:current_java_toolchain//tools/defaults:crosstool@bazel_tools//tools/cpp:current_cc_toolchain@bazel_tools//tools/cpp:current_cc_host_toolchain@bazel_tools//tools/cpp:current_libc_topThese targets will not be supported any more:
//tools/defaults:coverage_report_generator//tools/defaults:coverage_supportIf true, Bazel will stop retrieving the value of compiler from the cpp configuration when --compiler is not specified. This will cause a config_setting that have values = {"compiler": "x"} to not work properly when --compiler is not specified at command line.
The former behavior can be achieved by changing the config_setting to use flag_values = {"@bazel_tools/tools/cpp:compiler": "x"} instead:
# Before config_setting( name = "cpu_x_compiler_y", values = { "cpu": "x", "compiler": "y", }, ) # After config_setting( name = "cpu_x_compiler_y", values = { "cpu": "x", }, flag_values = { "@bazel_tools/tools/cpp:compiler": "y", }, )
--incompatible_disable_late_bound_option_defaultsfalse0.18.0