We can only link to monomorphizations from upstream crates if we know

they will be statically linked.

In the particular case of #64872, we get burned by an
attempt to link to a monomorphization in libcore.rlib that ends up not
being exported by libstd.dylib. (For that scenario, the attempt to
lookup the linkage returns `None`, which led us terribly astray.)
(That scenario is encoded in a test in a follow-on commit.)

Also added some `log::info` output for the `None` case, because I want
easy access in all of our builds to inspect what goes on in this
logic.

In response to review feedback, I had tried to revise the fix to be
more nuanced in handling of `None` (i.e., the case which I've
previously asserted to be "unknown linkage"). Alex's take on matters
is that we should use the output crate type to determine what format
the dependency here will have. However, further testing showed that
approach to be flawed.

So I added debugflag: `-Z share-generics-for-unknown-linkage`, to make
it easy to recover the earlier behavior (which I nonetheless assert to
be buggy in general), and use that flag to keep one of our codegen
tests working.

Author: pnkfelix

src/librustc/session/config.rs

@@ -1433,6 +1433,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
         "tell the linker to strip debuginfo when building without debuginfo enabled."),
     share_generics: Option<bool> = (None, parse_opt_bool, [TRACKED],
         "make the current crate share its generic instantiations"),
+    share_generics_for_unknown_linkage: bool = (false, parse_bool, [TRACKED],
+        "optimistically assume upstream crates with unknown linkage can share generics"),
     chalk: bool = (false, parse_bool, [TRACKED],
         "enable the experimental Chalk-based trait solving engine"),
     no_parallel_llvm: bool = (false, parse_bool, [UNTRACKED],

src/librustc_metadata/cstore_impl.rs

@@ -243,8 +243,45 @@ provide! { <'tcx> tcx, def_id, other, cdata,
         let formats = tcx.dependency_formats(LOCAL_CRATE);
         let remove_generics = formats.iter().any(|(_ty, list)| {
             match list.get(def_id.krate.as_usize() - 1) {
-                Some(Linkage::IncludedFromDylib) | Some(Linkage::Dynamic) => true,
-                _ => false,
+                Some(l @ Linkage::NotLinked) |
+                Some(l @ Linkage::IncludedFromDylib) |
+                Some(l @ Linkage::Dynamic) => {
+                    log::debug!("compiling `{B}` def_id: {D:?} cannot reuse generics \
+                                 from crate `{A}` because it has linkage {L:?}",
+                                A=tcx.crate_name(def_id.krate),
+                                B=tcx.crate_name(LOCAL_CRATE),
+                                D=def_id,
+                                L=l);
+                    true
+                }
+
+                Some(Linkage::Static) => {
+                    log::debug!("compiling `{B}` def_id: {D:?} attempt to reuse generics \
+                                 from statically-linked crate `{A}`",
+                                A=tcx.crate_name(def_id.krate),
+                                B=tcx.crate_name(LOCAL_CRATE),
+                                D=def_id);
+                    false
+                }
+
+                None => {
+                    // rust-lang/rust#65890: A has unknown dependency format when compiling B.
+                    if tcx.sess.opts.debugging_opts.share_generics_for_unknown_linkage {
+                        log::info!("`{B}`, crate-type {O:?}: attempt to reuse generics \
+                                    from crate `{A}` despite its unknown dependency format",
+                                   A=tcx.crate_name(def_id.krate),
+                                   B=tcx.crate_name(LOCAL_CRATE),
+                                   O=_ty);
+                        false
+                    } else {
+                        log::info!("`{B}`, crate-type {O:?}: cannot reuse generics \
+                                    from crate `{A}` because it has unknown dependency format",
+                                   A=tcx.crate_name(def_id.krate),
+                                   B=tcx.crate_name(LOCAL_CRATE),
+                                   O=_ty);
+                        true
+                    }
+                }
             }
         });
         if remove_generics {

src/test/codegen-units/partitioning/shared-generics.rs

@@ -1,6 +1,7 @@
 // ignore-tidy-linelength
 // no-prefer-dynamic
-// compile-flags:-Zprint-mono-items=eager -Zshare-generics=yes -Zincremental=tmp/partitioning-tests/shared-generics-exe
+// FIXME: Use `-Z share-generics-for-unknown-linkage` to workaround rust-lang/rust#65890
+// compile-flags:-Zprint-mono-items=eager -Zshare-generics=yes -Zincremental=tmp/partitioning-tests/shared-generics-exe -Z share-generics-for-unknown-linkage
 
 #![crate_type="rlib"]