rust/tests/ui/enum/simple-enum-usage-8506.rs

// https://github.com/rust-lang/rust/issues/8506
//@ run-pass
#![allow(non_upper_case_globals)]

#![allow(dead_code)]

enum Either {
    One,
    Other(String,String)
}

static one : Either = Either::One;

pub fn main () { }
Rehome tests/ui/issues/ tests [5/?] 2025-07-13 16:56:31 -04:00			`// https://github.com/rust-lang/rust/issues/8506`
Add `// run-pass` annotations to all the tests under `ui/run-pass/`. (I may have accidentally added it to some auxilliary crates as well; my emacs-macro-based methodology was pretty crude.) 2018-08-30 14:18:55 +02:00			`//@ run-pass`
Add `#![allow(..)]` for a slew of lints of migrated run-pass tests, to silence stderr output. 2018-08-31 15:02:01 +02:00			`#![allow(non_upper_case_globals)]`
rustdoc: Replace no-pretty-expanded with pretty-expanded Now that features must be declared expanded source often does not compile. This adds 'pretty-expanded' to a bunch of test cases that still work. 2015-03-22 13:13:15 -07:00
Use new attribute syntax in python files in src/etc too (#13478) 2014-04-14 21:00:31 +05:30			`#![allow(dead_code)]`
Fix ICE on statics with fancy nullable enums. Closes #8506. The `trans::adt` code for statics uses fields with `C_undef` values to insert alignment padding (because LLVM's own alignment padding isn't always sufficient for aggregate constants), and assumes that all fields in the actual Rust value are represented by non-undef LLVM values, to distinguish them from that padding. But for nullable pointer enums, if non-null variant has fields other than the pointer used as the discriminant, they would be set to undef in the null case, to reflect that they're never accessed. To avoid the obvious conflict between these two items, the latter undefs were wrapped in unary LLVM structs to distinguish them from the former undefs. Except this doesn't actually work -- LLVM, not unreasonably, treats the "wrapped undef" as a regular undef. So this commit just sets all fields to null in the null pointer case of a nullable pointer enum static, because the other fields don't really need to be undef in the first place. 2014-03-04 20:41:21 -08:00
			`enum Either {`
			`One,`
core: rename strbuf::StrBuf to string::String [breaking-change] 2014-05-22 16:57:53 -07:00			`Other(String,String)`
Fix ICE on statics with fancy nullable enums. Closes #8506. The `trans::adt` code for statics uses fields with `C_undef` values to insert alignment padding (because LLVM's own alignment padding isn't always sufficient for aggregate constants), and assumes that all fields in the actual Rust value are represented by non-undef LLVM values, to distinguish them from that padding. But for nullable pointer enums, if non-null variant has fields other than the pointer used as the discriminant, they would be set to undef in the null case, to reflect that they're never accessed. To avoid the obvious conflict between these two items, the latter undefs were wrapped in unary LLVM structs to distinguish them from the former undefs. Except this doesn't actually work -- LLVM, not unreasonably, treats the "wrapped undef" as a regular undef. So this commit just sets all fields to null in the null pointer case of a nullable pointer enum static, because the other fields don't really need to be undef in the first place. 2014-03-04 20:41:21 -08:00			`}`

Switch to purely namespaced enums This breaks code that referred to variant names in the same namespace as their enum. Reexport the variants in the old location or alter code to refer to the new locations: ``` pub enum Foo { A, B } fn main() { let a = A; } ``` => ``` pub use self::Foo::{A, B}; pub enum Foo { A, B } fn main() { let a = A; } ``` or ``` pub enum Foo { A, B } fn main() { let a = Foo::A; } ``` [breaking-change] 2014-11-06 00:05:53 -08:00			`static one : Either = Either::One;`
Fix ICE on statics with fancy nullable enums. Closes #8506. The `trans::adt` code for statics uses fields with `C_undef` values to insert alignment padding (because LLVM's own alignment padding isn't always sufficient for aggregate constants), and assumes that all fields in the actual Rust value are represented by non-undef LLVM values, to distinguish them from that padding. But for nullable pointer enums, if non-null variant has fields other than the pointer used as the discriminant, they would be set to undef in the null case, to reflect that they're never accessed. To avoid the obvious conflict between these two items, the latter undefs were wrapped in unary LLVM structs to distinguish them from the former undefs. Except this doesn't actually work -- LLVM, not unreasonably, treats the "wrapped undef" as a regular undef. So this commit just sets all fields to null in the null pointer case of a nullable pointer enum static, because the other fields don't really need to be undef in the first place. 2014-03-04 20:41:21 -08:00
			`pub fn main () { }`