fork/rules_rust

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

Chris FredricksonReplace slashes with underscores in default crate names. (#1336)a066bfed

0.5.0
20.3 KiB588 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")]
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):
101    """Returns the name of a library artifact, eg. libabc.a -> abc
102
103    Args:
104        lib (File): A library file
105
106    Returns:
107        str: The name of the library
108    """
109    # On macos and windows, dynamic/static libraries always end with the
110    # extension and potential versions will be before the extension, and should
111    # be part of the library name.
112    # On linux, the version usually comes after the extension.
113    # So regardless of the platform we want to find the extension and make
114    # everything left to it the library name.
115
116    # Search for the extension - starting from the right - by removing any
117    # trailing digit.
118    comps = lib.basename.split(".")
119    for comp in reversed(comps):
120        if comp.isdigit():
121            comps.pop()
122        else:
123            break
124
125    # The library name is now everything minus the extension.
126    libname = ".".join(comps[:-1])
127
128    if libname.startswith("lib"):
129        return libname[3:]
130    else:
131        return libname
132
133def abs(value):
134    """Returns the absolute value of a number.
135
136    Args:
137      value (int): A number.
138
139    Returns:
140      int: The absolute value of the number.
141    """
142    if value < 0:
143        return -value
144    return value
145
146def determine_output_hash(crate_root, label):
147    """Generates a hash of the crate root file's path.
148
149    Args:
150        crate_root (File): The crate's root file (typically `lib.rs`).
151        label (Label): The label of the target.
152
153    Returns:
154        str: A string representation of the hash.
155    """
156
157    # Take the absolute value of hash() since it could be negative.
158    h = abs(hash(crate_root.path) + hash(repr(label)))
159    return repr(h)
160
161def get_preferred_artifact(library_to_link, use_pic):
162    """Get the first available library to link from a LibraryToLink object.
163
164    Args:
165        library_to_link (LibraryToLink): See the followg links for additional details:
166            https://docs.bazel.build/versions/master/skylark/lib/LibraryToLink.html
167        use_pic: If set, prefers pic_static_library over static_library.
168
169    Returns:
170        File: Returns the first valid library type (only one is expected)
171    """
172    if use_pic:
173        # Order consistent with https://github.com/bazelbuild/bazel/blob/815dfdabb7df31d4e99b6fc7616ff8e2f9385d98/src/main/java/com/google/devtools/build/lib/rules/cpp/CcLinkingContext.java#L437.
174        return (
175            library_to_link.pic_static_library or
176            library_to_link.static_library or
177            library_to_link.interface_library or
178            library_to_link.dynamic_library
179        )
180    else:
181        return (
182            library_to_link.static_library or
183            library_to_link.pic_static_library or
184            library_to_link.interface_library or
185            library_to_link.dynamic_library
186        )
187
188def _expand_location(ctx, env, data):
189    """A trivial helper for `_expand_locations`
190
191    Args:
192        ctx (ctx): The rule's context object
193        env (str): The value possibly containing location macros to expand.
194        data (sequence of Targets): see `_expand_locations`
195
196    Returns:
197        string: The location-macro expanded version of the string.
198    """
199    for directive in ("$(execpath ", "$(location "):
200        if directive in env:
201            # build script runner will expand pwd to execroot for us
202            env = env.replace(directive, "${pwd}/" + directive)
203    return ctx.expand_location(env, data)
204
205def expand_dict_value_locations(ctx, env, data):
206    """Performs location-macro expansion on string values.
207
208    $(execroot ...) and $(location ...) are prefixed with ${pwd},
209    which process_wrapper and build_script_runner will expand at run time
210    to the absolute path. This is necessary because include_str!() is relative
211    to the currently compiled file, and build scripts run relative to the
212    manifest dir, so we can not use execroot-relative paths.
213
214    $(rootpath ...) is unmodified, and is useful for passing in paths via
215    rustc_env that are encoded in the binary with env!(), but utilized at
216    runtime, such as in tests. The absolute paths are not usable in this case,
217    as compilation happens in a separate sandbox folder, so when it comes time
218    to read the file at runtime, the path is no longer valid.
219
220    See [`expand_location`](https://docs.bazel.build/versions/main/skylark/lib/ctx.html#expand_location) for detailed documentation.
221
222    Args:
223        ctx (ctx): The rule's context object
224        env (dict): A dict whose values we iterate over
225        data (sequence of Targets): The targets which may be referenced by
226            location macros. This is expected to be the `data` attribute of
227            the target, though may have other targets or attributes mixed in.
228
229    Returns:
230        dict: A dict of environment variables with expanded location macros
231    """
232    return dict([(k, _expand_location(ctx, v, data)) for (k, v) in env.items()])
233
234def expand_list_element_locations(ctx, args, data):
235    """Performs location-macro expansion on a list of string values.
236
237    $(execroot ...) and $(location ...) are prefixed with ${pwd},
238    which process_wrapper and build_script_runner will expand at run time
239    to the absolute path.
240
241    See [`expand_location`](https://docs.bazel.build/versions/main/skylark/lib/ctx.html#expand_location) for detailed documentation.
242
243    Args:
244        ctx (ctx): The rule's context object
245        args (list): A list we iterate over
246        data (sequence of Targets): The targets which may be referenced by
247            location macros. This is expected to be the `data` attribute of
248            the target, though may have other targets or attributes mixed in.
249
250    Returns:
251        list: A list of arguments with expanded location macros
252    """
253    return [_expand_location(ctx, arg, data) for arg in args]
254
255def name_to_crate_name(name):
256    """Converts a build target's name into the name of its associated crate.
257
258    Crate names cannot contain certain characters, such as -, which are allowed
259    in build target names. All illegal characters will be converted to
260    underscores.
261
262    This is a similar conversion as that which cargo does, taking a
263    `Cargo.toml`'s `package.name` and canonicalizing it
264
265    Note that targets can specify the `crate_name` attribute to customize their
266    crate name; in situations where this is important, use the
267    compute_crate_name() function instead.
268
269    Args:
270        name (str): The name of the target.
271
272    Returns:
273        str: The name of the crate for this target.
274    """
275    for illegal in ("-", "/"):
276        name = name.replace(illegal, "_")
277    return name
278
279def _invalid_chars_in_crate_name(name):
280    """Returns any invalid chars in the given crate name.
281
282    Args:
283        name (str): Name to test.
284
285    Returns:
286        list: List of invalid characters in the crate name.
287    """
288
289    return dict([(c, ()) for c in name.elems() if not (c.isalnum() or c == "_")]).keys()
290
291def compute_crate_name(workspace_name, label, toolchain, name_override = None):
292    """Returns the crate name to use for the current target.
293
294    Args:
295        workspace_name (string): The current workspace name.
296        label (struct): The label of the current target.
297        toolchain (struct): The toolchain in use for the target.
298        name_override (String): An optional name to use (as an override of label.name).
299
300    Returns:
301        str: The crate name to use for this target.
302    """
303    if name_override:
304        invalid_chars = _invalid_chars_in_crate_name(name_override)
305        if invalid_chars:
306            fail("Crate name '{}' contains invalid character(s): {}".format(
307                name_override,
308                " ".join(invalid_chars),
309            ))
310        return name_override
311
312    if (toolchain and label and toolchain._rename_first_party_crates and
313        should_encode_label_in_crate_name(workspace_name, label, toolchain._third_party_dir)):
314        crate_name = encode_label_as_crate_name(label.package, label.name)
315    else:
316        crate_name = name_to_crate_name(label.name)
317
318    invalid_chars = _invalid_chars_in_crate_name(crate_name)
319    if invalid_chars:
320        fail(
321            "Crate name '{}' ".format(crate_name) +
322            "derived from Bazel target name '{}' ".format(label.name) +
323            "contains invalid character(s): {}\n".format(" ".join(invalid_chars)) +
324            "Consider adding a crate_name attribute to set a valid crate name",
325        )
326    return crate_name
327
328def dedent(doc_string):
329    """Remove any common leading whitespace from every line in text.
330
331    This functionality is similar to python's `textwrap.dedent` functionality
332    https://docs.python.org/3/library/textwrap.html#textwrap.dedent
333
334    Args:
335        doc_string (str): A docstring style string
336
337    Returns:
338        str: A string optimized for stardoc rendering
339    """
340    lines = doc_string.splitlines()
341    if not lines:
342        return doc_string
343
344    # If the first line is empty, use the second line
345    first_line = lines[0]
346    if not first_line:
347        first_line = lines[1]
348
349    # Detect how much space prepends the first line and subtract that from all lines
350    space_count = len(first_line) - len(first_line.lstrip())
351
352    # If there are no leading spaces, do not alter the docstring
353    if space_count == 0:
354        return doc_string
355    else:
356        # Remove the leading block of spaces from the current line
357        block = " " * space_count
358        return "\n".join([line.replace(block, "", 1).rstrip() for line in lines])
359
360def make_static_lib_symlink(actions, rlib_file):
361    """Add a .a symlink to an .rlib file.
362
363    The name of the symlink is derived from the <name> of the <name>.rlib file as follows:
364    * `<name>.a`, if <name> starts with `lib`
365    * `lib<name>.a`, otherwise.
366
367    For example, the name of the symlink for
368    * `libcratea.rlib` is `libcratea.a`
369    * `crateb.rlib` is `libcrateb.a`.
370
371    Args:
372        actions (actions): The rule's context actions object.
373        rlib_file (File): The file to symlink, which must end in .rlib.
374
375    Returns:
376        The symlink's File.
377    """
378    if not rlib_file.basename.endswith(".rlib"):
379        fail("file is not an .rlib: ", rlib_file.basename)
380    basename = rlib_file.basename[:-5]
381    if not basename.startswith("lib"):
382        basename = "lib" + basename
383    dot_a = actions.declare_file(basename + ".a", sibling = rlib_file)
384    actions.symlink(output = dot_a, target_file = rlib_file)
385    return dot_a
386
387def is_exec_configuration(ctx):
388    """Determine if a context is building for the exec configuration.
389
390    This is helpful when processing command line flags that should apply
391    to the target configuration but not the exec configuration.
392
393    Args:
394        ctx (ctx): The ctx object for the current target.
395
396    Returns:
397        True if the exec configuration is detected, False otherwise.
398    """
399
400    # TODO(djmarcin): Is there any better way to determine cfg=exec?
401    return ctx.genfiles_dir.path.find("-exec-") != -1
402
403def transform_deps(deps):
404    """Transforms a [Target] into [DepVariantInfo].
405
406    This helper function is used to transform ctx.attr.deps and ctx.attr.proc_macro_deps into
407    [DepVariantInfo].
408
409    Args:
410        deps (list of Targets): Dependencies coming from ctx.attr.deps or ctx.attr.proc_macro_deps
411
412    Returns:
413        list of DepVariantInfos.
414    """
415    return [DepVariantInfo(
416        crate_info = dep[CrateInfo] if CrateInfo in dep else None,
417        dep_info = dep[DepInfo] if DepInfo in dep else None,
418        build_info = dep[BuildInfo] if BuildInfo in dep else None,
419        cc_info = dep[CcInfo] if CcInfo in dep else None,
420    ) for dep in deps]
421
422def get_import_macro_deps(ctx):
423    """Returns a list of targets to be added to proc_macro_deps.
424
425    Args:
426        ctx (struct): the ctx of the current target.
427
428    Returns:
429        list of Targets. Either empty (if the fake import macro implementation
430        is being used), or a singleton list with the real implementation.
431    """
432    if ctx.attr._import_macro_dep.label.name == "fake_import_macro_impl":
433        return []
434
435    return [ctx.attr._import_macro_dep]
436
437def should_encode_label_in_crate_name(workspace_name, label, third_party_dir):
438    """Determines if the crate's name should include the Bazel label, encoded.
439
440    Crate names may only encode the label if the target is in the current repo,
441    the target is not in the third_party_dir, and the current repo is not
442    rules_rust.
443
444    Args:
445        workspace_name (string): The name of the current workspace.
446        label (Label): The package in question.
447        third_party_dir (string): The directory in which third-party packages are kept.
448
449    Returns:
450        True if the crate name should encode the label, False otherwise.
451    """
452
453    # TODO(hlopko): This code assumes a monorepo; make it work with external
454    # repositories as well.
455    return (
456        workspace_name != "rules_rust" and
457        not label.workspace_root and
458        not ("//" + label.package + "/").startswith(third_party_dir + "/")
459    )
460
461# This is a list of pairs, where the first element of the pair is a character
462# that is allowed in Bazel package or target names but not in crate names; and
463# the second element is an encoding of that char suitable for use in a crate
464# name.
465_encodings = (
466    (":", "colon"),
467    ("!", "bang"),
468    ("%", "percent"),
469    ("@", "at"),
470    ("^", "caret"),
471    ("`", "backtick"),
472    (" ", "space"),
473    ("\"", "quote"),
474    ("#", "hash"),
475    ("$", "dollar"),
476    ("&", "ampersand"),
477    ("'", "backslash"),
478    ("(", "lparen"),
479    (")", "rparen"),
480    ("*", "star"),
481    ("-", "dash"),
482    ("+", "plus"),
483    (",", "comma"),
484    (";", "semicolon"),
485    ("<", "langle"),
486    ("=", "equal"),
487    (">", "rangle"),
488    ("?", "question"),
489    ("[", "lbracket"),
490    ("]", "rbracket"),
491    ("{", "lbrace"),
492    ("|", "pipe"),
493    ("}", "rbrace"),
494    ("~", "tilde"),
495    ("/", "slash"),
496    (".", "dot"),
497)
498
499# For each of the above encodings, we generate two substitution rules: one that
500# ensures any occurrences of the encodings themselves in the package/target
501# aren't clobbered by this translation, and one that does the encoding itself.
502# We also include a rule that protects the clobbering-protection rules from
503# getting clobbered.
504_substitutions = [("_quote", "_quotequote_")] + [
505    subst
506    for (pattern, replacement) in _encodings
507    for subst in (
508        ("_{}_".format(replacement), "_quote{}_".format(replacement)),
509        (pattern, "_{}_".format(replacement)),
510    )
511]
512
513def encode_label_as_crate_name(package, name):
514    """Encodes the package and target names in a format suitable for a crate name.
515
516    Args:
517        package (string): The package of the target in question.
518        name (string): The name of the target in question.
519
520    Returns:
521        A string that encodes the package and target name, to be used as the crate's name.
522    """
523    full_name = package + ":" + name
524    return _replace_all(full_name, _substitutions)
525
526def decode_crate_name_as_label_for_testing(crate_name):
527    """Decodes a crate_name that was encoded by encode_label_as_crate_name.
528
529    This is used to check that the encoding is bijective; it is expected to only
530    be used in tests.
531
532    Args:
533        crate_name (string): The name of the crate.
534
535    Returns:
536        A string representing the Bazel label (package and target).
537    """
538    return _replace_all(crate_name, [(t[1], t[0]) for t in _substitutions])
539
540def _replace_all(string, substitutions):
541    """Replaces occurrences of the given patterns in `string`.
542
543    There are a few reasons this looks complicated:
544    * The substitutions are performed with some priority, i.e. patterns that are
545      listed first in `substitutions` are higher priority than patterns that are
546      listed later.
547    * We also take pains to avoid doing replacements that overlap with each
548      other, since overlaps invalidate pattern matches.
549    * To avoid hairy offset invalidation, we apply the substitutions
550      right-to-left.
551    * To avoid the "_quote" -> "_quotequote_" rule introducing new pattern
552      matches later in the string during decoding, we take the leftmost
553      replacement, in cases of overlap.  (Note that no rule can induce new
554      pattern matches *earlier* in the string.) (E.g. "_quotedot_" encodes to
555      "_quotequote_dot_". Note that "_quotequote_" and "_dot_" both occur in
556      this string, and overlap.).
557
558    Args:
559        string (string): the string in which the replacements should be performed.
560        substitutions: the list of patterns and replacements to apply.
561
562    Returns:
563        A string with the appropriate substitutions performed.
564    """
565
566    # Find the highest-priority pattern matches for each string index, going
567    # left-to-right and skipping indices that are already involved in a
568    # pattern match.
569    plan = {}
570    matched_indices_set = {}
571    for pattern_start in range(len(string)):
572        if pattern_start in matched_indices_set:
573            continue
574        for (pattern, replacement) in substitutions:
575            if not string.startswith(pattern, pattern_start):
576                continue
577            length = len(pattern)
578            plan[pattern_start] = (length, replacement)
579            matched_indices_set.update([(pattern_start + i, True) for i in range(length)])
580            break
581
582    # Execute the replacement plan, working from right to left.
583    for pattern_start in sorted(plan.keys(), reverse = True):
584        length, replacement = plan[pattern_start]
585        after_pattern = pattern_start + length
586        string = string[:pattern_start] + replacement + string[after_pattern:]
587
588    return string