| #![feature(generic_const_exprs)] |
| #![allow(unused_variables, dead_code, incomplete_features)] |
| |
| pub struct S; |
| |
| #[derive(Default)] |
| pub struct Foo { |
| pub bar: S = S, //~ ERROR default values on fields are experimental |
| pub baz: i32 = 42 + 3, //~ ERROR default values on fields are experimental |
| } |
| |
| #[derive(Default)] |
| pub enum Bar { |
| #[default] |
| Foo { //~ ERROR the `#[default]` attribute may only be used on unit enum variants |
| bar: S = S, //~ ERROR default values on fields are experimental |
| baz: i32 = 42 + 3, //~ ERROR default values on fields are experimental |
| } |
| } |
| |
| #[derive(Default)] |
| pub struct Qux<A, const C: i32> { |
| bar: S = Qux::<A, C>::S, //~ ERROR default values on fields are experimental |
| baz: i32 = foo(), //~ ERROR default values on fields are experimental |
| bat: i32 = <Qux<A, C> as T>::K, //~ ERROR default values on fields are experimental |
| bay: i32 = C, //~ ERROR default values on fields are experimental |
| bak: Vec<A> = Vec::new(), //~ ERROR default values on fields are experimental |
| } |
| |
| impl<A, const C: i32> Qux<A, C> { |
| const S: S = S; |
| } |
| |
| trait T { |
| const K: i32; |
| } |
| |
| impl<A, const C: i32> T for Qux<A, C> { |
| const K: i32 = 2; |
| } |
| |
| const fn foo() -> i32 { |
| 42 |
| } |
| |
| #[derive(Default)] |
| pub struct Opt { |
| mandatory: Option<()>, |
| optional: () = (), //~ ERROR default values on fields are experimental |
| } |
| |
| #[derive(Default)] |
| pub enum OptEnum { |
| #[default] |
| Variant { //~ ERROR the `#[default]` attribute may only be used on unit enum variants |
| mandatory: Option<()>, |
| optional: () = (), //~ ERROR default values on fields are experimental |
| } |
| } |
| |
| // Default field values may not be used on `union`s (at least, this is not described in the accepted |
| // RFC, and it's not currently clear how to extend the design to do so). We emit a feature gate |
| // error when the feature is not enabled, but syntactically reject default field values when used |
| // with unions when the feature is enabled. This can be adjusted if there's an acceptable design |
| // extension, or just unconditionally reject always. |
| union U { |
| x: i32 = 0, //~ ERROR default values on fields are experimental |
| y: f32 = 0.0, //~ ERROR default values on fields are experimental |
| } |
| |
| fn main () { |
| let x = Foo { .. }; //~ ERROR base expression required after `..` |
| let y = Foo::default(); |
| let z = Foo { baz: 1, .. }; //~ ERROR base expression required after `..` |
| |
| assert_eq!(45, x.baz); |
| assert_eq!(45, y.baz); |
| assert_eq!(1, z.baz); |
| |
| let x = Bar::Foo { .. }; //~ ERROR base expression required after `..` |
| let y = Bar::default(); |
| let z = Bar::Foo { baz: 1, .. }; //~ ERROR base expression required after `..` |
| |
| assert!(matches!(Bar::Foo { bar: S, baz: 45 }, x)); |
| assert!(matches!(Bar::Foo { bar: S, baz: 45 }, y)); |
| assert!(matches!(Bar::Foo { bar: S, baz: 1 }, z)); |
| |
| let x = Qux::<i32, 4> { .. }; //~ ERROR base expression required after `..` |
| assert!(matches!(Qux::<i32, 4> { bar: S, baz: 42, bat: 2, bay: 4, .. }, x)); |
| //~^ ERROR base expression required after `..` |
| assert!(x.bak.is_empty()); |
| let y = Opt { mandatory: None, .. }; |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(Opt::default(), y)); |
| let z = Opt::default(); |
| assert!(matches!(Opt { mandatory: None, .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(Opt { .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(Opt { optional: (), .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(Opt { optional: (), mandatory: None, .. }, z)); |
| //~^ ERROR base expression required after `..` |
| let y = OptEnum::Variant { mandatory: None, .. }; |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(OptEnum::default(), y)); |
| let z = OptEnum::default(); |
| assert!(matches!(OptEnum::Variant { mandatory: None, .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(OptEnum::Variant { .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(OptEnum::Variant { optional: (), .. }, z)); |
| //~^ ERROR base expression required after `..` |
| assert!(matches!(OptEnum::Variant { optional: (), mandatory: None, .. }, z)); |
| //~^ ERROR base expression required after `..` |
| } |