rust/tests/ui/for-loop-while/for-loop-goofiness.rs

// run-pass
#![allow(dead_code)]

enum BogusOption<T> {
    None,
    Some(T),
}

type Iterator = isize;

pub fn main() {
    let x = [ 3, 3, 3 ];
    for i in &x {
        assert_eq!(*i, 3);
    }
}
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 07:18:55 -05:00			`// run-pass`
Add `#![allow(..)]` as necessary to get re-migrated run-pass tests compiling with clean stderr again. Most were added mechanically. 2018-09-25 16:51:35 -05:00			`#![allow(dead_code)]`
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 15:13:15 -05:00
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change] 2014-07-21 22:54:28 -05:00			`enum BogusOption<T> {`
			`None,`
			`Some(T),`
			`}`

Mass rename uint/int to usize/isize Now that support has been removed, all lingering use cases are renamed. 2015-03-25 19:06:52 -05:00			`type Iterator = isize;`
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change] 2014-07-21 22:54:28 -05:00
			`pub fn main() {`
Remove all `i` suffixes 2015-01-25 15:05:03 -06:00			`let x = [ 3, 3, 3 ];`
`for x in xs.iter()` -> `for x in &xs` 2015-01-31 11:20:46 -06:00			`for i in &x {`
librustc: Stop desugaring `for` expressions and translate them directly. This makes edge cases in which the `Iterator` trait was not in scope and/or `Option` or its variants were not in scope work properly. This breaks code that looks like: struct MyStruct { ... } impl MyStruct { fn next(&mut self) -> Option<int> { ... } } for x in MyStruct { ... } { ... } Change ad-hoc `next` methods like the above to implementations of the `Iterator` trait. For example: impl Iterator<int> for MyStruct { fn next(&mut self) -> Option<int> { ... } } Closes #15392. [breaking-change] 2014-07-21 22:54:28 -05:00			`assert_eq!(*i, 3);`
			`}`
			`}`