From 64d98f8ee037282c35007b64c2649055c56af1db Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Wed, 17 Apr 2024 14:19:03 +0200 Subject: Merging upstream version 1.68.2+dfsg1. Signed-off-by: Daniel Baumann --- tests/ui/box/alloc-unstable-fail.rs | 6 +++++ tests/ui/box/alloc-unstable-fail.stderr | 12 +++++++++ tests/ui/box/alloc-unstable.rs | 8 ++++++ tests/ui/box/into-boxed-slice-fail.rs | 14 ++++++++++ tests/ui/box/into-boxed-slice-fail.stderr | 45 +++++++++++++++++++++++++++++++ tests/ui/box/into-boxed-slice.rs | 11 ++++++++ tests/ui/box/issue-82446.rs | 15 +++++++++++ tests/ui/box/issue-82446.stderr | 12 +++++++++ tests/ui/box/issue-95036.rs | 22 +++++++++++++++ tests/ui/box/large-allocator-ice.rs | 29 ++++++++++++++++++++ tests/ui/box/leak-alloc.rs | 29 ++++++++++++++++++++ tests/ui/box/leak-alloc.stderr | 15 +++++++++++ tests/ui/box/new-box-syntax.rs | 27 +++++++++++++++++++ tests/ui/box/new-box.rs | 30 +++++++++++++++++++++ tests/ui/box/new.rs | 6 +++++ tests/ui/box/thin_align.rs | 26 ++++++++++++++++++ tests/ui/box/thin_drop.rs | 37 +++++++++++++++++++++++++ tests/ui/box/thin_new.rs | 30 +++++++++++++++++++++ tests/ui/box/thin_zst.rs | 34 +++++++++++++++++++++++ 19 files changed, 408 insertions(+) create mode 100644 tests/ui/box/alloc-unstable-fail.rs create mode 100644 tests/ui/box/alloc-unstable-fail.stderr create mode 100644 tests/ui/box/alloc-unstable.rs create mode 100644 tests/ui/box/into-boxed-slice-fail.rs create mode 100644 tests/ui/box/into-boxed-slice-fail.stderr create mode 100644 tests/ui/box/into-boxed-slice.rs create mode 100644 tests/ui/box/issue-82446.rs create mode 100644 tests/ui/box/issue-82446.stderr create mode 100644 tests/ui/box/issue-95036.rs create mode 100644 tests/ui/box/large-allocator-ice.rs create mode 100644 tests/ui/box/leak-alloc.rs create mode 100644 tests/ui/box/leak-alloc.stderr create mode 100644 tests/ui/box/new-box-syntax.rs create mode 100644 tests/ui/box/new-box.rs create mode 100644 tests/ui/box/new.rs create mode 100644 tests/ui/box/thin_align.rs create mode 100644 tests/ui/box/thin_drop.rs create mode 100644 tests/ui/box/thin_new.rs create mode 100644 tests/ui/box/thin_zst.rs (limited to 'tests/ui/box') diff --git a/tests/ui/box/alloc-unstable-fail.rs b/tests/ui/box/alloc-unstable-fail.rs new file mode 100644 index 000000000..942757164 --- /dev/null +++ b/tests/ui/box/alloc-unstable-fail.rs @@ -0,0 +1,6 @@ +use std::boxed::Box; + +fn main() { + let _boxed: Box = Box::new(10); + //~^ ERROR use of unstable library feature 'allocator_api' +} diff --git a/tests/ui/box/alloc-unstable-fail.stderr b/tests/ui/box/alloc-unstable-fail.stderr new file mode 100644 index 000000000..03ae36e88 --- /dev/null +++ b/tests/ui/box/alloc-unstable-fail.stderr @@ -0,0 +1,12 @@ +error[E0658]: use of unstable library feature 'allocator_api' + --> $DIR/alloc-unstable-fail.rs:4:26 + | +LL | let _boxed: Box = Box::new(10); + | ^ + | + = note: see issue #32838 for more information + = help: add `#![feature(allocator_api)]` to the crate attributes to enable + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0658`. diff --git a/tests/ui/box/alloc-unstable.rs b/tests/ui/box/alloc-unstable.rs new file mode 100644 index 000000000..66388d0d5 --- /dev/null +++ b/tests/ui/box/alloc-unstable.rs @@ -0,0 +1,8 @@ +// run-pass +#![feature(allocator_api)] + +use std::boxed::Box; + +fn main() { + let _boxed: Box = Box::new(10); +} diff --git a/tests/ui/box/into-boxed-slice-fail.rs b/tests/ui/box/into-boxed-slice-fail.rs new file mode 100644 index 000000000..49dbb170f --- /dev/null +++ b/tests/ui/box/into-boxed-slice-fail.rs @@ -0,0 +1,14 @@ +#![feature(box_into_boxed_slice)] + +use std::boxed::Box; +use std::fmt::Debug; +fn main() { + let boxed_slice = Box::new([1,2,3]) as Box<[u8]>; + let _ = Box::into_boxed_slice(boxed_slice); + //~^ ERROR the size for values of type `[u8]` cannot be known at compilation time + //~^^ ERROR the size for values of type `[u8]` cannot be known at compilation time + let boxed_trait: Box = Box::new(5u8); + let _ = Box::into_boxed_slice(boxed_trait); + //~^ ERROR the size for values of type `dyn Debug` cannot be known at compilation time + //~^^ ERROR the size for values of type `dyn Debug` cannot be known at compilation time +} diff --git a/tests/ui/box/into-boxed-slice-fail.stderr b/tests/ui/box/into-boxed-slice-fail.stderr new file mode 100644 index 000000000..f102f666d --- /dev/null +++ b/tests/ui/box/into-boxed-slice-fail.stderr @@ -0,0 +1,45 @@ +error[E0277]: the size for values of type `[u8]` cannot be known at compilation time + --> $DIR/into-boxed-slice-fail.rs:7:35 + | +LL | let _ = Box::into_boxed_slice(boxed_slice); + | --------------------- ^^^^^^^^^^^ doesn't have a size known at compile-time + | | + | required by a bound introduced by this call + | + = help: the trait `Sized` is not implemented for `[u8]` +note: required by a bound in `Box::::into_boxed_slice` + --> $SRC_DIR/alloc/src/boxed.rs:LL:COL + +error[E0277]: the size for values of type `[u8]` cannot be known at compilation time + --> $DIR/into-boxed-slice-fail.rs:7:13 + | +LL | let _ = Box::into_boxed_slice(boxed_slice); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time + | + = help: the trait `Sized` is not implemented for `[u8]` + = note: slice and array elements must have `Sized` type + +error[E0277]: the size for values of type `dyn Debug` cannot be known at compilation time + --> $DIR/into-boxed-slice-fail.rs:11:35 + | +LL | let _ = Box::into_boxed_slice(boxed_trait); + | --------------------- ^^^^^^^^^^^ doesn't have a size known at compile-time + | | + | required by a bound introduced by this call + | + = help: the trait `Sized` is not implemented for `dyn Debug` +note: required by a bound in `Box::::into_boxed_slice` + --> $SRC_DIR/alloc/src/boxed.rs:LL:COL + +error[E0277]: the size for values of type `dyn Debug` cannot be known at compilation time + --> $DIR/into-boxed-slice-fail.rs:11:13 + | +LL | let _ = Box::into_boxed_slice(boxed_trait); + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ doesn't have a size known at compile-time + | + = help: the trait `Sized` is not implemented for `dyn Debug` + = note: slice and array elements must have `Sized` type + +error: aborting due to 4 previous errors + +For more information about this error, try `rustc --explain E0277`. diff --git a/tests/ui/box/into-boxed-slice.rs b/tests/ui/box/into-boxed-slice.rs new file mode 100644 index 000000000..61b3d9152 --- /dev/null +++ b/tests/ui/box/into-boxed-slice.rs @@ -0,0 +1,11 @@ +// run-pass +#![feature(box_into_boxed_slice)] + +use std::boxed::Box; +fn main() { + assert_eq!(Box::into_boxed_slice(Box::new(5u8)), Box::new([5u8]) as Box<[u8]>); + assert_eq!(Box::into_boxed_slice(Box::new([25u8])), Box::new([[25u8]]) as Box<[[u8; 1]]>); + let a: Box<[Box<[u8; 1]>]> = Box::into_boxed_slice(Box::new(Box::new([5u8]))); + let b: Box<[Box<[u8; 1]>]> = Box::new([Box::new([5u8])]); + assert_eq!(a, b); +} diff --git a/tests/ui/box/issue-82446.rs b/tests/ui/box/issue-82446.rs new file mode 100644 index 000000000..2960f7fbc --- /dev/null +++ b/tests/ui/box/issue-82446.rs @@ -0,0 +1,15 @@ +// https://github.com/rust-lang/rust/issues/82446 +// Spurious 'help: store this in the heap' regression test +trait MyTrait {} + +struct Foo { + val: Box +} + +fn make_it(val: &Box) { + Foo { + val //~ ERROR [E0308] + }; +} + +fn main() {} diff --git a/tests/ui/box/issue-82446.stderr b/tests/ui/box/issue-82446.stderr new file mode 100644 index 000000000..037473795 --- /dev/null +++ b/tests/ui/box/issue-82446.stderr @@ -0,0 +1,12 @@ +error[E0308]: mismatched types + --> $DIR/issue-82446.rs:11:9 + | +LL | val + | ^^^ expected struct `Box`, found reference + | + = note: expected struct `Box<(dyn MyTrait + 'static)>` + found reference `&Box<(dyn MyTrait + 'static)>` + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0308`. diff --git a/tests/ui/box/issue-95036.rs b/tests/ui/box/issue-95036.rs new file mode 100644 index 000000000..0611fabc1 --- /dev/null +++ b/tests/ui/box/issue-95036.rs @@ -0,0 +1,22 @@ +// compile-flags: -O +// build-pass + +#![feature(allocator_api)] + +#[inline(never)] +pub fn by_ref(node: &mut Box<[u8; 1], &std::alloc::Global>) { + node[0] = 9u8; +} + +pub fn main() { + let mut node = Box::new_in([5u8], &std::alloc::Global); + node[0] = 7u8; + + std::hint::black_box(node); + + let mut node = Box::new_in([5u8], &std::alloc::Global); + + by_ref(&mut node); + + std::hint::black_box(node); +} diff --git a/tests/ui/box/large-allocator-ice.rs b/tests/ui/box/large-allocator-ice.rs new file mode 100644 index 000000000..b3a882ff0 --- /dev/null +++ b/tests/ui/box/large-allocator-ice.rs @@ -0,0 +1,29 @@ +// build-pass +#![feature(allocator_api)] +#![allow(unused_must_use)] + +use std::alloc::Allocator; + +struct BigAllocator([usize; 2]); + +unsafe impl Allocator for BigAllocator { + fn allocate( + &self, + _: std::alloc::Layout, + ) -> Result, std::alloc::AllocError> { + todo!() + } + unsafe fn deallocate(&self, _: std::ptr::NonNull, _: std::alloc::Layout) { + todo!() + } +} + +fn main() { + Box::new_in((), &std::alloc::Global); + Box::new_in((), BigAllocator([0; 2])); + generic_function(0); +} + +fn generic_function(val: T) { + *Box::new_in(val, &std::alloc::Global); +} diff --git a/tests/ui/box/leak-alloc.rs b/tests/ui/box/leak-alloc.rs new file mode 100644 index 000000000..3f0f39f44 --- /dev/null +++ b/tests/ui/box/leak-alloc.rs @@ -0,0 +1,29 @@ +#![feature(allocator_api)] + +use std::alloc::{AllocError, Allocator, Layout, System}; +use std::ptr::NonNull; + +use std::boxed::Box; + +struct Alloc {} + +unsafe impl Allocator for Alloc { + fn allocate(&self, layout: Layout) -> Result, AllocError> { + System.allocate(layout) + } + + unsafe fn deallocate(&self, ptr: NonNull, layout: Layout) { + System.deallocate(ptr, layout) + } +} + +fn use_value(_: u32) {} + +fn main() { + let alloc = Alloc {}; + let boxed = Box::new_in(10, alloc.by_ref()); + let theref = Box::leak(boxed); + drop(alloc); + //~^ ERROR cannot move out of `alloc` because it is borrowed + use_value(*theref) +} diff --git a/tests/ui/box/leak-alloc.stderr b/tests/ui/box/leak-alloc.stderr new file mode 100644 index 000000000..e8a6ad099 --- /dev/null +++ b/tests/ui/box/leak-alloc.stderr @@ -0,0 +1,15 @@ +error[E0505]: cannot move out of `alloc` because it is borrowed + --> $DIR/leak-alloc.rs:26:10 + | +LL | let boxed = Box::new_in(10, alloc.by_ref()); + | -------------- borrow of `alloc` occurs here +LL | let theref = Box::leak(boxed); +LL | drop(alloc); + | ^^^^^ move out of `alloc` occurs here +LL | +LL | use_value(*theref) + | ------- borrow later used here + +error: aborting due to previous error + +For more information about this error, try `rustc --explain E0505`. diff --git a/tests/ui/box/new-box-syntax.rs b/tests/ui/box/new-box-syntax.rs new file mode 100644 index 000000000..c56e1dd46 --- /dev/null +++ b/tests/ui/box/new-box-syntax.rs @@ -0,0 +1,27 @@ +// run-pass +// pretty-expanded FIXME #23616 + +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +#![allow(dead_code, unused_variables)] + +// Tests that the new `box` syntax works with unique pointers. + +use std::boxed::Box; + +struct Structure { + x: isize, + y: isize, +} + +pub fn main() { + let y: Box = Box::new(2); + let b: Box = Box::new(1 + 2); + let c = Box::new(3 + 4); + + let s: Box = Box::new(Structure { + x: 3, + y: 4, + }); +} diff --git a/tests/ui/box/new-box.rs b/tests/ui/box/new-box.rs new file mode 100644 index 000000000..96a3b197f --- /dev/null +++ b/tests/ui/box/new-box.rs @@ -0,0 +1,30 @@ +// run-pass + +fn f(x: Box) { + let y: &isize = &*x; + println!("{}", *x); + println!("{}", *y); +} + +trait Trait { + fn printme(&self); +} + +struct Struct; + +impl Trait for Struct { + fn printme(&self) { + println!("hello world!"); + } +} + +fn g(x: Box) { + x.printme(); + let y: &dyn Trait = &*x; + y.printme(); +} + +fn main() { + f(Box::new(1234)); + g(Box::new(Struct) as Box); +} diff --git a/tests/ui/box/new.rs b/tests/ui/box/new.rs new file mode 100644 index 000000000..be1a40cf7 --- /dev/null +++ b/tests/ui/box/new.rs @@ -0,0 +1,6 @@ +// run-pass +// pretty-expanded FIXME #23616 + +fn main() { + let _a = Box::new(1); +} diff --git a/tests/ui/box/thin_align.rs b/tests/ui/box/thin_align.rs new file mode 100644 index 000000000..3c61d0090 --- /dev/null +++ b/tests/ui/box/thin_align.rs @@ -0,0 +1,26 @@ +#![feature(thin_box)] +// run-pass +use std::boxed::ThinBox; +use std::error::Error; +use std::ops::Deref; +use std::fmt; + +fn main() { + let expected = "Foo error!"; + let a: ThinBox = ThinBox::new_unsize(Foo(expected)); + let a = a.deref(); + let msg = a.to_string(); + assert_eq!(expected, msg); +} + +#[derive(Debug)] +#[repr(align(1024))] +struct Foo(&'static str); + +impl fmt::Display for Foo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl Error for Foo {} diff --git a/tests/ui/box/thin_drop.rs b/tests/ui/box/thin_drop.rs new file mode 100644 index 000000000..965613c11 --- /dev/null +++ b/tests/ui/box/thin_drop.rs @@ -0,0 +1,37 @@ +#![feature(thin_box)] +// run-pass +use std::boxed::ThinBox; +use std::error::Error; +use std::ops::Deref; +use std::fmt; + +fn main() { + let expected = "Foo error!"; + let mut dropped = false; + { + let foo = Foo(expected, &mut dropped); + let a: ThinBox = ThinBox::new_unsize(foo); + let a = a.deref(); + let msg = a.to_string(); + assert_eq!(expected, msg); + } + assert!(dropped); +} + +#[derive(Debug)] +#[repr(align(1024))] +struct Foo<'a>(&'static str, &'a mut bool); + +impl Drop for Foo<'_> { + fn drop(&mut self) { + *self.1 = true; + } +} + +impl fmt::Display for Foo<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", self.0) + } +} + +impl Error for Foo<'_> {} diff --git a/tests/ui/box/thin_new.rs b/tests/ui/box/thin_new.rs new file mode 100644 index 000000000..53f46478b --- /dev/null +++ b/tests/ui/box/thin_new.rs @@ -0,0 +1,30 @@ +#![feature(thin_box)] +// run-pass +use std::boxed::ThinBox; +use std::error::Error; +use std::{fmt, mem}; + +fn main() { + let thin_error: ThinBox = ThinBox::new_unsize(Foo); + assert_eq!(mem::size_of::<*const i32>(), mem::size_of_val(&thin_error)); + println!("{:?}", thin_error); + + let thin = ThinBox::new(42i32); + assert_eq!(mem::size_of::<*const i32>(), mem::size_of_val(&thin)); + println!("{:?}", thin); + + let thin_slice = ThinBox::<[i32]>::new_unsize([1, 2, 3, 4]); + assert_eq!(mem::size_of::<*const i32>(), mem::size_of_val(&thin_slice)); + println!("{:?}", thin_slice); +} + +#[derive(Debug)] +struct Foo; + +impl fmt::Display for Foo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "boooo!") + } +} + +impl Error for Foo {} diff --git a/tests/ui/box/thin_zst.rs b/tests/ui/box/thin_zst.rs new file mode 100644 index 000000000..77c400d17 --- /dev/null +++ b/tests/ui/box/thin_zst.rs @@ -0,0 +1,34 @@ +#![feature(thin_box)] +// run-pass +use std::boxed::ThinBox; +use std::error::Error; +use std::{fmt, mem}; +use std::ops::DerefMut; + +const EXPECTED: &str = "boooo!"; + +fn main() { + let thin_error: ThinBox = ThinBox::new_unsize(Foo); + assert_eq!(mem::size_of::<*const i32>(), mem::size_of_val(&thin_error)); + let msg = thin_error.to_string(); + assert_eq!(EXPECTED, msg); + + let mut thin_concrete_error: ThinBox = ThinBox::new(Foo); + assert_eq!(mem::size_of::<*const i32>(), mem::size_of_val(&thin_concrete_error)); + let msg = thin_concrete_error.to_string(); + assert_eq!(EXPECTED, msg); + let inner = thin_concrete_error.deref_mut(); + let msg = inner.to_string(); + assert_eq!(EXPECTED, msg); +} + +#[derive(Debug)] +struct Foo; + +impl fmt::Display for Foo { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}", EXPECTED) + } +} + +impl Error for Foo {} -- cgit v1.2.3