wip

Author: hlopko

rust/private/rustc.bzl

@@ -1149,30 +1149,6 @@ def construct_arguments(
 
     return args, env
 
-def _get_dynamic_libraries_for_runtime(cc_infos, is_linking_statically):
-    libraries = []
-
-    for cc_info in cc_infos:
-        for linker_input in cc_info.linking_context.linker_inputs.to_list():
-            libraries.extend(linker_input.libraries)
-
-    dynamic_libraries_for_runtime = []
-    for library in libraries:
-        artifact = _get_dynamic_library_for_runtime_or_none(library, is_linking_statically)
-        if artifact != None:
-            dynamic_libraries_for_runtime.append(artifact)
-
-    return dynamic_libraries_for_runtime
-
-def _get_dynamic_library_for_runtime_or_none(library, is_linking_statically):
-    if library.dynamic_library == None:
-        return None
-
-    if is_linking_statically and (library.static_library != None or library.pic_static_library != None):
-        return None
-
-    return library.dynamic_library
-
 def rustc_compile_action(
         *,
         ctx,
@@ -1527,58 +1503,30 @@ def rustc_compile_action(
 
     experimental_use_coverage_metadata_files = toolchain._experimental_use_coverage_metadata_files
 
-    runfiles_list = []
-    for data_dep in getattr(ctx.attr, "data", []):
-        if data_dep[DefaultInfo].data_runfiles.files:
-            runfiles_list.append(data_dep[DefaultInfo].data_runfiles)
-        else:
-            # This branch ensures interop with custom Starlark rules following
-            # https://bazel.build/extending/rules#runfiles_features_to_avoid
-            runfiles_list.append(ctx.runfiles(transitive_files = data_dep[DefaultInfo].files))
-            runfiles_list.append(data_dep[DefaultInfo].default_runfiles)
-
-    for src in getattr(ctx.attr, "srcs", []):
-        runfiles_list.append(src[DefaultInfo].default_runfiles)
-
-    for dep in getattr(ctx.attr, "deps", []):
-        runfiles_list.append(dep[DefaultInfo].default_runfiles)
-
-    if not experimental_use_coverage_metadata_files:
-        runfiles_list.append(ctx.runfiles(files = coverage_runfiles))
-
-    common_runfiles = ctx.runfiles().merge_all(runfiles_list)
-
-    cc_infos_from_deps = _collect_cc_infos_from_deps(ctx, toolchain, crate_info)
-
-    dynamic_libraries = ctx.runfiles(
-        files = _get_dynamic_libraries_for_runtime(cc_infos_from_deps, True),
-    )
-    library_default_runfiles = None
-    library_data_runfiles = None
-    binary_runfiles = None
-    if crate_info.type in ["rlib", "lib", "dylib"]:
-        # Default runfiles for library include dynamic libraries that don't have
-        # a static library equivalent.
-        library_default_runfiles = common_runfiles.merge(dynamic_libraries)
-
-        data_runfiles = ctx.runfiles(
-            files = _get_dynamic_libraries_for_runtime(cc_infos_from_deps, False),
-        )
-
-        # Data runfiles for library include dynamic libraries even when they have
-        # a static library equivalent.
-        library_data_runfiles = common_runfiles.merge(data_runfiles)
-    else:
-        binary_runfiles = common_runfiles.merge(dynamic_libraries)
-
-        if getattr(ctx.attr, "crate", None):
-            crate_default_info = ctx.attr.crate[DefaultInfo]
-            binary_runfiles = binary_runfiles.merge_all(
-                [
-                    crate_default_info.default_runfiles,
-                    crate_default_info.data_runfiles,
-                ],
-            )
+    runfiles = ctx.runfiles(files = getattr(ctx.files, "data", []))
+    transitive_runfiles = []
+    crate_attr = getattr(ctx.attr, "crate", None)
+    for runfiles_attr in (
+        getattr(ctx.attr, "srcs", []),
+        getattr(ctx.attr, "deps", []),
+        getattr(ctx.attr, "data", []),
+        [crate_attr] if crate_attr else [],
+    ):
+        if not runfiles_attr:
+            continue
+        for target in runfiles_attr:
+            transitive_runfiles.append(target[DefaultInfo].default_runfiles)
+    if crate_info.type in ["bin", "cdylib", "staticlib"]:
+        dynamic_libraries = ctx.runfiles(files = [
+            library_to_link.dynamic_library
+            for dep in getattr(ctx.attr, "deps", [])
+            if CcInfo in dep
+            for linker_input in dep[CcInfo].linking_context.linker_inputs.to_list()
+            for library_to_link in linker_input.libraries
+            if _is_dylib(library_to_link)
+        ])
+        transitive_runfiles.append(dynamic_libraries)
+    runfiles = runfiles.merge_all(transitive_runfiles)
 
     # TODO: Remove after some resolution to
     # https://github.com/bazelbuild/rules_rust/issues/771
@@ -1601,9 +1549,7 @@ def rustc_compile_action(
         DefaultInfo(
             # nb. This field is required for cc_library to depend on our output.
             files = depset(outputs),
-            default_runfiles = library_default_runfiles,
-            data_runfiles = library_data_runfiles,
-            runfiles = binary_runfiles,
+            runfiles = runfiles,
             executable = executable,
         ),
     ]
@@ -1764,31 +1710,6 @@ def _add_codegen_units_flags(toolchain, emit, args):
 
     args.add("-Ccodegen-units={}".format(toolchain._codegen_units))
 
-def _collect_cc_infos_from_deps(ctx, toolchain, crate_info):
-    cc_infos = []
-
-    # Flattening is okay since crate_info.deps only records direct deps.
-    for dep in crate_info.deps.to_list():
-        if dep.cc_info:
-            # A Rust staticlib or shared library doesn't need to propagate linker inputs
-            # of its dependencies, except for shared libraries.
-            if crate_info.type in ["cdylib", "staticlib"]:
-                shared_linker_inputs = _collect_nonstatic_linker_inputs(dep.cc_info)
-                if shared_linker_inputs:
-                    linking_context = cc_common.create_linking_context(
-                        linker_inputs = depset(shared_linker_inputs),
-                    )
-                    cc_infos.append(CcInfo(linking_context = linking_context))
-            else:
-                cc_infos.append(dep.cc_info)
-
-    if crate_info.type in ("rlib", "lib"):
-        libstd_and_allocator_cc_info = _get_std_and_alloc_info(ctx, toolchain, crate_info)
-        if libstd_and_allocator_cc_info:
-            # TODO: if we already have an rlib in our deps, we could skip this
-            cc_infos.append(libstd_and_allocator_cc_info)
-    return cc_infos
-
 def establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_configuration, interface_library):
     """If the produced crate is suitable yield a CcInfo to allow for interop with cc rules
 
@@ -1871,7 +1792,28 @@ def establish_cc_info(ctx, attr, crate_info, toolchain, cc_toolchain, feature_co
     cc_infos = [
         CcInfo(linking_context = linking_context),
         toolchain.stdlib_linkflags,
-    ] + _collect_cc_infos_from_deps(ctx, toolchain, crate_info)
+    ]
+
+    # Flattening is okay since crate_info.deps only records direct deps.
+    for dep in crate_info.deps.to_list():
+        if dep.cc_info:
+            # A Rust staticlib or shared library doesn't need to propagate linker inputs
+            # of its dependencies, except for shared libraries.
+            if crate_info.type in ["cdylib", "staticlib"]:
+                shared_linker_inputs = _collect_nonstatic_linker_inputs(dep.cc_info)
+                if shared_linker_inputs:
+                    linking_context = cc_common.create_linking_context(
+                        linker_inputs = depset(shared_linker_inputs),
+                    )
+                    cc_infos.append(CcInfo(linking_context = linking_context))
+            else:
+                cc_infos.append(dep.cc_info)
+
+    if crate_info.type in ("rlib", "lib"):
+        libstd_and_allocator_cc_info = _get_std_and_alloc_info(ctx, toolchain, crate_info)
+        if libstd_and_allocator_cc_info:
+            # TODO: if we already have an rlib in our deps, we could skip this
+            cc_infos.append(libstd_and_allocator_cc_info)
 
     providers = [cc_common.merge_cc_infos(cc_infos = cc_infos)]
     if dot_a: