rust/tests/ui/borrow_box.rs

116 lines
2.7 KiB
Rust
Raw Normal View History

2018-07-28 17:34:52 +02:00
#![deny(clippy::borrowed_box)]
#![allow(clippy::blacklisted_name)]
2017-06-11 05:50:57 +02:00
#![allow(unused_variables)]
#![allow(dead_code)]
use std::fmt::Display;
2017-06-11 05:50:57 +02:00
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.
2017-06-11 05:50:57 +02:00
println!("{:?}", foo)
}
pub fn test2() {
let foo: &Box<bool>;
}
struct Test3<'a> {
2018-12-09 23:26:16 +01:00
foo: &'a Box<bool>,
2017-06-11 05:50:57 +02:00
}
trait Test4 {
fn test4(a: &Box<bool>);
}
impl<'a> Test4 for Test3<'a> {
fn test4(a: &Box<bool>) {
unimplemented!();
}
}
2017-08-14 22:04:56 +02:00
use std::any::Any;
pub fn test5(foo: &mut Box<dyn Any>) {
2017-08-14 22:04:56 +02:00
println!("{:?}", foo)
}
pub fn test6() {
let foo: &Box<dyn Any>;
2017-08-14 22:04:56 +02:00
}
struct Test7<'a> {
foo: &'a Box<dyn Any>,
2017-08-14 22:04:56 +02:00
}
trait Test8 {
fn test8(a: &Box<dyn Any>);
2017-08-14 22:04:56 +02:00
}
impl<'a> Test8 for Test7<'a> {
fn test8(a: &Box<dyn Any>) {
2017-08-14 22:04:56 +02:00
unimplemented!();
}
}
pub fn test9(foo: &mut Box<dyn Any + Send + Sync>) {
2017-08-14 22:04:56 +02:00
let _ = foo;
}
pub fn test10() {
let foo: &Box<dyn Any + Send + 'static>;
2017-08-14 22:04:56 +02:00
}
struct Test11<'a> {
foo: &'a Box<dyn Any + Send>,
2017-08-14 22:04:56 +02:00
}
trait Test12 {
fn test4(a: &Box<dyn Any + 'static>);
2017-08-14 22:04:56 +02:00
}
impl<'a> Test12 for Test11<'a> {
fn test4(a: &Box<dyn Any + 'static>) {
2017-08-14 22:04:56 +02:00
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>) {}
pub fn test15(_display: &Box<dyn Display + Send>) {}
pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
pub fn test17(_display: &Box<impl Display>) {}
pub fn test18(_display: &Box<impl Display + Send>) {}
pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
// 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)>) {}
2018-12-09 23:26:16 +01:00
fn main() {
2017-06-11 05:50:57 +02:00
test1(&mut Box::new(false));
test2();
test5(&mut (Box::new(false) as Box<dyn Any>));
2017-08-14 22:04:56 +02:00
test6();
test9(&mut (Box::new(false) as Box<dyn Any + Send + Sync>));
2017-08-14 22:04:56 +02:00
test10();
2017-06-11 05:50:57 +02:00
}