mirror of
https://github.com/rust-lang/rust-clippy
synced 2024-09-20 06:31:54 +00:00
129 lines
3.5 KiB
Rust
129 lines
3.5 KiB
Rust
#![deny(clippy::borrowed_box)]
|
|
#![allow(dead_code, unused_variables)]
|
|
#![allow(
|
|
clippy::uninlined_format_args,
|
|
clippy::disallowed_names,
|
|
clippy::needless_pass_by_ref_mut
|
|
)]
|
|
//@no-rustfix
|
|
|
|
use std::fmt::Display;
|
|
|
|
pub fn test1(foo: &mut Box<bool>) {
|
|
// Although this function could be changed to "&mut bool",
|
|
// avoiding the Box, mutable references to boxes are not
|
|
// flagged by this lint.
|
|
//
|
|
// This omission is intentional: By passing a mutable Box,
|
|
// the memory location of the pointed-to object could be
|
|
// modified. By passing a mutable reference, the contents
|
|
// could change, but not the location.
|
|
println!("{:?}", foo)
|
|
}
|
|
|
|
pub fn test2() {
|
|
let foo: &Box<bool>;
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
}
|
|
|
|
struct Test3<'a> {
|
|
foo: &'a Box<bool>,
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
}
|
|
|
|
trait Test4 {
|
|
fn test4(a: &Box<bool>);
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
}
|
|
|
|
impl<'a> Test4 for Test3<'a> {
|
|
fn test4(a: &Box<bool>) {
|
|
unimplemented!();
|
|
}
|
|
}
|
|
|
|
use std::any::Any;
|
|
|
|
pub fn test5(foo: &mut Box<dyn Any>) {
|
|
println!("{:?}", foo)
|
|
}
|
|
|
|
pub fn test6() {
|
|
let foo: &Box<dyn Any>;
|
|
}
|
|
|
|
struct Test7<'a> {
|
|
foo: &'a Box<dyn Any>,
|
|
}
|
|
|
|
trait Test8 {
|
|
fn test8(a: &Box<dyn Any>);
|
|
}
|
|
|
|
impl<'a> Test8 for Test7<'a> {
|
|
fn test8(a: &Box<dyn Any>) {
|
|
unimplemented!();
|
|
}
|
|
}
|
|
|
|
pub fn test9(foo: &mut Box<dyn Any + Send + Sync>) {
|
|
let _ = foo;
|
|
}
|
|
|
|
pub fn test10() {
|
|
let foo: &Box<dyn Any + Send + 'static>;
|
|
}
|
|
|
|
struct Test11<'a> {
|
|
foo: &'a Box<dyn Any + Send>,
|
|
}
|
|
|
|
trait Test12 {
|
|
fn test4(a: &Box<dyn Any + 'static>);
|
|
}
|
|
|
|
impl<'a> Test12 for Test11<'a> {
|
|
fn test4(a: &Box<dyn Any + 'static>) {
|
|
unimplemented!();
|
|
}
|
|
}
|
|
|
|
pub fn test13(boxed_slice: &mut Box<[i32]>) {
|
|
// Unconditionally replaces the box pointer.
|
|
//
|
|
// This cannot be accomplished if "&mut [i32]" is passed,
|
|
// and provides a test case where passing a reference to
|
|
// a Box is valid.
|
|
let mut data = vec![12];
|
|
*boxed_slice = data.into_boxed_slice();
|
|
}
|
|
|
|
// The suggestion should include proper parentheses to avoid a syntax error.
|
|
pub fn test14(_display: &Box<dyn Display>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
pub fn test15(_display: &Box<dyn Display + Send>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
|
|
pub fn test17(_display: &Box<impl Display>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
pub fn test18(_display: &Box<impl Display + Send>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
|
|
// This exists only to check what happens when parentheses are already present.
|
|
// Even though the current implementation doesn't put extra parentheses,
|
|
// it's fine that unnecessary parentheses appear in the future for some reason.
|
|
pub fn test20(_display: &Box<(dyn Display + Send)>) {}
|
|
//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
|
|
|
|
fn main() {
|
|
test1(&mut Box::new(false));
|
|
test2();
|
|
test5(&mut (Box::new(false) as Box<dyn Any>));
|
|
test6();
|
|
test9(&mut (Box::new(false) as Box<dyn Any + Send + Sync>));
|
|
test10();
|
|
}
|