Reject EII overrides of dylib defaults

Author: qaijuang

compiler/rustc_passes/src/eii.rs

@@ -6,6 +6,7 @@ use std::iter;
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::attrs::{EiiDecl, EiiImpl};
 use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
+use rustc_middle::middle::dependency_format::Linkage;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::CrateType;
 
@@ -26,6 +27,23 @@ fn get_checking_mode(tcx: TyCtxt<'_>) -> CheckingMode {
     }
 }
 
+fn linked_in_dylib(tcx: TyCtxt<'_>, cnum: CrateNum) -> bool {
+    if cnum == LOCAL_CRATE {
+        return false;
+    }
+
+    let source = tcx.used_crate_source(cnum);
+    // If the only code artifact available is a dylib, any default impl inside it
+    // has already been materialized and cannot be overridden downstream.
+    let only_available_as_dylib =
+        source.rlib.is_none() && (source.dylib.is_some() || source.sdylib_interface.is_some());
+
+    only_available_as_dylib
+        || tcx.dependency_formats(()).iter().any(|(_, formats)| {
+            matches!(formats.get(cnum), Some(Linkage::Dynamic | Linkage::IncludedFromDylib))
+        })
+}
+
 /// Checks for a given crate, what EIIs need to be generated in it.
 /// This is usually a small subset of all EIIs.
 ///
@@ -93,21 +111,31 @@ pub(crate) fn check_externally_implementable_items<'tcx>(tcx: TyCtxt<'tcx>, ():
             }
         }
 
-        // more than one explicit implementation (across all crates)
-        // is instantly an error.
-        if explicit_impls.len() > 1 {
+        let mut duplicate_impls = explicit_impls.clone();
+        if !duplicate_impls.is_empty() {
+            duplicate_impls.extend(
+                default_impls
+                    .iter()
+                    .copied()
+                    .filter(|(_, impl_crate)| linked_in_dylib(tcx, *impl_crate)),
+            );
+        }
+
+        // more than one explicit implementation (across all crates), or an explicit
+        // implementation overriding a default implementation from a dylib, is instantly an error.
+        if duplicate_impls.len() > 1 {
             tcx.dcx().emit_err(DuplicateEiiImpls {
                 name: decl.name.name,
-                first_span: tcx.def_span(explicit_impls[0].0),
-                first_crate: tcx.crate_name(explicit_impls[0].1),
-                second_span: tcx.def_span(explicit_impls[1].0),
-                second_crate: tcx.crate_name(explicit_impls[1].1),
+                first_span: tcx.def_span(duplicate_impls[0].0),
+                first_crate: tcx.crate_name(duplicate_impls[0].1),
+                second_span: tcx.def_span(duplicate_impls[1].0),
+                second_crate: tcx.crate_name(duplicate_impls[1].1),
 
                 help: (),
 
-                additional_crates: (explicit_impls.len() > 2).then_some(()),
-                num_additional_crates: explicit_impls.len() - 2,
-                additional_crate_names: explicit_impls[2..]
+                additional_crates: (duplicate_impls.len() > 2).then_some(()),
+                num_additional_crates: duplicate_impls.len() - 2,
+                additional_crate_names: duplicate_impls[2..]
                     .iter()
                     .map(|i| format!("`{}`", tcx.crate_name(i.1)))
                     .collect::<Vec<_>>()

tests/ui/eii/duplicate/auxiliary/dylib_default.rs

@@ -0,0 +1,5 @@
+#![crate_type = "dylib"]
+#![feature(extern_item_impls)]
+
+#[eii(eii1)]
+fn decl1(x: u64) {}

tests/ui/eii/duplicate/dylib_default_duplicate.rs

@@ -0,0 +1,19 @@
+//@ aux-build: dylib_default.rs
+//@ needs-crate-type: dylib
+//@ ignore-backends: gcc
+// FIXME: linking on windows (specifically mingw) not yet supported, see tracking issue #125418
+//@ ignore-windows
+// Regression test for https://github.com/rust-lang/rust/issues/156320.
+// A default implementation from an upstream dylib has already been selected and
+// must not be overridden by a downstream explicit implementation.
+#![feature(extern_item_impls)]
+
+extern crate dylib_default;
+
+#[unsafe(dylib_default::eii1)]
+fn other(x: u64) {
+    //~^ ERROR multiple implementations of `#[eii1]`
+    println!("1{x}");
+}
+
+fn main() {}

tests/ui/eii/duplicate/dylib_default_duplicate.stderr

@@ -0,0 +1,15 @@
+error: multiple implementations of `#[eii1]`
+  --> $DIR/dylib_default_duplicate.rs:14:1
+   |
+LL | fn other(x: u64) {
+   | ^^^^^^^^^^^^^^^^ first implemented here in crate `dylib_default_duplicate`
+   |
+  ::: $DIR/auxiliary/dylib_default.rs:5:1
+   |
+LL | fn decl1(x: u64) {}
+   | ---------------- also implemented here in crate `dylib_default`
+   |
+   = help: an "externally implementable item" can only have a single implementation in the final artifact. When multiple implementations are found, also in different crates, they conflict
+
+error: aborting due to 1 previous error
+