Type inference regression in 1.86 stable, due to unstable ByteStr

[beanow-at-crabnebula]

Code

I tried this code:

#[test]
fn infer_as_ref() {
    let left = std::borrow::Cow::Borrowed("lhs");
    let right = String::from("rhs");
    assert!(left != right.as_ref());
}

I expected to see this happen: Compiles OK and test passes.

Instead, this happened: Fails to compile,

   Compiling asref v0.1.0 (/tmp/asref)
error[E0283]: type annotations needed
 --> src/lib.rs:5:18
  |
5 |     assert!(left != right.as_ref());
  |                  ^^ cannot infer type for reference `&_`
  |
  = note: multiple `impl`s satisfying `Cow<'_, str>: PartialEq<&_>` found in the `alloc` crate:
          - impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>;
          - impl<'a> PartialEq<&'a ByteStr> for Cow<'a, str>;

error[E0283]: type annotations needed
 --> src/lib.rs:5:27
  |
5 |     assert!(left != right.as_ref());
  |                           ^^^^^^
  |
  = note: multiple `impl`s satisfying `String: AsRef<_>` found in the following crates: `alloc`, `std`:
          - impl AsRef<OsStr> for String;
          - impl AsRef<Path> for String;
          - impl AsRef<[u8]> for String;
          - impl AsRef<str> for String;
help: try using a fully qualified path to specify the expected types
  |
5 -     assert!(left != right.as_ref());
5 +     assert!(left != <String as AsRef<T>>::as_ref(&right));
  |

For more information about this error, try `rustc --explain E0283`.
error: could not compile `asref` (lib test) due to 2 previous errors

Note: impl<'a> PartialEq<&'a ByteStr> for Cow<'a, str> should not be implemented as this should have a #![feature(bstr)] gate.

Version it worked on

It most recently worked on: Rust 1.85.1

Version with regression

rustc --version --verbose:

rustc 1.86.0 (05f9846f8 2025-03-31)
binary: rustc
commit-hash: 05f9846f893b09a1be1fc8560e33fc3c815cfecb
commit-date: 2025-03-31
host: x86_64-unknown-linux-gnu
release: 1.86.0
LLVM version: 19.1.7

Backtrace

Backtrace

<backtrace>

[beanow-at-crabnebula]

Related tracking issue #134915

A code example "in the wild" elastio/ssstar@2e66a5f

[apiraino]

Issue was discussed by team library, copying here from Zulip.

In the meeting t-libs were minded to call this acceptable breakage since the scope is quite small. E.g. crater¹ came back clean so it's unlikely to be a common issue. Though it was noted that crater may miss things due to the no disk space errors (including, apparently, the real world example).

@rustbot label -I-prioritize

Footnotes

1. our test run on a wide number of crates to verify if some change has impact on the ecosystrem ↩

[Amanieu]

This regression was supposed to be caught in the beta crater run in #137445, but it seems that it hit rust-lang/crater#700 (disk full error) during both the baseline (1.85) and beta (1.86) compilations of the crate.

cc @rust-lang/infra

[beanow-at-crabnebula]

Looking at the Zulip thread I feel there may be a misunderstanding.

@apiraino mentioned:

this seems something good to fix before goes stable

This is a regression where an unstable feature is causing a regression in stable release 1.86.0.

I'd agree it's a small regression and when stabilization of ByteStr happens it may be an acceptable one.
But I think it's surprising that an unstable feature causes regressions for stable rust.

I think there may be just some overlooked feature gates that need to be added for this to be properly contained to unstable.

[beanow-at-crabnebula]

For example, in the context of stable Rust there's no reason for type inference to consider a PartialEq Trait implementation for ByteStr when the ByteStr struct is not available and shouldn't be possible to create.

error[E0658]: use of unstable library feature `bstr`
  --> main.rs:90:10
   |
90 |     let a = std::bstr::ByteStr::new(b"abc");
   |             ^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: see issue #134915 <https://github.com/rust-lang/rust/issues/134915> for more information

[beanow-at-crabnebula]

The particular implementation from this code example seems to be this

rust/library/alloc/src/bstr.rs

Line 691 in 05f9846

impl_partial_eq_ord_cow!(&'a ByteStr, Cow<'a, str>);

Which appears to have the right unstable flags.

rust/library/alloc/src/bstr.rs

Lines 489 to 535 in 05f9846

	macro_rules! impl_partial_eq_ord_cow {
	($lhs:ty, $rhs:ty) => {
	#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
	#[allow(unused_lifetimes)]
	#[unstable(feature = "bstr", issue = "134915")]
	impl<'a> PartialEq<$rhs> for $lhs {
	#[inline]
	fn eq(&self, other: &$rhs) -> bool {
	let other: &[u8] = (&**other).as_ref();
	PartialEq::eq(self.as_bytes(), other)
	}
	}
	#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
	#[allow(unused_lifetimes)]
	#[unstable(feature = "bstr", issue = "134915")]
	impl<'a> PartialEq<$lhs> for $rhs {
	#[inline]
	fn eq(&self, other: &$lhs) -> bool {
	let this: &[u8] = (&**self).as_ref();
	PartialEq::eq(this, other.as_bytes())
	}
	}
	#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
	#[allow(unused_lifetimes)]
	#[unstable(feature = "bstr", issue = "134915")]
	impl<'a> PartialOrd<$rhs> for $lhs {
	#[inline]
	fn partial_cmp(&self, other: &$rhs) -> Option<Ordering> {
	let other: &[u8] = (&**other).as_ref();
	PartialOrd::partial_cmp(self.as_bytes(), other)
	}
	}
	#[cfg(not(test))] // https://github.com/rust-lang/rust/issues/135100
	#[allow(unused_lifetimes)]
	#[unstable(feature = "bstr", issue = "134915")]
	impl<'a> PartialOrd<$lhs> for $rhs {
	#[inline]
	fn partial_cmp(&self, other: &$lhs) -> Option<Ordering> {
	let this: &[u8] = (&**self).as_ref();
	PartialOrd::partial_cmp(this, other.as_bytes())
	}
	}
	};
	}

Maybe this is a deeper issue where type inference doesn't filter out unstable candidates that aren't enabled?