fork/rules_rust

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

Repana-ChowdappaAdd s390x arch support (#2616)3d1856b6

cleanup
17.8 KiB484 linesraw
1"""Unittests for rust rules."""
2
3load("@bazel_skylib//lib:unittest.bzl", "analysistest", "asserts")
4load("@rules_cc//cc:defs.bzl", "cc_library")
5load("//rust:defs.bzl", "rust_binary", "rust_library", "rust_proc_macro", "rust_shared_library", "rust_static_library")
6load(
7    "//test/unit:common.bzl",
8    "assert_argv_contains",
9    "assert_argv_contains_not",
10    "assert_argv_contains_prefix",
11    "assert_argv_contains_prefix_not",
12    "assert_argv_contains_prefix_suffix",
13    "assert_list_contains_adjacent_elements",
14)
15
16def _get_toolchain(ctx):
17    return ctx.attr._toolchain[platform_common.ToolchainInfo]
18
19def _get_darwin_component(arg):
20    # path/to/darwin_x86_64-fastbuild-fastbuild/package -> darwin_x86_64-fastbuild
21    darwin_component = [x for x in arg.split("/") if x.startswith("darwin")][0]
22
23    # darwin_x86_64-fastbuild -> darwin
24    return darwin_component.split("-")[0]
25
26def _rlib_has_no_native_libs_test_impl(ctx):
27    env = analysistest.begin(ctx)
28    tut = analysistest.target_under_test(env)
29    action = tut.actions[0]
30    assert_argv_contains(env, action, "--crate-type=rlib")
31    assert_argv_contains_not(env, action, "-lstatic=native_dep")
32    assert_argv_contains_not(env, action, "-ldylib=native_dep")
33    assert_argv_contains_prefix_not(env, action, "--codegen=linker=")
34    return analysistest.end(env)
35
36def _cdylib_has_native_libs_test_impl(ctx):
37    env = analysistest.begin(ctx)
38    tut = analysistest.target_under_test(env)
39    action = tut.actions[0]
40    toolchain = _get_toolchain(ctx)
41    compilation_mode = ctx.var["COMPILATION_MODE"]
42    pic_suffix = _get_pic_suffix(ctx, compilation_mode)
43    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
44    assert_argv_contains(env, action, "--crate-type=cdylib")
45    assert_argv_contains(env, action, "-lstatic=native_dep{}".format(pic_suffix))
46    if toolchain.target_os == "windows":
47        if toolchain.target_triple.abi == "msvc":
48            native_link_arg = "-Clink-arg=native_dep.lib"
49        else:
50            native_link_arg = "-Clink-arg=-lnative_dep.lib"
51    else:
52        native_link_arg = "-Clink-arg=-lnative_dep{}".format(pic_suffix)
53    assert_argv_contains(env, action, native_link_arg)
54    assert_argv_contains_prefix(env, action, "--codegen=linker=")
55    return analysistest.end(env)
56
57def _staticlib_has_native_libs_test_impl(ctx):
58    env = analysistest.begin(ctx)
59    tut = analysistest.target_under_test(env)
60    action = tut.actions[0]
61    toolchain = _get_toolchain(ctx)
62    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
63    assert_argv_contains(env, action, "--crate-type=staticlib")
64    assert_argv_contains(env, action, "-lstatic=native_dep")
65    if toolchain.target_os == "windows":
66        if toolchain.target_triple.abi == "msvc":
67            native_link_arg = "-Clink-arg=native_dep.lib"
68        else:
69            native_link_arg = "-Clink-arg=-lnative_dep.lib"
70    else:
71        native_link_arg = "-Clink-arg=-lnative_dep"
72    assert_argv_contains(env, action, native_link_arg)
73    assert_argv_contains_prefix(env, action, "--codegen=linker=")
74    return analysistest.end(env)
75
76def _proc_macro_has_native_libs_test_impl(ctx):
77    env = analysistest.begin(ctx)
78    tut = analysistest.target_under_test(env)
79    action = tut.actions[0]
80    toolchain = _get_toolchain(ctx)
81    compilation_mode = ctx.var["COMPILATION_MODE"]
82    pic_suffix = _get_pic_suffix(ctx, compilation_mode)
83    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
84    assert_argv_contains(env, action, "--crate-type=proc-macro")
85    assert_argv_contains(env, action, "-lstatic=native_dep{}".format(pic_suffix))
86    if toolchain.target_os == "windows":
87        if toolchain.target_triple.abi == "msvc":
88            native_link_arg = "-Clink-arg=native_dep.lib"
89        else:
90            native_link_arg = "-Clink-arg=-lnative_dep.lib"
91    else:
92        native_link_arg = "-Clink-arg=-lnative_dep{}".format(pic_suffix)
93    assert_argv_contains(env, action, native_link_arg)
94    assert_argv_contains_prefix(env, action, "--codegen=linker=")
95    return analysistest.end(env)
96
97def _bin_has_native_libs_test_impl(ctx):
98    env = analysistest.begin(ctx)
99    tut = analysistest.target_under_test(env)
100    action = tut.actions[0]
101    toolchain = _get_toolchain(ctx)
102    assert_argv_contains_prefix_suffix(env, action, "-Lnative=", "/native_deps")
103    assert_argv_contains(env, action, "-lstatic=native_dep")
104    if toolchain.target_os == "windows":
105        if toolchain.target_triple.abi == "msvc":
106            native_link_arg = "-Clink-arg=native_dep.lib"
107        else:
108            native_link_arg = "-Clink-arg=-lnative_dep.lib"
109    else:
110        native_link_arg = "-Clink-arg=-lnative_dep"
111    assert_argv_contains(env, action, native_link_arg)
112    assert_argv_contains_prefix(env, action, "--codegen=linker=")
113    return analysistest.end(env)
114
115def _extract_linker_args(argv):
116    return [
117        a.removeprefix("--codegen=").removeprefix("-C").removeprefix("link-arg=").removeprefix("link-args=")
118        for a in argv
119        if (
120            a.startswith("--codegen=link-arg=") or
121            a.startswith("--codegen=link-args=") or
122            a.startswith("-Clink-args=") or
123            a.startswith("-Clink-arg=") or
124            a.startswith("link-args=") or
125            a.startswith("link-arg=") or
126            a.startswith("-l") or
127            a.endswith(".lo") or
128            a.endswith(".o")
129        )
130    ]
131
132def _bin_has_native_dep_and_alwayslink_test_impl(ctx):
133    env = analysistest.begin(ctx)
134    tut = analysistest.target_under_test(env)
135    action = tut.actions[0]
136
137    toolchain = _get_toolchain(ctx)
138    compilation_mode = ctx.var["COMPILATION_MODE"]
139    workspace_prefix = "" if ctx.workspace_name == "rules_rust" else "external/rules_rust/"
140    link_args = _extract_linker_args(action.argv)
141    if toolchain.target_os == "darwin":
142        darwin_component = _get_darwin_component(link_args[-1])
143        want = [
144            "-lstatic=native_dep",
145            "-lnative_dep",
146            "-Wl,-force_load,bazel-out/{}-{}/bin/{}test/unit/native_deps/libalwayslink.lo".format(darwin_component, compilation_mode, workspace_prefix),
147        ]
148        assert_list_contains_adjacent_elements(env, link_args, want)
149    elif toolchain.target_os == "windows":
150        if toolchain.target_triple.abi == "msvc":
151            want = [
152                "-lstatic=native_dep",
153                "native_dep.lib",
154                "/WHOLEARCHIVE:bazel-out/x64_windows-{}/bin/{}test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode, workspace_prefix),
155            ]
156        else:
157            want = [
158                "-lstatic=native_dep",
159                "native_dep.lib",
160                "-Wl,--whole-archive",
161                "bazel-out/x64_windows-{}/bin/{}test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode, workspace_prefix),
162                "-Wl,--no-whole-archive",
163            ]
164    elif toolchain.target_arch == "s390x":
165        want = [
166            "-lstatic=native_dep",
167            "link-arg=-Wl,--whole-archive",
168            "link-arg=bazel-out/s390x-{}/bin/{}test/unit/native_deps/libalwayslink.lo".format(compilation_mode, workspace_prefix),
169            "link-arg=-Wl,--no-whole-archive",
170        ]
171    else:
172        want = [
173            "-lstatic=native_dep",
174            "-lnative_dep",
175            "-Wl,--whole-archive",
176            "bazel-out/k8-{}/bin/{}test/unit/native_deps/libalwayslink.lo".format(compilation_mode, workspace_prefix),
177            "-Wl,--no-whole-archive",
178        ]
179    assert_list_contains_adjacent_elements(env, link_args, want)
180    return analysistest.end(env)
181
182def _cdylib_has_native_dep_and_alwayslink_test_impl(ctx):
183    toolchain = _get_toolchain(ctx)
184
185    env = analysistest.begin(ctx)
186    tut = analysistest.target_under_test(env)
187    action = tut.actions[0]
188
189    linker_args = _extract_linker_args(action.argv)
190
191    toolchain = _get_toolchain(ctx)
192    compilation_mode = ctx.var["COMPILATION_MODE"]
193    workspace_prefix = "" if ctx.workspace_name == "rules_rust" else "external/rules_rust/"
194    pic_suffix = _get_pic_suffix(ctx, compilation_mode)
195    if toolchain.target_os == "darwin":
196        darwin_component = _get_darwin_component(linker_args[-1])
197        want = [
198            "-lstatic=native_dep{}".format(pic_suffix),
199            "-lnative_dep{}".format(pic_suffix),
200            "-Wl,-force_load,bazel-out/{}-{}/bin/{}test/unit/native_deps/libalwayslink{}.lo".format(darwin_component, compilation_mode, workspace_prefix, pic_suffix),
201        ]
202    elif toolchain.target_os == "windows":
203        if toolchain.target_triple.abi == "msvc":
204            want = [
205                "-lstatic=native_dep",
206                "native_dep.lib",
207                "/WHOLEARCHIVE:bazel-out/x64_windows-{}/bin/{}test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode, workspace_prefix),
208            ]
209        else:
210            want = [
211                "-lstatic=native_dep",
212                "native_dep.lib",
213                "-Wl,--whole-archive",
214                "bazel-out/x64_windows-{}/bin/{}test/unit/native_deps/alwayslink.lo.lib".format(compilation_mode, workspace_prefix),
215                "-Wl,--no-whole-archive",
216            ]
217    elif toolchain.target_arch == "s390x":
218        want = [
219            "-lstatic=native_dep{}".format(pic_suffix),
220            "link-arg=-Wl,--whole-archive",
221            "link-arg=bazel-out/s390x-{}/bin/{}test/unit/native_deps/libalwayslink{}.lo".format(compilation_mode, workspace_prefix, pic_suffix),
222            "link-arg=-Wl,--no-whole-archive",
223        ]
224    else:
225        want = [
226            "-lstatic=native_dep{}".format(pic_suffix),
227            "-lnative_dep{}".format(pic_suffix),
228            "-Wl,--whole-archive",
229            "bazel-out/k8-{}/bin/{}test/unit/native_deps/libalwayslink{}.lo".format(compilation_mode, workspace_prefix, pic_suffix),
230            "-Wl,--no-whole-archive",
231        ]
232    assert_list_contains_adjacent_elements(env, linker_args, want)
233    return analysistest.end(env)
234
235def _get_pic_suffix(ctx, compilation_mode):
236    toolchain = _get_toolchain(ctx)
237    if toolchain.target_os == "darwin" or toolchain.target_os == "windows":
238        return ""
239    return ".pic" if compilation_mode == "opt" else ""
240
241rlib_has_no_native_libs_test = analysistest.make(_rlib_has_no_native_libs_test_impl)
242staticlib_has_native_libs_test = analysistest.make(_staticlib_has_native_libs_test_impl, attrs = {
243    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
244})
245cdylib_has_native_libs_test = analysistest.make(_cdylib_has_native_libs_test_impl, attrs = {
246    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
247})
248proc_macro_has_native_libs_test = analysistest.make(_proc_macro_has_native_libs_test_impl, attrs = {
249    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
250})
251bin_has_native_libs_test = analysistest.make(_bin_has_native_libs_test_impl, attrs = {
252    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
253})
254bin_has_native_dep_and_alwayslink_test = analysistest.make(_bin_has_native_dep_and_alwayslink_test_impl, attrs = {
255    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
256})
257cdylib_has_native_dep_and_alwayslink_test = analysistest.make(_cdylib_has_native_dep_and_alwayslink_test_impl, attrs = {
258    "_toolchain": attr.label(default = Label("//rust/toolchain:current_rust_toolchain")),
259})
260
261def _native_dep_test():
262    rust_library(
263        name = "rlib_has_no_native_dep",
264        srcs = ["lib_using_native_dep.rs"],
265        edition = "2018",
266        deps = [":native_dep"],
267    )
268
269    rust_static_library(
270        name = "staticlib_has_native_dep",
271        srcs = ["lib_using_native_dep.rs"],
272        edition = "2018",
273        deps = [":native_dep"],
274    )
275
276    rust_shared_library(
277        name = "cdylib_has_native_dep",
278        srcs = ["lib_using_native_dep.rs"],
279        edition = "2018",
280        deps = [":native_dep"],
281    )
282
283    rust_proc_macro(
284        name = "proc_macro_has_native_dep",
285        srcs = ["proc_macro_using_native_dep.rs"],
286        edition = "2018",
287        deps = [":native_dep"],
288    )
289
290    rust_binary(
291        name = "bin_has_native_dep",
292        srcs = ["bin_using_native_dep.rs"],
293        edition = "2018",
294        deps = [":native_dep"],
295    )
296
297    rust_binary(
298        name = "bin_has_native_dep_and_alwayslink",
299        srcs = ["bin_using_native_dep.rs"],
300        edition = "2018",
301        deps = [":native_dep", ":alwayslink"],
302    )
303
304    cc_library(
305        name = "native_dep",
306        srcs = ["native_dep.cc"],
307        visibility = ["//test/unit:__subpackages__"],
308    )
309
310    cc_library(
311        name = "alwayslink",
312        srcs = ["alwayslink.cc"],
313        alwayslink = 1,
314    )
315
316    rust_shared_library(
317        name = "cdylib_has_native_dep_and_alwayslink",
318        srcs = ["lib_using_native_dep.rs"],
319        edition = "2018",
320        deps = [":native_dep", ":alwayslink"],
321    )
322
323    rlib_has_no_native_libs_test(
324        name = "rlib_has_no_native_libs_test",
325        target_under_test = ":rlib_has_no_native_dep",
326    )
327    staticlib_has_native_libs_test(
328        name = "staticlib_has_native_libs_test",
329        target_under_test = ":staticlib_has_native_dep",
330    )
331    cdylib_has_native_libs_test(
332        name = "cdylib_has_native_libs_test",
333        target_under_test = ":cdylib_has_native_dep",
334    )
335    proc_macro_has_native_libs_test(
336        name = "proc_macro_has_native_libs_test",
337        target_under_test = ":proc_macro_has_native_dep",
338    )
339    bin_has_native_libs_test(
340        name = "bin_has_native_libs_test",
341        target_under_test = ":bin_has_native_dep",
342    )
343    bin_has_native_dep_and_alwayslink_test(
344        name = "bin_has_native_dep_and_alwayslink_test",
345        target_under_test = ":bin_has_native_dep_and_alwayslink",
346    )
347    cdylib_has_native_dep_and_alwayslink_test(
348        name = "cdylib_has_native_dep_and_alwayslink_test",
349        target_under_test = ":cdylib_has_native_dep_and_alwayslink",
350    )
351
352def _linkopts_propagate_test_impl(ctx):
353    env = analysistest.begin(ctx)
354    tut = analysistest.target_under_test(env)
355    action = tut.actions[0]
356
357    # Ensure linkopts from direct (-Llinkoptdep1) and transitive
358    # (-Llinkoptdep2) dependencies are propagated.
359    # Consistently with cc rules, dependency linkopts take precedence over
360    # dependent linkopts (i.e. dependency linkopts appear later in the command
361    # line).
362
363    linkopt_args = _extract_linker_args(action.argv)
364    assert_list_contains_adjacent_elements(
365        env,
366        linkopt_args,
367        ["-Llinkoptdep1", "-Llinkoptdep2"],
368    )
369    return analysistest.end(env)
370
371linkopts_propagate_test = analysistest.make(_linkopts_propagate_test_impl)
372
373def _linkopts_test():
374    rust_binary(
375        name = "linkopts_rust_bin",
376        srcs = ["bin_using_native_dep.rs"],
377        edition = "2018",
378        deps = [":linkopts_native_dep_a"],
379    )
380
381    cc_library(
382        name = "linkopts_native_dep_a",
383        srcs = ["native_dep.cc"],
384        linkopts = ["-Llinkoptdep1"],
385        deps = [":linkopts_native_dep_b"],
386    )
387
388    cc_library(
389        name = "linkopts_native_dep_b",
390        linkopts = ["-Llinkoptdep2"],
391    )
392
393    linkopts_propagate_test(
394        name = "native_linkopts_propagate_test",
395        target_under_test = ":linkopts_rust_bin",
396    )
397
398def _check_additional_deps_test_impl(ctx, expect_additional_deps):
399    env = analysistest.begin(ctx)
400    tut = analysistest.target_under_test(env)
401    action = tut.actions[0]
402    additional_inputs = [inp.basename for inp in action.inputs.to_list()]
403    asserts.equals(env, "dynamic.lds" in additional_inputs, expect_additional_deps)
404    return analysistest.end(env)
405
406def _has_additional_deps_test_impl(ctx):
407    return _check_additional_deps_test_impl(ctx, expect_additional_deps = True)
408
409def _has_no_additional_deps_test_impl(ctx):
410    return _check_additional_deps_test_impl(ctx, expect_additional_deps = False)
411
412has_additional_deps_test = analysistest.make(_has_additional_deps_test_impl)
413has_no_additional_deps_test = analysistest.make(_has_no_additional_deps_test_impl)
414
415def _additional_deps_test():
416    rust_binary(
417        name = "bin_additional_deps",
418        srcs = ["bin_using_native_dep.rs"],
419        edition = "2018",
420        deps = [":additional_deps_cc"],
421    )
422
423    rust_shared_library(
424        name = "cdylib_additional_deps",
425        srcs = ["lib_using_native_dep.rs"],
426        edition = "2018",
427        deps = [":additional_deps_cc"],
428    )
429
430    rust_library(
431        name = "lib_additional_deps",
432        srcs = ["lib_using_native_dep.rs"],
433        edition = "2018",
434        deps = ["additional_deps_cc"],
435    )
436
437    cc_library(
438        name = "additional_deps_cc",
439        srcs = ["native_dep.cc"],
440        linkopts = ["-L$(execpath :dynamic.lds)"],
441        deps = [":dynamic.lds"],
442    )
443
444    has_additional_deps_test(
445        name = "bin_has_additional_deps_test",
446        target_under_test = ":bin_additional_deps",
447    )
448
449    has_additional_deps_test(
450        name = "cdylib_has_additional_deps_test",
451        target_under_test = ":cdylib_additional_deps",
452    )
453
454    has_no_additional_deps_test(
455        name = "lib_has_no_additional_deps_test",
456        target_under_test = ":lib_additional_deps",
457    )
458
459def native_deps_test_suite(name):
460    """Entry-point macro called from the BUILD file.
461
462    Args:
463        name: Name of the macro.
464    """
465    _native_dep_test()
466    _linkopts_test()
467    _additional_deps_test()
468
469    native.test_suite(
470        name = name,
471        tests = [
472            ":bin_has_additional_deps_test",
473            ":bin_has_native_dep_and_alwayslink_test",
474            ":bin_has_native_libs_test",
475            ":cdylib_has_additional_deps_test",
476            ":cdylib_has_native_dep_and_alwayslink_test",
477            ":cdylib_has_native_libs_test",
478            ":lib_has_no_additional_deps_test",
479            ":native_linkopts_propagate_test",
480            ":proc_macro_has_native_libs_test",
481            ":rlib_has_no_native_libs_test",
482            ":staticlib_has_native_libs_test",
483        ],
484    )