fork/rules_rust

git clone https://git.julia.blue/fork/rules_rust

UebelAndreMigrate all settings labels from aliases to using settings package (#3032)c3d71edd

cleanup
97.7 KiB2271 linesraw
1# Copyright 2018 The Bazel Authors. All rights reserved.
2#
3# Licensed under the Apache License, Version 2.0 (the "License");
4# you may not use this file except in compliance with the License.
5# You may obtain a copy of the License at
6#
7#    http://www.apache.org/licenses/LICENSE-2.0
8#
9# Unless required by applicable law or agreed to in writing, software
10# distributed under the License is distributed on an "AS IS" BASIS,
11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12# See the License for the specific language governing permissions and
13# limitations under the License.
14
15"""Functionality for constructing actions that invoke the Rust compiler"""
16
17load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
18load(
19    "@bazel_tools//tools/build_defs/cc:action_names.bzl",
20    "CPP_LINK_DYNAMIC_LIBRARY_ACTION_NAME",
21    "CPP_LINK_EXECUTABLE_ACTION_NAME",
22    "CPP_LINK_NODEPS_DYNAMIC_LIBRARY_ACTION_NAME",
23    "CPP_LINK_STATIC_LIBRARY_ACTION_NAME",
24)
25load("//rust/private:common.bzl", "rust_common")
26load("//rust/private:providers.bzl", "RustcOutputDiagnosticsInfo", _BuildInfo = "BuildInfo")
27load("//rust/private:stamp.bzl", "is_stamping_enabled")
28load(
29    "//rust/private:utils.bzl",
30    "abs",
31    "expand_dict_value_locations",
32    "expand_list_element_locations",
33    "find_cc_toolchain",
34    "get_lib_name_default",
35    "get_lib_name_for_windows",
36    "get_preferred_artifact",
37    "is_exec_configuration",
38    "make_static_lib_symlink",
39    "relativize",
40)
41load(":utils.bzl", "is_std_dylib")
42
43# This feature is disabled unless one of the dependencies is a cc_library.
44# Authors of C++ toolchains can place linker flags that should only be applied
45# when linking with C objects in a feature with this name, or require this
46# feature from other features which needs to be disabled together.
47RUST_LINK_CC_FEATURE = "rules_rust_link_cc"
48
49BuildInfo = _BuildInfo
50
51AliasableDepInfo = provider(
52    doc = "A provider mapping an alias name to a Crate's information.",
53    fields = {
54        "dep": "CrateInfo",
55        "name": "str",
56    },
57)
58
59_error_format_values = ["human", "json", "short"]
60
61ErrorFormatInfo = provider(
62    doc = "Set the --error-format flag for all rustc invocations",
63    fields = {"error_format": "(string) [" + ", ".join(_error_format_values) + "]"},
64)
65
66ExtraRustcFlagsInfo = provider(
67    doc = "Pass each value as an additional flag to non-exec rustc invocations",
68    fields = {"extra_rustc_flags": "List[string] Extra flags to pass to rustc in non-exec configuration"},
69)
70
71ExtraExecRustcFlagsInfo = provider(
72    doc = "Pass each value as an additional flag to exec rustc invocations",
73    fields = {"extra_exec_rustc_flags": "List[string] Extra flags to pass to rustc in exec configuration"},
74)
75
76PerCrateRustcFlagsInfo = provider(
77    doc = "Pass each value as an additional flag to non-exec rustc invocations for crates matching the provided filter",
78    fields = {"per_crate_rustc_flags": "List[string] Extra flags to pass to rustc in non-exec configuration"},
79)
80
81IsProcMacroDepInfo = provider(
82    doc = "Records if this is a transitive dependency of a proc-macro.",
83    fields = {"is_proc_macro_dep": "Boolean"},
84)
85
86def _is_proc_macro_dep_impl(ctx):
87    return IsProcMacroDepInfo(is_proc_macro_dep = ctx.build_setting_value)
88
89is_proc_macro_dep = rule(
90    doc = "Records if this is a transitive dependency of a proc-macro.",
91    implementation = _is_proc_macro_dep_impl,
92    build_setting = config.bool(flag = True),
93)
94
95IsProcMacroDepEnabledInfo = provider(
96    doc = "Enables the feature to record if a library is a transitive dependency of a proc-macro.",
97    fields = {"enabled": "Boolean"},
98)
99
100def _is_proc_macro_dep_enabled_impl(ctx):
101    return IsProcMacroDepEnabledInfo(enabled = ctx.build_setting_value)
102
103is_proc_macro_dep_enabled = rule(
104    doc = "Enables the feature to record if a library is a transitive dependency of a proc-macro.",
105    implementation = _is_proc_macro_dep_enabled_impl,
106    build_setting = config.bool(flag = True),
107)
108
109def _get_rustc_env(attr, toolchain, crate_name):
110    """Gathers rustc environment variables
111
112    Args:
113        attr (struct): The current target's attributes
114        toolchain (rust_toolchain): The current target's rust toolchain context
115        crate_name (str): The name of the crate to be compiled
116
117    Returns:
118        dict: Rustc environment variables
119    """
120    version = attr.version if hasattr(attr, "version") else "0.0.0"
121    major, minor, patch = version.split(".", 2)
122    if "-" in patch:
123        patch, pre = patch.split("-", 1)
124    else:
125        pre = ""
126
127    result = {
128        "CARGO_CFG_TARGET_ARCH": "" if toolchain.target_arch == None else toolchain.target_arch,
129        "CARGO_CFG_TARGET_OS": "" if toolchain.target_os == None else toolchain.target_os,
130        "CARGO_CRATE_NAME": crate_name,
131        "CARGO_PKG_AUTHORS": "",
132        "CARGO_PKG_DESCRIPTION": "",
133        "CARGO_PKG_HOMEPAGE": "",
134        "CARGO_PKG_NAME": attr.name,
135        "CARGO_PKG_VERSION": version,
136        "CARGO_PKG_VERSION_MAJOR": major,
137        "CARGO_PKG_VERSION_MINOR": minor,
138        "CARGO_PKG_VERSION_PATCH": patch,
139        "CARGO_PKG_VERSION_PRE": pre,
140    }
141    if hasattr(attr, "_is_proc_macro_dep_enabled") and attr._is_proc_macro_dep_enabled[IsProcMacroDepEnabledInfo].enabled:
142        is_proc_macro_dep = "0"
143        if hasattr(attr, "_is_proc_macro_dep") and attr._is_proc_macro_dep[IsProcMacroDepInfo].is_proc_macro_dep:
144            is_proc_macro_dep = "1"
145        result["BAZEL_RULES_RUST_IS_PROC_MACRO_DEP"] = is_proc_macro_dep
146    return result
147
148def get_compilation_mode_opts(ctx, toolchain):
149    """Gathers rustc flags for the current compilation mode (opt/debug)
150
151    Args:
152        ctx (ctx): The current rule's context object
153        toolchain (rust_toolchain): The current rule's `rust_toolchain`
154
155    Returns:
156        struct: See `_rust_toolchain_impl` for more details
157    """
158    comp_mode = ctx.var["COMPILATION_MODE"]
159    if not comp_mode in toolchain.compilation_mode_opts:
160        fail("Unrecognized compilation mode {} for toolchain.".format(comp_mode))
161
162    return toolchain.compilation_mode_opts[comp_mode]
163
164def _are_linkstamps_supported(feature_configuration, has_grep_includes):
165    # Are linkstamps supported by the C++ toolchain?
166    return (cc_common.is_enabled(feature_configuration = feature_configuration, feature_name = "linkstamps") and
167            # Is Bazel recent enough to support Starlark linkstamps?
168            hasattr(cc_common, "register_linkstamp_compile_action") and
169            # The current rule doesn't define _grep_includes attribute; this
170            # attribute is required for compiling linkstamps.
171            has_grep_includes)
172
173def _should_use_pic(cc_toolchain, feature_configuration, crate_type, compilation_mode):
174    """Whether or not [PIC][pic] should be enabled
175
176    [pic]: https://en.wikipedia.org/wiki/Position-independent_code
177
178    Args:
179        cc_toolchain (CcToolchainInfo): The current `cc_toolchain`.
180        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
181        crate_type (str): A Rust target's crate type.
182        compilation_mode: The compilation mode.
183
184    Returns:
185        bool: Whether or not [PIC][pic] should be enabled.
186    """
187
188    # We use the same logic to select between `pic` and `nopic` outputs as the C++ rules:
189    # - For shared libraries - we use `pic`. This covers `dylib`, `cdylib` and `proc-macro` crate types.
190    # - In `fastbuild` and `dbg` mode we use `pic` by default.
191    # - In `opt` mode we use `nopic` outputs to build binaries.
192    if crate_type in ("cdylib", "dylib", "proc-macro"):
193        return cc_toolchain.needs_pic_for_dynamic_libraries(feature_configuration = feature_configuration)
194    elif compilation_mode in ("fastbuild", "dbg"):
195        return True
196    return False
197
198def _is_proc_macro(crate_info):
199    return "proc-macro" in (crate_info.type, crate_info.wrapped_crate_type)
200
201def collect_deps(
202        deps,
203        proc_macro_deps,
204        aliases):
205    """Walks through dependencies and collects the transitive dependencies.
206
207    Args:
208        deps (list): The deps from ctx.attr.deps.
209        proc_macro_deps (list): The proc_macro deps from ctx.attr.proc_macro_deps.
210        aliases (dict): A dict mapping aliased targets to their actual Crate information.
211
212    Returns:
213        tuple: Returns a tuple of:
214            DepInfo,
215            BuildInfo,
216            linkstamps (depset[CcLinkstamp]): A depset of CcLinkstamps that need to be compiled and linked into all linked binaries when applicable.
217
218    """
219    direct_crates = []
220    transitive_crates = []
221    transitive_data = []
222    transitive_proc_macro_data = []
223    transitive_noncrates = []
224    transitive_build_infos = []
225    transitive_link_search_paths = []
226    build_info = None
227    linkstamps = []
228    transitive_crate_outputs = []
229    transitive_metadata_outputs = []
230
231    crate_deps = []
232    for dep in depset(transitive = [deps, proc_macro_deps]).to_list():
233        crate_group = None
234
235        if type(dep) == "Target" and rust_common.crate_group_info in dep:
236            crate_group = dep[rust_common.crate_group_info]
237        elif type(dep) == "struct" and hasattr(dep, "crate_group_info") and dep.crate_group_info != None:
238            crate_group = dep.crate_group_info
239        else:
240            crate_deps.append(dep)
241
242        if crate_group:
243            for dep_variant_info in crate_group.dep_variant_infos.to_list():
244                crate_deps.append(struct(
245                    crate_info = dep_variant_info.crate_info,
246                    dep_info = dep_variant_info.dep_info,
247                    cc_info = dep_variant_info.cc_info,
248                ))
249
250    aliases = {k.label: v for k, v in aliases.items()}
251    for dep in crate_deps:
252        (crate_info, dep_info) = _get_crate_and_dep_info(dep)
253        cc_info = _get_cc_info(dep)
254        dep_build_info = _get_build_info(dep)
255
256        if cc_info:
257            linkstamps.append(cc_info.linking_context.linkstamps())
258
259        if crate_info:
260            # This dependency is a rust_library
261
262            # When crate_info.owner is set, we use it. When the dep type is Target we get the
263            # label from dep.label
264            owner = getattr(crate_info, "owner", dep.label if type(dep) == "Target" else None)
265
266            direct_crates.append(AliasableDepInfo(
267                name = aliases.get(owner, crate_info.name),
268                dep = crate_info,
269            ))
270
271            transitive_crates.append(
272                depset(
273                    [crate_info],
274                    transitive = [] if _is_proc_macro(crate_info) else [dep_info.transitive_crates],
275                ),
276            )
277
278            if _is_proc_macro(crate_info):
279                # This crate's data and its non-macro dependencies' data are proc macro data.
280                transitive_proc_macro_data.append(crate_info.data)
281                transitive_proc_macro_data.append(dep_info.transitive_data)
282            else:
283                # This crate's proc macro dependencies' data are proc macro data.
284                transitive_proc_macro_data.append(dep_info.transitive_proc_macro_data)
285
286                # Track transitive non-macro data in case a proc macro depends on this crate.
287                transitive_data.append(crate_info.data)
288                transitive_data.append(dep_info.transitive_data)
289
290            # If this dependency produces metadata, add it to the metadata outputs.
291            # If it doesn't (for example a custom library that exports crate_info),
292            # we depend on crate_info.output.
293            depend_on = crate_info.metadata
294            if not crate_info.metadata:
295                depend_on = crate_info.output
296
297            # If this dependency is a proc_macro, it still can be used for lib crates
298            # that produce metadata.
299            # In that case, we don't depend on its metadata dependencies.
300            transitive_metadata_outputs.append(
301                depset(
302                    [depend_on],
303                    transitive = [] if _is_proc_macro(crate_info) else [dep_info.transitive_metadata_outputs],
304                ),
305            )
306
307            transitive_crate_outputs.append(
308                depset(
309                    [crate_info.output],
310                    transitive = [] if _is_proc_macro(crate_info) else [dep_info.transitive_crate_outputs],
311                ),
312            )
313
314            if "proc-macro" not in [crate_info.type, crate_info.wrapped_crate_type]:
315                transitive_noncrates.append(dep_info.transitive_noncrates)
316                transitive_link_search_paths.append(dep_info.link_search_path_files)
317
318            transitive_build_infos.append(dep_info.transitive_build_infos)
319        elif cc_info or dep_build_info:
320            if cc_info:
321                # This dependency is a cc_library
322                transitive_noncrates.append(cc_info.linking_context.linker_inputs)
323
324            if dep_build_info:
325                if build_info:
326                    fail("Several deps are providing build information, " +
327                         "only one is allowed in the dependencies")
328                build_info = dep_build_info
329                transitive_build_infos.append(depset([build_info]))
330                if build_info.link_search_paths:
331                    transitive_link_search_paths.append(depset([build_info.link_search_paths]))
332                transitive_data.append(build_info.compile_data)
333        else:
334            fail("rust targets can only depend on rust_library, rust_*_library or cc_library " +
335                 "targets.")
336
337    transitive_crates_depset = depset(transitive = transitive_crates)
338    transitive_data_depset = depset(transitive = transitive_data)
339    transitive_proc_macro_data_depset = depset(transitive = transitive_proc_macro_data)
340
341    return (
342        rust_common.dep_info(
343            direct_crates = depset(direct_crates),
344            transitive_crates = transitive_crates_depset,
345            transitive_data = transitive_data_depset,
346            transitive_proc_macro_data = transitive_proc_macro_data_depset,
347            transitive_noncrates = depset(
348                transitive = transitive_noncrates,
349                order = "topological",  # dylib link flag ordering matters.
350            ),
351            transitive_crate_outputs = depset(transitive = transitive_crate_outputs),
352            transitive_metadata_outputs = depset(transitive = transitive_metadata_outputs),
353            transitive_build_infos = depset(transitive = transitive_build_infos),
354            link_search_path_files = depset(transitive = transitive_link_search_paths),
355            dep_env = build_info.dep_env if build_info else None,
356        ),
357        build_info,
358        depset(transitive = linkstamps),
359    )
360
361def _collect_libs_from_linker_inputs(linker_inputs, use_pic):
362    # TODO: We could let the user choose how to link, instead of always preferring to link static libraries.
363    return [
364        get_preferred_artifact(lib, use_pic)
365        for li in linker_inputs
366        for lib in li.libraries
367    ]
368
369def _get_crate_and_dep_info(dep):
370    if type(dep) == "Target" and rust_common.crate_info in dep:
371        return (dep[rust_common.crate_info], dep[rust_common.dep_info])
372    elif type(dep) == "struct" and hasattr(dep, "crate_info"):
373        return (dep.crate_info, dep.dep_info)
374    return (None, None)
375
376def _get_cc_info(dep):
377    if type(dep) == "Target" and CcInfo in dep:
378        return dep[CcInfo]
379    elif type(dep) == "struct" and hasattr(dep, "cc_info"):
380        return dep.cc_info
381    return None
382
383def _get_build_info(dep):
384    if type(dep) == "Target" and BuildInfo in dep:
385        return dep[BuildInfo]
386    elif type(dep) == "struct" and hasattr(dep, "build_info"):
387        return dep.build_info
388    return None
389
390def get_cc_user_link_flags(ctx):
391    """Get the current target's linkopt flags
392
393    Args:
394        ctx (ctx): The current rule's context object
395
396    Returns:
397        depset: The flags passed to Bazel by --linkopt option.
398    """
399    return ctx.fragments.cpp.linkopts
400
401def get_linker_and_args(ctx, crate_type, cc_toolchain, feature_configuration, rpaths, add_flags_for_binary = False):
402    """Gathers cc_common linker information
403
404    Args:
405        ctx (ctx): The current target's context object
406        crate_type (str): The target crate's type (i.e. "bin", "proc-macro", etc.).
407        cc_toolchain (CcToolchain): cc_toolchain for which we are creating build variables.
408        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
409        rpaths (depset): Depset of directories where loader will look for libraries at runtime.
410        add_flags_for_binary (bool, optional): Whether to add "bin" link flags to the command regardless of `crate_type`.
411
412
413    Returns:
414        tuple: A tuple of the following items:
415            - (str): The tool path for given action.
416            - (sequence): A flattened command line flags for given action.
417            - (dict): Environment variables to be set for given action.
418    """
419    user_link_flags = get_cc_user_link_flags(ctx)
420
421    if crate_type in ("bin") or add_flags_for_binary:
422        is_linking_dynamic_library = False
423        action_name = CPP_LINK_EXECUTABLE_ACTION_NAME
424    elif crate_type in ("dylib"):
425        is_linking_dynamic_library = True
426        action_name = CPP_LINK_NODEPS_DYNAMIC_LIBRARY_ACTION_NAME
427    elif crate_type in ("staticlib"):
428        is_linking_dynamic_library = False
429        action_name = CPP_LINK_STATIC_LIBRARY_ACTION_NAME
430    elif crate_type in ("cdylib", "proc-macro"):
431        # Proc macros get compiled as shared libraries to be loaded by the compiler.
432        is_linking_dynamic_library = True
433        action_name = CPP_LINK_DYNAMIC_LIBRARY_ACTION_NAME
434    elif crate_type in ("lib", "rlib"):
435        fail("Invalid `crate_type` for linking action: {}".format(crate_type))
436    else:
437        fail("Unknown `crate_type`: {}".format(crate_type))
438
439    link_variables = cc_common.create_link_variables(
440        feature_configuration = feature_configuration,
441        cc_toolchain = cc_toolchain,
442        is_linking_dynamic_library = is_linking_dynamic_library,
443        runtime_library_search_directories = rpaths,
444        user_link_flags = user_link_flags,
445    )
446    link_args = cc_common.get_memory_inefficient_command_line(
447        feature_configuration = feature_configuration,
448        action_name = action_name,
449        variables = link_variables,
450    )
451    link_env = cc_common.get_environment_variables(
452        feature_configuration = feature_configuration,
453        action_name = action_name,
454        variables = link_variables,
455    )
456    ld = cc_common.get_tool_for_action(
457        feature_configuration = feature_configuration,
458        action_name = action_name,
459    )
460
461    return ld, link_args, link_env
462
463def _process_build_scripts(
464        build_info,
465        dep_info,
466        include_link_flags = True):
467    """Gathers the outputs from a target's `cargo_build_script` action.
468
469    Args:
470        build_info (BuildInfo): The target Build's dependency info.
471        dep_info (DepInfo): The Depinfo provider form the target Crate's set of inputs.
472        include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
473
474    Returns:
475        tuple: A tuple: A tuple of the following items:
476            - (depset[File]): A list of all build info `OUT_DIR` File objects
477            - (str): The `OUT_DIR` of the current build info
478            - (File): An optional path to a generated environment file from a `cargo_build_script` target
479            - (depset[File]): All direct and transitive build flags from the current build info.
480    """
481    extra_inputs, out_dir, build_env_file, build_flags_files = _create_extra_input_args(build_info, dep_info, include_link_flags = include_link_flags)
482    return extra_inputs, out_dir, build_env_file, build_flags_files
483
484def _symlink_for_ambiguous_lib(actions, toolchain, crate_info, lib):
485    """Constructs a disambiguating symlink for a library dependency.
486
487    Args:
488      actions (Actions): The rule's context actions object.
489      toolchain: The Rust toolchain object.
490      crate_info (CrateInfo): The target crate's info.
491      lib (File): The library to symlink to.
492
493    Returns:
494      (File): The disambiguating symlink for the library.
495    """
496    # FIXME: Once the relative order part of the native-link-modifiers rustc
497    # feature is stable, we should be able to eliminate the need to construct
498    # symlinks by passing the full paths to the libraries.
499    # https://github.com/rust-lang/rust/issues/81490.
500
501    # Take the absolute value of hash() since it could be negative.
502    path_hash = abs(hash(lib.path))
503    lib_name = get_lib_name_for_windows(lib) if toolchain.target_os.startswith("windows") else get_lib_name_default(lib)
504
505    if toolchain.target_os.startswith("windows"):
506        prefix = ""
507        extension = ".lib"
508    elif lib_name.endswith(".pic"):
509        # Strip the .pic suffix
510        lib_name = lib_name[:-4]
511        prefix = "lib"
512        extension = ".pic.a"
513    else:
514        prefix = "lib"
515        extension = ".a"
516
517    # Ensure the symlink follows the lib<name>.a pattern on Unix-like platforms
518    # or <name>.lib on Windows.
519    # Add a hash of the original library path to disambiguate libraries with the same basename.
520    symlink_name = "{}{}-{}{}".format(prefix, lib_name, path_hash, extension)
521
522    # Add the symlink to a target crate-specific _ambiguous_libs/ subfolder,
523    # to avoid possible collisions with sibling crates that may depend on the
524    # same ambiguous libraries.
525    symlink = actions.declare_file("_ambiguous_libs/" + crate_info.output.basename + "/" + symlink_name)
526    actions.symlink(
527        output = symlink,
528        target_file = lib,
529        progress_message = "Creating symlink to ambiguous lib: {}".format(lib.path),
530    )
531    return symlink
532
533def _disambiguate_libs(actions, toolchain, crate_info, dep_info, use_pic):
534    """Constructs disambiguating symlinks for ambiguous library dependencies.
535
536    The symlinks are all created in a _ambiguous_libs/ subfolder specific to
537    the target crate to avoid possible collisions with sibling crates that may
538    depend on the same ambiguous libraries.
539
540    Args:
541      actions (Actions): The rule's context actions object.
542      toolchain: The Rust toolchain object.
543      crate_info (CrateInfo): The target crate's info.
544      dep_info: (DepInfo): The target crate's dependency info.
545      use_pic: (boolean): Whether the build should use PIC.
546
547    Returns:
548      dict[String, File]: A mapping from ambiguous library paths to their
549        disambiguating symlink.
550    """
551    # FIXME: Once the relative order part of the native-link-modifiers rustc
552    # feature is stable, we should be able to eliminate the need to construct
553    # symlinks by passing the full paths to the libraries.
554    # https://github.com/rust-lang/rust/issues/81490.
555
556    # A dictionary from file paths of ambiguous libraries to the corresponding
557    # symlink.
558    ambiguous_libs = {}
559
560    # A dictionary maintaining a mapping from preferred library name to the
561    # last visited artifact with that name.
562    visited_libs = {}
563    for link_input in dep_info.transitive_noncrates.to_list():
564        for lib in link_input.libraries:
565            # FIXME: Dynamic libs are not disambiguated right now, there are
566            # cases where those have a non-standard name with version (e.g.,
567            # //test/unit/versioned_libs). We hope that the link modifiers
568            # stabilization will come before we need to make this work.
569            if _is_dylib(lib):
570                continue
571            artifact = get_preferred_artifact(lib, use_pic)
572            name = get_lib_name_for_windows(artifact) if toolchain.target_os.startswith("windows") else get_lib_name_default(artifact)
573
574            # On Linux-like platforms, normally library base names start with
575            # `lib`, following the pattern `lib[name].(a|lo)` and we pass
576            # -lstatic=name.
577            # On Windows, the base name looks like `name.lib` and we pass
578            # -lstatic=name.
579            # FIXME: Under the native-link-modifiers unstable rustc feature,
580            # we could use -lstatic:+verbatim instead.
581            needs_symlink_to_standardize_name = (
582                toolchain.target_os.startswith(("linux", "mac", "darwin")) and
583                artifact.basename.endswith(".a") and not artifact.basename.startswith("lib")
584            ) or (
585                toolchain.target_os.startswith("windows") and not artifact.basename.endswith(".lib")
586            )
587
588            # Detect cases where we need to disambiguate library dependencies
589            # by constructing symlinks.
590            if (
591                needs_symlink_to_standardize_name or
592                # We have multiple libraries with the same name.
593                (name in visited_libs and visited_libs[name].path != artifact.path)
594            ):
595                # Disambiguate the previously visited library (if we just detected
596                # that it is ambiguous) and the current library.
597                if name in visited_libs:
598                    old_path = visited_libs[name].path
599                    if old_path not in ambiguous_libs:
600                        ambiguous_libs[old_path] = _symlink_for_ambiguous_lib(actions, toolchain, crate_info, visited_libs[name])
601                ambiguous_libs[artifact.path] = _symlink_for_ambiguous_lib(actions, toolchain, crate_info, artifact)
602
603            visited_libs[name] = artifact
604    return ambiguous_libs
605
606def _depend_on_metadata(crate_info, force_depend_on_objects):
607    """Determines if we can depend on metadata for this crate.
608
609    By default (when pipelining is disabled or when the crate type needs to link against
610    objects) we depend on the set of object files (.rlib).
611    When pipelining is enabled and the crate type supports depending on metadata,
612    we depend on metadata files only (.rmeta).
613    In some rare cases, even if both of those conditions are true, we still want to
614    depend on objects. This is what force_depend_on_objects is.
615
616    Args:
617        crate_info (CrateInfo): The Crate to determine this for.
618        force_depend_on_objects (bool): if set we will not depend on metadata.
619
620    Returns:
621        Whether we can depend on metadata for this crate.
622    """
623    if force_depend_on_objects:
624        return False
625
626    return crate_info.type in ("rlib", "lib")
627
628def collect_inputs(
629        ctx,
630        file,
631        files,
632        linkstamps,
633        toolchain,
634        cc_toolchain,
635        feature_configuration,
636        crate_info,
637        dep_info,
638        build_info,
639        stamp = False,
640        force_depend_on_objects = False,
641        experimental_use_cc_common_link = False,
642        include_link_flags = True):
643    """Gather's the inputs and required input information for a rustc action
644
645    Args:
646        ctx (ctx): The rule's context object.
647        file (struct): A struct containing files defined in label type attributes marked as `allow_single_file`.
648        files (list): A list of all inputs (`ctx.files`).
649        linkstamps (depset): A depset of CcLinkstamps that need to be compiled and linked into all linked binaries.
650        toolchain (rust_toolchain): The current `rust_toolchain`.
651        cc_toolchain (CcToolchainInfo): The current `cc_toolchain`.
652        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
653        crate_info (CrateInfo): The Crate information of the crate to process build scripts for.
654        dep_info (DepInfo): The target Crate's dependency information.
655        build_info (BuildInfo): The target Crate's build settings.
656        stamp (bool, optional): Whether or not workspace status stamping is enabled. For more details see
657            https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
658        force_depend_on_objects (bool, optional): Forces dependencies of this rule to be objects rather than
659            metadata, even for libraries. This is used in rustdoc tests.
660        experimental_use_cc_common_link (bool, optional): Whether rules_rust uses cc_common.link to link
661            rust binaries.
662        include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
663
664    Returns:
665        tuple: A tuple: A tuple of the following items:
666            - (list): A list of all build info `OUT_DIR` File objects
667            - (str): The `OUT_DIR` of the current build info
668            - (File): An optional path to a generated environment file from a `cargo_build_script` target
669            - (depset[File]): All direct and transitive build flag files from the current build info
670            - (list[File]): Linkstamp outputs
671            - (dict[String, File]): Ambiguous libs, see `_disambiguate_libs`.
672    """
673    linker_script = getattr(file, "linker_script") if hasattr(file, "linker_script") else None
674
675    # TODO: As of writing this comment Bazel used Java CcToolchainInfo.
676    # However there is ongoing work to rewrite provider in Starlark.
677    # rules_rust is not coupled with Bazel release. Remove conditional and change to
678    # _linker_files once Starlark CcToolchainInfo is visible to Bazel.
679    # https://github.com/bazelbuild/rules_rust/issues/2425
680    if hasattr(cc_toolchain, "_linker_files"):
681        linker_depset = cc_toolchain._linker_files
682    else:
683        linker_depset = cc_toolchain.linker_files()
684    compilation_mode = ctx.var["COMPILATION_MODE"]
685
686    use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_info.type, compilation_mode)
687
688    # Pass linker inputs only for linking-like actions, not for example where
689    # the output is rlib. This avoids quadratic behavior where transitive noncrates are
690    # flattened on each transitive rust_library dependency.
691    additional_transitive_inputs = []
692    ambiguous_libs = {}
693    if crate_info.type not in ("lib", "rlib"):
694        linker_inputs = dep_info.transitive_noncrates.to_list()
695        ambiguous_libs = _disambiguate_libs(ctx.actions, toolchain, crate_info, dep_info, use_pic)
696        additional_transitive_inputs = _collect_libs_from_linker_inputs(linker_inputs, use_pic) + [
697            additional_input
698            for linker_input in linker_inputs
699            for additional_input in linker_input.additional_inputs
700        ] + ambiguous_libs.values()
701
702    # Compute linkstamps. Use the inputs of the binary as inputs to the
703    # linkstamp action to ensure linkstamps are rebuilt whenever binary inputs
704    # change.
705    linkstamp_outs = []
706
707    transitive_crate_outputs = dep_info.transitive_crate_outputs
708    if _depend_on_metadata(crate_info, force_depend_on_objects):
709        transitive_crate_outputs = dep_info.transitive_metadata_outputs
710
711    build_info_inputs = []
712    if build_info:
713        if build_info.rustc_env:
714            build_info_inputs.append(build_info.rustc_env)
715        if build_info.flags:
716            build_info_inputs.append(build_info.flags)
717
718    # The old default behavior was to include data files at compile time.
719    # This flag controls whether to include data files in compile_data.
720    data_included_in_inputs = []
721    if not toolchain._incompatible_do_not_include_data_in_compile_data:
722        data_included_in_inputs = getattr(files, "data", [])
723
724    nolinkstamp_compile_inputs = depset(
725        data_included_in_inputs +
726        build_info_inputs +
727        ([toolchain.target_json] if toolchain.target_json else []) +
728        ([] if linker_script == None else [linker_script]),
729        transitive = [
730            linker_depset,
731            crate_info.srcs,
732            transitive_crate_outputs,
733            depset(additional_transitive_inputs),
734            crate_info.compile_data,
735            dep_info.transitive_proc_macro_data,
736            toolchain.all_files,
737        ],
738    )
739
740    # Register linkstamps when linking with rustc (when linking with
741    # cc_common.link linkstamps are handled by cc_common.link itself).
742    if not experimental_use_cc_common_link and crate_info.type in ("bin", "cdylib"):
743        # There is no other way to register an action for each member of a depset than
744        # flattening the depset as of 2021-10-12. Luckily, usually there is only one linkstamp
745        # in a build, and we only flatten the list on binary targets that perform transitive linking,
746        # so it's extremely unlikely that this call to `to_list()` will ever be a performance
747        # problem.
748        for linkstamp in linkstamps.to_list():
749            # The linkstamp output path is based on the binary crate
750            # name and the input linkstamp path. This is to disambiguate
751            # the linkstamp outputs produced by multiple binary crates
752            # that depend on the same linkstamp. We use the same pattern
753            # for the output name as the one used by native cc rules.
754            out_name = "_objs/" + crate_info.output.basename + "/" + linkstamp.file().path[:-len(linkstamp.file().extension)] + "o"
755            linkstamp_out = ctx.actions.declare_file(out_name)
756            linkstamp_outs.append(linkstamp_out)
757            cc_common.register_linkstamp_compile_action(
758                actions = ctx.actions,
759                cc_toolchain = cc_toolchain,
760                feature_configuration = feature_configuration,
761                source_file = linkstamp.file(),
762                output_file = linkstamp_out,
763                compilation_inputs = linkstamp.hdrs(),
764                inputs_for_validation = nolinkstamp_compile_inputs,
765                label_replacement = str(ctx.label),
766                output_replacement = crate_info.output.path,
767            )
768
769    # If stamping is enabled include the volatile and stable status info file
770    stamp_info = [ctx.version_file, ctx.info_file] if stamp else []
771
772    compile_inputs = depset(
773        linkstamp_outs + stamp_info,
774        transitive = [
775            nolinkstamp_compile_inputs,
776        ],
777    )
778
779    build_script_compile_inputs, out_dir, build_env_file, build_flags_files = _process_build_scripts(
780        build_info = build_info,
781        dep_info = dep_info,
782        include_link_flags = include_link_flags,
783    )
784
785    # For backwards compatibility, we also check the value of the `rustc_env_files` attribute when
786    # `crate_info.rustc_env_files` is not populated.
787    build_env_files = crate_info.rustc_env_files if crate_info.rustc_env_files else getattr(files, "rustc_env_files", [])
788    if build_env_file:
789        build_env_files = [f for f in build_env_files] + [build_env_file]
790    compile_inputs = depset(build_env_files, transitive = [build_script_compile_inputs, compile_inputs])
791    return compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs
792
793def construct_arguments(
794        ctx,
795        attr,
796        file,
797        toolchain,
798        tool_path,
799        cc_toolchain,
800        feature_configuration,
801        crate_info,
802        dep_info,
803        linkstamp_outs,
804        ambiguous_libs,
805        output_hash,
806        rust_flags,
807        out_dir,
808        build_env_files,
809        build_flags_files,
810        emit = ["dep-info", "link"],
811        force_all_deps_direct = False,
812        add_flags_for_binary = False,
813        include_link_flags = True,
814        stamp = False,
815        remap_path_prefix = "",
816        use_json_output = False,
817        build_metadata = False,
818        force_depend_on_objects = False,
819        skip_expanding_rustc_env = False):
820    """Builds an Args object containing common rustc flags
821
822    Args:
823        ctx (ctx): The rule's context object
824        attr (struct): The attributes for the target. These may be different from ctx.attr in an aspect context.
825        file (struct): A struct containing files defined in label type attributes marked as `allow_single_file`.
826        toolchain (rust_toolchain): The current target's `rust_toolchain`
827        tool_path (str): Path to rustc
828        cc_toolchain (CcToolchain): The CcToolchain for the current target.
829        feature_configuration (FeatureConfiguration): Class used to construct command lines from CROSSTOOL features.
830        crate_info (CrateInfo): The CrateInfo provider of the target crate
831        dep_info (DepInfo): The DepInfo provider of the target crate
832        linkstamp_outs (list): Linkstamp outputs of native dependencies
833        ambiguous_libs (dict): Ambiguous libs, see `_disambiguate_libs`
834        output_hash (str): The hashed path of the crate root
835        rust_flags (list): Additional flags to pass to rustc
836        out_dir (str): The path to the output directory for the target Crate.
837        build_env_files (list): Files containing rustc environment variables, for instance from `cargo_build_script` actions.
838        build_flags_files (depset): The output files of a `cargo_build_script` actions containing rustc build flags
839        emit (list): Values for the --emit flag to rustc.
840        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
841            to the commandline as opposed to -L.
842        add_flags_for_binary (bool, optional): Whether to add "bin" link flags to the command regardless of `emit` and `crate_type`.
843        include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
844        stamp (bool, optional): Whether or not workspace status stamping is enabled. For more details see
845            https://docs.bazel.build/versions/main/user-manual.html#flag--stamp
846        remap_path_prefix (str, optional): A value used to remap `${pwd}` to. If set to None, no prefix will be set.
847        use_json_output (bool): Have rustc emit json and process_wrapper parse json messages to output rendered output.
848        build_metadata (bool): Generate CLI arguments for building *only* .rmeta files. This requires use_json_output.
849        force_depend_on_objects (bool): Force using `.rlib` object files instead of metadata (`.rmeta`) files even if they are available.
850        skip_expanding_rustc_env (bool): Whether to skip expanding CrateInfo.rustc_env_attr
851
852    Returns:
853        tuple: A tuple of the following items
854            - (struct): A struct of arguments used to run the `Rustc` action
855                - process_wrapper_flags (Args): Arguments for the process wrapper
856                - rustc_path (Args): Arguments for invoking rustc via the process wrapper
857                - rustc_flags (Args): Rust flags for the Rust compiler
858                - all (list): A list of all `Args` objects in the order listed above.
859                    This is to be passed to the `arguments` parameter of actions
860            - (dict): Common rustc environment variables
861    """
862    if build_metadata and not use_json_output:
863        fail("build_metadata requires parse_json_output")
864
865    output_dir = getattr(crate_info.output, "dirname", None)
866    linker_script = getattr(file, "linker_script", None)
867
868    env = _get_rustc_env(attr, toolchain, crate_info.name)
869
870    # Wrapper args first
871    process_wrapper_flags = ctx.actions.args()
872
873    for build_env_file in build_env_files:
874        process_wrapper_flags.add("--env-file", build_env_file)
875
876    process_wrapper_flags.add_all(build_flags_files, before_each = "--arg-file")
877
878    # Certain rust build processes expect to find files from the environment
879    # variable `$CARGO_MANIFEST_DIR`. Examples of this include pest, tera,
880    # asakuma.
881    #
882    # The compiler and by extension proc-macros see the current working
883    # directory as the Bazel exec root. This is what `$CARGO_MANIFEST_DIR`
884    # would default to but is often the wrong value (e.g. if the source is in a
885    # sub-package or if we are building something in an external repository).
886    # Hence, we need to set `CARGO_MANIFEST_DIR` explicitly.
887    #
888    # Since we cannot get the `exec_root` from starlark, we cheat a little and
889    # use `${pwd}` which resolves the `exec_root` at action execution time.
890    process_wrapper_flags.add("--subst", "pwd=${pwd}")
891
892    # If stamping is enabled, enable the functionality in the process wrapper
893    if stamp:
894        process_wrapper_flags.add("--volatile-status-file", ctx.version_file)
895        process_wrapper_flags.add("--stable-status-file", ctx.info_file)
896
897    # Both ctx.label.workspace_root and ctx.label.package are relative paths
898    # and either can be empty strings. Avoid trailing/double slashes in the path.
899    components = "${{pwd}}/{}/{}".format(ctx.label.workspace_root, ctx.label.package).split("/")
900    env["CARGO_MANIFEST_DIR"] = "/".join([c for c in components if c])
901
902    if out_dir != None:
903        env["OUT_DIR"] = "${pwd}/" + out_dir
904
905    # Arguments for launching rustc from the process wrapper
906    rustc_path = ctx.actions.args()
907    rustc_path.add("--")
908    rustc_path.add(tool_path)
909
910    # Rustc arguments
911    rustc_flags = ctx.actions.args()
912    rustc_flags.set_param_file_format("multiline")
913    rustc_flags.use_param_file("@%s", use_always = False)
914    rustc_flags.add(crate_info.root)
915    rustc_flags.add(crate_info.name, format = "--crate-name=%s")
916    rustc_flags.add(crate_info.type, format = "--crate-type=%s")
917
918    error_format = "human"
919    if hasattr(attr, "_error_format"):
920        error_format = attr._error_format[ErrorFormatInfo].error_format
921
922    if use_json_output:
923        # If --error-format was set to json, we just pass the output through
924        # Otherwise process_wrapper uses the "rendered" field.
925        process_wrapper_flags.add("--rustc-output-format", "json" if error_format == "json" else "rendered")
926
927        # Configure rustc json output by adding artifact notifications.
928        # These will always be filtered out by process_wrapper and will be use to terminate
929        # rustc when appropriate.
930        json = ["artifacts"]
931        if error_format == "short":
932            json.append("diagnostic-short")
933        elif error_format == "human" and toolchain.target_os != "windows":
934            # If the os is not windows, we can get colorized output.
935            json.append("diagnostic-rendered-ansi")
936
937        rustc_flags.add_joined(json, format_joined = "--json=%s", join_with = ",")
938
939        error_format = "json"
940
941    if build_metadata:
942        # Configure process_wrapper to terminate rustc when metadata are emitted
943        process_wrapper_flags.add("--rustc-quit-on-rmeta", "true")
944        if crate_info.rustc_rmeta_output:
945            process_wrapper_flags.add("--output-file", crate_info.rustc_rmeta_output.path)
946    elif crate_info.rustc_output:
947        process_wrapper_flags.add("--output-file", crate_info.rustc_output.path)
948
949    rustc_flags.add(error_format, format = "--error-format=%s")
950
951    # Mangle symbols to disambiguate crates with the same name. This could
952    # happen only for non-final artifacts where we compute an output_hash,
953    # e.g., rust_library.
954    #
955    # For "final" artifacts and ones intended for distribution outside of
956    # Bazel, such as rust_binary, rust_static_library and rust_shared_library,
957    # where output_hash is None we don't need to add these flags.
958    if output_hash:
959        rustc_flags.add(output_hash, format = "--codegen=metadata=-%s")
960        rustc_flags.add(output_hash, format = "--codegen=extra-filename=-%s")
961
962    if output_dir:
963        rustc_flags.add(output_dir, format = "--out-dir=%s")
964
965    compilation_mode = get_compilation_mode_opts(ctx, toolchain)
966    rustc_flags.add(compilation_mode.opt_level, format = "--codegen=opt-level=%s")
967    rustc_flags.add(compilation_mode.debug_info, format = "--codegen=debuginfo=%s")
968    rustc_flags.add(compilation_mode.strip_level, format = "--codegen=strip=%s")
969
970    # For determinism to help with build distribution and such
971    if remap_path_prefix != None:
972        rustc_flags.add("--remap-path-prefix=${{pwd}}={}".format(remap_path_prefix))
973
974    emit_without_paths = []
975    for kind in emit:
976        if kind == "link" and crate_info.type == "bin" and crate_info.output != None:
977            rustc_flags.add(crate_info.output, format = "--emit=link=%s")
978        else:
979            emit_without_paths.append(kind)
980
981    if emit_without_paths:
982        rustc_flags.add_joined(emit_without_paths, format_joined = "--emit=%s", join_with = ",")
983    if error_format != "json":
984        # Color is not compatible with json output.
985        rustc_flags.add("--color=always")
986    rustc_flags.add(toolchain.target_flag_value, format = "--target=%s")
987    if hasattr(attr, "crate_features"):
988        rustc_flags.add_all(getattr(attr, "crate_features"), before_each = "--cfg", format_each = 'feature="%s"')
989    if linker_script:
990        rustc_flags.add(linker_script, format = "--codegen=link-arg=-T%s")
991
992    # Tell Rustc where to find the standard library (or libcore)
993    rustc_flags.add_all(toolchain.rust_std_paths, before_each = "-L", format_each = "%s")
994    rustc_flags.add_all(rust_flags)
995
996    # Gather data path from crate_info since it is inherited from real crate for rust_doc and rust_test
997    # Deduplicate data paths due to https://github.com/bazelbuild/bazel/issues/14681
998    data_paths = depset(direct = getattr(attr, "data", []), transitive = [crate_info.compile_data_targets]).to_list()
999
1000    add_edition_flags(rustc_flags, crate_info)
1001
1002    # Link!
1003    if ("link" in emit and crate_info.type not in ["rlib", "lib"]) or add_flags_for_binary:
1004        # Rust's built-in linker can handle linking wasm files. We don't want to attempt to use the cc
1005        # linker since it won't understand.
1006        compilation_mode = ctx.var["COMPILATION_MODE"]
1007        if toolchain.target_arch not in ("wasm32", "wasm64"):
1008            if output_dir:
1009                use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_info.type, compilation_mode)
1010                rpaths = _compute_rpaths(toolchain, output_dir, dep_info, use_pic)
1011            else:
1012                rpaths = depset()
1013
1014            ld, link_args, link_env = get_linker_and_args(ctx, crate_info.type, cc_toolchain, feature_configuration, rpaths, add_flags_for_binary = add_flags_for_binary)
1015
1016            env.update(link_env)
1017            rustc_flags.add(ld, format = "--codegen=linker=%s")
1018
1019            # Split link args into individual "--codegen=link-arg=" flags to handle nested spaces.
1020            # Additional context: https://github.com/rust-lang/rust/pull/36574
1021            rustc_flags.add_all(link_args, format_each = "--codegen=link-arg=%s")
1022
1023        _add_native_link_flags(rustc_flags, dep_info, linkstamp_outs, ambiguous_libs, crate_info.type, toolchain, cc_toolchain, feature_configuration, compilation_mode, include_link_flags = include_link_flags)
1024
1025    use_metadata = _depend_on_metadata(crate_info, force_depend_on_objects)
1026
1027    # These always need to be added, even if not linking this crate.
1028    add_crate_link_flags(rustc_flags, dep_info, force_all_deps_direct, use_metadata)
1029
1030    needs_extern_proc_macro_flag = _is_proc_macro(crate_info) and crate_info.edition != "2015"
1031    if needs_extern_proc_macro_flag:
1032        rustc_flags.add("--extern")
1033        rustc_flags.add("proc_macro")
1034
1035    if toolchain.llvm_cov and ctx.configuration.coverage_enabled:
1036        # https://doc.rust-lang.org/rustc/instrument-coverage.html
1037        rustc_flags.add("--codegen=instrument-coverage")
1038
1039    if toolchain._experimental_link_std_dylib:
1040        rustc_flags.add("--codegen=prefer-dynamic")
1041
1042    # Make bin crate data deps available to tests.
1043    for data in getattr(attr, "data", []):
1044        if rust_common.crate_info in data:
1045            dep_crate_info = data[rust_common.crate_info]
1046            if dep_crate_info.type == "bin":
1047                # Trying to make CARGO_BIN_EXE_{} canonical across platform by strip out extension if exists
1048                env_basename = dep_crate_info.output.basename[:-(1 + len(dep_crate_info.output.extension))] if len(dep_crate_info.output.extension) > 0 else dep_crate_info.output.basename
1049                env["CARGO_BIN_EXE_" + env_basename] = dep_crate_info.output.short_path
1050
1051    # Add environment variables from the Rust toolchain.
1052    env.update(toolchain.env)
1053
1054    # Update environment with user provided variables.
1055    if skip_expanding_rustc_env:
1056        env.update(crate_info.rustc_env)
1057    else:
1058        env.update(expand_dict_value_locations(
1059            ctx,
1060            crate_info.rustc_env,
1061            data_paths,
1062            {},
1063        ))
1064
1065    # Ensure the sysroot is set for the target platform
1066    if toolchain._toolchain_generated_sysroot:
1067        rustc_flags.add(toolchain.sysroot, format = "--sysroot=%s")
1068
1069    if toolchain._rename_first_party_crates:
1070        env["RULES_RUST_THIRD_PARTY_DIR"] = toolchain._third_party_dir
1071
1072    if crate_info.type in toolchain.extra_rustc_flags_for_crate_types.keys():
1073        rustc_flags.add_all(toolchain.extra_rustc_flags_for_crate_types[crate_info.type])
1074
1075    if is_exec_configuration(ctx):
1076        rustc_flags.add_all(toolchain.extra_exec_rustc_flags)
1077    else:
1078        rustc_flags.add_all(toolchain.extra_rustc_flags)
1079
1080    # extra_rustc_flags apply to the target configuration, not the exec configuration.
1081    if hasattr(ctx.attr, "_extra_rustc_flags") and not is_exec_configuration(ctx):
1082        rustc_flags.add_all(ctx.attr._extra_rustc_flags[ExtraRustcFlagsInfo].extra_rustc_flags)
1083
1084    if hasattr(ctx.attr, "_extra_rustc_flag") and not is_exec_configuration(ctx):
1085        rustc_flags.add_all(ctx.attr._extra_rustc_flag[ExtraRustcFlagsInfo].extra_rustc_flags)
1086
1087    if hasattr(ctx.attr, "_per_crate_rustc_flag") and not is_exec_configuration(ctx):
1088        per_crate_rustc_flags = ctx.attr._per_crate_rustc_flag[PerCrateRustcFlagsInfo].per_crate_rustc_flags
1089        _add_per_crate_rustc_flags(ctx, rustc_flags, crate_info, per_crate_rustc_flags)
1090
1091    if hasattr(ctx.attr, "_extra_exec_rustc_flags") and is_exec_configuration(ctx):
1092        rustc_flags.add_all(ctx.attr._extra_exec_rustc_flags[ExtraExecRustcFlagsInfo].extra_exec_rustc_flags)
1093
1094    if hasattr(ctx.attr, "_extra_exec_rustc_flag") and is_exec_configuration(ctx):
1095        rustc_flags.add_all(ctx.attr._extra_exec_rustc_flag[ExtraExecRustcFlagsInfo].extra_exec_rustc_flags)
1096
1097    if _is_no_std(ctx, toolchain, crate_info):
1098        rustc_flags.add('--cfg=feature="no_std"')
1099
1100    # Add target specific flags last, so they can override previous flags
1101    rustc_flags.add_all(
1102        expand_list_element_locations(
1103            ctx,
1104            getattr(attr, "rustc_flags", []),
1105            data_paths,
1106            {},
1107        ),
1108    )
1109
1110    # Needed for bzlmod-aware runfiles resolution.
1111    env["REPOSITORY_NAME"] = ctx.label.workspace_name
1112
1113    # Create a struct which keeps the arguments separate so each may be tuned or
1114    # replaced where necessary
1115    args = struct(
1116        process_wrapper_flags = process_wrapper_flags,
1117        rustc_path = rustc_path,
1118        rustc_flags = rustc_flags,
1119        all = [process_wrapper_flags, rustc_path, rustc_flags],
1120    )
1121
1122    return args, env
1123
1124def rustc_compile_action(
1125        ctx,
1126        attr,
1127        toolchain,
1128        rust_flags = [],
1129        output_hash = None,
1130        force_all_deps_direct = False,
1131        crate_info_dict = None,
1132        skip_expanding_rustc_env = False,
1133        include_coverage = True):
1134    """Create and run a rustc compile action based on the current rule's attributes
1135
1136    Args:
1137        ctx (ctx): The rule's context object
1138        attr (struct): Attributes to use for the rust compile action
1139        toolchain (rust_toolchain): The current `rust_toolchain`
1140        output_hash (str, optional): The hashed path of the crate root. Defaults to None.
1141        rust_flags (list, optional): Additional flags to pass to rustc. Defaults to [].
1142        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
1143            to the commandline as opposed to -L.
1144        crate_info_dict: A mutable dict used to create CrateInfo provider
1145        skip_expanding_rustc_env (bool, optional): Whether to expand CrateInfo.rustc_env
1146        include_coverage (bool, optional): Whether to generate coverage information or not.
1147
1148    Returns:
1149        list: A list of the following providers:
1150            - (CrateInfo): info for the crate we just built; same as `crate_info` parameter.
1151            - (DepInfo): The transitive dependencies of this crate.
1152            - (DefaultInfo): The output file for this crate, and its runfiles.
1153    """
1154    crate_info = rust_common.create_crate_info(**crate_info_dict)
1155
1156    build_metadata = crate_info_dict.get("metadata", None)
1157    rustc_output = crate_info_dict.get("rustc_output", None)
1158    rustc_rmeta_output = crate_info_dict.get("rustc_rmeta_output", None)
1159
1160    # Determine whether to use cc_common.link:
1161    #  * either if experimental_use_cc_common_link is 1,
1162    #  * or if experimental_use_cc_common_link is -1 and
1163    #    the toolchain experimental_use_cc_common_link is true.
1164    experimental_use_cc_common_link = False
1165    if hasattr(ctx.attr, "experimental_use_cc_common_link"):
1166        if ctx.attr.experimental_use_cc_common_link == 0:
1167            experimental_use_cc_common_link = False
1168        elif ctx.attr.experimental_use_cc_common_link == 1:
1169            experimental_use_cc_common_link = True
1170        elif ctx.attr.experimental_use_cc_common_link == -1:
1171            experimental_use_cc_common_link = toolchain._experimental_use_cc_common_link
1172
1173    dep_info, build_info, linkstamps = collect_deps(
1174        deps = crate_info_dict["deps"],
1175        proc_macro_deps = crate_info_dict["proc_macro_deps"],
1176        aliases = crate_info_dict["aliases"],
1177    )
1178    extra_disabled_features = [RUST_LINK_CC_FEATURE]
1179    if crate_info.type in ["bin", "cdylib"] and dep_info.transitive_noncrates.to_list():
1180        # One or more of the transitive deps is a cc_library / cc_import
1181        extra_disabled_features = []
1182    cc_toolchain, feature_configuration = find_cc_toolchain(ctx, extra_disabled_features)
1183    if not _are_linkstamps_supported(
1184        feature_configuration = feature_configuration,
1185        has_grep_includes = hasattr(ctx.attr, "_use_grep_includes"),
1186    ):
1187        linkstamps = depset([])
1188
1189    # Determine if the build is currently running with --stamp
1190    stamp = is_stamping_enabled(attr)
1191
1192    compile_inputs, out_dir, build_env_files, build_flags_files, linkstamp_outs, ambiguous_libs = collect_inputs(
1193        ctx = ctx,
1194        file = ctx.file,
1195        files = ctx.files,
1196        linkstamps = linkstamps,
1197        toolchain = toolchain,
1198        cc_toolchain = cc_toolchain,
1199        feature_configuration = feature_configuration,
1200        crate_info = crate_info,
1201        dep_info = dep_info,
1202        build_info = build_info,
1203        stamp = stamp,
1204        experimental_use_cc_common_link = experimental_use_cc_common_link,
1205    )
1206
1207    # The types of rustc outputs to emit.
1208    # If we build metadata, we need to keep the command line of the two invocations
1209    # (rlib and rmeta) as similar as possible, otherwise rustc rejects the rmeta as
1210    # a candidate.
1211    # Because of that we need to add emit=metadata to both the rlib and rmeta invocation.
1212    #
1213    # When cc_common linking is enabled, emit a `.o` file, which is later
1214    # passed to the cc_common.link action.
1215    emit = ["dep-info", "link"]
1216    if build_metadata:
1217        emit.append("metadata")
1218    if experimental_use_cc_common_link:
1219        emit = ["obj"]
1220
1221    args, env_from_args = construct_arguments(
1222        ctx = ctx,
1223        attr = attr,
1224        file = ctx.file,
1225        toolchain = toolchain,
1226        tool_path = toolchain.rustc.path,
1227        cc_toolchain = cc_toolchain,
1228        emit = emit,
1229        feature_configuration = feature_configuration,
1230        crate_info = crate_info,
1231        dep_info = dep_info,
1232        linkstamp_outs = linkstamp_outs,
1233        ambiguous_libs = ambiguous_libs,
1234        output_hash = output_hash,
1235        rust_flags = rust_flags,
1236        out_dir = out_dir,
1237        build_env_files = build_env_files,
1238        build_flags_files = build_flags_files,
1239        force_all_deps_direct = force_all_deps_direct,
1240        stamp = stamp,
1241        use_json_output = bool(build_metadata) or bool(rustc_output) or bool(rustc_rmeta_output),
1242        skip_expanding_rustc_env = skip_expanding_rustc_env,
1243    )
1244
1245    args_metadata = None
1246    if build_metadata:
1247        args_metadata, _ = construct_arguments(
1248            ctx = ctx,
1249            attr = attr,
1250            file = ctx.file,
1251            toolchain = toolchain,
1252            tool_path = toolchain.rustc.path,
1253            cc_toolchain = cc_toolchain,
1254            emit = emit,
1255            feature_configuration = feature_configuration,
1256            crate_info = crate_info,
1257            dep_info = dep_info,
1258            linkstamp_outs = linkstamp_outs,
1259            ambiguous_libs = ambiguous_libs,
1260            output_hash = output_hash,
1261            rust_flags = rust_flags,
1262            out_dir = out_dir,
1263            build_env_files = build_env_files,
1264            build_flags_files = build_flags_files,
1265            force_all_deps_direct = force_all_deps_direct,
1266            stamp = stamp,
1267            use_json_output = True,
1268            build_metadata = True,
1269        )
1270
1271    env = dict(ctx.configuration.default_shell_env)
1272
1273    # this is the final list of env vars
1274    env.update(env_from_args)
1275
1276    if hasattr(attr, "version") and attr.version != "0.0.0":
1277        formatted_version = " v{}".format(attr.version)
1278    else:
1279        formatted_version = ""
1280
1281    # Declares the outputs of the rustc compile action.
1282    # By default this is the binary output; if cc_common.link is used, this is
1283    # the main `.o` file (`output_o` below).
1284    outputs = [crate_info.output]
1285
1286    # The `.o` output file, only used for linking via cc_common.link.
1287    output_o = None
1288    if experimental_use_cc_common_link:
1289        obj_ext = ".o"
1290        output_o = ctx.actions.declare_file(crate_info.name + obj_ext, sibling = crate_info.output)
1291        outputs = [output_o]
1292
1293    # For a cdylib that might be added as a dependency to a cc_* target on Windows, it is important to include the
1294    # interface library that rustc generates in the output files.
1295    interface_library = None
1296    if toolchain.target_os == "windows" and crate_info.type == "cdylib":
1297        # Rustc generates the import library with a `.dll.lib` extension rather than the usual `.lib` one that msvc
1298        # expects (see https://github.com/rust-lang/rust/pull/29520 for more context).
1299        interface_library = ctx.actions.declare_file(crate_info.output.basename + ".lib", sibling = crate_info.output)
1300        outputs.append(interface_library)
1301
1302    # The action might generate extra output that we don't want to include in the `DefaultInfo` files.
1303    action_outputs = list(outputs)
1304    if rustc_output:
1305        action_outputs.append(rustc_output)
1306
1307    # Get the compilation mode for the current target.
1308    compilation_mode = get_compilation_mode_opts(ctx, toolchain)
1309
1310    # Rustc generates a pdb file (on Windows) or a dsym folder (on macos) so provide it in an output group for crate
1311    # types that benefit from having debug information in a separate file.
1312    pdb_file = None
1313    dsym_folder = None
1314    if crate_info.type in ("cdylib", "bin"):
1315        if toolchain.target_os == "windows" and compilation_mode.strip_level == "none":
1316            pdb_file = ctx.actions.declare_file(crate_info.output.basename[:-len(crate_info.output.extension)] + "pdb", sibling = crate_info.output)
1317            action_outputs.append(pdb_file)
1318        elif toolchain.target_os == "darwin":
1319            dsym_folder = ctx.actions.declare_directory(crate_info.output.basename + ".dSYM", sibling = crate_info.output)
1320            action_outputs.append(dsym_folder)
1321
1322    if ctx.executable._process_wrapper:
1323        # Run as normal
1324        ctx.actions.run(
1325            executable = ctx.executable._process_wrapper,
1326            inputs = compile_inputs,
1327            outputs = action_outputs,
1328            env = env,
1329            arguments = args.all,
1330            mnemonic = "Rustc",
1331            progress_message = "Compiling Rust {} {}{} ({} files)".format(
1332                crate_info.type,
1333                ctx.label.name,
1334                formatted_version,
1335                len(crate_info.srcs.to_list()),
1336            ),
1337            toolchain = "@rules_rust//rust:toolchain_type",
1338        )
1339        if args_metadata:
1340            ctx.actions.run(
1341                executable = ctx.executable._process_wrapper,
1342                inputs = compile_inputs,
1343                outputs = [build_metadata] + [x for x in [rustc_rmeta_output] if x],
1344                env = env,
1345                arguments = args_metadata.all,
1346                mnemonic = "RustcMetadata",
1347                progress_message = "Compiling Rust metadata {} {}{} ({} files)".format(
1348                    crate_info.type,
1349                    ctx.label.name,
1350                    formatted_version,
1351                    len(crate_info.srcs.to_list()),
1352                ),
1353                toolchain = "@rules_rust//rust:toolchain_type",
1354            )
1355    elif hasattr(ctx.executable, "_bootstrap_process_wrapper"):
1356        # Run without process_wrapper
1357        if build_env_files or build_flags_files or stamp or build_metadata:
1358            fail("build_env_files, build_flags_files, stamp, build_metadata are not supported when building without process_wrapper")
1359        ctx.actions.run(
1360            executable = ctx.executable._bootstrap_process_wrapper,
1361            inputs = compile_inputs,
1362            outputs = action_outputs,
1363            env = env,
1364            arguments = [args.rustc_path, args.rustc_flags],
1365            mnemonic = "Rustc",
1366            progress_message = "Compiling Rust (without process_wrapper) {} {}{} ({} files)".format(
1367                crate_info.type,
1368                ctx.label.name,
1369                formatted_version,
1370                len(crate_info.srcs.to_list()),
1371            ),
1372            toolchain = "@rules_rust//rust:toolchain_type",
1373        )
1374    else:
1375        fail("No process wrapper was defined for {}".format(ctx.label))
1376
1377    if experimental_use_cc_common_link:
1378        # Wrap the main `.o` file into a compilation output suitable for
1379        # cc_common.link. The main `.o` file is useful in both PIC and non-PIC
1380        # modes.
1381        compilation_outputs = cc_common.create_compilation_outputs(
1382            objects = depset([output_o]),
1383            pic_objects = depset([output_o]),
1384        )
1385
1386        malloc_library = ctx.attr._custom_malloc or ctx.attr.malloc
1387
1388        # Collect the linking contexts of the standard library and dependencies.
1389        linking_contexts = [
1390            malloc_library[CcInfo].linking_context,
1391            _get_std_and_alloc_info(ctx, toolchain, crate_info).linking_context,
1392            toolchain.stdlib_linkflags.linking_context,
1393        ]
1394
1395        for dep in crate_info.deps.to_list():
1396            if dep.cc_info:
1397                linking_contexts.append(dep.cc_info.linking_context)
1398
1399        # In the cc_common.link action we need to pass the name of the final
1400        # binary (output) relative to the package of this target.
1401        # We compute it by stripping the path to the package directory,
1402        # which is a prefix of the path of `crate_info.output`.
1403
1404        # The path to the package dir, including a trailing "/".
1405        package_dir = ctx.bin_dir.path + "/"
1406
1407        # For external repositories, workspace root is not part of the output
1408        # path when sibling repository layout is used (the repository name is
1409        # part of the bin_dir). This scenario happens when the workspace root
1410        # starts with "../"
1411        if ctx.label.workspace_root and not ctx.label.workspace_root.startswith("../"):
1412            package_dir = package_dir + ctx.label.workspace_root + "/"
1413        if ctx.label.package:
1414            package_dir = package_dir + ctx.label.package + "/"
1415
1416        if not crate_info.output.path.startswith(package_dir):
1417            fail("The package dir path", package_dir, "should be a prefix of the crate_info.output.path", crate_info.output.path)
1418
1419        output_relative_to_package = crate_info.output.path[len(package_dir):]
1420
1421        # Compile actions that produce shared libraries create output of the form "libfoo.so" for linux and macos;
1422        # cc_common.link expects us to pass "foo" to the name parameter. We cannot simply use crate_info.name because
1423        # the name of the crate does not always match the name of output file, e.g a crate named foo-bar will produce
1424        # a (lib)foo_bar output file.
1425        if crate_info.type == "cdylib":
1426            output_lib = crate_info.output.basename
1427            if toolchain.target_os != "windows":
1428                # Strip the leading "lib" prefix
1429                output_lib = output_lib[3:]
1430
1431            # Strip the file extension
1432            output_lib = output_lib[:-(1 + len(crate_info.output.extension))]
1433
1434            # Remove the basename (which contains the undesired 'lib' prefix and the file extension)
1435            output_relative_to_package = output_relative_to_package[:-len(crate_info.output.basename)]
1436
1437            # Append the name of the library
1438            output_relative_to_package = output_relative_to_package + output_lib
1439
1440        cc_common.link(
1441            actions = ctx.actions,
1442            feature_configuration = feature_configuration,
1443            cc_toolchain = cc_toolchain,
1444            linking_contexts = linking_contexts,
1445            compilation_outputs = compilation_outputs,
1446            name = output_relative_to_package,
1447            stamp = ctx.attr.stamp,
1448            output_type = "executable" if crate_info.type == "bin" else "dynamic_library",
1449        )
1450
1451        outputs = [crate_info.output]
1452
1453    coverage_runfiles = []
1454    if toolchain.llvm_cov and ctx.configuration.coverage_enabled and crate_info.is_test:
1455        coverage_runfiles = [toolchain.llvm_cov, toolchain.llvm_profdata]
1456
1457    experimental_use_coverage_metadata_files = toolchain._experimental_use_coverage_metadata_files
1458
1459    dynamic_libraries = [
1460        library_to_link.dynamic_library
1461        for dep in getattr(ctx.attr, "deps", [])
1462        if CcInfo in dep
1463        for linker_input in dep[CcInfo].linking_context.linker_inputs.to_list()
1464        for library_to_link in linker_input.libraries
1465        if _is_dylib(library_to_link)
1466    ]
1467    runfiles = ctx.runfiles(
1468        files = getattr(ctx.files, "data", []) +
1469                ([] if experimental_use_coverage_metadata_files else coverage_runfiles) +
1470                dynamic_libraries,
1471        collect_data = True,
1472    )
1473    if getattr(ctx.attr, "crate", None):
1474        runfiles = runfiles.merge(ctx.attr.crate[DefaultInfo].default_runfiles)
1475        runfiles = runfiles.merge(ctx.attr.crate[DefaultInfo].data_runfiles)
1476
1477    # TODO: Remove after some resolution to
1478    # https://github.com/bazelbuild/rules_rust/issues/771
1479    out_binary = getattr(attr, "out_binary", False)
1480
1481    executable = crate_info.output if crate_info.type == "bin" or crate_info.is_test or out_binary else None
1482
1483    instrumented_files_kwargs = {
1484        "dependency_attributes": ["deps", "crate"],
1485        "extensions": ["rs"],
1486        "source_attributes": ["srcs"],
1487    }
1488
1489    if experimental_use_coverage_metadata_files:
1490        instrumented_files_kwargs.update({
1491            "metadata_files": coverage_runfiles + [executable] if executable else [],
1492        })
1493
1494    providers = [
1495        DefaultInfo(
1496            # nb. This field is required for cc_library to depend on our output.
1497            files = depset(outputs),
1498            runfiles = runfiles,
1499            executable = executable,
1500        ),
1501    ]
1502
1503    # When invoked by aspects (and when running `bazel coverage`), the
1504    # baseline_coverage.dat created here will conflict with the baseline_coverage.dat of the
1505    # underlying target, which is a build failure. So we add an option to disable it so that this
1506    # function can be invoked from aspects for rules that have its own InstrumentedFilesInfo.
1507    if include_coverage:
1508        providers.append(
1509            coverage_common.instrumented_files_info(
1510                ctx,
1511                **instrumented_files_kwargs
1512            ),
1513        )
1514
1515    if crate_info_dict != None:
1516        crate_info_dict.update({
1517            "rustc_env": env,
1518        })
1519        crate_info = rust_common.create_crate_info(**crate_info_dict)
1520
1521    if crate_info.type in ["staticlib", "cdylib"]:
1522        # These rules are not supposed to be depended on by other rust targets, and
1523        # as such they shouldn't provide a CrateInfo. However, one may still want to
1524        # write a rust_test for them, so we provide the CrateInfo wrapped in a provider
1525        # that rust_test understands.
1526        providers.extend([rust_common.test_crate_info(crate = crate_info), dep_info])
1527    else:
1528        providers.extend([crate_info, dep_info])
1529
1530    providers += establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_configuration, interface_library)
1531
1532    output_group_info = {}
1533
1534    if pdb_file:
1535        output_group_info["pdb_file"] = depset([pdb_file])
1536    if dsym_folder:
1537        output_group_info["dsym_folder"] = depset([dsym_folder])
1538    if build_metadata:
1539        output_group_info["build_metadata"] = depset([build_metadata])
1540        if rustc_rmeta_output:
1541            output_group_info["rustc_rmeta_output"] = depset([rustc_rmeta_output])
1542    if rustc_output:
1543        output_group_info["rustc_output"] = depset([rustc_output])
1544
1545    if output_group_info:
1546        providers.append(OutputGroupInfo(**output_group_info))
1547
1548    return providers
1549
1550def _is_no_std(ctx, toolchain, crate_info):
1551    if is_exec_configuration(ctx) or crate_info.is_test:
1552        return False
1553    if toolchain._no_std == "off":
1554        return False
1555    return True
1556
1557def _get_std_and_alloc_info(ctx, toolchain, crate_info):
1558    if is_exec_configuration(ctx):
1559        return toolchain.libstd_and_allocator_ccinfo
1560    if toolchain._experimental_use_global_allocator:
1561        if _is_no_std(ctx, toolchain, crate_info):
1562            return toolchain.nostd_and_global_allocator_cc_info
1563        else:
1564            return toolchain.libstd_and_global_allocator_ccinfo
1565    else:
1566        return toolchain.libstd_and_allocator_ccinfo
1567
1568def _is_dylib(dep):
1569    return not bool(dep.static_library or dep.pic_static_library)
1570
1571def _collect_nonstatic_linker_inputs(cc_info):
1572    shared_linker_inputs = []
1573    for linker_input in cc_info.linking_context.linker_inputs.to_list():
1574        dylibs = [
1575            lib
1576            for lib in linker_input.libraries
1577            if _is_dylib(lib)
1578        ]
1579        if dylibs:
1580            shared_linker_inputs.append(cc_common.create_linker_input(
1581                owner = linker_input.owner,
1582                libraries = depset(dylibs),
1583            ))
1584    return shared_linker_inputs
1585
1586def establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_configuration, interface_library):
1587    """If the produced crate is suitable yield a CcInfo to allow for interop with cc rules
1588
1589    Args:
1590        ctx (ctx): The rule's context object
1591        attr (struct): Attributes to use in gathering CcInfo
1592        crate_info (CrateInfo): The CrateInfo provider of the target crate
1593        toolchain (rust_toolchain): The current `rust_toolchain`
1594        cc_toolchain (CcToolchainInfo): The current `CcToolchainInfo`
1595        feature_configuration (FeatureConfiguration): Feature configuration to be queried.
1596        interface_library (File): Optional interface library for cdylib crates on Windows.
1597
1598    Returns:
1599        list: A list containing the CcInfo provider
1600    """
1601
1602    # A test will not need to produce CcInfo as nothing can depend on test targets
1603    if crate_info.is_test:
1604        return []
1605
1606    # Only generate CcInfo for particular crate types
1607    if crate_info.type not in ("staticlib", "cdylib", "rlib", "lib"):
1608        return []
1609
1610    # TODO: Remove after some resolution to
1611    # https://github.com/bazelbuild/rules_rust/issues/771
1612    if getattr(attr, "out_binary", False):
1613        return []
1614
1615    if crate_info.type == "staticlib":
1616        library_to_link = cc_common.create_library_to_link(
1617            actions = ctx.actions,
1618            feature_configuration = feature_configuration,
1619            cc_toolchain = cc_toolchain,
1620            static_library = crate_info.output,
1621            # TODO(hlopko): handle PIC/NOPIC correctly
1622            pic_static_library = crate_info.output,
1623            alwayslink = getattr(attr, "alwayslink", False),
1624        )
1625    elif crate_info.type in ("rlib", "lib"):
1626        # bazel hard-codes a check for endswith((".a", ".pic.a",
1627        # ".lib")) in create_library_to_link, so we work around that
1628        # by creating a symlink to the .rlib with a .a extension.
1629        dot_a = make_static_lib_symlink(ctx.label.package, ctx.actions, crate_info.output)
1630
1631        # TODO(hlopko): handle PIC/NOPIC correctly
1632        library_to_link = cc_common.create_library_to_link(
1633            actions = ctx.actions,
1634            feature_configuration = feature_configuration,
1635            cc_toolchain = cc_toolchain,
1636            static_library = dot_a,
1637            # TODO(hlopko): handle PIC/NOPIC correctly
1638            pic_static_library = dot_a,
1639            alwayslink = getattr(attr, "alwayslink", False),
1640        )
1641    elif crate_info.type == "cdylib":
1642        library_to_link = cc_common.create_library_to_link(
1643            actions = ctx.actions,
1644            feature_configuration = feature_configuration,
1645            cc_toolchain = cc_toolchain,
1646            dynamic_library = crate_info.output,
1647            interface_library = interface_library,
1648        )
1649    else:
1650        fail("Unexpected case")
1651
1652    link_input = cc_common.create_linker_input(
1653        owner = ctx.label,
1654        libraries = depset([library_to_link]),
1655    )
1656
1657    linking_context = cc_common.create_linking_context(
1658        # TODO - What to do for no_std?
1659        linker_inputs = depset([link_input]),
1660    )
1661
1662    cc_infos = [
1663        CcInfo(linking_context = linking_context),
1664        toolchain.stdlib_linkflags,
1665    ]
1666
1667    # Flattening is okay since crate_info.deps only records direct deps.
1668    for dep in crate_info.deps.to_list():
1669        if dep.cc_info:
1670            # A Rust staticlib or shared library doesn't need to propagate linker inputs
1671            # of its dependencies, except for shared libraries.
1672            if crate_info.type in ["cdylib", "staticlib"]:
1673                shared_linker_inputs = _collect_nonstatic_linker_inputs(dep.cc_info)
1674                if shared_linker_inputs:
1675                    linking_context = cc_common.create_linking_context(
1676                        linker_inputs = depset(shared_linker_inputs),
1677                    )
1678                    cc_infos.append(CcInfo(linking_context = linking_context))
1679            else:
1680                cc_infos.append(dep.cc_info)
1681
1682    if crate_info.type in ("rlib", "lib"):
1683        libstd_and_allocator_cc_info = _get_std_and_alloc_info(ctx, toolchain, crate_info)
1684        if libstd_and_allocator_cc_info:
1685            # TODO: if we already have an rlib in our deps, we could skip this
1686            cc_infos.append(libstd_and_allocator_cc_info)
1687
1688    return [cc_common.merge_cc_infos(cc_infos = cc_infos)]
1689
1690def add_edition_flags(args, crate):
1691    """Adds the Rust edition flag to an arguments object reference
1692
1693    Args:
1694        args (Args): A reference to an Args object
1695        crate (CrateInfo): A CrateInfo provider
1696    """
1697    if crate.edition != "2015":
1698        args.add(crate.edition, format = "--edition=%s")
1699
1700def _create_extra_input_args(build_info, dep_info, include_link_flags = True):
1701    """Gather additional input arguments from transitive dependencies
1702
1703    Args:
1704        build_info (BuildInfo): The BuildInfo provider from the target Crate's set of inputs.
1705        dep_info (DepInfo): The Depinfo provider form the target Crate's set of inputs.
1706        include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
1707
1708    Returns:
1709        tuple: A tuple of the following items:
1710            - (depset[File]): A list of all build info `OUT_DIR` File objects
1711            - (str): The `OUT_DIR` of the current build info
1712            - (File): An optional generated environment file from a `cargo_build_script` target
1713            - (depset[File]): All direct and transitive build flag files from the current build info to be passed to rustc.
1714    """
1715    input_files = []
1716    input_depsets = []
1717
1718    # Arguments to the commandline line wrapper that are going to be used
1719    # to create the final command line
1720    out_dir = None
1721    build_env_file = None
1722    build_flags_files = []
1723
1724    if build_info:
1725        if build_info.out_dir:
1726            out_dir = build_info.out_dir.path
1727            input_files.append(build_info.out_dir)
1728        build_env_file = build_info.rustc_env
1729        if build_info.flags:
1730            build_flags_files.append(build_info.flags)
1731        if build_info.linker_flags and include_link_flags:
1732            build_flags_files.append(build_info.linker_flags)
1733            input_files.append(build_info.linker_flags)
1734
1735        input_depsets.append(build_info.compile_data)
1736
1737    out_dir_compile_inputs = depset(
1738        input_files,
1739        transitive = [dep_info.link_search_path_files, dep_info.transitive_data] + input_depsets,
1740    )
1741
1742    return (
1743        out_dir_compile_inputs,
1744        out_dir,
1745        build_env_file,
1746        depset(build_flags_files, transitive = [dep_info.link_search_path_files]),
1747    )
1748
1749def _compute_rpaths(toolchain, output_dir, dep_info, use_pic):
1750    """Determine the artifact's rpaths relative to the bazel root for runtime linking of shared libraries.
1751
1752    Args:
1753        toolchain (rust_toolchain): The current `rust_toolchain`
1754        output_dir (str): The output directory of the current target
1755        dep_info (DepInfo): The current target's dependency info
1756        use_pic: If set, prefers pic_static_library over static_library.
1757
1758    Returns:
1759        depset: A set of relative paths from the output directory to each dependency
1760    """
1761
1762    # Windows has no rpath equivalent, so always return an empty depset.
1763    # Fuchsia assembles shared libraries during packaging.
1764    if toolchain.target_os == "windows" or toolchain.target_os == "fuchsia":
1765        return depset([])
1766
1767    dylibs = [
1768        get_preferred_artifact(lib, use_pic)
1769        for linker_input in dep_info.transitive_noncrates.to_list()
1770        for lib in linker_input.libraries
1771        if _is_dylib(lib)
1772    ]
1773
1774    # Include std dylib if dylib linkage is enabled
1775    if toolchain._experimental_link_std_dylib:
1776        # TODO: Make toolchain.rust_std to only include libstd.so
1777        # When dylib linkage is enabled, toolchain.rust_std should only need to
1778        # include libstd.so. Hence, no filtering needed.
1779        for file in toolchain.rust_std.to_list():
1780            if is_std_dylib(file):
1781                dylibs.append(file)
1782
1783    if not dylibs:
1784        return depset([])
1785
1786    # For darwin, dylibs compiled by Bazel will fail to be resolved at runtime
1787    # without a version of Bazel that includes
1788    # https://github.com/bazelbuild/bazel/pull/13427. This is known to not be
1789    # included in Bazel 4.1 and below.
1790    if toolchain.target_os not in ["linux", "darwin", "android"]:
1791        fail("Runtime linking is not supported on {}, but found {}".format(
1792            toolchain.target_os,
1793            dep_info.transitive_noncrates,
1794        ))
1795
1796    # Multiple dylibs can be present in the same directory, so deduplicate them.
1797    return depset([
1798        relativize(lib_dir, output_dir)
1799        for lib_dir in _get_dir_names(dylibs)
1800    ])
1801
1802def _get_dir_names(files):
1803    """Returns a list of directory names from the given list of File objects
1804
1805    Args:
1806        files (list): A list of File objects
1807
1808    Returns:
1809        list: A list of directory names for all files
1810    """
1811    dirs = {}
1812    for f in files:
1813        dirs[f.dirname] = None
1814    return dirs.keys()
1815
1816def add_crate_link_flags(args, dep_info, force_all_deps_direct = False, use_metadata = False):
1817    """Adds link flags to an Args object reference
1818
1819    Args:
1820        args (Args): An arguments object reference
1821        dep_info (DepInfo): The current target's dependency info
1822        force_all_deps_direct (bool, optional): Whether to pass the transitive rlibs with --extern
1823            to the commandline as opposed to -L.
1824        use_metadata (bool, optional): Build command line arugments using metadata for crates that provide it.
1825    """
1826
1827    direct_crates = depset(
1828        transitive = [
1829            dep_info.direct_crates,
1830            dep_info.transitive_crates,
1831        ],
1832    ) if force_all_deps_direct else dep_info.direct_crates
1833
1834    crate_to_link_flags = _crate_to_link_flag_metadata if use_metadata else _crate_to_link_flag
1835    args.add_all(direct_crates, uniquify = True, map_each = crate_to_link_flags)
1836
1837    args.add_all(
1838        dep_info.transitive_crates,
1839        map_each = _get_crate_dirname,
1840        uniquify = True,
1841        format_each = "-Ldependency=%s",
1842    )
1843
1844def _crate_to_link_flag_metadata(crate):
1845    """A helper macro used by `add_crate_link_flags` for adding crate link flags to a Arg object
1846
1847    Args:
1848        crate (CrateInfo|AliasableDepInfo): A CrateInfo or an AliasableDepInfo provider
1849
1850    Returns:
1851        list: Link flags for the given provider
1852    """
1853
1854    # This is AliasableDepInfo, we should use the alias as a crate name
1855    if hasattr(crate, "dep"):
1856        name = crate.name
1857        crate_info = crate.dep
1858    else:
1859        name = crate.name
1860        crate_info = crate
1861
1862    lib_or_meta = crate_info.metadata
1863    if not crate_info.metadata:
1864        lib_or_meta = crate_info.output
1865    return ["--extern={}={}".format(name, lib_or_meta.path)]
1866
1867def _crate_to_link_flag(crate):
1868    """A helper macro used by `add_crate_link_flags` for adding crate link flags to a Arg object
1869
1870    Args:
1871        crate (CrateInfo|AliasableDepInfo): A CrateInfo or an AliasableDepInfo provider
1872
1873    Returns:
1874        list: Link flags for the given provider
1875    """
1876
1877    # This is AliasableDepInfo, we should use the alias as a crate name
1878    if hasattr(crate, "dep"):
1879        name = crate.name
1880        crate_info = crate.dep
1881    else:
1882        name = crate.name
1883        crate_info = crate
1884    return ["--extern={}={}".format(name, crate_info.output.path)]
1885
1886def _get_crate_dirname(crate):
1887    """A helper macro used by `add_crate_link_flags` for getting the directory name of the current crate's output path
1888
1889    Args:
1890        crate (CrateInfo): A CrateInfo provider from the current rule
1891
1892    Returns:
1893        str: The directory name of the the output File that will be produced.
1894    """
1895    return crate.output.dirname
1896
1897def _portable_link_flags(lib, use_pic, ambiguous_libs, get_lib_name, for_windows = False, for_darwin = False, flavor_msvc = False):
1898    artifact = get_preferred_artifact(lib, use_pic)
1899    if ambiguous_libs and artifact.path in ambiguous_libs:
1900        artifact = ambiguous_libs[artifact.path]
1901    if lib.static_library or lib.pic_static_library:
1902        # To ensure appropriate linker library argument order, in the presence
1903        # of both native libraries that depend on rlibs and rlibs that depend
1904        # on native libraries, we use an approach where we "sandwich" the
1905        # rust libraries between two similar sections of all of native
1906        # libraries:
1907        # n1 n2 ... r1 r2 ... n1 n2 ...
1908        # A         B         C
1909        # This way any dependency from a native library to a rust library
1910        # is resolved from A to B, and any dependency from a rust library to
1911        # a native one is resolved from B to C.
1912        # The question of resolving dependencies from a native library from A
1913        # to any rust library is addressed in a different place, where we
1914        # create symlinks to the rlibs, pretending they are native libraries,
1915        # and adding references to these symlinks in the native section A.
1916        # We rely in the behavior of -Clink-arg to put the linker args
1917        # at the end of the linker invocation constructed by rustc.
1918
1919        # We skip adding `-Clink-arg=-l` for libstd and libtest from the standard library, as
1920        # these two libraries are present both as an `.rlib` and a `.so` format.
1921        # On linux, Rustc adds a -Bdynamic to the linker command line before the libraries specified
1922        # with `-Clink-arg`, which leads to us linking against the `.so`s but not putting the
1923        # corresponding value to the runtime library search paths, which results in a
1924        # "cannot open shared object file: No such file or directory" error at exectuion time.
1925        # We can fix this by adding a `-Clink-arg=-Bstatic` on linux, but we don't have that option for
1926        # macos. The proper solution for this issue would be to remove `libtest-{hash}.so` and `libstd-{hash}.so`
1927        # from the toolchain. However, it is not enough to change the toolchain's `rust_std_{...}` filegroups
1928        # here: https://github.com/bazelbuild/rules_rust/blob/a9d5d894ad801002d007b858efd154e503796b9f/rust/private/repository_utils.bzl#L144
1929        # because rustc manages to escape the sandbox and still finds them at linking time.
1930        # We need to modify the repository rules to erase those files completely.
1931        if "lib/rustlib" in artifact.path and (
1932            artifact.basename.startswith("libtest-") or artifact.basename.startswith("libstd-") or
1933            artifact.basename.startswith("test-") or artifact.basename.startswith("std-")
1934        ):
1935            return [] if for_darwin else ["-lstatic=%s" % get_lib_name(artifact)]
1936
1937        if for_windows:
1938            if flavor_msvc:
1939                return [
1940                    "-lstatic=%s" % get_lib_name(artifact),
1941                    "-Clink-arg={}".format(artifact.basename),
1942                ]
1943            else:
1944                return [
1945                    "-lstatic=%s" % get_lib_name(artifact),
1946                    "-Clink-arg=-l{}".format(artifact.basename),
1947                ]
1948        else:
1949            return [
1950                "-lstatic=%s" % get_lib_name(artifact),
1951                "-Clink-arg=-l{}".format(get_lib_name(artifact)),
1952            ]
1953    elif _is_dylib(lib):
1954        return [
1955            "-ldylib=%s" % get_lib_name(artifact),
1956        ]
1957
1958    return []
1959
1960def _add_user_link_flags(ret, linker_input):
1961    ret.extend(["--codegen=link-arg={}".format(flag) for flag in linker_input.user_link_flags])
1962
1963def _make_link_flags_windows(make_link_flags_args, flavor_msvc):
1964    linker_input, use_pic, ambiguous_libs, include_link_flags = make_link_flags_args
1965    ret = []
1966    for lib in linker_input.libraries:
1967        if lib.alwayslink:
1968            if flavor_msvc:
1969                ret.extend(["-C", "link-arg=/WHOLEARCHIVE:%s" % get_preferred_artifact(lib, use_pic).path])
1970            else:
1971                ret.extend([
1972                    "-C",
1973                    "link-arg=-Wl,--whole-archive",
1974                    "-C",
1975                    ("link-arg=%s" % get_preferred_artifact(lib, use_pic).path),
1976                    "-C",
1977                    "link-arg=-Wl,--no-whole-archive",
1978                ])
1979        elif include_link_flags:
1980            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs, get_lib_name_for_windows, for_windows = True, flavor_msvc = flavor_msvc))
1981    _add_user_link_flags(ret, linker_input)
1982    return ret
1983
1984def _make_link_flags_windows_msvc(make_link_flags_args):
1985    return _make_link_flags_windows(make_link_flags_args, flavor_msvc = True)
1986
1987def _make_link_flags_windows_gnu(make_link_flags_args):
1988    return _make_link_flags_windows(make_link_flags_args, flavor_msvc = False)
1989
1990def _make_link_flags_darwin(make_link_flags_args):
1991    linker_input, use_pic, ambiguous_libs, include_link_flags = make_link_flags_args
1992    ret = []
1993    for lib in linker_input.libraries:
1994        if lib.alwayslink:
1995            ret.extend([
1996                "-C",
1997                ("link-arg=-Wl,-force_load,%s" % get_preferred_artifact(lib, use_pic).path),
1998            ])
1999        elif include_link_flags:
2000            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs, get_lib_name_default, for_darwin = True))
2001    _add_user_link_flags(ret, linker_input)
2002    return ret
2003
2004def _make_link_flags_default(make_link_flags_args):
2005    linker_input, use_pic, ambiguous_libs, include_link_flags = make_link_flags_args
2006    ret = []
2007    for lib in linker_input.libraries:
2008        if lib.alwayslink:
2009            ret.extend([
2010                "-C",
2011                "link-arg=-Wl,--whole-archive",
2012                "-C",
2013                ("link-arg=%s" % get_preferred_artifact(lib, use_pic).path),
2014                "-C",
2015                "link-arg=-Wl,--no-whole-archive",
2016            ])
2017        elif include_link_flags:
2018            ret.extend(_portable_link_flags(lib, use_pic, ambiguous_libs, get_lib_name_default))
2019    _add_user_link_flags(ret, linker_input)
2020    return ret
2021
2022def _libraries_dirnames(make_link_flags_args):
2023    link_input, use_pic, _, _ = make_link_flags_args
2024
2025    # De-duplicate names.
2026    return depset([get_preferred_artifact(lib, use_pic).dirname for lib in link_input.libraries]).to_list()
2027
2028def _add_native_link_flags(args, dep_info, linkstamp_outs, ambiguous_libs, crate_type, toolchain, cc_toolchain, feature_configuration, compilation_mode, include_link_flags = True):
2029    """Adds linker flags for all dependencies of the current target.
2030
2031    Args:
2032        args (Args): The Args struct for a ctx.action
2033        dep_info (DepInfo): Dependency Info provider
2034        linkstamp_outs (list): Linkstamp outputs of native dependencies
2035        ambiguous_libs (dict): Ambiguous libs, see `_disambiguate_libs`
2036        crate_type: Crate type of the current target
2037        toolchain (rust_toolchain): The current `rust_toolchain`
2038        cc_toolchain (CcToolchainInfo): The current `cc_toolchain`
2039        feature_configuration (FeatureConfiguration): feature configuration to use with cc_toolchain
2040        compilation_mode (bool): The compilation mode for this build.
2041        include_link_flags (bool, optional): Whether to include flags like `-l` that instruct the linker to search for a library.
2042    """
2043    if crate_type in ["lib", "rlib"]:
2044        return
2045
2046    use_pic = _should_use_pic(cc_toolchain, feature_configuration, crate_type, compilation_mode)
2047
2048    if toolchain.target_os == "windows":
2049        make_link_flags = _make_link_flags_windows_msvc if toolchain.target_triple.abi == "msvc" else _make_link_flags_windows_gnu
2050        get_lib_name = get_lib_name_for_windows
2051    elif toolchain.target_os.startswith(("mac", "darwin", "ios")):
2052        make_link_flags = _make_link_flags_darwin
2053        get_lib_name = get_lib_name_default
2054    else:
2055        make_link_flags = _make_link_flags_default
2056        get_lib_name = get_lib_name_default
2057
2058    # TODO(hlopko): Remove depset flattening by using lambdas once we are on >=Bazel 5.0
2059    make_link_flags_args = [(arg, use_pic, ambiguous_libs, include_link_flags) for arg in dep_info.transitive_noncrates.to_list()]
2060    args.add_all(make_link_flags_args, map_each = _libraries_dirnames, uniquify = True, format_each = "-Lnative=%s")
2061    if ambiguous_libs:
2062        # If there are ambiguous libs, the disambiguation symlinks to them are
2063        # all created in the same directory. Add it to the library search path.
2064        ambiguous_libs_dirname = ambiguous_libs.values()[0].dirname
2065        args.add(ambiguous_libs_dirname, format = "-Lnative=%s")
2066
2067    args.add_all(make_link_flags_args, map_each = make_link_flags)
2068
2069    args.add_all(linkstamp_outs, before_each = "-C", format_each = "link-args=%s")
2070
2071    if crate_type in ["dylib", "cdylib"]:
2072        # For shared libraries we want to link C++ runtime library dynamically
2073        # (for example libstdc++.so or libc++.so).
2074        args.add_all(
2075            cc_toolchain.dynamic_runtime_lib(feature_configuration = feature_configuration),
2076            map_each = _get_dirname,
2077            format_each = "-Lnative=%s",
2078        )
2079        if include_link_flags:
2080            args.add_all(
2081                cc_toolchain.dynamic_runtime_lib(feature_configuration = feature_configuration),
2082                map_each = get_lib_name,
2083                format_each = "-ldylib=%s",
2084            )
2085    else:
2086        # For all other crate types we want to link C++ runtime library statically
2087        # (for example libstdc++.a or libc++.a).
2088        args.add_all(
2089            cc_toolchain.static_runtime_lib(feature_configuration = feature_configuration),
2090            map_each = _get_dirname,
2091            format_each = "-Lnative=%s",
2092        )
2093        if include_link_flags:
2094            args.add_all(
2095                cc_toolchain.static_runtime_lib(feature_configuration = feature_configuration),
2096                map_each = get_lib_name,
2097                format_each = "-lstatic=%s",
2098            )
2099
2100def _get_dirname(file):
2101    """A helper function for `_add_native_link_flags`.
2102
2103    Args:
2104        file (File): The target file
2105
2106    Returns:
2107        str: Directory name of `file`
2108    """
2109    return file.dirname
2110
2111def _add_per_crate_rustc_flags(ctx, args, crate_info, per_crate_rustc_flags):
2112    """Adds matching per-crate rustc flags to an arguments object reference
2113
2114    Args:
2115        ctx (ctx): The source rule's context object
2116        args (Args): A reference to an Args object
2117        crate_info (CrateInfo): A CrateInfo provider
2118        per_crate_rustc_flags (list): A list of per_crate_rustc_flag values
2119    """
2120    for per_crate_rustc_flag in per_crate_rustc_flags:
2121        at_index = per_crate_rustc_flag.find("@")
2122        if at_index == -1:
2123            fail("per_crate_rustc_flag '{}' does not follow the expected format: prefix_filter@flag".format(per_crate_rustc_flag))
2124
2125        prefix_filter = per_crate_rustc_flag[:at_index]
2126        flag = per_crate_rustc_flag[at_index + 1:]
2127        if not flag:
2128            fail("per_crate_rustc_flag '{}' does not follow the expected format: prefix_filter@flag".format(per_crate_rustc_flag))
2129
2130        label_string = str(ctx.label)
2131        label = label_string[1:] if label_string.startswith("@//") else label_string
2132        execution_path = crate_info.root.path
2133
2134        if label.startswith(prefix_filter) or execution_path.startswith(prefix_filter):
2135            args.add(flag)
2136
2137def _error_format_impl(ctx):
2138    """Implementation of the `error_format` rule
2139
2140    Args:
2141        ctx (ctx): The rule's context object
2142
2143    Returns:
2144        list: A list containing the ErrorFormatInfo provider
2145    """
2146    raw = ctx.build_setting_value
2147    if raw not in _error_format_values:
2148        fail("{} expected a value in `{}` but got `{}`".format(
2149            ctx.label,
2150            _error_format_values,
2151            raw,
2152        ))
2153    return [ErrorFormatInfo(error_format = raw)]
2154
2155error_format = rule(
2156    doc = (
2157        "Change the [--error-format](https://doc.rust-lang.org/rustc/command-line-arguments.html#option-error-format) " +
2158        "flag from the command line with `--@rules_rust//rust/settings:error_format`. See rustc documentation for valid values."
2159    ),
2160    implementation = _error_format_impl,
2161    build_setting = config.string(flag = True),
2162)
2163
2164def _rustc_output_diagnostics_impl(ctx):
2165    """Implementation of the `rustc_output_diagnostics` rule
2166
2167    Args:
2168        ctx (ctx): The rule's context object
2169
2170    Returns:
2171        list: A list containing the RustcOutputDiagnosticsInfo provider
2172    """
2173    return [RustcOutputDiagnosticsInfo(
2174        rustc_output_diagnostics = ctx.build_setting_value,
2175    )]
2176
2177rustc_output_diagnostics = rule(
2178    doc = (
2179        "Setting this flag from the command line with `--@rules_rust//rust/settings:rustc_output_diagnostics` " +
2180        "makes rules_rust save rustc json output(suitable for consumption by rust-analyzer) in a file. " +
2181        "These are accessible via the " +
2182        "`rustc_rmeta_output`(for pipelined compilation) and `rustc_output` output groups. " +
2183        "You can find these using `bazel cquery`"
2184    ),
2185    implementation = _rustc_output_diagnostics_impl,
2186    build_setting = config.bool(flag = True),
2187)
2188
2189def _extra_rustc_flags_impl(ctx):
2190    return ExtraRustcFlagsInfo(extra_rustc_flags = ctx.build_setting_value)
2191
2192extra_rustc_flags = rule(
2193    doc = (
2194        "Add additional rustc_flags from the command line with `--@rules_rust//rust/settings:extra_rustc_flags`. " +
2195        "This flag should only be used for flags that need to be applied across the entire build. For options that " +
2196        "apply to individual crates, use the rustc_flags attribute on the individual crate's rule instead. NOTE: " +
2197        "These flags not applied to the exec configuration (proc-macros, cargo_build_script, etc); " +
2198        "use `--@rules_rust//rust/settings:extra_exec_rustc_flags` to apply flags to the exec configuration."
2199    ),
2200    implementation = _extra_rustc_flags_impl,
2201    build_setting = config.string_list(flag = True),
2202)
2203
2204def _extra_rustc_flag_impl(ctx):
2205    return ExtraRustcFlagsInfo(extra_rustc_flags = [f for f in ctx.build_setting_value if f != ""])
2206
2207extra_rustc_flag = rule(
2208    doc = (
2209        "Add additional rustc_flag from the command line with `--@rules_rust//rust/settings:extra_rustc_flag`. " +
2210        "Multiple uses are accumulated and appended after the extra_rustc_flags."
2211    ),
2212    implementation = _extra_rustc_flag_impl,
2213    build_setting = config.string_list(flag = True, repeatable = True),
2214)
2215
2216def _extra_exec_rustc_flags_impl(ctx):
2217    return ExtraExecRustcFlagsInfo(extra_exec_rustc_flags = ctx.build_setting_value)
2218
2219extra_exec_rustc_flags = rule(
2220    doc = (
2221        "Add additional rustc_flags in the exec configuration from the command line with `--@rules_rust//rust/settings:extra_exec_rustc_flags`. " +
2222        "This flag should only be used for flags that need to be applied across the entire build. " +
2223        "These flags only apply to the exec configuration (proc-macros, cargo_build_script, etc)."
2224    ),
2225    implementation = _extra_exec_rustc_flags_impl,
2226    build_setting = config.string_list(flag = True),
2227)
2228
2229def _extra_exec_rustc_flag_impl(ctx):
2230    return ExtraExecRustcFlagsInfo(extra_exec_rustc_flags = [f for f in ctx.build_setting_value if f != ""])
2231
2232extra_exec_rustc_flag = rule(
2233    doc = (
2234        "Add additional rustc_flags in the exec configuration from the command line with `--@rules_rust//rust/settings:extra_exec_rustc_flag`. " +
2235        "Multiple uses are accumulated and appended after the extra_exec_rustc_flags."
2236    ),
2237    implementation = _extra_exec_rustc_flag_impl,
2238    build_setting = config.string_list(flag = True, repeatable = True),
2239)
2240
2241def _per_crate_rustc_flag_impl(ctx):
2242    return PerCrateRustcFlagsInfo(per_crate_rustc_flags = [f for f in ctx.build_setting_value if f != ""])
2243
2244per_crate_rustc_flag = rule(
2245    doc = (
2246        "Add additional rustc_flag to matching crates from the command line with `--@rules_rust//rust/settings:experimental_per_crate_rustc_flag`. " +
2247        "The expected flag format is prefix_filter@flag, where any crate with a label or execution path starting with the prefix filter will be built with the given flag." +
2248        "The label matching uses the canonical form of the label (i.e //package:label_name)." +
2249        "The execution path is the relative path to your workspace directory including the base name (including extension) of the crate root." +
2250        "This flag is only applied to the exec configuration (proc-macros, cargo_build_script, etc)." +
2251        "Multiple uses are accumulated."
2252    ),
2253    implementation = _per_crate_rustc_flag_impl,
2254    build_setting = config.string_list(flag = True, repeatable = True),
2255)
2256
2257def _no_std_impl(ctx):
2258    value = str(ctx.attr._no_std[BuildSettingInfo].value)
2259    if is_exec_configuration(ctx):
2260        return [config_common.FeatureFlagInfo(value = "off")]
2261    return [config_common.FeatureFlagInfo(value = value)]
2262
2263no_std = rule(
2264    doc = (
2265        "No std; we need this so that we can distinguish between host and exec"
2266    ),
2267    attrs = {
2268        "_no_std": attr.label(default = "//rust/settings:no_std"),
2269    },
2270    implementation = _no_std_impl,
2271)