Closed
Description
auto-reduced (treereduce-rust):
fn bar() -> impl Into<
[u8; {
f_t(&*s);
c(&*s);
c(&*s);
struct X;
c1(*x);
let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> { *x };
}],
> {
[99]
}
original code
original:
// run-pass
#![allow(dead_code)]
fn foo<T>(t: T) -> impl Into<[T; { const FOO: usize = 1; FOO }]> {
[t]
}
fn bar() -> impl Into<[u8; {
let s = String::new();
let _: &str = &*s;
let _: &str = &*{ String::new() };
let _: &str = &mut *{ String::new() };
let _ = &*s; // Don't lint. Inferred type would change.
let _: &_ = &*s; // Don't lint. Inferred type would change.
f_str(&*s);
f_t(&*s); // Don't lint. Inferred type would change.
f_ref_t(&*s); // Don't lint. Inferred type would change.
f_str_t(&*s, &*s); // Don't lint second param.
let b = Box::new(Box::new(Box::new(5)));
let _: &Box<i32> = &**b;
let _: &Box<_> = &**b; // Don't lint. Inferred type would change.
f_box_t(&**b); // Don't lint. Inferred type would change.
let c = |_x: &str| ();
c(&*s);
let c = |_x| ();
c(&*s); // Don't lint. Inferred type would change.
fn _f(x: &String) -> &str {
&**x
}
fn _f1(x: &String) -> &str {
{ &**x }
}
fn _f2(x: &String) -> &str {
&**{ x }
}
fn _f3(x: &Box<Box<Box<i32>>>) -> &Box<i32> {
&***x
}
fn _f4(
x: String,
f1: impl Fn(&str),
f2: &dyn Fn(&str),
f3: fn(&str),
f4: impl CallableStr,
f5: <() as CallableStr>::T,
f6: <i32 as CallableStr>::T,
f7: &dyn CallableStr<T = fn(&str)>,
f8: impl CallableT<str>,
f9: <() as CallableT<str>>::T,
f10: <i32 as CallableT<str>>::T,
f11: &dyn CallableT<str, T = fn(&str)>,
) {
f1(&*x);
f2(&*x);
f3(&*x);
f4.callable_str()(&*x);
f5(&*x);
f6(&*x);
f7.callable_str()(&*x);
f8.callable_t()(&*x);
f9(&*x);
f10(&*x);
f11.callable_t()(&*x);
}
struct S1<'a>(&'a str);
let _ = S1(&*s);
struct S2<'a> {
s: &'a str,
}
let _ = S2 { s: &*s };
struct S3<'a, T: ?Sized>(&'a T);
let _ = S3(&*s); // Don't lint. Inferred type would change.
struct S4<'a, T: ?Sized> {
s: &'a T,
}
let _ = S4 { s: &*s }; // Don't lint. Inferred type would change.
enum E1<'a> {
S1(&'a str),
S2 { s: &'a str },
}
impl<'a> E1<'a> {
fn m1(s: &'a String) {
let _ = Self::S1(&**s);
let _ = Self::S2 { s: &**s };
}
}
let _ = E1::S1(&*s);
let _ = E1::S2 { s: &*s };
enum E2<'a, T: ?Sized> {
S1(&'a T),
S2 { s: &'a T },
}
let _ = E2::S1(&*s); // Don't lint. Inferred type would change.
let _ = E2::S2 { s: &*s }; // Don't lint. Inferred type would change.
let ref_s = &s;
let _: &String = &*ref_s; // Don't lint reborrow.
f_string(&*ref_s); // Don't lint reborrow.
struct S5 {
foo: u32,
}
let b = Box::new(Box::new(S5 { foo: 5 }));
let _ = b.foo;
let _ = (*b).foo;
let _ = (**b).foo;
struct S6 {
foo: S5,
}
impl core::ops::Deref for S6 {
type Target = S5;
fn deref(&self) -> &Self::Target {
&self.foo
}
}
let s6 = S6 { foo: S5 { foo: 5 } };
let _ = (*s6).foo; // Don't lint. `S6` also has a field named `foo`
let ref_str = &"foo";
let _ = f_str(*ref_str);
let ref_ref_str = &ref_str;
let _ = f_str(**ref_ref_str);
fn _f5(x: &u32) -> u32 {
if true {
*x
} else {
return *x;
}
}
f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
let x = &&40;
unsafe {
var(0, &**x);
}
let s = &"str";
let _ = || return *s;
let _ = || -> &'static str { return *s };
struct X;
struct Y(X);
impl core::ops::Deref for Y {
type Target = X;
fn deref(&self) -> &Self::Target {
&self.0
}
}
let _: &X = &*{ Y(X) };
let _: &X = &*match 0 {
#[rustfmt::skip]
0 => { Y(X) },
_ => panic!(),
};
let _: &X = &*if true { Y(X) } else { panic!() };
fn deref_to_u<U, T: core::ops::Deref<Target = U>>(x: &T) -> &U {
&**x
}
let _ = |x: &'static Box<dyn Iterator<Item = u32>>| -> &'static dyn Iterator<Item = u32> { &**x };
fn ret_any(x: &Box<dyn std::any::Any>) -> &dyn std::any::Any {
&**x
}
let x = String::new();
let _: *const str = &*x;
struct S7([u32; 1]);
impl core::ops::Deref for S7 {
type Target = [u32; 1];
fn deref(&self) -> &Self::Target {
&self.0
}
}
let x = S7([0]);
let _: &[u32] = &*x;
let c1 = |x: &Vec<&u32>| {};
let x = &&vec![&1u32];
c1(*x);
let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
if b {
return *x;
}
*x
};
}]> {
[99]
}
fn main() {
println!("{:?}", foo(42).into());
println!("{:?}", bar().into());
}Version information
rustc 1.79.0-dev
binary: rustc
commit-hash: unknown
commit-date: unknown
host: x86_64-unknown-linux-gnu
release: 1.79.0-dev
LLVM version: 18.1.3
Command:
/home/matthias/.rustup/toolchains/local-debug-assertions/bin/rustc -Zincremental-verify-ich=yes -Cincremental=<dir> -Cdebuginfo=2
Metadata
Metadata
Assignees
Labels
Category: This is a bug.Call for participation: An issue has been fixed and does not reproduce, but no test has been added.`#![feature(closure_lifetime_binder)]`Issue: The compiler panicked, giving an Internal Compilation Error (ICE) ❄️Relevant to the compiler team, which will review and decide on the PR/issue.This issue requires a build of rustc or tooling with debug-assertions in some way