diff options
Diffstat (limited to 'gcc/testsuite/rust')
155 files changed, 5099 insertions, 395 deletions
diff --git a/gcc/testsuite/rust/compile/additional-trait-bounds1.rs b/gcc/testsuite/rust/compile/additional-trait-bounds1.rs new file mode 100644 index 0000000..449a72f --- /dev/null +++ b/gcc/testsuite/rust/compile/additional-trait-bounds1.rs @@ -0,0 +1,10 @@ +#![feature(optin_builtin_traits)] + +pub unsafe auto trait Send {} +#[lang = "sync"] +pub unsafe auto trait Sync {} + +trait A {} + +impl dyn A + Send {} +impl dyn A + Send + Sync {} diff --git a/gcc/testsuite/rust/compile/additional-trait-bounds2.rs b/gcc/testsuite/rust/compile/additional-trait-bounds2.rs new file mode 100644 index 0000000..1c49b75 --- /dev/null +++ b/gcc/testsuite/rust/compile/additional-trait-bounds2.rs @@ -0,0 +1,9 @@ +#![feature(optin_builtin_traits)] + +pub unsafe auto trait Send {} +#[lang = "sync"] +pub unsafe auto trait Sync {} + +trait A {} + +impl dyn A + Send + Sync + NonExist {} // { dg-error "could not resolve type path .NonExist." } diff --git a/gcc/testsuite/rust/compile/additional-trait-bounds2nr2.rs b/gcc/testsuite/rust/compile/additional-trait-bounds2nr2.rs new file mode 100644 index 0000000..6764f6e --- /dev/null +++ b/gcc/testsuite/rust/compile/additional-trait-bounds2nr2.rs @@ -0,0 +1,11 @@ +// { dg-additional-options "-frust-name-resolution-2.0" } + +#![feature(optin_builtin_traits)] + +pub unsafe auto trait Send {} +#[lang = "sync"] +pub unsafe auto trait Sync {} + +trait A {} + +impl dyn A + Send + Sync + NonExist {} // { dg-error "could not resolve type path .NonExist." } diff --git a/gcc/testsuite/rust/compile/auto_traits1.rs b/gcc/testsuite/rust/compile/auto_traits1.rs new file mode 100644 index 0000000..192052d --- /dev/null +++ b/gcc/testsuite/rust/compile/auto_traits1.rs @@ -0,0 +1,27 @@ +// { dg-additional-options "-frust-compile-until=typecheck" } + +#![feature(optin_builtin_traits)] + +pub unsafe auto trait Send {} +#[lang = "sync"] +pub unsafe auto trait Sync {} + +trait A { + fn a_method(&self) {} +} + +fn foo(a: &(dyn A + Send + Sync)) { + a.a_method(); +} + +struct S; + +impl A for S { + fn a_method(&self) {} +} + +fn main() { + let s = S; + + foo(&s); +} diff --git a/gcc/testsuite/rust/compile/auto_traits2.rs b/gcc/testsuite/rust/compile/auto_traits2.rs new file mode 100644 index 0000000..382d446 --- /dev/null +++ b/gcc/testsuite/rust/compile/auto_traits2.rs @@ -0,0 +1,25 @@ +#![feature(optin_builtin_traits)] + +pub unsafe auto trait Send {} +#[lang = "sync"] +pub unsafe auto trait Sync {} + +trait A { + fn a_method(&self) {} +} + +fn foo(a: &(dyn A + Send + Sync)) { + a.a_method(); +} + +struct S; + +impl A for S { + fn a_method(&self) {} // { dg-warning "unused name" } +} + +fn main() { + let s = S; + + foo(&s); +} diff --git a/gcc/testsuite/rust/compile/auto_traits4.rs b/gcc/testsuite/rust/compile/auto_traits4.rs new file mode 100644 index 0000000..f1cd1e4 --- /dev/null +++ b/gcc/testsuite/rust/compile/auto_traits4.rs @@ -0,0 +1,14 @@ +#![feature(optin_builtin_traits)] + +unsafe auto trait Send {} +unsafe auto trait Sync {} + +fn take_send(_: &dyn Send) {} +fn take_sync(_: &dyn Sync) {} + +fn main() { + let a = i32; + + take_send(&a); + take_sync(&a); +} diff --git a/gcc/testsuite/rust/compile/cast_float_as_integer.rs b/gcc/testsuite/rust/compile/cast_float_as_integer.rs new file mode 100644 index 0000000..e6b86db --- /dev/null +++ b/gcc/testsuite/rust/compile/cast_float_as_integer.rs @@ -0,0 +1,10 @@ +// { dg-options "-w" } +fn main(){ + let foo:f64 = 13.37; + let _ = foo as i64; + let _ = foo as u64; + let _ = foo as isize; + let _ = foo as usize; + let _ = foo as i8; + let _ = foo as u8; +} diff --git a/gcc/testsuite/rust/compile/cfg-core1.rs b/gcc/testsuite/rust/compile/cfg-core1.rs new file mode 100644 index 0000000..7780cc9 --- /dev/null +++ b/gcc/testsuite/rust/compile/cfg-core1.rs @@ -0,0 +1,12 @@ +// { dg-additional-options "-frust-cfg=A -frust-cfg=B" } + +#[cfg_attr(A, cfg(B))] +struct Foo0; + +#[cfg_attr(A, cfg(C))] +struct Bar0; + +fn main() { + let a = Foo0; + let a = Bar0; // { dg-error "cannot find value" } +} diff --git a/gcc/testsuite/rust/compile/cfg-core2.rs b/gcc/testsuite/rust/compile/cfg-core2.rs new file mode 100644 index 0000000..e346edd --- /dev/null +++ b/gcc/testsuite/rust/compile/cfg-core2.rs @@ -0,0 +1,12 @@ +// { dg-additional-options "-frust-cfg=B" } + +#[cfg(not(any(A, B)))] +struct Foo0; + +#[cfg(not(any(A, C)))] +struct Bar0; + +fn main() { + let a = Foo0; // { dg-error "cannot find value" } + let a = Bar0; +} diff --git a/gcc/testsuite/rust/compile/cmp1.rs b/gcc/testsuite/rust/compile/cmp1.rs new file mode 100644 index 0000000..4da5b1c --- /dev/null +++ b/gcc/testsuite/rust/compile/cmp1.rs @@ -0,0 +1,78 @@ +// { dg-options "-w" } +// taken from https://github.com/rust-lang/rust/blob/e1884a8e3c3e813aada8254edfa120e85bf5ffca/library/core/src/cmp.rs#L98 + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "eq"] +#[stable(feature = "rust1", since = "1.0.0")] +#[doc(alias = "==")] +#[doc(alias = "!=")] +pub trait PartialEq<Rhs: ?Sized = Self> { + /// This method tests for `self` and `other` values to be equal, and is used + /// by `==`. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn eq(&self, other: &Rhs) -> bool; + + /// This method tests for `!=`. + #[inline] + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } +} + +enum BookFormat { + Paperback, + Hardback, + Ebook, +} + +impl PartialEq<BookFormat> for BookFormat { + fn eq(&self, other: &BookFormat) -> bool { + self == other + } +} + +pub struct Book { + isbn: i32, + format: BookFormat, +} + +// Implement <Book> == <BookFormat> comparisons +impl PartialEq<BookFormat> for Book { + fn eq(&self, other: &BookFormat) -> bool { + self.format == *other + } +} + +// Implement <BookFormat> == <Book> comparisons +impl PartialEq<Book> for BookFormat { + fn eq(&self, other: &Book) -> bool { + *self == other.format + } +} + +// Implement <Book> == <Book> comparisons +impl PartialEq<Book> for Book { + fn eq(&self, other: &Book) -> bool { + self.isbn == other.isbn + } +} + +pub fn main() { + let b1 = Book { + isbn: 1, + format: BookFormat::Paperback, + }; + let b2 = Book { + isbn: 2, + format: BookFormat::Paperback, + }; + + let _c1: bool = b1 == BookFormat::Paperback; + let _c2: bool = BookFormat::Paperback == b2; + let _c3: bool = b1 != b2; +} diff --git a/gcc/testsuite/rust/compile/const_generics_3.rs b/gcc/testsuite/rust/compile/const_generics_3.rs index e4e9008..524d48d 100644 --- a/gcc/testsuite/rust/compile/const_generics_3.rs +++ b/gcc/testsuite/rust/compile/const_generics_3.rs @@ -1,10 +1,12 @@ -// { dg-additional-options "-w" } +// { dg-additional-options "-w -frust-name-resolution-2.0" } + +#[lang = "sized"] +trait Sized {} const M: usize = 4; struct Foo<T, const N: usize = 1> { - // FIXME: This error is bogus. But having it means parsing is valid! - value: [i32; N], // { dg-error "cannot find value .N. in this scope" } + value: [T; N], } fn main() { diff --git a/gcc/testsuite/rust/compile/const_generics_4.rs b/gcc/testsuite/rust/compile/const_generics_4.rs index b364d3b..2766e4c 100644 --- a/gcc/testsuite/rust/compile/const_generics_4.rs +++ b/gcc/testsuite/rust/compile/const_generics_4.rs @@ -4,4 +4,4 @@ const P: usize = 14; struct Foo<const N: usize = { M }>; // { dg-error "cannot find value .M. in this scope" } struct Bar<const N: usize = { P }>; -struct Baz<const N: NotAType = { P }>; // { dg-error "failed to resolve TypePath: NotAType in this scope" } +struct Baz<const N: NotAType = { P }>; // { dg-error "could not resolve type path .NotAType." } diff --git a/gcc/testsuite/rust/compile/const_generics_7.rs b/gcc/testsuite/rust/compile/const_generics_7.rs index 2c128db..dad4c21 100644 --- a/gcc/testsuite/rust/compile/const_generics_7.rs +++ b/gcc/testsuite/rust/compile/const_generics_7.rs @@ -1,17 +1,17 @@ struct S<const N: usize>; -pub fn foo<const N: FooBar>() {} // { dg-error "failed to resolve" } -type Foo<const N: FooBar> = S<N>; // { dg-error "failed to resolve" } -struct Foo2<const N: FooBar>; // { dg-error "failed to resolve" } -enum Foo3<const N: FooBar> { // { dg-error "failed to resolve" } +pub fn foo<const N: FooBar>() {} // { dg-error "could not resolve" } +type Foo<const N: FooBar> = S<N>; // { dg-error "could not resolve" } +struct Foo2<const N: FooBar>; // { dg-error "could not resolve" } +enum Foo3<const N: FooBar> { // { dg-error "could not resolve" } Foo, Bar, } -union Foo4<const N: FooBar> { // { dg-error "failed to resolve" } +union Foo4<const N: FooBar> { // { dg-error "could not resolve" } a: usize, b: i32, } -trait Fooable<const N: FooBar> {} // { dg-error "failed to resolve" } +trait Fooable<const N: FooBar> {} // { dg-error "could not resolve" } trait Traitable {} -impl<const N: FooBar> Traitable for Foo2<N> {} // { dg-error "failed to resolve" } +impl<const N: FooBar> Traitable for Foo2<N> {} // { dg-error "could not resolve" } diff --git a/gcc/testsuite/rust/compile/crate-metavar1.rs b/gcc/testsuite/rust/compile/crate-metavar1.rs new file mode 100644 index 0000000..45384e1 --- /dev/null +++ b/gcc/testsuite/rust/compile/crate-metavar1.rs @@ -0,0 +1,14 @@ +macro_rules! foo { + () => { + $crate::inner::bar() + } +} + +pub mod inner { + pub fn bar() { } +} + +fn main() { + foo!(); + crate::inner::bar(); +} diff --git a/gcc/testsuite/rust/compile/derive-debug1.rs b/gcc/testsuite/rust/compile/derive-debug1.rs new file mode 100644 index 0000000..2596a37 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-debug1.rs @@ -0,0 +1,41 @@ +#[lang = "sized"] +trait Sized {} + +mod core { + pub mod result { + pub enum Result<T, E> { + #[lang = "Ok"] + Ok(T), + #[lang = "Err"] + Err(E), + } + } + + mod fmt { + struct Formatter; // { dg-warning "is never constructed" } + struct Error; // { dg-warning "is never constructed" } + + type Result = core::result::Result<(), Error>; + + trait Debug { + fn fmt(&self, fmt: &mut Formatter) -> Result; + } + } +} + +#[derive(Debug)] // { dg-warning "unused name" } +// { dg-warning "stub implementation" "" { target *-*-* } .-1 } +struct Foo { a: i32, b: i64 } // { dg-warning "is never constructed" } + +#[derive(Debug)] // { dg-warning "unused name" } +// { dg-warning "stub implementation" "" { target *-*-* } .-1 } +struct Bar(i32, i32); // { dg-warning "is never constructed" } + +#[derive(Debug)] // { dg-warning "unused name" } +// { dg-warning "stub implementation" "" { target *-*-* } .-1 } +enum Baz { + A, + B(i32), + C { a: i32 } +} + diff --git a/gcc/testsuite/rust/compile/derive-default1.rs b/gcc/testsuite/rust/compile/derive-default1.rs new file mode 100644 index 0000000..902c65e --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-default1.rs @@ -0,0 +1,29 @@ +#[derive(Default)] +struct Foo { _a: i32, _b: i64, _c: u8 } + +#[lang = "sized"] +trait Sized {} + +mod core { + mod default { + trait Default: Sized { + fn default() -> Self; + } + + impl Default for i32 { + fn default() -> Self { 0 } + } + + impl Default for i64 { + fn default() -> Self { 27 } + } + + impl Default for u8 { + fn default() -> Self { 18 } + } + } +} + +fn main() { + let _ = Foo::default(); +} diff --git a/gcc/testsuite/rust/compile/derive-eq-invalid.rs b/gcc/testsuite/rust/compile/derive-eq-invalid.rs new file mode 100644 index 0000000..b0bf856 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-eq-invalid.rs @@ -0,0 +1,52 @@ +mod core { + mod cmp { + #[lang = "eq"] + pub trait PartialEq<Rhs: ?Sized = Self> { + fn eq(&self, other: &Rhs) -> bool; + + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } + } + + pub trait Eq: PartialEq<Self> { + fn assert_receiver_is_total_eq(&self) {} + } + } +} + +#[lang = "phantom_data"] +struct PhantomData<T>; + +#[lang = "sized"] +trait Sized {} + +#[lang = "structural_peq"] +trait StructuralPartialEq {} + +#[lang = "structural_teq"] +trait StructuralEq {} + +#[derive(PartialEq)] +struct NotEq; + +#[derive(Eq, PartialEq)] // { dg-error "bounds not satisfied for NotEq .Eq." } +struct Container(NotEq); + +// #[derive(Eq)] +// struct Foo { a: i32 } +// #[derive(Eq)] +// struct Bar(i32); + +// #[derive(Eq)] +// enum Baz { +// A, +// B(i32), +// C { a: i32 } +// } + +// #[derive(Eq)] +// union Qux { +// a: i32, +// b: i64, +// } diff --git a/gcc/testsuite/rust/compile/derive-hash1.rs b/gcc/testsuite/rust/compile/derive-hash1.rs new file mode 100644 index 0000000..80e1e2d --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-hash1.rs @@ -0,0 +1,91 @@ +#![feature(intrinsics)] + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod intrinsics { + #[lang = "discriminant_kind"] + pub trait DiscriminantKind { + #[lang = "discriminant_type"] + type Discriminant; + } + + extern "rust-intrinsic" { + pub fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant; + } + } + + pub mod hash { + pub trait Hasher {} + + pub trait Hash { + /// Feeds this value into the given [`Hasher`]. + /// + /// # Examples + /// + /// ``` + /// use std::collections::hash_map::DefaultHasher; + /// use std::hash::{Hash, Hasher}; + /// + /// let mut hasher = DefaultHasher::new(); + /// 7920.hash(&mut hasher); + /// println!("Hash is {:x}!", hasher.finish()); + /// ``` + #[stable(feature = "rust1", since = "1.0.0")] + fn hash<H: Hasher>(&self, state: &mut H); + + /// Feeds a slice of this type into the given [`Hasher`]. + /// + /// # Examples + /// + /// ``` + /// use std::collections::hash_map::DefaultHasher; + /// use std::hash::{Hash, Hasher}; + /// + /// let mut hasher = DefaultHasher::new(); + /// let numbers = [6, 28, 496, 8128]; + /// Hash::hash_slice(&numbers, &mut hasher); + /// println!("Hash is {:x}!", hasher.finish()); + /// ``` + #[stable(feature = "hash_slice", since = "1.3.0")] + fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) + where + Self: Sized, + { + // for piece in data { + // piece.hash(state); + // } + } + } + } +} + +impl core::hash::Hash for i32 { + fn hash<H: core::hash::Hasher>(&self, state: &mut H) {} +} + +impl core::hash::Hash for i64 { + fn hash<H: core::hash::Hasher>(&self, state: &mut H) {} +} + +// for the discriminant value +impl core::hash::Hash for isize { + fn hash<H: core::hash::Hasher>(&self, state: &mut H) {} +} + +#[derive(Hash)] +struct Foo { // { dg-warning "never constructed" } + a: i32, + b: i32, +} + +#[derive(Hash)] +struct Bar(i32, i64); // { dg-warning "never constructed" } + +#[derive(Hash)] +enum Baz { + A, + B(i32), + C { a: i64 } +} diff --git a/gcc/testsuite/rust/compile/derive-partialeq1.rs b/gcc/testsuite/rust/compile/derive-partialeq1.rs new file mode 100644 index 0000000..35e33fb --- /dev/null +++ b/gcc/testsuite/rust/compile/derive-partialeq1.rs @@ -0,0 +1,62 @@ +#![feature(intrinsics)] + +#[lang = "sized"] +trait Sized {} + +#[lang = "copy"] +trait Copy {} + +#[lang = "structural_peq"] +trait StructuralPartialEq {} + +#[lang = "eq"] +pub trait PartialEq<Rhs: ?Sized = Self> { + /// This method tests for `self` and `other` values to be equal, and is used + /// by `==`. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn eq(&self, other: &Rhs) -> bool; + + /// This method tests for `!=`. + #[inline] + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } +} + +#[derive(PartialEq, Copy)] // { dg-warning "unused name" } +struct Foo; + +#[derive(PartialEq)] +struct Bar(Foo); + +#[derive(PartialEq)] +struct Baz { _inner: Foo } + +extern "C" { + fn puts(s: *const i8); +} + +fn print(b: bool) { + if b { + unsafe { puts("true" as *const str as *const i8) } + } else { + unsafe { puts("false" as *const str as *const i8) } + } +} + +fn main() -> i32 { + let x = Foo; + + let b1 = x == Foo; + let b2 = Bar(x) != Bar(Foo); + let b3 = Baz { _inner: Foo } != Baz { _inner: x }; + + print(b1); + print(b2); + print(b3); + + 0 +} diff --git a/gcc/testsuite/rust/compile/derive_clone_enum1.rs b/gcc/testsuite/rust/compile/derive_clone_enum1.rs new file mode 100644 index 0000000..947dc5c6 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive_clone_enum1.rs @@ -0,0 +1,16 @@ +#[lang = "clone"] +trait Clone { + pub fn clone(&self) -> Self; +} + +impl Clone for i32 { + fn clone(&self) -> Self { + *self + } +} + +#[derive(Clone)] +enum AllIdentifiers { + A, + B +} diff --git a/gcc/testsuite/rust/compile/derive_clone_enum2.rs b/gcc/testsuite/rust/compile/derive_clone_enum2.rs new file mode 100644 index 0000000..c7a4ad5 --- /dev/null +++ b/gcc/testsuite/rust/compile/derive_clone_enum2.rs @@ -0,0 +1,16 @@ +#[lang = "clone"] +trait Clone { + pub fn clone(&self) -> Self; +} + +impl Clone for i32 { + fn clone(&self) -> Self { + *self + } +} + +#[derive(Clone)] +enum TupleEnum { + A(i32), + B(i32, i32, i32) +} diff --git a/gcc/testsuite/rust/compile/derive_clone_enum3.rs b/gcc/testsuite/rust/compile/derive_clone_enum3.rs new file mode 100644 index 0000000..92fd6ee --- /dev/null +++ b/gcc/testsuite/rust/compile/derive_clone_enum3.rs @@ -0,0 +1,16 @@ +#[lang = "clone"] +trait Clone { + pub fn clone(&self) -> Self; +} + +impl Clone for i32 { + fn clone(&self) -> Self { + *self + } +} + +#[derive(Clone)] +enum StructEnum { + A { i0: i32 }, + B { i0: i32, i1: i32, i2: i32 } +} diff --git a/gcc/testsuite/rust/compile/derive_macro1.rs b/gcc/testsuite/rust/compile/derive_macro1.rs index 779aad78e..bc10d60 100644 --- a/gcc/testsuite/rust/compile/derive_macro1.rs +++ b/gcc/testsuite/rust/compile/derive_macro1.rs @@ -1,6 +1,7 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } diff --git a/gcc/testsuite/rust/compile/derive_macro3.rs b/gcc/testsuite/rust/compile/derive_macro3.rs index 1c7d473..ad40cae 100644 --- a/gcc/testsuite/rust/compile/derive_macro3.rs +++ b/gcc/testsuite/rust/compile/derive_macro3.rs @@ -1,6 +1,7 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } diff --git a/gcc/testsuite/rust/compile/derive_macro4.rs b/gcc/testsuite/rust/compile/derive_macro4.rs index 7802e8f..8bf1bca 100644 --- a/gcc/testsuite/rust/compile/derive_macro4.rs +++ b/gcc/testsuite/rust/compile/derive_macro4.rs @@ -1,17 +1,17 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "copy"] pub trait Copy {} + +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } +#[lang = "phantom_data"] struct PhantomData<T>; -pub struct AssertParamIsCopy<T: Copy> { - _field: PhantomData<T>, -} - #[derive(Clone)] // { dg-error "bounds not satisfied for U .Copy. is not satisfied" } union U { i: i32, diff --git a/gcc/testsuite/rust/compile/derive_macro6.rs b/gcc/testsuite/rust/compile/derive_macro6.rs index b7bf7a7..412144d 100644 --- a/gcc/testsuite/rust/compile/derive_macro6.rs +++ b/gcc/testsuite/rust/compile/derive_macro6.rs @@ -1,7 +1,10 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "copy"] pub trait Copy {} + +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } @@ -9,10 +12,6 @@ pub trait Clone { #[lang = "phantom_data"] pub struct PhantomData<T>; -pub struct AssertParamIsCopy<T: Copy> { - pub _field: PhantomData<T>, -} - impl Copy for i32 {} impl Copy for i64 {} impl Copy for U {} diff --git a/gcc/testsuite/rust/compile/enum_variant_name.rs b/gcc/testsuite/rust/compile/enum_variant_name.rs new file mode 100644 index 0000000..671fced --- /dev/null +++ b/gcc/testsuite/rust/compile/enum_variant_name.rs @@ -0,0 +1,12 @@ +// { dg-additional-options "-w -frust-name-resolution-2.0" } +struct E1; + +enum Test { + E1 = { + let x = E1; + { + let x = E1; + } + 0 + }, +} diff --git a/gcc/testsuite/rust/compile/exhaustiveness1.rs b/gcc/testsuite/rust/compile/exhaustiveness1.rs index fe95ea3..356636b 100644 --- a/gcc/testsuite/rust/compile/exhaustiveness1.rs +++ b/gcc/testsuite/rust/compile/exhaustiveness1.rs @@ -15,9 +15,7 @@ fn s2(s: S) { } fn s3(s: S) { - match s { - // { dg-error "non-exhaustive patterns: '_' not covered" "" { target *-*-* } .-1 } - } + match s {} } enum E { diff --git a/gcc/testsuite/rust/compile/extern_generics.rs b/gcc/testsuite/rust/compile/extern_generics.rs new file mode 100644 index 0000000..26f97a6 --- /dev/null +++ b/gcc/testsuite/rust/compile/extern_generics.rs @@ -0,0 +1,8 @@ +#[lang="sized"] +trait Sized {} + + +// E0044 +fn main() { +extern "C" { fn some_func<T>(x: T); } // { dg-error "foreign items may not have type parameters .E0044." } +}
\ No newline at end of file diff --git a/gcc/testsuite/rust/compile/feature_rust_attri0.rs b/gcc/testsuite/rust/compile/feature_rust_attri0.rs index 9c11f56..1937acf 100644 --- a/gcc/testsuite/rust/compile/feature_rust_attri0.rs +++ b/gcc/testsuite/rust/compile/feature_rust_attri0.rs @@ -1,3 +1,7 @@ +extern "C" { + fn printf(s: *const i8, ...); +} + #[rustc_builtin_macro] //{ dg-error "internal implementation detail. " "" { target *-*-* } } macro_rules! line { () => {{}}; @@ -5,7 +9,7 @@ macro_rules! line { fn main() -> i32 { let a = line!(); - print(a); + printf("%d\0" as *const str as *const i8, a); 0 } diff --git a/gcc/testsuite/rust/compile/for-loop1.rs b/gcc/testsuite/rust/compile/for-loop1.rs new file mode 100644 index 0000000..21e0399 --- /dev/null +++ b/gcc/testsuite/rust/compile/for-loop1.rs @@ -0,0 +1,543 @@ +// { dg-output "loop\r*\nloop\r*\n" } +#![feature(intrinsics)] + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); + fn puts(s: *const i8); +} + +mod option { + pub enum Option<T> { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result<T, E> { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool); + pub fn wrapping_add<T>(a: T, b: T) -> T; + pub fn wrapping_sub<T>(a: T, b: T) -> T; + pub fn rotate_left<T>(a: T, b: T) -> T; + pub fn rotate_right<T>(a: T, b: T) -> T; + pub fn offset<T>(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init<T>(dst: *mut T, src: T); + pub fn uninit<T>() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl<T> *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + crate::intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl<T> *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + crate::intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = crate::mem::size_of::<T>() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if crate::mem::size_of::<T>() < 32 { + let z = read(x); + crate::intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write<T>(dst: *mut T, src: T) { + crate::intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read<T>(src: *const T) -> T { + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = crate::mem::size_of::<Block>(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = crate::mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = crate::mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute<T, U>(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of<T>() -> usize; + } + + pub fn swap<T>(x: &mut T, y: &mut T) { + unsafe { + crate::ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace<T>(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized<T>() -> T { + crate::intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; crate::mem::size_of::<Self>()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; crate::mem::size_of::<Self>()]) -> Self { + unsafe { crate::mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option<Self> { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { crate::intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add<RHS = Self> { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub<RHS = Self> { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range<Idx> { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom<T>: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result<Self, Self::Error>; +} + +pub trait From<T>: Sized { + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> T { + t + } +} + +impl<T, U> TryFrom<U> for T +where + T: From<U>, +{ + type Error = !; + + fn try_from(value: U) -> Result<Self, Self::Error> { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option<usize>; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option<Self>; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + crate::mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + crate::mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option<Self> { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option<Self> { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option<usize> { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option<Self> { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option<Self::Item>; +} + +impl<A: Step> Iterator for Range<A> { + type Item = A; + + fn next(&mut self) -> Option<A> { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + crate::mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator<Item = Self::Item>; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} + +pub fn main() { + let a = 1usize..3usize; + + for i in a { // { dg-warning "unused name" } + unsafe { puts("loop\0" as *const str as *const i8); } + } +} diff --git a/gcc/testsuite/rust/compile/for-loop2.rs b/gcc/testsuite/rust/compile/for-loop2.rs new file mode 100644 index 0000000..a0ad066 --- /dev/null +++ b/gcc/testsuite/rust/compile/for-loop2.rs @@ -0,0 +1,547 @@ +// { dg-output "1\r*\n2\r*\n" } +#![feature(intrinsics)] + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); + fn puts(s: *const i8); +} + +mod option { + pub enum Option<T> { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result<T, E> { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool); + pub fn wrapping_add<T>(a: T, b: T) -> T; + pub fn wrapping_sub<T>(a: T, b: T) -> T; + pub fn rotate_left<T>(a: T, b: T) -> T; + pub fn rotate_right<T>(a: T, b: T) -> T; + pub fn offset<T>(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init<T>(dst: *mut T, src: T); + pub fn uninit<T>() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl<T> *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + crate::intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl<T> *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + crate::intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = crate::mem::size_of::<T>() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if crate::mem::size_of::<T>() < 32 { + let z = read(x); + crate::intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write<T>(dst: *mut T, src: T) { + crate::intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read<T>(src: *const T) -> T { + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = crate::mem::size_of::<Block>(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = crate::mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = crate::mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute<T, U>(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of<T>() -> usize; + } + + pub fn swap<T>(x: &mut T, y: &mut T) { + unsafe { + crate::ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace<T>(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized<T>() -> T { + crate::intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + crate::intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + crate::intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; crate::mem::size_of::<Self>()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; crate::mem::size_of::<Self>()]) -> Self { + unsafe { crate::mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option<Self> { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { crate::intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add<RHS = Self> { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub<RHS = Self> { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range<Idx> { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom<T>: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result<Self, Self::Error>; +} + +pub trait From<T>: Sized { + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> T { + t + } +} + +impl<T, U> TryFrom<U> for T +where + T: From<U>, +{ + type Error = !; + + fn try_from(value: U) -> Result<Self, Self::Error> { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option<usize>; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option<Self>; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + crate::mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + crate::mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option<Self> { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option<Self> { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option<usize> { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option<Self> { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option<Self::Item>; +} + +impl<A: Step> Iterator for Range<A> { + type Item = A; + + fn next(&mut self) -> Option<A> { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + crate::mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator<Item = Self::Item>; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} + +pub fn main() { + // make sure we can desugar for-loops inside other blocks + + if true { + for _ in 20usize..40usize { + unsafe { + puts("loop\0" as *const str as *const i8); + } + } + } +} diff --git a/gcc/testsuite/rust/compile/generic-default1.rs b/gcc/testsuite/rust/compile/generic-default1.rs index 0a132bf..4155640 100644 --- a/gcc/testsuite/rust/compile/generic-default1.rs +++ b/gcc/testsuite/rust/compile/generic-default1.rs @@ -1,5 +1,5 @@ struct Foo<A = i321>(A); -// { dg-error "failed to resolve TypePath: i321" "" { target *-*-* } .-1 } +// { dg-error "could not resolve type path .i321." "" { target *-*-* } .-1 } fn main() { let a; diff --git a/gcc/testsuite/rust/compile/generics4.rs b/gcc/testsuite/rust/compile/generics4.rs index 31b681a..c4dbc432 100644 --- a/gcc/testsuite/rust/compile/generics4.rs +++ b/gcc/testsuite/rust/compile/generics4.rs @@ -6,7 +6,6 @@ struct GenericStruct<T>(T, usize); fn main() { let a2; a2 = GenericStruct::<i8, i32>(1, 456); // { dg-error "generic item takes at most 1 type arguments but 2 were supplied" } - // { dg-error {Failed to resolve expression of function call} "" { target *-*-* } .-1 } let b2: i32 = a2.0; // { dg-error {Expected Tuple or ADT got: T\?} "" { target *-*-* } .-1 } diff --git a/gcc/testsuite/rust/compile/generics5.rs b/gcc/testsuite/rust/compile/generics5.rs index 6c847b5..f861038 100644 --- a/gcc/testsuite/rust/compile/generics5.rs +++ b/gcc/testsuite/rust/compile/generics5.rs @@ -3,7 +3,7 @@ struct GenericStruct<T>(T, usize); fn main() { let a2; a2 = GenericStruct::<i8, T>(1, 456); - // { dg-error "failed to resolve TypePath: T" "" { target *-*-* } .-1 } + // { dg-error "could not resolve type path .T." "" { target *-*-* } .-1 } let b2: i32 = a2.0; let c2: usize = a2.1; diff --git a/gcc/testsuite/rust/compile/generics6.rs b/gcc/testsuite/rust/compile/generics6.rs index 33093cf..d77c559 100644 --- a/gcc/testsuite/rust/compile/generics6.rs +++ b/gcc/testsuite/rust/compile/generics6.rs @@ -27,6 +27,5 @@ impl Foo<f32> { fn main() { let a: i32 = Foo::test(); // { dg-error "multiple applicable items in scope for: .test." } - // { dg-error {Failed to resolve expression of function call} "" { target *-*-* } .-1 } } diff --git a/gcc/testsuite/rust/compile/generics9.rs b/gcc/testsuite/rust/compile/generics9.rs index 3766703..3c787aa 100644 --- a/gcc/testsuite/rust/compile/generics9.rs +++ b/gcc/testsuite/rust/compile/generics9.rs @@ -1,5 +1,5 @@ struct Foo<A, B = (A, B)>(A, B); -// { dg-error "failed to resolve TypePath: B" "" { target *-*-* } .-1 } +// { dg-error "could not resolve type path .B." "" { target *-*-* } .-1 } fn main() { let a: Foo<bool>; diff --git a/gcc/testsuite/rust/compile/if-without-else.rs b/gcc/testsuite/rust/compile/if-without-else.rs new file mode 100644 index 0000000..1a0f644 --- /dev/null +++ b/gcc/testsuite/rust/compile/if-without-else.rs @@ -0,0 +1,9 @@ +fn foo(pred: bool) -> u8 { + if pred { // { dg-error "mismatched types" } + 1 + } + 3 +} + +fn main(){ +} diff --git a/gcc/testsuite/rust/compile/if_let_expr.rs b/gcc/testsuite/rust/compile/if_let_expr.rs index 7bab19a..b0879e5 100644 --- a/gcc/testsuite/rust/compile/if_let_expr.rs +++ b/gcc/testsuite/rust/compile/if_let_expr.rs @@ -7,8 +7,9 @@ pub enum Option<T> { } fn main() { - let x = Option::Some(3); // { dg-warning "unused name" } - let a = if let Option::Some(1) = x { + let x = Option::Some(3); + + let a = if let Option::Some(1) = x {// { dg-warning "unused name" } 1 } else if x == Option::Some(2) { 2 diff --git a/gcc/testsuite/rust/compile/if_let_expr_simple.rs b/gcc/testsuite/rust/compile/if_let_expr_simple.rs new file mode 100644 index 0000000..d7fb0af --- /dev/null +++ b/gcc/testsuite/rust/compile/if_let_expr_simple.rs @@ -0,0 +1,12 @@ +enum MyOption { + Some(i32), + None, +} + +pub fn toto(i : MyOption) -> i32 { + if let MyOption::Some(v) = i { + v + } else { + 23i32 + } +} diff --git a/gcc/testsuite/rust/compile/iflet.rs b/gcc/testsuite/rust/compile/iflet.rs new file mode 100644 index 0000000..6d46339 --- /dev/null +++ b/gcc/testsuite/rust/compile/iflet.rs @@ -0,0 +1,32 @@ +pub fn simple_iflet() -> i32 { + let mut res = 0; + + enum E { + X(i32), + } + let v = E::X(4); + + if let E::X(n) = v { + res = 1; + } + + res +} + +pub fn simple_iflet_else() -> i32 { + let mut res = 0; + + enum E { + X(i32), + Y, + } + let v = E::X(4); + + if let E::Y = v { + res = 1; + } else { + res = 2; + } + + res +} diff --git a/gcc/testsuite/rust/compile/implicit_returns_err3.rs b/gcc/testsuite/rust/compile/implicit_returns_err3.rs index ac98213..f0330ac 100644 --- a/gcc/testsuite/rust/compile/implicit_returns_err3.rs +++ b/gcc/testsuite/rust/compile/implicit_returns_err3.rs @@ -1,6 +1,6 @@ fn test(x: i32) -> i32 { // { dg-error "mismatched types, expected .i32. but got ...." } if x > 1 { - 1 + return 1; } } diff --git a/gcc/testsuite/rust/compile/issue-1446.rs b/gcc/testsuite/rust/compile/issue-1446.rs index 8bfa42b..969ad38 100644 --- a/gcc/testsuite/rust/compile/issue-1446.rs +++ b/gcc/testsuite/rust/compile/issue-1446.rs @@ -1,3 +1,11 @@ +// fake function +pub fn swap_bytes(this: u32) -> u32 { + (((this) & 0xff000000) >> 24) + | (((this) & 0x00ff0000) >> 8) + | (((this) & 0x0000ff00) << 8) + | (((this) & 0x000000ff) << 24) +} + pub fn to_le(this: u32) -> u32 { #[cfg(target_endian = "little")] { @@ -5,6 +13,6 @@ pub fn to_le(this: u32) -> u32 { } #[cfg(not(target_endian = "little"))] { - this.swap_bytes() + swap_bytes(this) } } diff --git a/gcc/testsuite/rust/compile/issue-1525.rs b/gcc/testsuite/rust/compile/issue-1525.rs new file mode 100644 index 0000000..b2247cd --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-1525.rs @@ -0,0 +1,4 @@ +fn main() { + const slice: &[i32] = &[1, 2, 3]; + let _slice2: &[i32] = slice; +} diff --git a/gcc/testsuite/rust/compile/issue-1773.rs b/gcc/testsuite/rust/compile/issue-1773.rs index 468497a..41c82f0 100644 --- a/gcc/testsuite/rust/compile/issue-1773.rs +++ b/gcc/testsuite/rust/compile/issue-1773.rs @@ -1,8 +1,4 @@ -#[lang = "sized"] -// { dg-skip-if "" { *-*-* } } -pub trait Sized {} - -trait Foo<T> { +trait Foo { type A; fn test(a: Self::A) -> Self::A { @@ -10,9 +6,14 @@ trait Foo<T> { } } -struct Bar<T>(T); -impl<T> Foo<T> for Bar<i32> { - type A = T; +struct Bar(i32); +impl Foo for Bar { + type A = i32; +} + +struct Baz(f32); +impl Foo for Baz { + type A = f32; } fn main() { @@ -21,4 +22,10 @@ fn main() { let b; b = Bar::test(a.0); + + let c; + c = Baz(123f32); + + let d; + d = Baz::test(c.0); } diff --git a/gcc/testsuite/rust/compile/issue-1901.rs b/gcc/testsuite/rust/compile/issue-1901.rs index cfd8ef4..b43e34f 100644 --- a/gcc/testsuite/rust/compile/issue-1901.rs +++ b/gcc/testsuite/rust/compile/issue-1901.rs @@ -13,14 +13,14 @@ mod ptr { #[lang = "const_ptr"] impl<T> *const T { pub unsafe fn offset(self, count: isize) -> *const T { - intrinsics::offset(self, count) + crate::intrinsics::offset(self, count) } } #[lang = "mut_ptr"] impl<T> *mut T { pub unsafe fn offset(self, count: isize) -> *mut T { - intrinsics::offset(self, count) as *mut T + crate::intrinsics::offset(self, count) as *mut T } } } diff --git a/gcc/testsuite/rust/compile/issue-1981.rs b/gcc/testsuite/rust/compile/issue-1981.rs index bfd8d2c..de9588c 100644 --- a/gcc/testsuite/rust/compile/issue-1981.rs +++ b/gcc/testsuite/rust/compile/issue-1981.rs @@ -16,30 +16,30 @@ mod ptr { #[lang = "const_ptr"] impl<T> *const T { pub unsafe fn offset(self, count: isize) -> *const T { - intrinsics::offset(self, count) + crate::intrinsics::offset(self, count) } } #[lang = "mut_ptr"] impl<T> *mut T { pub unsafe fn offset(self, count: isize) -> *mut T { - intrinsics::offset(self, count) as *mut T + crate::intrinsics::offset(self, count) as *mut T } } pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { let x = x as *mut u8; let y = y as *mut u8; - let len = mem::size_of::<T>() * count; + let len = crate::mem::size_of::<T>() * count; swap_nonoverlapping_bytes(x, y, len) } pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { // For types smaller than the block optimization below, // just swap directly to avoid pessimizing codegen. - if mem::size_of::<T>() < 32 { + if crate::mem::size_of::<T>() < 32 { let z = read(x); - intrinsics::copy_nonoverlapping(y, x, 1); + crate::intrinsics::copy_nonoverlapping(y, x, 1); write(y, z); } else { swap_nonoverlapping(x, y, 1); @@ -47,12 +47,12 @@ mod ptr { } pub unsafe fn write<T>(dst: *mut T, src: T) { - intrinsics::move_val_init(&mut *dst, src) + crate::intrinsics::move_val_init(&mut *dst, src) } pub unsafe fn read<T>(src: *const T) -> T { - let mut tmp: T = mem::uninitialized(); - intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); tmp } @@ -60,7 +60,7 @@ mod ptr { struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64); - let block_size = mem::size_of::<Block>(); + let block_size = crate::mem::size_of::<Block>(); // Loop through x & y, copying them `Block` at a time // The optimizer should unroll the loop fully for most types @@ -69,31 +69,31 @@ mod ptr { while i + block_size <= len { // Create some uninitialized memory as scratch space // Declaring `t` here avoids aligning the stack when this loop is unused - let mut t: Block = mem::uninitialized(); + let mut t: Block = crate::mem::uninitialized(); let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); // Swap a block of bytes of x & y, using t as a temporary buffer // This should be optimized into efficient SIMD operations where available - intrinsics::copy_nonoverlapping(x, t, block_size); - intrinsics::copy_nonoverlapping(y, x, block_size); - intrinsics::copy_nonoverlapping(t, y, block_size); + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); i += block_size; } if i < len { // Swap any remaining bytes - let mut t: UnalignedBlock = mem::uninitialized(); + let mut t: UnalignedBlock = crate::mem::uninitialized(); let rem = len - i; let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); - intrinsics::copy_nonoverlapping(x, t, rem); - intrinsics::copy_nonoverlapping(y, x, rem); - intrinsics::copy_nonoverlapping(t, y, rem); + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); } } } @@ -106,7 +106,7 @@ mod mem { pub fn swap<T>(x: &mut T, y: &mut T) { unsafe { - ptr::swap_nonoverlapping_one(x, y); + crate::ptr::swap_nonoverlapping_one(x, y); } } @@ -116,7 +116,7 @@ mod mem { } pub unsafe fn uninitialized<T>() -> T { - intrinsics::uninit() + crate::intrinsics::uninit() } } @@ -126,7 +126,7 @@ trait Step { impl Step for i32 { fn replace_zero(&mut self) -> Self { - mem::replace(self, 0) + crate::mem::replace(self, 0) } } diff --git a/gcc/testsuite/rust/compile/issue-2015.rs b/gcc/testsuite/rust/compile/issue-2015.rs new file mode 100644 index 0000000..7789ecd --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2015.rs @@ -0,0 +1,19 @@ +// { dg-additional-options "-frust-compile-until=lowering" } + +macro_rules! impl_foo { + () => { impl Foo } +} + +pub trait Foo {} + +pub trait Bar { + type Baz; +} + +pub fn foo(_value: impl Bar<Baz = impl_foo!()>) -> i32 { + 15 +} + +pub fn bar(_value: impl Bar<Baz = impl Foo>) -> i32 { + 16 +} diff --git a/gcc/testsuite/rust/compile/issue-2035.rs b/gcc/testsuite/rust/compile/issue-2035.rs new file mode 100644 index 0000000..c0817d5 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2035.rs @@ -0,0 +1,10 @@ +fn func(i: i32) { + i(); + // { dg-error "expected function, found .i32. .E0618." "" { target *-*-* } .-1 } +} + +fn main() { + let i = 0i32; + i(); + // { dg-error "expected function, found .i32. .E0618." "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-2323.rs b/gcc/testsuite/rust/compile/issue-2323.rs new file mode 100644 index 0000000..02a3f90 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2323.rs @@ -0,0 +1,9 @@ +#[lang = "sized"] +trait Sized {} + +pub struct S<T>(T); + +pub fn foo<T>(x: T) { + let y = S(x); + y.0; +} diff --git a/gcc/testsuite/rust/compile/issue-2330.rs b/gcc/testsuite/rust/compile/issue-2330.rs index 97c1503..6ab46c7 100644 --- a/gcc/testsuite/rust/compile/issue-2330.rs +++ b/gcc/testsuite/rust/compile/issue-2330.rs @@ -95,30 +95,30 @@ mod ptr { #[lang = "const_ptr"] impl<T> *const T { pub unsafe fn offset(self, count: isize) -> *const T { - intrinsics::offset(self, count) + crate::intrinsics::offset(self, count) } } #[lang = "mut_ptr"] impl<T> *mut T { pub unsafe fn offset(self, count: isize) -> *mut T { - intrinsics::offset(self, count) as *mut T + crate::intrinsics::offset(self, count) as *mut T } } pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { let x = x as *mut u8; let y = y as *mut u8; - let len = mem::size_of::<T>() * count; + let len = crate::mem::size_of::<T>() * count; swap_nonoverlapping_bytes(x, y, len) } pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { // For types smaller than the block optimization below, // just swap directly to avoid pessimizing codegen. - if mem::size_of::<T>() < 32 { + if crate::mem::size_of::<T>() < 32 { let z = read(x); - intrinsics::copy_nonoverlapping(y, x, 1); + crate::intrinsics::copy_nonoverlapping(y, x, 1); write(y, z); } else { swap_nonoverlapping(x, y, 1); @@ -126,12 +126,12 @@ mod ptr { } pub unsafe fn write<T>(dst: *mut T, src: T) { - intrinsics::move_val_init(&mut *dst, src) + crate::intrinsics::move_val_init(&mut *dst, src) } pub unsafe fn read<T>(src: *const T) -> T { - let mut tmp: T = mem::uninitialized(); - intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); tmp } @@ -139,7 +139,7 @@ mod ptr { struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64); - let block_size = mem::size_of::<Block>(); + let block_size = crate::mem::size_of::<Block>(); // Loop through x & y, copying them `Block` at a time // The optimizer should unroll the loop fully for most types @@ -148,31 +148,31 @@ mod ptr { while i + block_size <= len { // Create some uninitialized memory as scratch space // Declaring `t` here avoids aligning the stack when this loop is unused - let mut t: Block = mem::uninitialized(); + let mut t: Block = crate::mem::uninitialized(); let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); // Swap a block of bytes of x & y, using t as a temporary buffer // This should be optimized into efficient SIMD operations where available - intrinsics::copy_nonoverlapping(x, t, block_size); - intrinsics::copy_nonoverlapping(y, x, block_size); - intrinsics::copy_nonoverlapping(t, y, block_size); + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); i += block_size; } if i < len { // Swap any remaining bytes - let mut t: UnalignedBlock = mem::uninitialized(); + let mut t: UnalignedBlock = crate::mem::uninitialized(); let rem = len - i; let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); - intrinsics::copy_nonoverlapping(x, t, rem); - intrinsics::copy_nonoverlapping(y, x, rem); - intrinsics::copy_nonoverlapping(t, y, rem); + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); } } } @@ -185,7 +185,7 @@ mod mem { pub fn swap<T>(x: &mut T, y: &mut T) { unsafe { - ptr::swap_nonoverlapping_one(x, y); + crate::ptr::swap_nonoverlapping_one(x, y); } } @@ -195,6 +195,6 @@ mod mem { } pub unsafe fn uninitialized<T>() -> T { - intrinsics::uninit() + crate::intrinsics::uninit() } } diff --git a/gcc/testsuite/rust/compile/issue-2369.rs b/gcc/testsuite/rust/compile/issue-2369.rs new file mode 100644 index 0000000..9475aef --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2369.rs @@ -0,0 +1,21 @@ +#[lang = "sized"] +trait Sized {} + +fn main() { + pub trait Foo { + type A; + fn boo(&self) -> <Self as Foo>::A; + } + + struct Bar; + + impl Foo for isize { + type A = usize; + fn boo(&self) -> usize { + 42 + } + } + + fn baz<I>(x: &<I as Foo<A = Bar>>::A) {} + // { dg-error "associated type bindings are not allowed here .E0229." "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-2394.rs b/gcc/testsuite/rust/compile/issue-2394.rs new file mode 100644 index 0000000..92f7afc --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2394.rs @@ -0,0 +1,14 @@ +const A: i32 = (1 / 0); +// { dg-error "division by zero" "" { target *-*-* } .-1 } + +fn main() { + let a = 1 / 0; + // { dg-error "division by zero" "" { target *-*-* } .-1 } + + let b = 3; + let c = b / 0; + // { dg-error "division by zero" "" { target *-*-* } .-1 } + + let a = 1 << 500; + // { dg-error "left shift count >= width of type" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-2423.rs b/gcc/testsuite/rust/compile/issue-2423.rs new file mode 100644 index 0000000..6fcd32f --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2423.rs @@ -0,0 +1,14 @@ +impl NonExistant { + // { dg-error "could not resolve" "" { target *-*-* } .-1 } + fn test() {} +} + +impl NotFound for NonExistant { + // { dg-error "could not resolve" "" { target *-*-* } .-1 } + fn test() {} +} + +trait A {} + +impl A for NotFound {} +// { dg-error "could not resolve" "" { target *-*-* } .-1 } diff --git a/gcc/testsuite/rust/compile/issue-2567-1.rs b/gcc/testsuite/rust/compile/issue-2567-1.rs new file mode 100644 index 0000000..f5af249 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2567-1.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } +enum Empty {} + +fn foo(x: Empty) { + let x: Empty = match x { + // empty + }; +} diff --git a/gcc/testsuite/rust/compile/issue-2567-2.rs b/gcc/testsuite/rust/compile/issue-2567-2.rs new file mode 100644 index 0000000..719511d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2567-2.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } +enum Empty {} + +fn foo(x: Empty) { + let x: i32 = match x { + // empty + }; +} diff --git a/gcc/testsuite/rust/compile/issue-2567-3.rs b/gcc/testsuite/rust/compile/issue-2567-3.rs new file mode 100644 index 0000000..09efaf0 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2567-3.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } +enum Empty {} + +fn foo(x: Empty) { + match x { + // empty + } +} diff --git a/gcc/testsuite/rust/compile/issue-266.rs b/gcc/testsuite/rust/compile/issue-266.rs new file mode 100644 index 0000000..11196cb --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-266.rs @@ -0,0 +1,3 @@ +fn main() { + 'label: while break 'label {} +} diff --git a/gcc/testsuite/rust/compile/issue-2847.rs b/gcc/testsuite/rust/compile/issue-2847.rs new file mode 100644 index 0000000..2bc5566 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2847.rs @@ -0,0 +1,8 @@ +pub fn myfun1((x, _): (i32, i32)) -> i32 { + x +} + +pub fn myfun2() -> i32 { + let (x, _) = (1, 2); + x +} diff --git a/gcc/testsuite/rust/compile/issue-2905-1.rs b/gcc/testsuite/rust/compile/issue-2905-1.rs new file mode 100644 index 0000000..9b0c19d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2905-1.rs @@ -0,0 +1,27 @@ +#![feature(lang_items)] + +#[lang = "sized"] +trait Sized {} + +pub struct A<T>(T); + +pub trait B { + type C; +} + +// ------ +// swap these two items + +impl B for i32 { + type C = Weird<i32>; +} + +pub struct Weird<T>(A<(T,)>); + +// ------ + +trait Foo {} + +impl Foo for Weird<i32> {} + +fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-2905-2.rs b/gcc/testsuite/rust/compile/issue-2905-2.rs new file mode 100644 index 0000000..1c9516d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2905-2.rs @@ -0,0 +1,136 @@ +// { dg-options "-w" } +#![feature(intrinsics)] +#![feature(lang_items)] + +#[lang = "sized"] +trait Sized {} + +extern "rust-intrinsic" { + fn transmute<T, U>(_: T) -> U; + fn offset<T>(src: *const T, offset: isize) -> *const T; +} + +pub mod core { + pub mod marker { + #[lang = "phantom_data"] + pub struct PhantomData<T>; + } + + pub mod slice { + use crate::core::marker::PhantomData; + use crate::core::option::Option; + + impl<T> crate::core::iter::IntoIterator for &[T] { + type Item = &T; + type IntoIter = Weird<T>; + + fn into_iter(self) -> Weird<T> { + self.iter() + } + } + + pub struct Weird<T> { + ptr: *const T, // should be NonNull<T> but here it does not matter + end: *const T, + _marker: PhantomData<&T>, + } + + impl<T> Weird<T> { + pub(super) fn new(slice: &[T]) -> Self { + let ptr = slice.as_ptr(); + // SAFETY: Similar to `IterMut::new`. + unsafe { + // should be: ptr.add(slice.len()) + let end = transmute::<*const T, usize>(ptr) + slice.len(); // TODO(Arthur): Missing `* size_of::<T>()`? + let end = transmute::<usize, *const T>(end); + + Self { + ptr, + end, + _marker: PhantomData, + } + } + } + + fn is_empty(&self) -> bool { + self.ptr == self.end + } + + fn next_unchecked(&mut self) -> *const T { + let old = self.ptr; + + self.ptr = unsafe { offset(self.ptr, 1) }; + + old + } + } + + trait Foo {} + + impl<T> Foo for Weird<T> {} + + // impl<T> core::iter::Iterator for Iter<T> { + // type Item = &T; + + // fn next(&mut self) -> Option<&T> { + // if self.is_empty() { + // Option::None + // } else { + // Option::Some(&*self.next_unchecked()) + // } + // } + // } + + union Repr<T> { + pub(crate) rust: *const [T], + rust_mut: *mut [T], + pub(crate) raw: FatPtr<T>, + } + + struct FatPtr<T> { + data: *const T, + pub(crate) len: usize, + } + + impl<T> [T] { + pub fn iter(&self) -> Weird<T> { + Weird::new(self) + } + + pub fn as_ptr(&self) -> *const T { + self as *const [T] as *const T + } + + pub fn len(&self) -> usize { + unsafe { Repr { rust: self }.raw.len } + } + } + } + + pub mod iter { + use crate::core::option::Option; + + pub trait IntoIterator { + type Item; + + type IntoIter: Iterator<Item = Self::Item>; + + fn into_iter(self) -> Self::IntoIter; + } + + pub trait Iterator { + type Item; + + fn next(&mut self) -> Option<Self::Item>; + } + } + + pub mod option { + pub enum Option<T> { + Some(T), + None, + } + } +} + +fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-2907.rs b/gcc/testsuite/rust/compile/issue-2907.rs new file mode 100644 index 0000000..1af843f --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2907.rs @@ -0,0 +1,33 @@ +#![feature(lang_items)] + +#[lang = "sized"] +pub trait Sized {} + +pub trait Bar {} + +pub trait Foo { + type Ty; + + fn foo(self) -> Self::Ty; +} + +impl<B: Bar> Foo for B { + type Ty = u32; + + fn foo(self) -> Self::Ty { + // { dg-warning "unused name" "" { target *-*-* } .-1 } + 14 + } +} + +struct Qux; + +impl Bar for Qux {} + +fn main() { + let a = Qux; + a.foo(); + + let b = Qux; + Foo::foo(b); +} diff --git a/gcc/testsuite/rust/compile/issue-2953-1.rs b/gcc/testsuite/rust/compile/issue-2953-1.rs new file mode 100644 index 0000000..d07059e --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2953-1.rs @@ -0,0 +1,27 @@ +#[lang = "sized"] +pub trait Sized { + // Empty. +} + +#[lang = "fn_once"] +pub trait FnOnce<Args> { + /// The returned type after the call operator is used. + #[lang = "fn_once_output"] + type Output; + + /// Performs the call operation. + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} + +pub enum Ordering { + /// An ordering where a compared value is less than another. + Less = -1, + /// An ordering where a compared value is equal to another. + Equal = 0, + /// An ordering where a compared value is greater than another. + Greater = 1, +} + +pub fn f<F: FnOnce(i32) -> Ordering>(g: F) -> Ordering { + g(1) +} diff --git a/gcc/testsuite/rust/compile/issue-2953-2.rs b/gcc/testsuite/rust/compile/issue-2953-2.rs new file mode 100644 index 0000000..5927624 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2953-2.rs @@ -0,0 +1,37 @@ +#[lang = "sized"] +pub trait Sized { + // Empty. +} + +#[lang = "fn_once"] +pub trait FnOnce<Args> { + /// The returned type after the call operator is used. + #[lang = "fn_once_output"] + type Output; + + /// Performs the call operation. + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} + +pub enum Ordering { + /// An ordering where a compared value is less than another. + Less = -1, + /// An ordering where a compared value is equal to another. + Equal = 0, + /// An ordering where a compared value is greater than another. + Greater = 1, +} + +pub fn max_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T { + match compare(&v1, &v2) { + Ordering::Less | Ordering::Equal => v2, + Ordering::Greater => v1, + } +} + +pub fn min_by<T, F: FnOnce(&T, &T) -> Ordering>(v1: T, v2: T, compare: F) -> T { + match compare(&v1, &v2) { + Ordering::Less | Ordering::Equal => v1, + Ordering::Greater => v2, + } +} diff --git a/gcc/testsuite/rust/compile/issue-2954.rs b/gcc/testsuite/rust/compile/issue-2954.rs new file mode 100644 index 0000000..52f7c91 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-2954.rs @@ -0,0 +1,17 @@ +#[lang = "sized"] +trait Sized {} + +#[lang = "receiver"] +#[unstable(feature = "receiver_trait", issue = "none")] +// #[doc(hidden)] +pub trait Receiver { + // Empty. +} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl<T: ?Sized> Receiver for &T {} + +#[unstable(feature = "receiver_trait", issue = "none")] +impl<T: ?Sized> Receiver for &mut T {} + + diff --git a/gcc/testsuite/rust/compile/issue-3009.rs b/gcc/testsuite/rust/compile/issue-3009.rs new file mode 100644 index 0000000..2eb4ef3 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3009.rs @@ -0,0 +1,24 @@ +#[lang = "sized"] +trait Sized {} + +struct Foo { + // { dg-warning "struct is never constructed" "" { target *-*-* } .-1 } + t: u64, +} + +impl Foo { + fn of<T>() -> Foo { + // { dg-warning "associated function is never used" "" { target *-*-* } .-1 } + Foo { t: 14 } + } +} + +trait Bar { + fn bar() -> Foo; +} + +impl<T> Bar for T { + fn bar() -> Foo { + Foo::of::<T>() + } +} diff --git a/gcc/testsuite/rust/compile/issue-3022.rs b/gcc/testsuite/rust/compile/issue-3022.rs new file mode 100644 index 0000000..b8b8e6f --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3022.rs @@ -0,0 +1,18 @@ +#[lang = "sized"] +trait Sized {} + +trait Foo<T> { + fn foo(self) -> T; +} + +struct Bar<T, U> { + // { dg-warning "struct is never constructed" "" { target *-*-* } .-1 } + value: U, + valte: T, +} + +impl<T: Foo<U>, U> Foo<U> for Bar<T, U> { + fn foo(self) -> U { + self.value + } +} diff --git a/gcc/testsuite/rust/compile/issue-3031.rs b/gcc/testsuite/rust/compile/issue-3031.rs new file mode 100644 index 0000000..33f5bf0 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3031.rs @@ -0,0 +1,15 @@ +#![feature(no_core)] +#![feature(lang_items)] +#![no_core] + +#[lang = "sized"] +trait Sized {} + +trait A<T: ?Sized> {} + +struct Cell<X> { + // { dg-warning "struct is never constructed" "" { target *-*-* } .-1 } + x: X, +} + +impl<T, U> A<Cell<U>> for Cell<T> where T: A<U> {} diff --git a/gcc/testsuite/rust/compile/issue-3032-1.rs b/gcc/testsuite/rust/compile/issue-3032-1.rs new file mode 100644 index 0000000..e9eb027 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3032-1.rs @@ -0,0 +1,58 @@ +#![feature(negative_impls)] + +#[lang = "sized"] +trait Sized {} + +#[lang = "deref"] +pub trait Deref { + /// The resulting type after dereferencing. + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_target"] + type Target: ?Sized; + + /// Dereferences the value. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_method"] + fn deref(&self) -> &Self::Target; +} + +impl<T: ?Sized> Deref for &T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +// this is added because of #3030 +extern "C" { + fn never() -> !; +} + +impl<T: ?Sized> !DerefMut for &T { + fn deref_mut(&mut self) -> &mut T { + unsafe { never() } + } +} + +impl<T: ?Sized> Deref for &mut T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +#[lang = "deref_mut"] +pub trait DerefMut: Deref { + /// Mutably dereferences the value. + #[stable(feature = "rust1", since = "1.0.0")] + fn deref_mut(&mut self) -> &mut Self::Target; +} + +impl<T: ?Sized> DerefMut for &mut T { + fn deref_mut(&mut self) -> &mut T { + *self + } +} diff --git a/gcc/testsuite/rust/compile/issue-3032-2.rs b/gcc/testsuite/rust/compile/issue-3032-2.rs new file mode 100644 index 0000000..9e09d41 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3032-2.rs @@ -0,0 +1,49 @@ +#![feature(negative_impls)] + +#[lang = "sized"] +trait Sized {} + +#[lang = "deref"] +pub trait Deref { + /// The resulting type after dereferencing. + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_target"] + type Target: ?Sized; + + /// Dereferences the value. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_method"] + fn deref(&self) -> &Self::Target; +} + +impl<T: ?Sized> Deref for &T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +impl<T: ?Sized> !DerefMut for &T {} + +impl<T: ?Sized> Deref for &mut T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +#[lang = "deref_mut"] +pub trait DerefMut: Deref { + /// Mutably dereferences the value. + #[stable(feature = "rust1", since = "1.0.0")] + fn deref_mut(&mut self) -> &mut Self::Target; +} + +impl<T: ?Sized> DerefMut for &mut T { + fn deref_mut(&mut self) -> &mut T { + *self + } +} diff --git a/gcc/testsuite/rust/compile/issue-3033.rs b/gcc/testsuite/rust/compile/issue-3033.rs new file mode 100644 index 0000000..9085b76 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3033.rs @@ -0,0 +1,144 @@ +#![feature(negative_impls)] + +#[lang = "copy"] +trait Copy {} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[repr(transparent)] +#[repr(no_niche)] // rust-lang/rust#68303. +pub struct UnsafeCell<T: ?Sized> { + value: T, + // { dg-warning "field is never read" "" { target *-*-* } .-1 } +} + +impl<T: ?Sized> UnsafeCell<T> { + /// Gets a mutable pointer to the wrapped value. + /// + /// This can be cast to a pointer of any kind. + /// Ensure that the access is unique (no active references, mutable or not) + /// when casting to `&mut T`, and ensure that there are no mutations + /// or mutable aliases going on when casting to `&T` + /// + /// # Examples + /// + /// + /// use std::cell::UnsafeCell; + /// + /// let uc = UnsafeCell::new(5); + /// + /// let five = uc.get(); + /// + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_const_stable(feature = "const_unsafecell_get", since = "1.32.0")] + pub const fn get(&self) -> *mut T { + // We can just cast the pointer from `UnsafeCell<T>` to `T` because of + // #[repr(transparent)]. This exploits libstd's special status, there is + // no guarantee for user code that this will work in future versions of the compiler! + self as *const UnsafeCell<T> as *const T as *mut T + } +} + +#[stable(feature = "rust1", since = "1.0.0")] +#[repr(transparent)] +pub struct Cell<T: ?Sized> { + value: UnsafeCell<T>, + // { dg-warning "field is never read" "" { target *-*-* } .-1 } +} + +impl<T: Copy> Cell<T> { + /// Returns a copy of the contained value. + /// + /// # Examples + /// + /// + /// use std::cell::Cell; + /// + /// let c = Cell::new(5); + /// + /// let five = c.get(); + /// + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + pub fn get(&self) -> T { + // SAFETY: This can cause data races if called from a separate thread, + // but `Cell` is `!Sync` so this won't happen. + unsafe { *self.value.get() } + } +} + +#[lang = "sized"] +trait Sized {} + +#[lang = "deref"] +pub trait Deref { + /// The resulting type after dereferencing. + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_target"] + type Target: ?Sized; + + /// Dereferences the value. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + // #[rustc_diagnostic_item = "deref_method"] + fn deref(&self) -> &Self::Target; +} + +impl<T: ?Sized> Deref for &T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +// this is added because of #3030 +extern "C" { + fn never() -> !; +} + +impl<T: ?Sized> !DerefMut for &T { + fn deref_mut(&mut self) -> &mut T { + unsafe { never() } + } +} + +impl<T: ?Sized> Deref for &mut T { + type Target = T; + + fn deref(&self) -> &T { + *self + } +} + +#[lang = "deref_mut"] +pub trait DerefMut: Deref { + /// Mutably dereferences the value. + #[stable(feature = "rust1", since = "1.0.0")] + fn deref_mut(&mut self) -> &mut Self::Target; +} + +#[inline] +pub fn new<'b>(borrow: &'b Cell<i32>) { + let b = borrow.get(); + // { dg-warning "unused name" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-3046.rs b/gcc/testsuite/rust/compile/issue-3046.rs index c982cc9..f0c72a3 100644 --- a/gcc/testsuite/rust/compile/issue-3046.rs +++ b/gcc/testsuite/rust/compile/issue-3046.rs @@ -12,12 +12,10 @@ fn test(v: LOption) -> Res { return Res::BAD; } - fn main() { // Should be: // test(LOption::Some(2)); - // + // test(LOption(2)); // { dg-error "expected function, tuple struct or tuple variant, found enum" "" { target *-*-* } .-1 } - // { dg-error "failed to resolve type for argument expr in CallExpr" "" { target *-*-* } .-2 } } diff --git a/gcc/testsuite/rust/compile/issue-3140.rs b/gcc/testsuite/rust/compile/issue-3140.rs new file mode 100644 index 0000000..dcf86db --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3140.rs @@ -0,0 +1,27 @@ +enum State { + Succeeded, + Failed, +} + +fn print_on_failure(state: &State) { + let mut num = 0; + match *state { + // error: expected unit struct, unit variant or constant, found tuple + // variant `State::Failed` + State::Failed => { + num = 1; + } + State::Succeeded => { + num = 2; + } + _ => (), + } +} + +fn main() { + let b = State::Failed(1); + // { dg-error "expected function, tuple struct or tuple variant, found struct .State." "" { target *-*-* } .-1 } + + print_on_failure(&b); + // { dg-error "cannot find value .b. in this scope" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-3174.rs b/gcc/testsuite/rust/compile/issue-3174.rs new file mode 100644 index 0000000..87588e1 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3174.rs @@ -0,0 +1,28 @@ +extern "C" { + fn printf(s: *const i8, ...); +} + +enum Option { + Some(i32), + None, +} + +impl Option { + fn add(&mut self) { + match *self { + Option::Some(ref mut a) => *a += 1, + Option::None => {} + } + } +} + +fn main() { + unsafe { + let mut a = Option::None; + a.add(); + let _s = "%d\n\0"; + let _s = _s as *const str; + let s = _s as *const i8; + printf(s, a); + } +} diff --git a/gcc/testsuite/rust/compile/issue-3231.rs b/gcc/testsuite/rust/compile/issue-3231.rs new file mode 100644 index 0000000..59726cb --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3231.rs @@ -0,0 +1,8 @@ +// { dg-options "-w" } +pub enum X {} + +pub fn foo(x: X) { + let _a: i32 = match x {}; +} + +pub fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-3242.rs b/gcc/testsuite/rust/compile/issue-3242.rs new file mode 100644 index 0000000..a4542aea0 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3242.rs @@ -0,0 +1,23 @@ +#[lang = "sized"] +pub trait Sized {} + +trait Foo<T> { + type A; + + fn test(a: Self::A) -> Self::A { + a + } +} + +struct Bar<T>(T); +impl<T> Foo<T> for Bar<i32> { + type A = T; +} + +fn main() { + let a; + a = Bar(123); + + let b; + b = Bar::test(a.0); +} diff --git a/gcc/testsuite/rust/compile/issue-3261.rs b/gcc/testsuite/rust/compile/issue-3261.rs new file mode 100644 index 0000000..37e974d --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3261.rs @@ -0,0 +1,18 @@ +// { dg-options "-w" } +fn main() { + let a: i8 = 50; + let b = a as f32; + let c = a as f64; + + let a: i16 = 1337; + let b = a as f32; + let c = a as f64; + + let a: i32 = 1337; + let b = a as f32; + let c = a as f64; + + let a: i64 = 1337; + let b = a as f32; + let c = a as f64; +} diff --git a/gcc/testsuite/rust/compile/issue-3304.rs b/gcc/testsuite/rust/compile/issue-3304.rs new file mode 100644 index 0000000..6ab614f --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3304.rs @@ -0,0 +1,10 @@ +// { dg-additional-options "-frust-name-resolution-2.0" } +#[lang = "sized"] +trait Sized {} + +pub enum ROption<T> { + RSome(T), + RNone, +} + +fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-3315-1.rs b/gcc/testsuite/rust/compile/issue-3315-1.rs new file mode 100644 index 0000000..07581da --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3315-1.rs @@ -0,0 +1,8 @@ +//You should be able to create a module of the same name as a builtin type + +mod i32 { +} + +fn main() -> isize { + 0 +} diff --git a/gcc/testsuite/rust/compile/issue-3315-2.rs b/gcc/testsuite/rust/compile/issue-3315-2.rs new file mode 100644 index 0000000..71abd6c --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3315-2.rs @@ -0,0 +1,7 @@ +mod i32 { +} + +fn main() -> isize { + let i:i32 = 0 as i32; + i as isize +} diff --git a/gcc/testsuite/rust/compile/issue-3350.rs b/gcc/testsuite/rust/compile/issue-3350.rs new file mode 100644 index 0000000..8880659 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3350.rs @@ -0,0 +1,10 @@ +static FOO: i32 = 0; + +pub fn bar() -> i32 { + FOO +} + +pub fn baz() -> i32 { + static QUX: i32 = 0; + QUX +} diff --git a/gcc/testsuite/rust/compile/issue-3382.rs b/gcc/testsuite/rust/compile/issue-3382.rs new file mode 100644 index 0000000..6f4382f --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3382.rs @@ -0,0 +1,61 @@ +#[lang = "sized"] +trait Sized {} + +enum Result<T, E> { + #[lang = "Ok"] + Ok(T), + #[lang = "Err"] + Err(E), +} + +#[lang = "try"] +pub trait Try { + /// The type of this value when viewed as successful. + // #[unstable(feature = "try_trait", issue = "42327")] + type Ok; + /// The type of this value when viewed as failed. + // #[unstable(feature = "try_trait", issue = "42327")] + type Error; + + /// Applies the "?" operator. A return of `Ok(t)` means that the + /// execution should continue normally, and the result of `?` is the + /// value `t`. A return of `Err(e)` means that execution should branch + /// to the innermost enclosing `catch`, or return from the function. + /// + /// If an `Err(e)` result is returned, the value `e` will be "wrapped" + /// in the return type of the enclosing scope (which must itself implement + /// `Try`). Specifically, the value `X::from_error(From::from(e))` + /// is returned, where `X` is the return type of the enclosing function. + #[lang = "into_result"] + #[unstable(feature = "try_trait", issue = "42327")] + fn into_result(self) -> Result<Self::Ok, Self::Error>; + + /// Wrap an error value to construct the composite result. For example, + /// `Result::Err(x)` and `Result::from_error(x)` are equivalent. + #[lang = "from_error"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_error(v: Self::Ok) -> Self; + + /// Wrap an OK value to construct the composite result. For example, + /// `Result::Ok(x)` and `Result::from_ok(x)` are equivalent. + #[lang = "from_ok"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_ok(v: Self::Error) -> Self; +} + +impl<T, E> Try for Result<T, E> { + type Ok = T; + type Error = E; + + fn into_result(self) -> Result<T, E> { + self + } + + fn from_ok(v: T) -> Self { + Result::Ok(v) + } + + fn from_error(v: E) -> Self { + Result::Err(v) + } +} diff --git a/gcc/testsuite/rust/compile/issue-3402-1.rs b/gcc/testsuite/rust/compile/issue-3402-1.rs new file mode 100644 index 0000000..ed603ce --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3402-1.rs @@ -0,0 +1,29 @@ +pub struct Foo { + a: i32, + // { dg-warning "field is never read" "" { target *-*-* } .-1 } +} +pub struct Bar(i32); + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod default { + pub trait Default: Sized { + fn default() -> Self; + } + + impl Default for i32 { + fn default() -> Self { + 0 + } + } + } +} + +impl ::core::default::Default for Bar { + #[inline] + fn default() -> Bar { + Bar(core::default::Default::default()) + } +} diff --git a/gcc/testsuite/rust/compile/issue-3402-2.rs b/gcc/testsuite/rust/compile/issue-3402-2.rs new file mode 100644 index 0000000..b665af2 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3402-2.rs @@ -0,0 +1,18 @@ +pub struct Bar(i32); + +#[lang = "sized"] +trait Sized {} + +pub trait A: Sized { + fn foo() -> Self; +} + +impl A for i32 { + fn foo() -> Self { + 0 + } +} + +pub fn bar() { + let _ = Bar(A::foo()); +} diff --git a/gcc/testsuite/rust/compile/issue-3403.rs b/gcc/testsuite/rust/compile/issue-3403.rs new file mode 100644 index 0000000..ced6b4e --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3403.rs @@ -0,0 +1,38 @@ +pub struct Foo { + a: i32, + // { dg-warning "field is never read" "" { target *-*-* } .-1 } +} +pub struct Bar(i32); + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod default { + pub trait Default: Sized { + fn default() -> Self; + } + + impl Default for i32 { + fn default() -> Self { + 0 + } + } + } +} + +impl ::core::default::Default for Bar { + #[inline] + fn default() -> Bar { + Bar(core::default::Default::default()) + } +} + +impl ::core::default::Default for Foo { + #[inline] + fn default() -> Foo { + Foo { + a: core::default::Default::default(), + } + } +} diff --git a/gcc/testsuite/rust/compile/issue-3541-1.rs b/gcc/testsuite/rust/compile/issue-3541-1.rs new file mode 100644 index 0000000..6b47b7e --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3541-1.rs @@ -0,0 +1,5 @@ +impl B for u32 { + const BAR: i32; // { dg-error "associated constant in .impl." } +} + +trait B {} diff --git a/gcc/testsuite/rust/compile/issue-3541-2.rs b/gcc/testsuite/rust/compile/issue-3541-2.rs new file mode 100644 index 0000000..9f17eed --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3541-2.rs @@ -0,0 +1,3 @@ +trait B { + const BAR: i32; +} diff --git a/gcc/testsuite/rust/compile/issue-3549.rs b/gcc/testsuite/rust/compile/issue-3549.rs new file mode 100644 index 0000000..cedbb5a --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3549.rs @@ -0,0 +1,3 @@ +fn main() { + r#""#; +} diff --git a/gcc/testsuite/rust/compile/issue-3552.rs b/gcc/testsuite/rust/compile/issue-3552.rs new file mode 100644 index 0000000..9a4451b14b --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3552.rs @@ -0,0 +1,14 @@ +trait Foo { + const BAR: u32; +} + +const TRAIT_REF_BAR: u32 = <Foo>::BAR; +// { dg-error "no default expression on trait constant" "" { target *-*-* } .-1 } + +struct GlobalTraitRef; + +impl Foo for GlobalTraitRef { + const BAR: u32 = TRAIT_REF_BAR; +} + +fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-3553.rs b/gcc/testsuite/rust/compile/issue-3553.rs new file mode 100644 index 0000000..546f3c1 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3553.rs @@ -0,0 +1,18 @@ +trait Foo { + fn f(&self) -> isize; +} + +trait Bar: Foo { + fn g(&self) -> isize; +} + +struct A { + x: isize, +} + +impl Bar for A { + // { dg-error "the trait bound .A: Foo. is not satisfied .E0277." "" { target *-*-* } .-1 } + fn g(&self) -> isize { + self.f() + } +} diff --git a/gcc/testsuite/rust/compile/issue-3554-1.rs b/gcc/testsuite/rust/compile/issue-3554-1.rs new file mode 100644 index 0000000..a66be35 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3554-1.rs @@ -0,0 +1,8 @@ +trait Tr { + fn foo(); + + fn bar(&self) { + self.foo() + // { dg-error "no method named .foo. found in the current scope .E0599." "" { target *-*-* } .-1 } + } +} diff --git a/gcc/testsuite/rust/compile/issue-3554-2.rs b/gcc/testsuite/rust/compile/issue-3554-2.rs new file mode 100644 index 0000000..e455a8b --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3554-2.rs @@ -0,0 +1,18 @@ +#[lang = "sized"] +pub trait Sized {} + +#[lang = "fn_once"] +pub trait FnOnce<Args> { + #[lang = "fn_once_output"] + type Output; + + extern "rust-call" fn call_once(self, args: Args) -> Self::Output; +} +trait Tr { + fn foo(); + + fn bar(&self) { + (|| self.foo())() + // { dg-error "no method named .foo. found in the current scope .E0599." "" { target *-*-* } .-1 } + } +} diff --git a/gcc/testsuite/rust/compile/issue-3563.rs b/gcc/testsuite/rust/compile/issue-3563.rs new file mode 100644 index 0000000..46e7624 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3563.rs @@ -0,0 +1,17 @@ +pub struct AA { + pub data: [u8; 10], +} + +impl AA { + pub const fn new() -> Self { + let mut res: AA = AA { data: [0; 10] }; + res.data[0] = 5; + res + } +} + +static mut BB: AA = AA::new(); + +fn main() { + let _ptr = unsafe { &mut BB }; +} diff --git a/gcc/testsuite/rust/compile/issue-3566-1.rs b/gcc/testsuite/rust/compile/issue-3566-1.rs new file mode 100644 index 0000000..b7e5be0 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3566-1.rs @@ -0,0 +1,8 @@ +mod a { + pub mod b { + + pub fn f(x: [u8; { 100 }]) -> [u8; { 100 }] { + x + } + } +} diff --git a/gcc/testsuite/rust/compile/issue-3566-2.rs b/gcc/testsuite/rust/compile/issue-3566-2.rs new file mode 100644 index 0000000..3f3ea73 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3566-2.rs @@ -0,0 +1,22 @@ +// run-pass + +#![allow(H8)] +#![allow(dead_code)] + + +// pretty-expanded FIXME #23616 + +mod a { + pub mod b { + pub type t = isize; + + pub fn f(x: [u8; { let s = 17; 100 }]) -> [u8; { let z = 18; 100 }] { + //~^ WARN unused variable: `s` + //~| WARN unused variable: `z` + x +} + } +} + +pub fn main() { //~ ERROR cannot move out + } diff --git a/gcc/testsuite/rust/compile/issue-3567.rs b/gcc/testsuite/rust/compile/issue-3567.rs new file mode 100644 index 0000000..021d9c2 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3567.rs @@ -0,0 +1,4 @@ +fn main() { + let _: &[i8] = &[i8]; + // { dg-error "expected value .E0423." "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/issue-3568.rs b/gcc/testsuite/rust/compile/issue-3568.rs new file mode 100644 index 0000000..222a174 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3568.rs @@ -0,0 +1,7 @@ +pub type T = (); +mod foo { + pub use super::T; +} + +pub use foo::super::foo::S as T; +// { dg-error ".super. can only be used in start position" "" { target *-*-* } .-1 } diff --git a/gcc/testsuite/rust/compile/issue-3588.rs b/gcc/testsuite/rust/compile/issue-3588.rs new file mode 100644 index 0000000..744d967 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3588.rs @@ -0,0 +1,5 @@ +const FOO: i32 = if true { [1, 2, 3] } else { [2, 3, 4] }[0]; + +pub fn test() -> i32 { + FOO +} diff --git a/gcc/testsuite/rust/compile/issue-3605.rs b/gcc/testsuite/rust/compile/issue-3605.rs new file mode 100644 index 0000000..05e6e48 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3605.rs @@ -0,0 +1,5 @@ +enum Foo<'a> {} + +enum Bar<'a> { + in_band_def_explicit_impl(Foo<'a>), +} diff --git a/gcc/testsuite/rust/compile/issue-3606.rs b/gcc/testsuite/rust/compile/issue-3606.rs new file mode 100644 index 0000000..73b0bd6 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3606.rs @@ -0,0 +1,6 @@ +// { dg-options "-w" } +#[repr()] +pub struct Coord { + x: u32, + y: u32, +} diff --git a/gcc/testsuite/rust/compile/issue-3613.rs b/gcc/testsuite/rust/compile/issue-3613.rs new file mode 100644 index 0000000..f2e1092 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3613.rs @@ -0,0 +1,18 @@ +mod m1 { + pub enum Baz4 { + foo1, + foo2, + } +} + +fn bar(x: m1::foo) { + // { dg-error "unknown reference for resolved name: .foo." "" { target *-*-* } .-1 } + match x { + m1::foo::foo1 => {} + // { dg-error "failed to type resolve root segment" "" { target *-*-* } .-1 } + m1::NodePosition::foo2 => {} + // { dg-error "failed to type resolve root segment" "" { target *-*-* } .-1 } + } +} + +pub fn main() {} diff --git a/gcc/testsuite/rust/compile/issue-3614.rs b/gcc/testsuite/rust/compile/issue-3614.rs new file mode 100644 index 0000000..350a7e4 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3614.rs @@ -0,0 +1,3 @@ +#[repr] // { dg-error "malformed .repr. attribute" } + +struct _B {} diff --git a/gcc/testsuite/rust/compile/issue-3615.rs b/gcc/testsuite/rust/compile/issue-3615.rs new file mode 100644 index 0000000..e5c5072 --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-3615.rs @@ -0,0 +1,7 @@ +pub trait Trait { + pub fn nrvo(init: fn()) -> [u8; 4096] { + let mut buf = [0; 4096]; + + buf + } +} diff --git a/gcc/testsuite/rust/compile/iterators1.rs b/gcc/testsuite/rust/compile/iterators1.rs index 35fea5a..2ea3d74 100644 --- a/gcc/testsuite/rust/compile/iterators1.rs +++ b/gcc/testsuite/rust/compile/iterators1.rs @@ -98,30 +98,30 @@ mod ptr { #[lang = "const_ptr"] impl<T> *const T { pub unsafe fn offset(self, count: isize) -> *const T { - intrinsics::offset(self, count) + crate::intrinsics::offset(self, count) } } #[lang = "mut_ptr"] impl<T> *mut T { pub unsafe fn offset(self, count: isize) -> *mut T { - intrinsics::offset(self, count) as *mut T + crate::intrinsics::offset(self, count) as *mut T } } pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { let x = x as *mut u8; let y = y as *mut u8; - let len = mem::size_of::<T>() * count; + let len = crate::mem::size_of::<T>() * count; swap_nonoverlapping_bytes(x, y, len) } pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { // For types smaller than the block optimization below, // just swap directly to avoid pessimizing codegen. - if mem::size_of::<T>() < 32 { + if crate::mem::size_of::<T>() < 32 { let z = read(x); - intrinsics::copy_nonoverlapping(y, x, 1); + crate::intrinsics::copy_nonoverlapping(y, x, 1); write(y, z); } else { swap_nonoverlapping(x, y, 1); @@ -129,12 +129,12 @@ mod ptr { } pub unsafe fn write<T>(dst: *mut T, src: T) { - intrinsics::move_val_init(&mut *dst, src) + crate::intrinsics::move_val_init(&mut *dst, src) } pub unsafe fn read<T>(src: *const T) -> T { - let mut tmp: T = mem::uninitialized(); - intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + let mut tmp: T = crate::mem::uninitialized(); + crate::intrinsics::copy_nonoverlapping(src, &mut tmp, 1); tmp } @@ -142,7 +142,7 @@ mod ptr { struct Block(u64, u64, u64, u64); struct UnalignedBlock(u64, u64, u64, u64); - let block_size = mem::size_of::<Block>(); + let block_size = crate::mem::size_of::<Block>(); // Loop through x & y, copying them `Block` at a time // The optimizer should unroll the loop fully for most types @@ -151,31 +151,31 @@ mod ptr { while i + block_size <= len { // Create some uninitialized memory as scratch space // Declaring `t` here avoids aligning the stack when this loop is unused - let mut t: Block = mem::uninitialized(); + let mut t: Block = crate::mem::uninitialized(); let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); // Swap a block of bytes of x & y, using t as a temporary buffer // This should be optimized into efficient SIMD operations where available - intrinsics::copy_nonoverlapping(x, t, block_size); - intrinsics::copy_nonoverlapping(y, x, block_size); - intrinsics::copy_nonoverlapping(t, y, block_size); + crate::intrinsics::copy_nonoverlapping(x, t, block_size); + crate::intrinsics::copy_nonoverlapping(y, x, block_size); + crate::intrinsics::copy_nonoverlapping(t, y, block_size); i += block_size; } if i < len { // Swap any remaining bytes - let mut t: UnalignedBlock = mem::uninitialized(); + let mut t: UnalignedBlock = crate::mem::uninitialized(); let rem = len - i; let t = &mut t as *mut _ as *mut u8; let x = x.offset(i as isize); let y = y.offset(i as isize); - intrinsics::copy_nonoverlapping(x, t, rem); - intrinsics::copy_nonoverlapping(y, x, rem); - intrinsics::copy_nonoverlapping(t, y, rem); + crate::intrinsics::copy_nonoverlapping(x, t, rem); + crate::intrinsics::copy_nonoverlapping(y, x, rem); + crate::intrinsics::copy_nonoverlapping(t, y, rem); } } } @@ -190,7 +190,7 @@ mod mem { pub fn swap<T>(x: &mut T, y: &mut T) { unsafe { - ptr::swap_nonoverlapping_one(x, y); + crate::ptr::swap_nonoverlapping_one(x, y); } } @@ -200,7 +200,7 @@ mod mem { } pub unsafe fn uninitialized<T>() -> T { - intrinsics::uninit() + crate::intrinsics::uninit() } } @@ -210,48 +210,30 @@ macro_rules! impl_uint { impl $ty { pub fn wrapping_add(self, rhs: Self) -> Self { unsafe { - intrinsics::wrapping_add(self, rhs) + crate::intrinsics::wrapping_add(self, rhs) } } pub fn wrapping_sub(self, rhs: Self) -> Self { unsafe { - intrinsics::wrapping_sub(self, rhs) + crate::intrinsics::wrapping_sub(self, rhs) } } pub fn rotate_left(self, n: u32) -> Self { unsafe { - intrinsics::rotate_left(self, n as Self) + crate::intrinsics::rotate_left(self, n as Self) } } pub fn rotate_right(self, n: u32) -> Self { unsafe { - intrinsics::rotate_right(self, n as Self) + crate::intrinsics::rotate_right(self, n as Self) } } - pub fn to_le(self) -> Self { - #[cfg(target_endian = "little")] - { - self - } - } - - pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { - Self::from_le(Self::from_ne_bytes(bytes)) - } - - pub const fn from_le(x: Self) -> Self { - #[cfg(target_endian = "little")] - { - x - } - } - - pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { - unsafe { mem::transmute(bytes) } + pub const fn from_ne_bytes(bytes: [u8; crate::mem::size_of::<Self>()]) -> Self { + unsafe { crate::mem::transmute(bytes) } } pub fn checked_add(self, rhs: Self) -> Option<Self> { @@ -264,7 +246,7 @@ macro_rules! impl_uint { } pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { - let (a, b) = unsafe { intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + let (a, b) = unsafe { crate::intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; (a as Self, b) } } @@ -380,12 +362,12 @@ macro_rules! step_identical_methods { () => { #[inline] fn replace_one(&mut self) -> Self { - mem::replace(self, 1) + crate::mem::replace(self, 1) } #[inline] fn replace_zero(&mut self) -> Self { - mem::replace(self, 0) + crate::mem::replace(self, 0) } #[inline] @@ -500,7 +482,7 @@ impl<A: Step> Iterator for Range<A> { // and this won't actually result in an extra check in an optimized build. match self.start.add_usize(1) { Option::Some(mut n) => { - mem::swap(&mut n, &mut self.start); + crate::mem::swap(&mut n, &mut self.start); Option::Some(n) } Option::None => Option::None, diff --git a/gcc/testsuite/rust/compile/macros/builtin/eager1.rs b/gcc/testsuite/rust/compile/macros/builtin/eager1.rs index 65a80fd..7c6f6f9 100644 --- a/gcc/testsuite/rust/compile/macros/builtin/eager1.rs +++ b/gcc/testsuite/rust/compile/macros/builtin/eager1.rs @@ -15,7 +15,7 @@ macro_rules! b { } fn main() { - // { dg-final { scan-tree-dump-times {"test1canary"} 1 gimple } } + // { dg-final { scan-assembler {"test1canary"} } } let _ = concat!(a!(), 1, b!()); // should not error concat!(a!(), true, b!(),); diff --git a/gcc/testsuite/rust/compile/macros/builtin/option_env1.rs b/gcc/testsuite/rust/compile/macros/builtin/option_env1.rs new file mode 100644 index 0000000..cf9f65b --- /dev/null +++ b/gcc/testsuite/rust/compile/macros/builtin/option_env1.rs @@ -0,0 +1,29 @@ +#![feature(rustc_attrs)] + +#[rustc_builtin_macro] +macro_rules! option_env { + () => {} +} + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod option { + pub enum Option<T> { + #[lang = "Some"] + Some(T), + #[lang = "None"] + None, + } + } +} + +use core::option::Option; + + +fn main() { + // Both a guaranteed-to-exist variable and a failed find should compile + let _: Option<&str> = option_env!("PWD"); + let _: Option<&str> = option_env!("PROBABLY_DOESNT_EXIST"); +} diff --git a/gcc/testsuite/rust/compile/macros/builtin/option_env2.rs b/gcc/testsuite/rust/compile/macros/builtin/option_env2.rs new file mode 100644 index 0000000..63f72545 --- /dev/null +++ b/gcc/testsuite/rust/compile/macros/builtin/option_env2.rs @@ -0,0 +1,27 @@ +#![feature(rustc_attrs)] + +#[rustc_builtin_macro] +macro_rules! option_env { + () => {} +} + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod option { + pub enum Option<T> { + #[lang = "Some"] + Some(T), + #[lang = "None"] + None, + } + } +} + +use core::option::Option; + +fn main() { + let _: Option<&str> = option_env!(42); + // { dg-error "argument must be a string literal" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/macros/builtin/option_env3.rs b/gcc/testsuite/rust/compile/macros/builtin/option_env3.rs new file mode 100644 index 0000000..ad6dd4c --- /dev/null +++ b/gcc/testsuite/rust/compile/macros/builtin/option_env3.rs @@ -0,0 +1,28 @@ +#![feature(rustc_attrs)] + +#[rustc_builtin_macro] +macro_rules! option_env { + () => {} +} + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod option { + pub enum Option<T> { + #[lang = "Some"] + Some(T), + #[lang = "None"] + None, + } + } +} + +use core::option::Option; + + +fn main() { + let _: Option<&str> = option_env!("A","B"); + // { dg-error "'option_env!' takes 1 argument" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/macros/builtin/recurse2.rs b/gcc/testsuite/rust/compile/macros/builtin/recurse2.rs index 2e73ab5..73e6ab4 100644 --- a/gcc/testsuite/rust/compile/macros/builtin/recurse2.rs +++ b/gcc/testsuite/rust/compile/macros/builtin/recurse2.rs @@ -15,7 +15,29 @@ macro_rules! a { }; } +extern "C" { + fn printf(fmt: *const i8, ...); +} + +fn print_ptr(s: &str) { + unsafe { + printf("%p\n\0" as *const str as *const i8, s as *const str); + } +} + +fn print_str(s: &str) { + unsafe { + printf( + "%s\n\0" as *const str as *const i8, + s as *const str as *const i8, + ); + } +} + +// { dg-final { scan-assembler {"abheyho"} } } +static S: &str = concat!("a", 'b', a!(), a!(b c d e f a!()), '\0'); + fn main() { - // { dg-final { scan-tree-dump-times {"abheyho"} 1 gimple } } - let _ = concat!("a", 'b', a!(), a!(b c d e f a!()), '\0'); + print_ptr(S); + print_str(S); } diff --git a/gcc/testsuite/rust/compile/macros/mbe/macro-expand-module.rs b/gcc/testsuite/rust/compile/macros/mbe/macro-expand-module.rs new file mode 100644 index 0000000..e3e702e --- /dev/null +++ b/gcc/testsuite/rust/compile/macros/mbe/macro-expand-module.rs @@ -0,0 +1,11 @@ +mod foo { + macro_rules! bar { + () => () + } + + bar! (); + + pub struct S; +} + +pub fn buzz(_: foo::S) {} diff --git a/gcc/testsuite/rust/compile/macros/mbe/macro43.rs b/gcc/testsuite/rust/compile/macros/mbe/macro43.rs index 992bc77..0a7f038 100644 --- a/gcc/testsuite/rust/compile/macros/mbe/macro43.rs +++ b/gcc/testsuite/rust/compile/macros/mbe/macro43.rs @@ -1,3 +1,10 @@ +use Option::{None, Some}; + +enum Option<T> { + None, + Some(T) +} + macro_rules! nonzero_integers { ( $( $Ty: ident($Int: ty); )+ ) => { $( @@ -14,7 +21,7 @@ macro_rules! nonzero_integers { // not all derive macros are implemented yet, and this test does not test these anyways // #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] #[repr(transparent)] - pub struct $Ty(NonZero<$Int>); + pub struct $Ty($Int); impl $Ty { /// Create a non-zero without checking the value. @@ -25,7 +32,7 @@ macro_rules! nonzero_integers { #[stable(feature = "nonzero", since = "1.28.0")] #[inline] pub const unsafe fn new_unchecked(n: $Int) -> Self { - $Ty(NonZero(n)) + $Ty(n) } /// Create a non-zero if the given value is not zero. @@ -33,7 +40,7 @@ macro_rules! nonzero_integers { #[inline] pub fn new(n: $Int) -> Option<Self> { if n != 0 { - Some($Ty(NonZero(n))) + Some($Ty(n)) } else { None } @@ -43,12 +50,12 @@ macro_rules! nonzero_integers { #[stable(feature = "nonzero", since = "1.28.0")] #[inline] pub fn get(self) -> $Int { - self.0 .0 + self.0 } } - impl_nonzero_fmt! { // { dg-error "unknown macro" } + impl_nonzero_fmt! { // { dg-error "could not resolve macro invocation" } (Debug, Display, Binary, Octal, LowerHex, UpperHex) for $Ty } )+ diff --git a/gcc/testsuite/rust/compile/macros/mbe/macro44.rs b/gcc/testsuite/rust/compile/macros/mbe/macro44.rs index dabac6f..0cfd987 100644 --- a/gcc/testsuite/rust/compile/macros/mbe/macro44.rs +++ b/gcc/testsuite/rust/compile/macros/mbe/macro44.rs @@ -16,7 +16,7 @@ mod foo { } fn bar_f() { - baz!(); // { dg-error "unknown macro" } + baz!(); // { dg-error "could not resolve macro invocation" } } } diff --git a/gcc/testsuite/rust/compile/method2.rs b/gcc/testsuite/rust/compile/method2.rs index c8699f7..961a039 100644 --- a/gcc/testsuite/rust/compile/method2.rs +++ b/gcc/testsuite/rust/compile/method2.rs @@ -12,5 +12,5 @@ fn main() { let b; b = a.test::<asfasfr>(false); - // { dg-error "failed to resolve TypePath: asfasfr" "" { target *-*-* } .-1 } + // { dg-error "could not resolve type path .asfasfr." "" { target *-*-* } .-1 } } diff --git a/gcc/testsuite/rust/compile/multiline-string.rs b/gcc/testsuite/rust/compile/multiline-string.rs new file mode 100644 index 0000000..fcd6fa8 --- /dev/null +++ b/gcc/testsuite/rust/compile/multiline-string.rs @@ -0,0 +1,14 @@ +fn main() { + let _a = "gcc + + rs"; + + let _b = "rust + + c + gcc + + + + rs"; +} diff --git a/gcc/testsuite/rust/compile/mutability_checks1.rs b/gcc/testsuite/rust/compile/mutability_checks1.rs new file mode 100644 index 0000000..4affae0 --- /dev/null +++ b/gcc/testsuite/rust/compile/mutability_checks1.rs @@ -0,0 +1,15 @@ +pub fn test() { + let a; + a = 1; + a = 2 + 1; + // { dg-error "assignment of read-only variable" "" { target *-*-* } .-1 } + + struct Foo(i32); + let a = Foo(1); + a.0 = 2; + // { dg-error "assignment of read-only variable" "" { target *-*-* } .-1 } + + let a = [1, 2, 3, 4]; + a[0] = 1 + 2; + // { dg-error "assignment of read-only variable" "" { target *-*-* } .-1 } +} diff --git a/gcc/testsuite/rust/compile/nested_macro_use2.rs b/gcc/testsuite/rust/compile/nested_macro_use2.rs index 4659500..7bb6154 100644 --- a/gcc/testsuite/rust/compile/nested_macro_use2.rs +++ b/gcc/testsuite/rust/compile/nested_macro_use2.rs @@ -8,5 +8,5 @@ mod foo { } fn main() { - baz!(); // { dg-error "unknown macro: .baz." } + baz!(); // { dg-error "could not resolve macro invocation .baz." } } diff --git a/gcc/testsuite/rust/compile/nr2/compile.exp b/gcc/testsuite/rust/compile/nr2/compile.exp index 0afe36c..35637f1 100644 --- a/gcc/testsuite/rust/compile/nr2/compile.exp +++ b/gcc/testsuite/rust/compile/nr2/compile.exp @@ -14,9 +14,7 @@ # along with GCC; see the file COPYING3. If not see # <http://www.gnu.org/licenses/>. -# Compile tests, no torture testing, for name resolution 2.0 -# -# These tests raise errors in the front end; torture testing doesn't apply. +# Run compile tests with name resolution 2.0 enabled # Load support procs. load_lib rust-dg.exp @@ -44,23 +42,23 @@ namespace eval rust-nr2-ns { # Run tests in directories # Manually specifying these, in case some other test file # does something weird - set test_dirs {. compile macros/builtin macros/mbe macros/proc} + set test_dirs {{} {macros builtin} {macros mbe} {macros proc} {torture}} set tests_expect_ok "" set tests_expect_err "" foreach test_dir $test_dirs { - foreach test [lsort [glob -nocomplain -tails -directory $srcdir/$subdir/../$test_dir *.rs]] { - if {$test_dir == "."} { - set test_lbl $test - } else { - set test_lbl "$test_dir/$test" - } + set directory [list {*}[file split $srcdir] {*}[file split $subdir]] + set directory [lreplace $directory end end] + set directory [list {*}$directory {*}$test_dir] + foreach test [lsort [glob -nocomplain -tails -directory [file join {*}$directory] *.rs]] { + # use '/' as the path seperator for entries in the exclude file + set test_lbl [join [list {*}$test_dir $test] "/"] set idx [lsearch -exact -sorted $exclude $test_lbl] if {$idx == -1} { - lappend tests_expect_ok $srcdir/$subdir/../$test_dir/$test + lappend tests_expect_ok [file join {*}$directory $test] } else { - lappend tests_expect_err $srcdir/$subdir/../$test_dir/$test + lappend tests_expect_err [file join {*}$directory $test] set exclude [lreplace $exclude $idx $idx] } } diff --git a/gcc/testsuite/rust/compile/nr2/exclude b/gcc/testsuite/rust/compile/nr2/exclude index ecef6d2..19bf6f8 100644 --- a/gcc/testsuite/rust/compile/nr2/exclude +++ b/gcc/testsuite/rust/compile/nr2/exclude @@ -1,237 +1,33 @@ -# relies on exact source file path match -# TODO: patch this file or nr2/compile.exp to handle this -debug-diagnostics-on.rs - -# main list -attr-mismatch-crate-name.rs -attr_deprecated.rs -attr_deprecated_2.rs -auto_trait_super_trait.rs -auto_trait_valid.rs -auto_trait_invalid.rs -bad=file-name.rs -bounds1.rs -break-rust2.rs -break-rust3.rs -macros/builtin/eager1.rs -macros/builtin/eager2.rs -macros/builtin/recurse2.rs -macros/builtin/include3.rs -macros/builtin/include4.rs canonical_paths1.rs cfg1.rs -cfg3.rs -cfg4.rs -cfg5.rs -closure_no_type_anno.rs -complex-path1.rs -complex_qualified_path_in_expr.rs -const-issue1440.rs -const_generics_3.rs -const_generics_4.rs -const_generics_5.rs -const_generics_7.rs -derive_empty.rs -derive_macro1.rs -derive_macro3.rs -derive_macro4.rs -derive_macro6.rs -expected_type_args2.rs -expected_type_args3.rs -feature_rust_attri0.rs -feature_rust_attri1.rs -for_lifetimes.rs -format_args_basic_expansion.rs -generic-default1.rs -generics1.rs -generics10.rs -generics11.rs -generics2.rs -generics3.rs -generics4.rs -generics5.rs -generics6.rs -generics7.rs -generics8.rs generics9.rs -if_let_expr.rs -infer-crate-name.rs -issue-1019.rs -issue-1031.rs -issue-1034.rs -issue-1128.rs -issue-1129-2.rs -issue-1130.rs -issue-1165.rs -issue-1173.rs -issue-1235.rs -issue-1237.rs -issue-1272.rs -issue-1289.rs -issue-1447.rs -issue-1483.rs -issue-1589.rs -issue-1725-1.rs -issue-1725-2.rs -issue-1786.rs -issue-1813.rs -issue-1893.rs -issue-1901.rs -issue-1930.rs -issue-1981.rs -issue-2019-1.rs -issue-2019-2.rs -issue-2019-3.rs -issue-2036.rs -issue-2037.rs issue-2043.rs -issue-2070.rs -issue-2105.rs -issue-2106.rs -issue-2135.rs -issue-2136-1.rs -issue-2136-2.rs -issue-2139.rs -issue-2142.rs -issue-2165.rs -issue-2166.rs -issue-2190-1.rs -issue-2190-2.rs -issue-2195.rs -issue-2238.rs -issue-2304.rs -issue-2330.rs -issue-2375.rs -issue-2478.rs -issue-2479.rs -issue-2514.rs -issue-2723-1.rs -issue-2723-2.rs -issue-2772-1.rs -issue-2772-2.rs -issue-2775.rs -issue-2747.rs -issue-2782.rs issue-2812.rs -issue-850.rs -issue-852.rs -issue-855.rs -issue-925.rs -iterators1.rs +issue-3315-2.rs lookup_err1.rs -macros/mbe/macro-issue1233.rs -macros/mbe/macro-issue1400.rs -macros/mbe/macro13.rs -macros/mbe/macro15.rs -macros/mbe/macro20.rs -macros/mbe/macro23.rs -macros/mbe/macro40.rs -macros/mbe/macro43.rs -macros/mbe/macro44.rs -macros/mbe/macro50.rs -macros/mbe/macro54.rs macros/mbe/macro6.rs -macros/mbe/macro_rules_macro_rules.rs -macros/mbe/macro_use1.rs -match-never-ltype.rs -match-never-rtype.rs -match1.rs -match2.rs -match3.rs -match4.rs -match5.rs -match9.rs -method2.rs -multi_reference_type.rs multiple_bindings1.rs multiple_bindings2.rs -name_resolution2.rs -name_resolution4.rs -nested_generic.rs -nested_macro_use1.rs -nested_macro_use2.rs -nested_macro_use3.rs -non_member_const.rs -not_find_value_in_scope.rs -parse_associated_type_as_generic_arg.rs -parse_associated_type_as_generic_arg2.rs -parse_associated_type_as_generic_arg3.rs -parse_complex_generic_application.rs -parse_complex_generic_application2.rs -path_as_generic_arg.rs -pattern-struct.rs -privacy1.rs -privacy3.rs -privacy4.rs privacy5.rs -privacy6.rs privacy8.rs -macros/proc/attribute_non_function.rs -macros/proc/derive_non_function.rs -macros/proc/non_function.rs pub_restricted_1.rs pub_restricted_2.rs pub_restricted_3.rs -redef_error2.rs -redef_error4.rs -redef_error5.rs -redef_error6.rs -rustc_attr1.rs -self-path1.rs -self-path2.rs -sizeof-stray-infer-var-bug.rs -specify-crate-name.rs -stmt_with_block_dot.rs -struct-expr-parse.rs -trait-cycle.rs -traits1.rs -traits10.rs -traits11.rs -traits12.rs -traits2.rs -traits3.rs -traits4.rs -traits5.rs -traits6.rs -traits7.rs -traits8.rs -traits9.rs -type-bindings1.rs -unconstrained_type_param.rs undeclared_label.rs -unsafe1.rs -unsafe11.rs -unsafe2.rs -unsafe3.rs -unsafe6.rs -unsafe7.rs use_1.rs -use_2.rs -v0-mangle1.rs -v0-mangle2.rs while_break_expr.rs -negative_impls.rs -auto_trait.rs -exhaustiveness1.rs -exhaustiveness2.rs -exhaustiveness3.rs -trait13.rs -trait14.rs -issue-2324-1.rs -issue-2324-2.rs -issue-2725.rs -issue-2987.rs -issue-3045-1.rs -issue-3045-2.rs -issue-3046.rs -unknown-associated-item.rs -issue-3030.rs -issue-3035.rs -issue-3082.rs -issue-3139-1.rs -issue-3139-2.rs -issue-3139-3.rs -issue-3036.rs -issue-2951.rs -issue-2203.rs -issue-2499.rs
\ No newline at end of file +issue-2905-2.rs +issue-266.rs +derive_clone_enum3.rs +derive-debug1.rs +derive-default1.rs +issue-3402-1.rs +issue-3403.rs +derive-eq-invalid.rs +derive-hash1.rs +torture/alt_patterns1.rs +torture/loop4.rs +torture/loop8.rs +torture/name_resolve1.rs +issue-3568.rs +# please don't delete the trailing newline diff --git a/gcc/testsuite/rust/compile/ptr_int_cast.rs b/gcc/testsuite/rust/compile/ptr_int_cast.rs new file mode 100644 index 0000000..3a2a5d5 --- /dev/null +++ b/gcc/testsuite/rust/compile/ptr_int_cast.rs @@ -0,0 +1,18 @@ +fn main(){ + let foo = 1337; + let bar_ptr = &foo as *const i32; + + let bar_ptr_usize = bar_ptr as usize; + let bar_ptr_isize = bar_ptr as isize; + let bar_ptr_u64 = bar_ptr as u64; + let bar_ptr_i64 = bar_ptr as i64; + let bar_ptr_i8 = bar_ptr as i8; + let bar_ptr_u8 = bar_ptr as u8; + + let _ = bar_ptr_usize as *const i32; + let _ = bar_ptr_isize as *const i32; + let _ = bar_ptr_u64 as *const i32; + let _ = bar_ptr_i64 as *const i32; + let _ = bar_ptr_i8 as *const i32; + let _ = bar_ptr_u8 as *const i32; +} diff --git a/gcc/testsuite/rust/compile/redef_error2.rs b/gcc/testsuite/rust/compile/redef_error2.rs index 65793bc..ed946f8 100644 --- a/gcc/testsuite/rust/compile/redef_error2.rs +++ b/gcc/testsuite/rust/compile/redef_error2.rs @@ -1,4 +1,4 @@ const TEST: i32 = 2; -const TEST: f32 = 3.0; // { dg-error "redefined multiple times" } +const TEST: f32 = 3.0; // { dg-error "defined multiple times" } fn main() {} diff --git a/gcc/testsuite/rust/compile/redef_error5.rs b/gcc/testsuite/rust/compile/redef_error5.rs index dc6ad50..b3d71e1 100644 --- a/gcc/testsuite/rust/compile/redef_error5.rs +++ b/gcc/testsuite/rust/compile/redef_error5.rs @@ -2,7 +2,7 @@ struct Foo(i32, bool); impl Foo { const TEST: i32 = 123; - const TEST: bool = false; // { dg-error "redefined multiple times" } + const TEST: bool = false; // { dg-error "defined multiple times" } } fn main() {} diff --git a/gcc/testsuite/rust/compile/reference1.rs b/gcc/testsuite/rust/compile/reference1.rs index 2f94754..28f7a26 100644 --- a/gcc/testsuite/rust/compile/reference1.rs +++ b/gcc/testsuite/rust/compile/reference1.rs @@ -2,5 +2,5 @@ fn main() { let a = &123; let b: &mut i32 = a; // { dg-error "mismatched mutability" "" { target *-*-* } .-1 } - // { dg-error "mismatched types, expected .&mut i32. but got .& i32." "" { target *-*-* } .-2 } + // { dg-error "mismatched types, expected .&mut i32. but got .& <integer>." "" { target *-*-* } .-2 } } diff --git a/gcc/testsuite/rust/compile/self-path2.rs b/gcc/testsuite/rust/compile/self-path2.rs index b9b82ca..6441c33 100644 --- a/gcc/testsuite/rust/compile/self-path2.rs +++ b/gcc/testsuite/rust/compile/self-path2.rs @@ -11,11 +11,11 @@ fn baz() { crate::bar(); crate::self::foo(); - // { dg-error "failed to resolve: .self. in paths can only be used in start position" "" { target *-*-* } .-1 } + // { dg-error "leading path segment .self. can only be used at the beginning of a path" "" { target *-*-* } .-1 } } type a = foo; type b = crate::foo; type c = self::foo; type d = crate::self::foo; -// { dg-error "failed to resolve: .self. in paths can only be used in start position" "" { target *-*-* } .-1 } +// { dg-error "leading path segment .self. can only be used at the beginning of a path" "" { target *-*-* } .-1 } diff --git a/gcc/testsuite/rust/compile/self_import_namespace.rs b/gcc/testsuite/rust/compile/self_import_namespace.rs new file mode 100644 index 0000000..2d9b2ed --- /dev/null +++ b/gcc/testsuite/rust/compile/self_import_namespace.rs @@ -0,0 +1,14 @@ +// { dg-additional-options "-frust-name-resolution-2.0" } + +mod bar { + pub mod foo {} + pub fn foo() {} +} + +// This only imports the module `foo`. The function `foo` lives in +// the value namespace and is not imported. +use bar::foo::{self}; + +fn main() { + foo(); // { dg-error "expected value" } +} diff --git a/gcc/testsuite/rust/compile/sizeof-stray-infer-var-bug.rs b/gcc/testsuite/rust/compile/sizeof-stray-infer-var-bug.rs index 8275691..c46a97d 100644 --- a/gcc/testsuite/rust/compile/sizeof-stray-infer-var-bug.rs +++ b/gcc/testsuite/rust/compile/sizeof-stray-infer-var-bug.rs @@ -14,6 +14,6 @@ mod ptr { pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { let x = x as *mut T; let y = y as *mut T; - let len = mem::size_of::<T>() * count; + let len = crate::mem::size_of::<T>() * count; } } diff --git a/gcc/testsuite/rust/compile/structural-eq-peq.rs b/gcc/testsuite/rust/compile/structural-eq-peq.rs new file mode 100644 index 0000000..d04c295 --- /dev/null +++ b/gcc/testsuite/rust/compile/structural-eq-peq.rs @@ -0,0 +1,9 @@ +#[lang = "structural_peq"] +pub trait StructuralPartialEq { + // Empty. +} + +#[lang = "structural_teq"] +pub trait StructuralEq { + // Empty. +} diff --git a/gcc/testsuite/rust/compile/torture/builtin_abort.rs b/gcc/testsuite/rust/compile/torture/builtin_abort.rs index 3112cdc..919caa4 100644 --- a/gcc/testsuite/rust/compile/torture/builtin_abort.rs +++ b/gcc/testsuite/rust/compile/torture/builtin_abort.rs @@ -12,7 +12,7 @@ mod intrinsics { } } -pub fn main () -> i32 { - abort(); +pub fn main() -> i32 { + crate::intrinsics::abort(); 0 } diff --git a/gcc/testsuite/rust/compile/torture/if.rs b/gcc/testsuite/rust/compile/torture/if.rs index bcd520f..3b753a7 100644 --- a/gcc/testsuite/rust/compile/torture/if.rs +++ b/gcc/testsuite/rust/compile/torture/if.rs @@ -4,6 +4,10 @@ fn foo() -> bool { fn bar() {} +fn baz(a: i32) { + a; +} + struct Foo1 { one: i32 } @@ -13,7 +17,7 @@ fn main() { if foo() { bar(); let a = Foo1{one: 1}; - a.one + baz (a.one); } -}
\ No newline at end of file +} diff --git a/gcc/testsuite/rust/compile/torture/uninit-intrinsic-1.rs b/gcc/testsuite/rust/compile/torture/uninit-intrinsic-1.rs index fa329c6..af1cb54 100644 --- a/gcc/testsuite/rust/compile/torture/uninit-intrinsic-1.rs +++ b/gcc/testsuite/rust/compile/torture/uninit-intrinsic-1.rs @@ -11,7 +11,7 @@ mod intrinsics { mod mem { pub unsafe fn uninitialized<T>() -> T { - intrinsics::uninit() + crate::intrinsics::uninit() } } @@ -21,6 +21,6 @@ struct Foo(i32, i32); impl Foo { pub fn new() -> Self { - unsafe { mem::uninitialized::<Foo>() } + unsafe { crate::mem::uninitialized::<Foo>() } } } diff --git a/gcc/testsuite/rust/compile/try-catch-unwind-new.rs b/gcc/testsuite/rust/compile/try-catch-unwind-new.rs new file mode 100644 index 0000000..b176f7a --- /dev/null +++ b/gcc/testsuite/rust/compile/try-catch-unwind-new.rs @@ -0,0 +1,20 @@ +// { dg-options "-O2 -w -fdump-tree-optimized" } +#![feature(intrinsics)] + +extern "rust-intrinsic" { + // { dg-final { scan-tree-dump-times "__builtin_eh_pointer" 1 "optimized" } } + fn catch_unwind(try_fn: fn(_: *mut u8), data: *mut u8, catch_fn: fn(_: *mut u8, _: *mut u8)); +} + +extern "C" { + fn try_fn(data: *mut u8); + fn catch_fn(data: *mut u8, ex: *mut u8); +} + +pub fn not_main(d: &mut u8) { + unsafe { + // { dg-final { scan-tree-dump-times "try_fn" 1 "optimized" } } + catch_unwind(try_fn, d, catch_fn); + // { dg-final { scan-tree-dump-times "catch_fn" 1 "optimized" } } + } +} diff --git a/gcc/testsuite/rust/compile/try-catch-unwind-old.rs b/gcc/testsuite/rust/compile/try-catch-unwind-old.rs new file mode 100644 index 0000000..e97d52c --- /dev/null +++ b/gcc/testsuite/rust/compile/try-catch-unwind-old.rs @@ -0,0 +1,21 @@ +// { dg-options "-O2 -w -fdump-tree-optimized" } +#![feature(intrinsics)] + +extern "rust-intrinsic" { + // { dg-final { scan-tree-dump-times "__builtin_eh_pointer" 1 "optimized" } } + fn r#try(try_fn: fn(_: *mut u8), data: *mut u8, catch_fn: fn(_: *mut u8, _: *mut u8)) -> i32; +} + +extern "C" { + fn try_fn(data: *mut u8); + fn catch_fn(data: *mut u8, ex: *mut u8); +} + +pub fn not_main(d: &mut u8) -> i32 { + unsafe { + // { dg-final { scan-tree-dump-times "try_fn" 1 "optimized" } } + let _: i32 = r#try(try_fn, d, catch_fn); + // { dg-final { scan-tree-dump-times "catch_fn" 1 "optimized" } } + } + 42 +} diff --git a/gcc/testsuite/rust/compile/try-expr1.rs b/gcc/testsuite/rust/compile/try-expr1.rs new file mode 100644 index 0000000..f1a7865 --- /dev/null +++ b/gcc/testsuite/rust/compile/try-expr1.rs @@ -0,0 +1,84 @@ +// { dg-additional-options "-frust-compile-until=typecheck" } + +#[lang = "sized"] +trait Sized {} + +enum Result { + #[lang = "Ok"] + Ok(i32), + #[lang = "Err"] + Err(i32) +} + +pub trait From<T>: Sized { + /// Performs the conversion. + #[lang = "from"] + #[stable(feature = "rust1", since = "1.0.0")] + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> Self { t } +} + +#[lang = "try"] +pub trait Try { + /// The type of this value when viewed as successful. + // #[unstable(feature = "try_trait", issue = "42327")] + // type Ok; + /// The type of this value when viewed as failed. + // #[unstable(feature = "try_trait", issue = "42327")] + // type Error; + + /// Applies the "?" operator. A return of `Ok(t)` means that the + /// execution should continue normally, and the result of `?` is the + /// value `t`. A return of `Err(e)` means that execution should branch + /// to the innermost enclosing `catch`, or return from the function. + /// + /// If an `Err(e)` result is returned, the value `e` will be "wrapped" + /// in the return type of the enclosing scope (which must itself implement + /// `Try`). Specifically, the value `X::from_error(From::from(e))` + /// is returned, where `X` is the return type of the enclosing function. + #[lang = "into_result"] + #[unstable(feature = "try_trait", issue = "42327")] + fn into_result(self) -> Result; + + /// Wrap an error value to construct the composite result. For example, + /// `Result::Err(x)` and `Result::from_error(x)` are equivalent. + #[lang = "from_error"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_error(v: i32) -> Self; + + /// Wrap an OK value to construct the composite result. For example, + /// `Result::Ok(x)` and `Result::from_ok(x)` are equivalent. + #[lang = "from_ok"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_ok(v: i32) -> Self; +} + +impl Try for Result { + // type Ok = i32; + // type Error = i32; + + fn into_result(self) -> Result { + self + } + + fn from_ok(v: i32) -> Self { + Result::Ok(v) + } + + fn from_error(v: i32) -> Self { + Result::Err(v) + } +} + +fn bar() -> Result { + Result::Ok(15) +} + +fn foo() -> Result { + let a = bar()?; + + Result::Ok(a) +} diff --git a/gcc/testsuite/rust/compile/try-trait.rs b/gcc/testsuite/rust/compile/try-trait.rs new file mode 100644 index 0000000..9ec135d --- /dev/null +++ b/gcc/testsuite/rust/compile/try-trait.rs @@ -0,0 +1,44 @@ +#[lang = "sized"] +trait Sized {} + +enum Result<T, E> { + #[lang = "Ok"] + Ok(T), + #[lang = "Err"] + Err(E) +} + +#[lang = "try"] +pub trait Try { + /// The type of this value when viewed as successful. + #[unstable(feature = "try_trait", issue = "42327")] + type Ok; + /// The type of this value when viewed as failed. + #[unstable(feature = "try_trait", issue = "42327")] + type Error; + + /// Applies the "?" operator. A return of `Ok(t)` means that the + /// execution should continue normally, and the result of `?` is the + /// value `t`. A return of `Err(e)` means that execution should branch + /// to the innermost enclosing `catch`, or return from the function. + /// + /// If an `Err(e)` result is returned, the value `e` will be "wrapped" + /// in the return type of the enclosing scope (which must itself implement + /// `Try`). Specifically, the value `X::from_error(From::from(e))` + /// is returned, where `X` is the return type of the enclosing function. + #[lang = "into_result"] + #[unstable(feature = "try_trait", issue = "42327")] + fn into_result(self) -> Result<Self::Ok, Self::Error>; + + /// Wrap an error value to construct the composite result. For example, + /// `Result::Err(x)` and `Result::from_error(x)` are equivalent. + #[lang = "from_error"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_error(v: Self::Error) -> Self; + + /// Wrap an OK value to construct the composite result. For example, + /// `Result::Ok(x)` and `Result::from_ok(x)` are equivalent. + #[lang = "from_ok"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_ok(v: Self::Ok) -> Self; +} diff --git a/gcc/testsuite/rust/compile/type-bindings1.rs b/gcc/testsuite/rust/compile/type-bindings1.rs index 358035b..ef0b471 100644 --- a/gcc/testsuite/rust/compile/type-bindings1.rs +++ b/gcc/testsuite/rust/compile/type-bindings1.rs @@ -7,5 +7,4 @@ fn main() { let a; a = Foo::<A = i32, B = f32>(123f32); // { dg-error "associated type bindings are not allowed here" "" { target *-*-* } .-1 } - // { dg-error {Failed to resolve expression of function call} "" { target *-*-* } .-2 } } diff --git a/gcc/testsuite/rust/compile/unconstrained_type_param.rs b/gcc/testsuite/rust/compile/unconstrained_type_param.rs index 1cef0b9..60554da 100644 --- a/gcc/testsuite/rust/compile/unconstrained_type_param.rs +++ b/gcc/testsuite/rust/compile/unconstrained_type_param.rs @@ -13,5 +13,4 @@ impl<X, Y> Foo<X> { fn main() { let a = Foo::test(); // { dg-error "expected" "" { target *-*-* } .-1 } - // { dg-error "Failed to resolve expression of function call" "" { target *-*-* } .-2 } } diff --git a/gcc/testsuite/rust/execute/crate-metavar1.rs b/gcc/testsuite/rust/execute/crate-metavar1.rs new file mode 100644 index 0000000..8418308 --- /dev/null +++ b/gcc/testsuite/rust/execute/crate-metavar1.rs @@ -0,0 +1,11 @@ +macro_rules! foo { + () => { + $crate::bar() + } +} + +pub fn bar() -> i32 { 1 } + +fn main() -> i32 { + foo!() - crate::bar() +} diff --git a/gcc/testsuite/rust/execute/torture/builtin_macro_include_bytes.rs b/gcc/testsuite/rust/execute/torture/builtin_macro_include_bytes.rs index 6aec417..c8a2dae 100644 --- a/gcc/testsuite/rust/execute/torture/builtin_macro_include_bytes.rs +++ b/gcc/testsuite/rust/execute/torture/builtin_macro_include_bytes.rs @@ -25,7 +25,7 @@ fn print_int(value: i32) { fn check_bytes(bytes: &[u8; 16]) { let the_bytes = b"hello, include!\n"; - let x = true; + let mut x = true; let mut i = 0; // X is true iff bytes == the_bytes diff --git a/gcc/testsuite/rust/execute/torture/builtin_macro_option_env.rs b/gcc/testsuite/rust/execute/torture/builtin_macro_option_env.rs new file mode 100644 index 0000000..56fbeaa --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/builtin_macro_option_env.rs @@ -0,0 +1,65 @@ +// { dg-output "VALUE\r*\nVALUE\r*\n" } +// { dg-set-compiler-env-var ENV_MACRO_TEST "VALUE" } + +#![feature(rustc_attrs)] + +#[rustc_builtin_macro] +macro_rules! option_env { + () => {{}}; +} + +#[lang = "sized"] +trait Sized {} + +pub mod core { + pub mod option { + pub enum Option<T> { + #[lang = "Some"] + Some(T), + #[lang = "None"] + None, + } + } +} + +use core::option::Option; + +extern "C" { + fn printf(fmt: *const i8, ...); +} + +fn print(s: &str) { + unsafe { + printf( + "%s\n" as *const str as *const i8, + s as *const str as *const i8, + ); + } +} + +macro_rules! env_macro_test { + () => { "ENV_MACRO_TEST" } +} + +fn main() -> i32 { + let val0: Option<&'static str> = option_env!("ENV_MACRO_TEST"); + + + match val0 { + Option::None => {}, + Option::Some(s) => { + print(s); + } + } + + //eager expansion test + let val1: Option<&'static str> = option_env!(env_macro_test!(),); + + match val1 { + Option::None => {}, + Option::Some(s) => { + print(s); + } + } + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/derive-default1.rs b/gcc/testsuite/rust/execute/torture/derive-default1.rs new file mode 100644 index 0000000..4bcafa0 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/derive-default1.rs @@ -0,0 +1,26 @@ +#[derive(Default)] +struct Foo { a: i32 } +#[derive(Default)] +struct Bar(i32); + +#[lang = "sized"] +trait Sized {} + +mod core { + mod default { + trait Default: Sized { + fn default() -> Self; + } + + impl Default for i32 { + fn default() -> Self { 1 } + } + } +} + +fn main() -> i32 { + let foo = Foo::default(); + let bar = Bar::default(); + + foo.a + bar.0 - 2 +} diff --git a/gcc/testsuite/rust/execute/torture/derive-partialeq1.rs b/gcc/testsuite/rust/execute/torture/derive-partialeq1.rs new file mode 100644 index 0000000..67b2773 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/derive-partialeq1.rs @@ -0,0 +1,64 @@ +// { dg-output "true\r*\nfalse\r*\nfalse\r*\n" } + +#![feature(intrinsics)] + +#[lang = "sized"] +trait Sized {} + +#[lang = "copy"] +trait Copy {} + +#[lang = "eq"] +pub trait PartialEq<Rhs: ?Sized = Self> { + /// This method tests for `self` and `other` values to be equal, and is used + /// by `==`. + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn eq(&self, other: &Rhs) -> bool; + + /// This method tests for `!=`. + #[inline] + #[must_use] + #[stable(feature = "rust1", since = "1.0.0")] + fn ne(&self, other: &Rhs) -> bool { + !self.eq(other) + } +} + +#[lang = "structural_peq"] +trait StructuralPartialEq {} + +#[derive(PartialEq, Copy)] // { dg-warning "unused name" } +struct Foo; + +#[derive(PartialEq)] +struct Bar(Foo); + +#[derive(PartialEq)] +struct Baz { _inner: Foo } + +extern "C" { + fn puts(s: *const i8); +} + +fn print(b: bool) { + if b { + unsafe { puts("true" as *const str as *const i8) } + } else { + unsafe { puts("false" as *const str as *const i8) } + } +} + +fn main() -> i32 { + let x = Foo; + + let b1 = x == Foo; + let b2 = Bar(x) != Bar(Foo); + let b3 = Baz { _inner: Foo } != Baz { _inner: x }; + + print(b1); + print(b2); + print(b3); + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/derive_clone_enum1.rs b/gcc/testsuite/rust/execute/torture/derive_clone_enum1.rs new file mode 100644 index 0000000..542ecd8 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/derive_clone_enum1.rs @@ -0,0 +1,51 @@ +#[lang = "clone"] +trait Clone { + pub fn clone(&self) -> Self; +} + +impl Clone for i32 { + fn clone(&self) -> Self { + *self + } +} + +#[derive(Clone)] +enum MixAndMatch { + A, + B(i32), + C { inner: i32 } +} + +fn main() -> i32 { + let a = MixAndMatch::A; + let a_copy = a.clone(); + + // we want res to stay at zero - when we don't match on the right thing, increase it + + let mut res = match a_copy { + MixAndMatch::A => 0, + _ => 1, + }; + + let a = MixAndMatch::B(15); + let a_copy = a.clone(); + + match a_copy { + MixAndMatch::B(15) => {}, + _ => res += 1, + }; + + let a = MixAndMatch::C { inner: 15 }; + let a_copy = a.clone(); + + match a_copy { + MixAndMatch::C { inner } => { + if inner != 15 { + res += 1; + } + }, + _ => res += 1, + }; + + res +} diff --git a/gcc/testsuite/rust/execute/torture/derive_macro3.rs b/gcc/testsuite/rust/execute/torture/derive_macro3.rs index 7b3a089..4138a5b 100644 --- a/gcc/testsuite/rust/execute/torture/derive_macro3.rs +++ b/gcc/testsuite/rust/execute/torture/derive_macro3.rs @@ -1,6 +1,7 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } diff --git a/gcc/testsuite/rust/execute/torture/derive_macro4.rs b/gcc/testsuite/rust/execute/torture/derive_macro4.rs index c355ac7..38c4808 100644 --- a/gcc/testsuite/rust/execute/torture/derive_macro4.rs +++ b/gcc/testsuite/rust/execute/torture/derive_macro4.rs @@ -1,6 +1,7 @@ #[lang = "sized"] pub trait Sized {} +#[lang = "clone"] pub trait Clone { fn clone(&self) -> Self; } diff --git a/gcc/testsuite/rust/execute/torture/enum_intrinsics1.rs b/gcc/testsuite/rust/execute/torture/enum_intrinsics1.rs new file mode 100644 index 0000000..c30bbd3 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/enum_intrinsics1.rs @@ -0,0 +1,48 @@ +/* { dg-output "0\r*\n2\r*\n" } */ +#![feature(intrinsics)] + +#[lang = "sized"] +pub trait Sized {} + +enum BookFormat { + Paperback, + Hardback, + Ebook, +} + +extern "C" { + fn printf(s: *const i8, ...); +} + +mod core { + mod intrinsics { + #[lang = "discriminant_kind"] + pub trait DiscriminantKind { + #[lang = "discriminant_type"] + type Discriminant; + } + + extern "rust-intrinsic" { + pub fn discriminant_value<T>(v: &T) -> <T as DiscriminantKind>::Discriminant; + } + } +} + +pub fn main() -> i32 { + let a = BookFormat::Paperback; + let b = BookFormat::Ebook; + + unsafe { + let val1: isize = core::intrinsics::discriminant_value(&a); + let val2 = core::intrinsics::discriminant_value(&b); + + let a = "%i\n"; + let b = a as *const str; + let c = b as *const i8; + + printf(c, val1 as i32); + printf(c, val2 as i32); + } + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/enum_intrinsics2.rs b/gcc/testsuite/rust/execute/torture/enum_intrinsics2.rs new file mode 100644 index 0000000..c1bae35 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/enum_intrinsics2.rs @@ -0,0 +1,25 @@ +#![feature(intrinsics)] + +#[lang = "sized"] +pub trait Sized {} + +enum BookFormat { + Paperback, + Hardback, + Ebook, +} + +mod core { + mod intrinsics { + extern "rust-intrinsic" { + #[rustc_const_unstable(feature = "variant_count", issue = "73662")] + pub fn variant_count<T>() -> usize; + } + } +} + +pub fn main() -> i32 { + let count = core::intrinsics::variant_count::<BookFormat>(); + + (count as i32) - 3 +} diff --git a/gcc/testsuite/rust/execute/torture/for-loop1.rs b/gcc/testsuite/rust/execute/torture/for-loop1.rs new file mode 100644 index 0000000..5a6a70c --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/for-loop1.rs @@ -0,0 +1,545 @@ +// { dg-output "loop\r*\nloop\r*\n" } +#![feature(intrinsics)] + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); + fn puts(s: *const i8); +} + +mod option { + pub enum Option<T> { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result<T, E> { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool); + pub fn wrapping_add<T>(a: T, b: T) -> T; + pub fn wrapping_sub<T>(a: T, b: T) -> T; + pub fn rotate_left<T>(a: T, b: T) -> T; + pub fn rotate_right<T>(a: T, b: T) -> T; + pub fn offset<T>(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init<T>(dst: *mut T, src: T); + pub fn uninit<T>() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl<T> *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl<T> *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = mem::size_of::<T>() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if mem::size_of::<T>() < 32 { + let z = read(x); + intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write<T>(dst: *mut T, src: T) { + intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read<T>(src: *const T) -> T { + let mut tmp: T = mem::uninitialized(); + intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = mem::size_of::<Block>(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + intrinsics::copy_nonoverlapping(x, t, block_size); + intrinsics::copy_nonoverlapping(y, x, block_size); + intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + intrinsics::copy_nonoverlapping(x, t, rem); + intrinsics::copy_nonoverlapping(y, x, rem); + intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute<T, U>(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of<T>() -> usize; + } + + pub fn swap<T>(x: &mut T, y: &mut T) { + unsafe { + ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace<T>(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized<T>() -> T { + intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { + unsafe { mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option<Self> { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add<RHS = Self> { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub<RHS = Self> { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range<Idx> { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom<T>: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result<Self, Self::Error>; +} + +pub trait From<T>: Sized { + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> T { + t + } +} + +impl<T, U> TryFrom<U> for T +where + T: From<U>, +{ + type Error = !; + + fn try_from(value: U) -> Result<Self, Self::Error> { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option<usize>; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option<Self>; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option<Self> { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option<Self> { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option<usize> { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option<Self> { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option<Self::Item>; +} + +impl<A: Step> Iterator for Range<A> { + type Item = A; + + fn next(&mut self) -> Option<A> { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator<Item = Self::Item>; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} + +pub fn main() -> i32 { + let a = 1usize..3usize; + + for i in a { // { dg-warning "unused name" } + unsafe { puts("loop\0" as *const str as *const i8); } + } + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/for-loop2.rs b/gcc/testsuite/rust/execute/torture/for-loop2.rs new file mode 100644 index 0000000..5ba2cd1 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/for-loop2.rs @@ -0,0 +1,544 @@ +// { dg-output "loop1\r*\nloop2\r*\n" } +#![feature(intrinsics)] + +pub use option::Option::{self, None, Some}; +pub use result::Result::{self, Err, Ok}; + +extern "C" { + fn printf(s: *const i8, ...); +} + +mod option { + pub enum Option<T> { + #[lang = "None"] + None, + #[lang = "Some"] + Some(T), + } +} + +mod result { + enum Result<T, E> { + Ok(T), + Err(E), + } +} + +#[lang = "sized"] +pub trait Sized {} + +#[lang = "clone"] +pub trait Clone: Sized { + fn clone(&self) -> Self; + + fn clone_from(&mut self, source: &Self) { + *self = source.clone() + } +} + +mod impls { + use super::Clone; + + macro_rules! impl_clone { + ($($t:ty)*) => { + $( + impl Clone for $t { + fn clone(&self) -> Self { + *self + } + } + )* + } + } + + impl_clone! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +#[lang = "copy"] +pub trait Copy: Clone { + // Empty. +} + +mod copy_impls { + use super::Copy; + + macro_rules! impl_copy { + ($($t:ty)*) => { + $( + impl Copy for $t {} + )* + } + } + + impl_copy! { + usize u8 u16 u32 u64 // u128 + isize i8 i16 i32 i64 // i128 + f32 f64 + bool char + } +} + +mod intrinsics { + extern "rust-intrinsic" { + pub fn add_with_overflow<T>(x: T, y: T) -> (T, bool); + pub fn wrapping_add<T>(a: T, b: T) -> T; + pub fn wrapping_sub<T>(a: T, b: T) -> T; + pub fn rotate_left<T>(a: T, b: T) -> T; + pub fn rotate_right<T>(a: T, b: T) -> T; + pub fn offset<T>(ptr: *const T, count: isize) -> *const T; + pub fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize); + pub fn move_val_init<T>(dst: *mut T, src: T); + pub fn uninit<T>() -> T; + } +} + +mod ptr { + #[lang = "const_ptr"] + impl<T> *const T { + pub unsafe fn offset(self, count: isize) -> *const T { + intrinsics::offset(self, count) + } + } + + #[lang = "mut_ptr"] + impl<T> *mut T { + pub unsafe fn offset(self, count: isize) -> *mut T { + intrinsics::offset(self, count) as *mut T + } + } + + pub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) { + let x = x as *mut u8; + let y = y as *mut u8; + let len = mem::size_of::<T>() * count; + swap_nonoverlapping_bytes(x, y, len) + } + + pub unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) { + // For types smaller than the block optimization below, + // just swap directly to avoid pessimizing codegen. + if mem::size_of::<T>() < 32 { + let z = read(x); + intrinsics::copy_nonoverlapping(y, x, 1); + write(y, z); + } else { + swap_nonoverlapping(x, y, 1); + } + } + + pub unsafe fn write<T>(dst: *mut T, src: T) { + intrinsics::move_val_init(&mut *dst, src) + } + + pub unsafe fn read<T>(src: *const T) -> T { + let mut tmp: T = mem::uninitialized(); + intrinsics::copy_nonoverlapping(src, &mut tmp, 1); + tmp + } + + pub unsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) { + struct Block(u64, u64, u64, u64); + struct UnalignedBlock(u64, u64, u64, u64); + + let block_size = mem::size_of::<Block>(); + + // Loop through x & y, copying them `Block` at a time + // The optimizer should unroll the loop fully for most types + // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively + let mut i: usize = 0; + while i + block_size <= len { + // Create some uninitialized memory as scratch space + // Declaring `t` here avoids aligning the stack when this loop is unused + let mut t: Block = mem::uninitialized(); + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + // Swap a block of bytes of x & y, using t as a temporary buffer + // This should be optimized into efficient SIMD operations where available + intrinsics::copy_nonoverlapping(x, t, block_size); + intrinsics::copy_nonoverlapping(y, x, block_size); + intrinsics::copy_nonoverlapping(t, y, block_size); + i += block_size; + } + + if i < len { + // Swap any remaining bytes + let mut t: UnalignedBlock = mem::uninitialized(); + let rem = len - i; + + let t = &mut t as *mut _ as *mut u8; + let x = x.offset(i as isize); + let y = y.offset(i as isize); + + intrinsics::copy_nonoverlapping(x, t, rem); + intrinsics::copy_nonoverlapping(y, x, rem); + intrinsics::copy_nonoverlapping(t, y, rem); + } + } +} + +mod mem { + extern "rust-intrinsic" { + #[rustc_const_stable(feature = "const_transmute", since = "1.46.0")] + pub fn transmute<T, U>(_: T) -> U; + #[rustc_const_stable(feature = "const_size_of", since = "1.40.0")] + pub fn size_of<T>() -> usize; + } + + pub fn swap<T>(x: &mut T, y: &mut T) { + unsafe { + ptr::swap_nonoverlapping_one(x, y); + } + } + + pub fn replace<T>(dest: &mut T, mut src: T) -> T { + swap(dest, &mut src); + src + } + + pub unsafe fn uninitialized<T>() -> T { + intrinsics::uninit() + } +} + +macro_rules! impl_uint { + ($($ty:ident = $lang:literal),*) => { + $( + impl $ty { + pub fn wrapping_add(self, rhs: Self) -> Self { + unsafe { + intrinsics::wrapping_add(self, rhs) + } + } + + pub fn wrapping_sub(self, rhs: Self) -> Self { + unsafe { + intrinsics::wrapping_sub(self, rhs) + } + } + + pub fn rotate_left(self, n: u32) -> Self { + unsafe { + intrinsics::rotate_left(self, n as Self) + } + } + + pub fn rotate_right(self, n: u32) -> Self { + unsafe { + intrinsics::rotate_right(self, n as Self) + } + } + + pub fn to_le(self) -> Self { + #[cfg(target_endian = "little")] + { + self + } + } + + pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { + Self::from_le(Self::from_ne_bytes(bytes)) + } + + pub const fn from_le(x: Self) -> Self { + #[cfg(target_endian = "little")] + { + x + } + } + + pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self { + unsafe { mem::transmute(bytes) } + } + + pub fn checked_add(self, rhs: Self) -> Option<Self> { + let (a, b) = self.overflowing_add(rhs); + if b { + Option::None + } else { + Option::Some(a) + } + } + + pub fn overflowing_add(self, rhs: Self) -> (Self, bool) { + let (a, b) = unsafe { intrinsics::add_with_overflow(self as $ty, rhs as $ty) }; + (a as Self, b) + } + } + )* + } +} + +impl_uint!( + u8 = "u8", + u16 = "u16", + u32 = "u32", + u64 = "u64", + usize = "usize" +); + +#[lang = "add"] +pub trait Add<RHS = Self> { + type Output; + + fn add(self, rhs: RHS) -> Self::Output; +} +macro_rules! add_impl { + ($($t:ty)*) => ($( + impl Add for $t { + type Output = $t; + + fn add(self, other: $t) -> $t { self + other } + } + )*) +} + +add_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "sub"] +pub trait Sub<RHS = Self> { + type Output; + + fn sub(self, rhs: RHS) -> Self::Output; +} +macro_rules! sub_impl { + ($($t:ty)*) => ($( + impl Sub for $t { + type Output = $t; + + fn sub(self, other: $t) -> $t { self - other } + } + )*) +} + +sub_impl! { usize u8 u16 u32 u64 /*isize i8 i16 i32 i64*/ f32 f64 } + +#[lang = "Range"] +pub struct Range<Idx> { + pub start: Idx, + pub end: Idx, +} + +pub trait TryFrom<T>: Sized { + /// The type returned in the event of a conversion error. + type Error; + + /// Performs the conversion. + fn try_from(value: T) -> Result<Self, Self::Error>; +} + +pub trait From<T>: Sized { + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> T { + t + } +} + +impl<T, U> TryFrom<U> for T +where + T: From<U>, +{ + type Error = !; + + fn try_from(value: U) -> Result<Self, Self::Error> { + Ok(T::from(value)) + } +} + +trait Step { + /// Returns the number of steps between two step objects. The count is + /// inclusive of `start` and exclusive of `end`. + /// + /// Returns `None` if it is not possible to calculate `steps_between` + /// without overflow. + fn steps_between(start: &Self, end: &Self) -> Option<usize>; + + /// Replaces this step with `1`, returning itself + fn replace_one(&mut self) -> Self; + + /// Replaces this step with `0`, returning itself + fn replace_zero(&mut self) -> Self; + + /// Adds one to this step, returning the result + fn add_one(&self) -> Self; + + /// Subtracts one to this step, returning the result + fn sub_one(&self) -> Self; + + /// Add an usize, returning None on overflow + fn add_usize(&self, n: usize) -> Option<Self>; +} + +// These are still macro-generated because the integer literals resolve to different types. +macro_rules! step_identical_methods { + () => { + #[inline] + fn replace_one(&mut self) -> Self { + mem::replace(self, 1) + } + + #[inline] + fn replace_zero(&mut self) -> Self { + mem::replace(self, 0) + } + + #[inline] + fn add_one(&self) -> Self { + Add::add(*self, 1) + } + + #[inline] + fn sub_one(&self) -> Self { + Sub::sub(*self, 1) + } + }; +} + +macro_rules! step_impl_unsigned { + ($($t:ty)*) => ($( + impl Step for $t { + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= usize here + Option::Some((*end - *start) as usize) + } else { + Option::Some(0) + } + } + + fn add_usize(&self, n: usize) -> Option<Self> { + match <$t>::try_from(n) { + Result::Ok(n_as_t) => self.checked_add(n_as_t), + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} +macro_rules! step_impl_signed { + ($( [$t:ty : $unsigned:ty] )*) => ($( + impl Step for $t { + #[inline] + #[allow(trivial_numeric_casts)] + fn steps_between(start: &$t, end: &$t) -> Option<usize> { + if *start < *end { + // Note: We assume $t <= isize here + // Use .wrapping_sub and cast to usize to compute the + // difference that may not fit inside the range of isize. + Option::Some((*end as isize).wrapping_sub(*start as isize) as usize) + } else { + Option::Some(0) + } + } + + #[inline] + #[allow(unreachable_patterns)] + fn add_usize(&self, n: usize) -> Option<Self> { + match <$unsigned>::try_from(n) { + Result::Ok(n_as_unsigned) => { + // Wrapping in unsigned space handles cases like + // `-120_i8.add_usize(200) == Option::Some(80_i8)`, + // even though 200_usize is out of range for i8. + let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t; + if wrapped >= *self { + Option::Some(wrapped) + } else { + Option::None // Addition overflowed + } + } + Result::Err(_) => Option::None, + } + } + + step_identical_methods!(); + } + )*) +} + +macro_rules! step_impl_no_between { + ($($t:ty)*) => ($( + impl Step for $t { + #[inline] + fn steps_between(_start: &Self, _end: &Self) -> Option<usize> { + Option::None + } + + #[inline] + fn add_usize(&self, n: usize) -> Option<Self> { + self.checked_add(n as $t) + } + + step_identical_methods!(); + } + )*) +} + +step_impl_unsigned!(usize); + +pub trait Iterator { + type Item; + + #[lang = "next"] + fn next(&mut self) -> Option<Self::Item>; +} + +impl<A: Step> Iterator for Range<A> { + type Item = A; + + fn next(&mut self) -> Option<A> { + if self.start < self.end { + // We check for overflow here, even though it can't actually + // happen. Adding this check does however help llvm vectorize loops + // for some ranges that don't get vectorized otherwise, + // and this won't actually result in an extra check in an optimized build. + match self.start.add_usize(1) { + Option::Some(mut n) => { + mem::swap(&mut n, &mut self.start); + Option::Some(n) + } + Option::None => Option::None, + } + } else { + Option::None + } + } +} + +pub trait IntoIterator { + type Item; + + type IntoIter: Iterator<Item = Self::Item>; + + #[lang = "into_iter"] + fn into_iter(self) -> Self::IntoIter; +} + +impl<I: Iterator> IntoIterator for I { + type Item = I::Item; + type IntoIter = I; + + fn into_iter(self) -> I { + self + } +} + +pub fn main() -> i32 { + let a = 1usize..3usize; + + for i in a { + unsafe { printf("loop%d\n\0" as *const str as *const i8, i); } + } + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/iflet.rs b/gcc/testsuite/rust/execute/torture/iflet.rs new file mode 100644 index 0000000..da4e93a --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/iflet.rs @@ -0,0 +1,84 @@ +enum Res { + OK, + BAD, +} + +enum LOption { + Some(i32), + None, +} + +// Expect a Some(_) +// +// Check we can match a Some. +fn test_can_destructure_Some(v: LOption) -> Res { + if let LOption::Some(v) = v { + return Res::OK; + } + return Res::BAD; +} + +// Expect Some(100). +// +// Check we can destructure and the inner value is correct. +fn test_inner_value_is_100(v: LOption) -> Res { + if let LOption::Some(v) = v { + return match v { + 100 => Res::OK, + _ => Res::BAD, + } + } + return Res::BAD; +} + +// Expect a None as actual parameter. +// +// Only when we FAIL to match a Some do we take the else and return OK. +fn test_if_else(v: LOption) -> Res { + if let LOption::Some(v) = v { + return Res::BAD; + } else { + return Res::OK; + } +} + +fn main() -> i32 { + + // Passing a None, so the function should return BAD + match test_can_destructure_Some(LOption::None) { + Res::OK => return 1, + Res::BAD => (), + } + + // Same, but with a Some, should return OK + match test_can_destructure_Some(LOption::Some(1)) { + Res::OK => (), + Res::BAD => return 1, + } + + // Check the destructuring is correct by looking for Some(100) + match test_inner_value_is_100(LOption::Some(100)) { + Res::OK => (), + Res::BAD => return 1, + } + + // ... passing Some(1) should return BAD + match test_inner_value_is_100(LOption::Some(1)) { + Res::OK => return 1, + Res::BAD => (), + } + + // ... and so does passing None + match test_inner_value_is_100(LOption::None) { + Res::OK => return 1, + Res::BAD => (), + } + + // Check if let... else ... + match test_if_else(LOption::None) { + Res::OK => (), + Res::BAD => return 1, + } + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/issue-3126.rs b/gcc/testsuite/rust/execute/torture/issue-3126.rs new file mode 100644 index 0000000..f505146 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/issue-3126.rs @@ -0,0 +1,52 @@ +/* { dg-output "child\r*\n" }*/ +extern "C" { + fn printf(s: *const i8, ...); +} + +#[lang = "sized"] +pub trait Sized {} + +struct Foo { + my_int: u32, + // { dg-warning "field is never read: .my_int." "" { target *-*-* } .-1 } +} + +trait Parent<T> { + fn parent(&self) -> T; +} + +trait Child: Parent<u32> { + fn child(&self); +} + +impl Parent<u32> for Foo { + fn parent(&self) -> u32 { + unsafe { + let parent = "parent %i\n\0"; + let msg = parent as *const str; + printf(msg as *const i8, self.my_int); + return self.my_int; + } + } +} + +impl Child for Foo { + fn child(&self) { + let _ = self; + unsafe { + let child = "child\n\0"; + let msg = child as *const str; + printf(msg as *const i8); + } + } +} + +pub fn main() -> i32 { + let a = Foo { my_int: 0xf00dfeed }; + let b: &dyn Child = &a; + + // b.parent(); + b.child(); + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/issue-3381.rs b/gcc/testsuite/rust/execute/torture/issue-3381.rs new file mode 100644 index 0000000..62dbcd0 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/issue-3381.rs @@ -0,0 +1,90 @@ +/* { dg-output "Err: 15\r*\n" } */ +#[lang = "sized"] +trait Sized {} + +enum Result<T, E> { + #[lang = "Ok"] + Ok(T), + #[lang = "Err"] + Err(E), +} + +#[lang = "try"] +pub trait Try { + type Ok; + type Error; + + #[lang = "into_result"] + #[unstable(feature = "try_trait", issue = "42327")] + fn into_result(self) -> Result<Self::Ok, Self::Error>; + + #[lang = "from_error"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_error(v: Self::Ok) -> Self; + + #[lang = "from_ok"] + #[unstable(feature = "try_trait", issue = "42327")] + fn from_ok(v: Self::Error) -> Self; +} + +impl<T, E> Try for Result<T, E> { + type Ok = T; + type Error = E; + + fn into_result(self) -> Result<T, E> { + self + } + + fn from_ok(v: T) -> Self { + Result::Ok(v) + } + + fn from_error(v: E) -> Self { + Result::Err(v) + } +} + +pub trait From<T>: Sized { + fn from(_: T) -> Self; +} + +impl<T> From<T> for T { + fn from(t: T) -> Self { + t + } +} + +fn print(s: &str, value: i32) { + extern "C" { + fn printf(s: *const i8, ...); + } + + unsafe { + printf(s as *const str as *const i8, value); + } +} + +fn baz() -> Result<i32, i32> { + Result::Err(15) +} + +fn foo() -> Result<i32, i32> { + let b = match baz() { + Result::Ok(value) => value, + Result::Err(err) => { + return Try::from_error(From::from(err)); + } + }; + + Result::Ok(15 + b) +} + +fn main() -> i32 { + let a = foo(); + match a { + Result::Ok(value) => print("Ok: %i\n", value), + Result::Err(err) => print("Err: %i\n", err), + }; + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/issue-3502.rs b/gcc/testsuite/rust/execute/torture/issue-3502.rs new file mode 100644 index 0000000..f07a126 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/issue-3502.rs @@ -0,0 +1,52 @@ +/* { dg-output "parent 123\r*\nchild\r*\n" } */ +extern "C" { + fn printf(s: *const i8, ...); +} + +#[lang = "sized"] +pub trait Sized {} + +struct Foo { + my_int: u32, + // { dg-warning "field is never read: .my_int." "" { target *-*-* } .-1 } +} + +trait Parent<T> { + fn parent(&self) -> T; +} + +trait Child: Parent<u32> { + fn child(&self); +} + +impl Parent<u32> for Foo { + fn parent(&self) -> u32 { + unsafe { + let parent = "parent %u\n\0"; + let msg = parent as *const str; + printf(msg as *const i8, self.my_int); + return self.my_int; + } + } +} + +impl Child for Foo { + fn child(&self) { + let _ = self; + unsafe { + let child = "child\n\0"; + let msg = child as *const str; + printf(msg as *const i8); + } + } +} + +pub fn main() -> i32 { + let a = Foo { my_int: 123 }; + let b: &dyn Child = &a; + + b.parent(); + b.child(); + + 0 +} diff --git a/gcc/testsuite/rust/execute/torture/multiline-string.rs b/gcc/testsuite/rust/execute/torture/multiline-string.rs new file mode 100644 index 0000000..4d22f99 --- /dev/null +++ b/gcc/testsuite/rust/execute/torture/multiline-string.rs @@ -0,0 +1,15 @@ +// { dg-output "gcc\n\nrs\n" } + +extern "C" { + fn printf(fmt: *const i8, ...); +} + +fn main() -> i32 { + let a = "gcc + +rs\0"; + + unsafe { printf("%s\n\0" as *const str as *const i8, a as *const str as *const i8); } + + 0 +} diff --git a/gcc/testsuite/rust/link/generic_function_0.rs b/gcc/testsuite/rust/link/generic_function_0.rs index 179c822..58b8eb1 100644 --- a/gcc/testsuite/rust/link/generic_function_0.rs +++ b/gcc/testsuite/rust/link/generic_function_0.rs @@ -1,6 +1,3 @@ -// { dg-xfail-if "https://github.com/Rust-GCC/gccrs/issues/2349" { *-*-* } } -// { dg-excess-errors "" { xfail *-*-* } } - extern crate generic_function_1; use generic_function_1::generic_function; diff --git a/gcc/testsuite/rust/link/trait_import_0.rs b/gcc/testsuite/rust/link/trait_import_0.rs index 1b8c90a..ac8c581 100644 --- a/gcc/testsuite/rust/link/trait_import_0.rs +++ b/gcc/testsuite/rust/link/trait_import_0.rs @@ -1,6 +1,3 @@ -// { dg-xfail-if "https://github.com/Rust-GCC/gccrs/issues/2349" { *-*-* } } -// { dg-excess-errors "" { xfail *-*-* } } - extern crate trait_import_1; use trait_import_1::Add; diff --git a/gcc/testsuite/rust/link/trait_import_1.rs b/gcc/testsuite/rust/link/trait_import_1.rs index fc7f516..e54b0e1 100644 --- a/gcc/testsuite/rust/link/trait_import_1.rs +++ b/gcc/testsuite/rust/link/trait_import_1.rs @@ -1,3 +1,6 @@ +#[lang = "sized"] +pub trait Sized {} + #[lang = "add"] pub trait Add<Rhs = Self> { type Output; |