fork/rules_rust

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

scentiniDo not pass `--Clink-arg=-l` for libstd and libtest (#1500)4e5fac59

0.9.0
21.9 KiB635 linesraw
1# Copyright 2015 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"""Utility functions not specific to the rust toolchain."""
16
17load("@bazel_tools//tools/cpp:toolchain_utils.bzl", find_rules_cc_toolchain = "find_cpp_toolchain")
18load(":providers.bzl", "BuildInfo", "CrateInfo", "DepInfo", "DepVariantInfo")
19
20UNSUPPORTED_FEATURES = [
21    "thin_lto",
22    "module_maps",
23    "use_header_modules",
24    "fdo_instrument",
25    "fdo_optimize",
26]
27
28def find_toolchain(ctx):
29    """Finds the first rust toolchain that is configured.
30
31    Args:
32        ctx (ctx): The ctx object for the current target.
33
34    Returns:
35        rust_toolchain: A Rust toolchain context.
36    """
37    return ctx.toolchains[Label("//rust:toolchain_type")]
38
39def find_cc_toolchain(ctx):
40    """Extracts a CcToolchain from the current target's context
41
42    Args:
43        ctx (ctx): The current target's rule context object
44
45    Returns:
46        tuple: A tuple of (CcToolchain, FeatureConfiguration)
47    """
48    cc_toolchain = find_rules_cc_toolchain(ctx)
49
50    feature_configuration = cc_common.configure_features(
51        ctx = ctx,
52        cc_toolchain = cc_toolchain,
53        requested_features = ctx.features,
54        unsupported_features = UNSUPPORTED_FEATURES + ctx.disabled_features,
55    )
56    return cc_toolchain, feature_configuration
57
58# TODO: Replace with bazel-skylib's `path.dirname`. This requires addressing some
59# dependency issues or generating docs will break.
60def relativize(path, start):
61    """Returns the relative path from start to path.
62
63    Args:
64        path (str): The path to relativize.
65        start (str): The ancestor path against which to relativize.
66
67    Returns:
68        str: The portion of `path` that is relative to `start`.
69    """
70    src_parts = _path_parts(start)
71    dest_parts = _path_parts(path)
72    n = 0
73    for src_part, dest_part in zip(src_parts, dest_parts):
74        if src_part != dest_part:
75            break
76        n += 1
77
78    relative_path = ""
79    for _ in range(n, len(src_parts)):
80        relative_path += "../"
81    relative_path += "/".join(dest_parts[n:])
82
83    return relative_path
84
85def _path_parts(path):
86    """Takes a path and returns a list of its parts with all "." elements removed.
87
88    The main use case of this function is if one of the inputs to relativize()
89    is a relative path, such as "./foo".
90
91    Args:
92      path (str): A string representing a unix path
93
94    Returns:
95      list: A list containing the path parts with all "." elements removed.
96    """
97    path_parts = path.split("/")
98    return [part for part in path_parts if part != "."]
99
100def get_lib_name(lib, for_windows = False):
101    """Returns the name of a library artifact, eg. libabc.a -> abc
102
103    Args:
104        lib (File): A library file
105        for_windows: Whether we're building on Windows.
106
107    Returns:
108        str: The name of the library
109    """
110    # On macos and windows, dynamic/static libraries always end with the
111    # extension and potential versions will be before the extension, and should
112    # be part of the library name.
113    # On linux, the version usually comes after the extension.
114    # So regardless of the platform we want to find the extension and make
115    # everything left to it the library name.
116
117    # Search for the extension - starting from the right - by removing any
118    # trailing digit.
119    comps = lib.basename.split(".")
120    for comp in reversed(comps):
121        if comp.isdigit():
122            comps.pop()
123        else:
124            break
125
126    # The library name is now everything minus the extension.
127    libname = ".".join(comps[:-1])
128
129    if libname.startswith("lib") and not for_windows:
130        return libname[3:]
131    else:
132        return libname
133
134def abs(value):
135    """Returns the absolute value of a number.
136
137    Args:
138      value (int): A number.
139
140    Returns:
141      int: The absolute value of the number.
142    """
143    if value < 0:
144        return -value
145    return value
146
147def determine_output_hash(crate_root, label):
148    """Generates a hash of the crate root file's path.
149
150    Args:
151        crate_root (File): The crate's root file (typically `lib.rs`).
152        label (Label): The label of the target.
153
154    Returns:
155        str: A string representation of the hash.
156    """
157
158    # Take the absolute value of hash() since it could be negative.
159    h = abs(hash(crate_root.path) + hash(repr(label)))
160    return repr(h)
161
162def get_preferred_artifact(library_to_link, use_pic):
163    """Get the first available library to link from a LibraryToLink object.
164
165    Args:
166        library_to_link (LibraryToLink): See the followg links for additional details:
167            https://docs.bazel.build/versions/master/skylark/lib/LibraryToLink.html
168        use_pic: If set, prefers pic_static_library over static_library.
169
170    Returns:
171        File: Returns the first valid library type (only one is expected)
172    """
173    if use_pic:
174        # Order consistent with https://github.com/bazelbuild/bazel/blob/815dfdabb7df31d4e99b6fc7616ff8e2f9385d98/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingContext.java#L437.
175        return (
176            library_to_link.pic_static_library or
177            library_to_link.static_library or
178            library_to_link.interface_library or
179            library_to_link.dynamic_library
180        )
181    else:
182        return (
183            library_to_link.static_library or
184            library_to_link.pic_static_library or
185            library_to_link.interface_library or
186            library_to_link.dynamic_library
187        )
188
189def _expand_location(ctx, env, data):
190    """A trivial helper for `expand_dict_value_locations` and `expand_list_element_locations`
191
192    Args:
193        ctx (ctx): The rule's context object
194        env (str): The value possibly containing location macros to expand.
195        data (sequence of Targets): See one of the parent functions.
196
197    Returns:
198        string: The location-macro expanded version of the string.
199    """
200    for directive in ("$(execpath ", "$(location "):
201        if directive in env:
202            # build script runner will expand pwd to execroot for us
203            env = env.replace(directive, "$${pwd}/" + directive)
204    return ctx.expand_make_variables(
205        env,
206        ctx.expand_location(env, data),
207        {},
208    )
209
210def expand_dict_value_locations(ctx, env, data):
211    """Performs location-macro expansion on string values.
212
213    $(execroot ...) and $(location ...) are prefixed with ${pwd},
214    which process_wrapper and build_script_runner will expand at run time
215    to the absolute path. This is necessary because include_str!() is relative
216    to the currently compiled file, and build scripts run relative to the
217    manifest dir, so we can not use execroot-relative paths.
218
219    $(rootpath ...) is unmodified, and is useful for passing in paths via
220    rustc_env that are encoded in the binary with env!(), but utilized at
221    runtime, such as in tests. The absolute paths are not usable in this case,
222    as compilation happens in a separate sandbox folder, so when it comes time
223    to read the file at runtime, the path is no longer valid.
224
225    For detailed documentation, see:
226    - [`expand_location`](https://bazel.build/rules/lib/ctx#expand_location)
227    - [`expand_make_variables`](https://bazel.build/rules/lib/ctx#expand_make_variables)
228
229    Args:
230        ctx (ctx): The rule's context object
231        env (dict): A dict whose values we iterate over
232        data (sequence of Targets): The targets which may be referenced by
233            location macros. This is expected to be the `data` attribute of
234            the target, though may have other targets or attributes mixed in.
235
236    Returns:
237        dict: A dict of environment variables with expanded location macros
238    """
239    return dict([(k, _expand_location(ctx, v, data)) for (k, v) in env.items()])
240
241def expand_list_element_locations(ctx, args, data):
242    """Performs location-macro expansion on a list of string values.
243
244    $(execroot ...) and $(location ...) are prefixed with ${pwd},
245    which process_wrapper and build_script_runner will expand at run time
246    to the absolute path.
247
248    For detailed documentation, see:
249    - [`expand_location`](https://bazel.build/rules/lib/ctx#expand_location)
250    - [`expand_make_variables`](https://bazel.build/rules/lib/ctx#expand_make_variables)
251
252    Args:
253        ctx (ctx): The rule's context object
254        args (list): A list we iterate over
255        data (sequence of Targets): The targets which may be referenced by
256            location macros. This is expected to be the `data` attribute of
257            the target, though may have other targets or attributes mixed in.
258
259    Returns:
260        list: A list of arguments with expanded location macros
261    """
262    return [_expand_location(ctx, arg, data) for arg in args]
263
264def name_to_crate_name(name):
265    """Converts a build target's name into the name of its associated crate.
266
267    Crate names cannot contain certain characters, such as -, which are allowed
268    in build target names. All illegal characters will be converted to
269    underscores.
270
271    This is a similar conversion as that which cargo does, taking a
272    `Cargo.toml`'s `package.name` and canonicalizing it
273
274    Note that targets can specify the `crate_name` attribute to customize their
275    crate name; in situations where this is important, use the
276    compute_crate_name() function instead.
277
278    Args:
279        name (str): The name of the target.
280
281    Returns:
282        str: The name of the crate for this target.
283    """
284    for illegal in ("-", "/"):
285        name = name.replace(illegal, "_")
286    return name
287
288def _invalid_chars_in_crate_name(name):
289    """Returns any invalid chars in the given crate name.
290
291    Args:
292        name (str): Name to test.
293
294    Returns:
295        list: List of invalid characters in the crate name.
296    """
297
298    return dict([(c, ()) for c in name.elems() if not (c.isalnum() or c == "_")]).keys()
299
300def compute_crate_name(workspace_name, label, toolchain, name_override = None):
301    """Returns the crate name to use for the current target.
302
303    Args:
304        workspace_name (string): The current workspace name.
305        label (struct): The label of the current target.
306        toolchain (struct): The toolchain in use for the target.
307        name_override (String): An optional name to use (as an override of label.name).
308
309    Returns:
310        str: The crate name to use for this target.
311    """
312    if name_override:
313        invalid_chars = _invalid_chars_in_crate_name(name_override)
314        if invalid_chars:
315            fail("Crate name '{}' contains invalid character(s): {}".format(
316                name_override,
317                " ".join(invalid_chars),
318            ))
319        return name_override
320
321    if (toolchain and label and toolchain._rename_first_party_crates and
322        should_encode_label_in_crate_name(workspace_name, label, toolchain._third_party_dir)):
323        crate_name = encode_label_as_crate_name(label.package, label.name)
324    else:
325        crate_name = name_to_crate_name(label.name)
326
327    invalid_chars = _invalid_chars_in_crate_name(crate_name)
328    if invalid_chars:
329        fail(
330            "Crate name '{}' ".format(crate_name) +
331            "derived from Bazel target name '{}' ".format(label.name) +
332            "contains invalid character(s): {}\n".format(" ".join(invalid_chars)) +
333            "Consider adding a crate_name attribute to set a valid crate name",
334        )
335    return crate_name
336
337def dedent(doc_string):
338    """Remove any common leading whitespace from every line in text.
339
340    This functionality is similar to python's `textwrap.dedent` functionality
341    https://docs.python.org/3/library/textwrap.html#textwrap.dedent
342
343    Args:
344        doc_string (str): A docstring style string
345
346    Returns:
347        str: A string optimized for stardoc rendering
348    """
349    lines = doc_string.splitlines()
350    if not lines:
351        return doc_string
352
353    # If the first line is empty, use the second line
354    first_line = lines[0]
355    if not first_line:
356        first_line = lines[1]
357
358    # Detect how much space prepends the first line and subtract that from all lines
359    space_count = len(first_line) - len(first_line.lstrip())
360
361    # If there are no leading spaces, do not alter the docstring
362    if space_count == 0:
363        return doc_string
364    else:
365        # Remove the leading block of spaces from the current line
366        block = " " * space_count
367        return "\n".join([line.replace(block, "", 1).rstrip() for line in lines])
368
369def make_static_lib_symlink(actions, rlib_file):
370    """Add a .a symlink to an .rlib file.
371
372    The name of the symlink is derived from the <name> of the <name>.rlib file as follows:
373    * `<name>.a`, if <name> starts with `lib`
374    * `lib<name>.a`, otherwise.
375
376    For example, the name of the symlink for
377    * `libcratea.rlib` is `libcratea.a`
378    * `crateb.rlib` is `libcrateb.a`.
379
380    Args:
381        actions (actions): The rule's context actions object.
382        rlib_file (File): The file to symlink, which must end in .rlib.
383
384    Returns:
385        The symlink's File.
386    """
387    if not rlib_file.basename.endswith(".rlib"):
388        fail("file is not an .rlib: ", rlib_file.basename)
389    basename = rlib_file.basename[:-5]
390    if not basename.startswith("lib"):
391        basename = "lib" + basename
392    dot_a = actions.declare_file(basename + ".a", sibling = rlib_file)
393    actions.symlink(output = dot_a, target_file = rlib_file)
394    return dot_a
395
396def is_exec_configuration(ctx):
397    """Determine if a context is building for the exec configuration.
398
399    This is helpful when processing command line flags that should apply
400    to the target configuration but not the exec configuration.
401
402    Args:
403        ctx (ctx): The ctx object for the current target.
404
405    Returns:
406        True if the exec configuration is detected, False otherwise.
407    """
408
409    # TODO(djmarcin): Is there any better way to determine cfg=exec?
410    return ctx.genfiles_dir.path.find("-exec-") != -1
411
412def transform_deps(deps):
413    """Transforms a [Target] into [DepVariantInfo].
414
415    This helper function is used to transform ctx.attr.deps and ctx.attr.proc_macro_deps into
416    [DepVariantInfo].
417
418    Args:
419        deps (list of Targets): Dependencies coming from ctx.attr.deps or ctx.attr.proc_macro_deps
420
421    Returns:
422        list of DepVariantInfos.
423    """
424    return [DepVariantInfo(
425        crate_info = dep[CrateInfo] if CrateInfo in dep else None,
426        dep_info = dep[DepInfo] if DepInfo in dep else None,
427        build_info = dep[BuildInfo] if BuildInfo in dep else None,
428        cc_info = dep[CcInfo] if CcInfo in dep else None,
429    ) for dep in deps]
430
431def get_import_macro_deps(ctx):
432    """Returns a list of targets to be added to proc_macro_deps.
433
434    Args:
435        ctx (struct): the ctx of the current target.
436
437    Returns:
438        list of Targets. Either empty (if the fake import macro implementation
439        is being used), or a singleton list with the real implementation.
440    """
441    if ctx.attr._import_macro_dep.label.name == "fake_import_macro_impl":
442        return []
443
444    return [ctx.attr._import_macro_dep]
445
446def should_encode_label_in_crate_name(workspace_name, label, third_party_dir):
447    """Determines if the crate's name should include the Bazel label, encoded.
448
449    Crate names may only encode the label if the target is in the current repo,
450    the target is not in the third_party_dir, and the current repo is not
451    rules_rust.
452
453    Args:
454        workspace_name (string): The name of the current workspace.
455        label (Label): The package in question.
456        third_party_dir (string): The directory in which third-party packages are kept.
457
458    Returns:
459        True if the crate name should encode the label, False otherwise.
460    """
461
462    # TODO(hlopko): This code assumes a monorepo; make it work with external
463    # repositories as well.
464    return (
465        workspace_name != "rules_rust" and
466        not label.workspace_root and
467        not ("//" + label.package + "/").startswith(third_party_dir + "/")
468    )
469
470# This is a list of pairs, where the first element of the pair is a character
471# that is allowed in Bazel package or target names but not in crate names; and
472# the second element is an encoding of that char suitable for use in a crate
473# name.
474_encodings = (
475    (":", "x"),
476    ("!", "excl"),
477    ("%", "prc"),
478    ("@", "ao"),
479    ("^", "caret"),
480    ("`", "bt"),
481    (" ", "sp"),
482    ("\"", "dq"),
483    ("#", "octo"),
484    ("$", "dllr"),
485    ("&", "amp"),
486    ("'", "sq"),
487    ("(", "lp"),
488    (")", "rp"),
489    ("*", "astr"),
490    ("-", "d"),
491    ("+", "pl"),
492    (",", "cm"),
493    (";", "sm"),
494    ("<", "la"),
495    ("=", "eq"),
496    (">", "ra"),
497    ("?", "qm"),
498    ("[", "lbk"),
499    ("]", "rbk"),
500    ("{", "lbe"),
501    ("|", "pp"),
502    ("}", "rbe"),
503    ("~", "td"),
504    ("/", "y"),
505    (".", "pd"),
506)
507
508# For each of the above encodings, we generate two substitution rules: one that
509# ensures any occurrences of the encodings themselves in the package/target
510# aren't clobbered by this translation, and one that does the encoding itself.
511# We also include a rule that protects the clobbering-protection rules from
512# getting clobbered.
513_substitutions = [("_z", "_zz_")] + [
514    subst
515    for (pattern, replacement) in _encodings
516    for subst in (
517        ("_{}_".format(replacement), "_z{}_".format(replacement)),
518        (pattern, "_{}_".format(replacement)),
519    )
520]
521
522# Expose the substitutions for testing only.
523substitutions_for_testing = _substitutions
524
525def encode_label_as_crate_name(package, name):
526    """Encodes the package and target names in a format suitable for a crate name.
527
528    Args:
529        package (string): The package of the target in question.
530        name (string): The name of the target in question.
531
532    Returns:
533        A string that encodes the package and target name, to be used as the crate's name.
534    """
535    return _encode_raw_string(package + ":" + name)
536
537def _encode_raw_string(str):
538    """Encodes a string using the above encoding format.
539
540    Args:
541        str (string): The string to be encoded.
542
543    Returns:
544        An encoded version of the input string.
545    """
546    return _replace_all(str, _substitutions)
547
548# Expose the underlying encoding function for testing only.
549encode_raw_string_for_testing = _encode_raw_string
550
551def decode_crate_name_as_label_for_testing(crate_name):
552    """Decodes a crate_name that was encoded by encode_label_as_crate_name.
553
554    This is used to check that the encoding is bijective; it is expected to only
555    be used in tests.
556
557    Args:
558        crate_name (string): The name of the crate.
559
560    Returns:
561        A string representing the Bazel label (package and target).
562    """
563    return _replace_all(crate_name, [(t[1], t[0]) for t in _substitutions])
564
565def _replace_all(string, substitutions):
566    """Replaces occurrences of the given patterns in `string`.
567
568    There are a few reasons this looks complicated:
569    * The substitutions are performed with some priority, i.e. patterns that are
570      listed first in `substitutions` are higher priority than patterns that are
571      listed later.
572    * We also take pains to avoid doing replacements that overlap with each
573      other, since overlaps invalidate pattern matches.
574    * To avoid hairy offset invalidation, we apply the substitutions
575      right-to-left.
576    * To avoid the "_quote" -> "_quotequote_" rule introducing new pattern
577      matches later in the string during decoding, we take the leftmost
578      replacement, in cases of overlap.  (Note that no rule can induce new
579      pattern matches *earlier* in the string.) (E.g. "_quotedot_" encodes to
580      "_quotequote_dot_". Note that "_quotequote_" and "_dot_" both occur in
581      this string, and overlap.).
582
583    Args:
584        string (string): the string in which the replacements should be performed.
585        substitutions: the list of patterns and replacements to apply.
586
587    Returns:
588        A string with the appropriate substitutions performed.
589    """
590
591    # Find the highest-priority pattern matches for each string index, going
592    # left-to-right and skipping indices that are already involved in a
593    # pattern match.
594    plan = {}
595    matched_indices_set = {}
596    for pattern_start in range(len(string)):
597        if pattern_start in matched_indices_set:
598            continue
599        for (pattern, replacement) in substitutions:
600            if not string.startswith(pattern, pattern_start):
601                continue
602            length = len(pattern)
603            plan[pattern_start] = (length, replacement)
604            matched_indices_set.update([(pattern_start + i, True) for i in range(length)])
605            break
606
607    # Execute the replacement plan, working from right to left.
608    for pattern_start in sorted(plan.keys(), reverse = True):
609        length, replacement = plan[pattern_start]
610        after_pattern = pattern_start + length
611        string = string[:pattern_start] + replacement + string[after_pattern:]
612
613    return string
614
615def can_build_metadata(toolchain, ctx, crate_type):
616    """Can we build metadata for this rust_library?
617
618    Args:
619        toolchain (toolchain): The rust toolchain
620        ctx (ctx): The rule's context object
621        crate_type (String): one of lib|rlib|dylib|staticlib|cdylib|proc-macro
622
623    Returns:
624        bool: whether we can build metadata for this rule.
625    """
626
627    # In order to enable pipelined compilation we require that:
628    # 1) The _pipelined_compilation flag is enabled,
629    # 2) the OS running the rule is something other than windows as we require sandboxing (for now),
630    # 3) process_wrapper is enabled (this is disabled when compiling process_wrapper itself),
631    # 4) the crate_type is rlib or lib.
632    return toolchain._pipelined_compilation and \
633           toolchain.os != "windows" and \
634           ctx.attr._process_wrapper and \
635           crate_type in ("rlib", "lib")