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]

src/libcore/char.rs

@@ -17,7 +17,10 @@

use mem::transmute;
use option::{None, Option, Some};
use iter::{Iterator, range_step};
use iter::range_step;

#[cfg(stage0)]
use iter::Iterator; // NOTE(stage0): Remove after snapshot.

// UTF-8 ranges and tags for encoding characters
static TAG_CONT: u8    = 0b1000_0000u8;

src/libcore/fmt/float.rs

@@ -13,15 +13,19 @@
use char;
use collections::Collection;
use fmt;
use iter::{Iterator, range, DoubleEndedIterator};
use iter::{range, DoubleEndedIterator};
use num::{Float, FPNaN, FPInfinite, ToPrimitive, Primitive};
use num::{Zero, One, cast};
use option::{None, Some};
use result::Ok;
use slice::{ImmutableVector, MutableVector};
use slice;
use str::StrSlice;

#[cfg(stage0)]
use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
#[cfg(stage0)]
use option::{Some, None};   // NOTE(stage0): Remove after snapshot.

/// A flag that specifies whether to use exponential (scientific) notation.
pub enum ExponentFormat {
    /// Do not use exponential notation.

src/libcore/fmt/num.rs

@@ -16,11 +16,15 @@

use collections::Collection;
use fmt;
use iter::{Iterator, DoubleEndedIterator};
use iter::DoubleEndedIterator;
use num::{Int, cast, zero};
use option::{Some, None};
use slice::{ImmutableVector, MutableVector};

#[cfg(stage0)]
use iter::Iterator;         // NOTE(stage0): Remove after snapshot.
#[cfg(stage0)]
use option::{Some, None};   // NOTE(stage0): Remove after snapshot.

/// A type that represents a specific radix
trait GenericRadix {
    /// The number of digits.

src/libcore/iter.rs

@@ -95,6 +95,7 @@ pub trait Extendable<A>: FromIterator<A> {
/// is returned. A concrete Iterator implementation may choose to behave however
/// it wishes, either by returning `None` infinitely, or by doing something
/// else.
#[lang="iterator"]
pub trait Iterator<A> {
    /// Advance the iterator and return the next value. Return `None` when the end is reached.
    fn next(&mut self) -> Option<A>;

src/libcore/option.rs

@@ -147,7 +147,12 @@ use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize};
use mem;
use slice;

/// The `Option`
// Note that this is not a lang item per se, but it has a hidden dependency on
// `Iterator`, which is one. The compiler assumes that the `next` method of
// `Iterator` is an enumeration with one type parameter and two variants,
// which basically means it must be `Option`.

/// The `Option` type.
#[deriving(Clone, PartialEq, PartialOrd, Eq, Ord, Show)]
pub enum Option<T> {
    /// No value

src/libcore/ptr.rs

@@ -90,11 +90,14 @@
use mem;
use clone::Clone;
use intrinsics;
use iter::{range, Iterator};
use iter::range;
use option::{Some, None, Option};

use cmp::{PartialEq, Eq, PartialOrd, Equiv, Ordering, Less, Equal, Greater};

#[cfg(stage0)]
use iter::Iterator; // NOTE(stage0): Remove after snapshot.

pub use intrinsics::copy_memory;
pub use intrinsics::copy_nonoverlapping_memory;
pub use intrinsics::set_memory;

src/libcore/str.rs

@@ -28,7 +28,7 @@ use iter::{Map, Iterator};
use iter::{DoubleEndedIterator, ExactSize};
use iter::range;
use num::{CheckedMul, Saturating};
use option::{None, Option, Some};
use option::{Option, None, Some};
use raw::Repr;
use slice::ImmutableVector;
use slice;
@@ -1027,9 +1027,12 @@ pub mod traits {
    use cmp::{Ord, Ordering, Less, Equal, Greater, PartialEq, PartialOrd, Equiv, Eq};
    use collections::Collection;
    use iter::Iterator;
    use option::{Option, Some, None};
    use option::{Option, Some};
    use str::{Str, StrSlice, eq_slice};

    #[cfg(stage0)]
    use option::None;   // NOTE(stage0): Remove after snapshot.

    impl<'a> Ord for &'a str {
        #[inline]
        fn cmp(&self, other: & &'a str) -> Ordering {

src/libcoretest/iter.rs

@@ -137,8 +137,8 @@ fn test_iterator_take_while() {
    let ys = [0u, 1, 2, 3, 5, 13];
    let mut it = xs.iter().take_while(|&x| *x < 15u);
    let mut i = 0;
    for &x in it {
        assert_eq!(x, ys[i]);
    for x in it {
        assert_eq!(*x, ys[i]);
        i += 1;
    }
    assert_eq!(i, ys.len());
@@ -150,8 +150,8 @@ fn test_iterator_skip_while() {
    let ys = [15, 16, 17, 19];
    let mut it = xs.iter().skip_while(|&x| *x < 15u);
    let mut i = 0;
    for &x in it {
        assert_eq!(x, ys[i]);
    for x in it {
        assert_eq!(*x, ys[i]);
        i += 1;
    }
    assert_eq!(i, ys.len());

src/librustc/middle/borrowck/check_loans.rs

@@ -440,6 +440,7 @@ impl<'a> CheckLoanCtxt<'a> {
                euv::AddrOf(..) |
                euv::AutoRef(..) |
                euv::ClosureInvocation(..) |
                euv::ForLoop(..) |
                euv::RefBinding(..) => {
                    format!("previous borrow of `{}` occurs here",
                            self.bccx.loan_path_to_string(&*old_loan.loan_path))
@@ -668,6 +669,11 @@ impl<'a> CheckLoanCtxt<'a> {
            return;
        }

        // Initializations are OK.
        if mode == euv::Init {
            return
        }

        // For immutable local variables, assignments are legal
        // if they cannot already have been assigned
        if self.is_local_variable_or_arg(assignee_cmt.clone()) {

src/librustc/middle/borrowck/mod.rs

@@ -651,7 +651,8 @@ impl<'a> BorrowckCtxt<'a> {
                    euv::OverloadedOperator |
                    euv::AddrOf |
                    euv::RefBinding |
                    euv::AutoRef => {
                    euv::AutoRef |
                    euv::ForLoop => {
                        format!("cannot borrow {} as mutable", descr)
                    }
                    euv::ClosureInvocation => {
@@ -712,6 +713,10 @@ impl<'a> BorrowckCtxt<'a> {
            BorrowViolation(euv::ClosureInvocation) => {
                "closure invocation"
            }

            BorrowViolation(euv::ForLoop) => {
                "`for` loop"
            }
        };

        match cause {

src/librustc/middle/cfg/construct.rs

@@ -240,7 +240,7 @@ impl<'a> CFGBuilder<'a> {
                //   v 3
                // [expr]
                //
                // Note that `break` and `loop` statements
                // Note that `break` and `continue` statements
                // may cause additional edges.

                // Is the condition considered part of the loop?
@@ -258,7 +258,44 @@ impl<'a> CFGBuilder<'a> {
                expr_exit
            }

            ast::ExprForLoop(..) => fail!("non-desugared expr_for_loop"),
            ast::ExprForLoop(ref pat, ref head, ref body, _) => {
                //
                //          [pred]
                //            |
                //            v 1
                //          [head]
                //            |
                //            v 2
                //        [loopback] <--+ 7
                //            |         |
                //            v 3       |
                //   +------[cond]      |
                //   |        |         |
                //   |        v 5       |
                //   |       [pat]      |
                //   |        |         |
                //   |        v 6       |
                //   v 4    [body] -----+
                // [expr]
                //
                // Note that `break` and `continue` statements
                // may cause additional edges.

                let head = self.expr(head.clone(), pred);       // 1
                let loopback = self.add_dummy_node([head]);     // 2
                let cond = self.add_dummy_node([loopback]);     // 3
                let expr_exit = self.add_node(expr.id, [cond]); // 4
                self.loop_scopes.push(LoopScope {
                    loop_id: expr.id,
                    continue_index: loopback,
                    break_index: expr_exit,
                });
                let pat = self.pat(&**pat, cond);               // 5
                let body = self.block(&**body, pat);            // 6
                self.add_contained_edge(body, loopback);        // 7
                self.loop_scopes.pop();
                expr_exit
            }

            ast::ExprLoop(ref body, _) => {
                //

src/librustc/middle/check_loop.rs

@@ -42,6 +42,10 @@ impl<'a> Visitor<Context> for CheckLoopVisitor<'a> {
            ast::ExprLoop(ref b, _) => {
                self.visit_block(&**b, Loop);
            }
            ast::ExprForLoop(_, ref e, ref b, _) => {
                self.visit_expr(&**e, cx);
                self.visit_block(&**b, Loop);
            }
            ast::ExprFnBlock(_, ref b) |
            ast::ExprProc(_, ref b) |
            ast::ExprUnboxedFn(_, ref b) => {

src/librustc/middle/check_match.rs

@@ -170,6 +170,24 @@ fn check_expr(cx: &mut MatchCheckCtxt, ex: &Expr) {
                .collect();
            check_exhaustive(cx, ex.span, &matrix);
        },
        ExprForLoop(ref pat, _, _, _) => {
            let mut static_inliner = StaticInliner {
                tcx: cx.tcx
            };
            match is_refutable(cx, static_inliner.fold_pat(*pat)) {
                Some(uncovered_pat) => {
                    cx.tcx.sess.span_err(
                        pat.span,
                        format!("refutable pattern in `for` loop binding: \
                                 `{}` not covered",
                                pat_to_string(&*uncovered_pat)).as_slice());
                },
                None => {}
            }

            // Check legality of move bindings.
            check_legality_of_move_bindings(cx, false, [ *pat ]);
        }
        _ => ()
    }
}

src/librustc/middle/dead.rs

@@ -354,11 +354,11 @@ fn create_and_seed_worklist(tcx: &ty::ctxt,
    // depending on whether a crate is built as bin or lib, and we want
    // the warning to be consistent, we also seed the worklist with
    // exported symbols.
    for &id in exported_items.iter() {
        worklist.push(id);
    for id in exported_items.iter() {
        worklist.push(*id);
    }
    for &id in reachable_symbols.iter() {
        worklist.push(id);
    for id in reachable_symbols.iter() {
        worklist.push(*id);
    }

    // Seed entry point

src/librustc/middle/expr_use_visitor.rs

@@ -79,7 +79,8 @@ pub enum LoanCause {
    AutoRef,
    RefBinding,
    OverloadedOperator,
    ClosureInvocation
    ClosureInvocation,
    ForLoop,
}

#[deriving(PartialEq,Show)]
@@ -395,7 +396,16 @@ impl<'d,'t,TYPER:mc::Typer> ExprUseVisitor<'d,'t,TYPER> {
                self.walk_block(&**blk);
            }

            ast::ExprForLoop(..) => fail!("non-desugared expr_for_loop"),
            ast::ExprForLoop(ref pat, ref head, ref blk, _) => {
                // The pattern lives as long as the block.
                debug!("walk_expr for loop case: blk id={}", blk.id);
                self.walk_expr(&**head);

                let head_cmt = return_if_err!(self.mc.cat_expr(&**head));
                self.walk_pat(head_cmt, pat.clone());

                self.walk_block(&**blk);
            }

            ast::ExprUnary(_, ref lhs) => {
                if !self.walk_overloaded_operator(expr, &**lhs, []) {

src/librustc/middle/lang_items.rs

@@ -299,5 +299,7 @@ lets_do_this! {
    NoShareItem,                     "no_share_bound",          no_share_bound;
    ManagedItem,                     "managed_bound",           managed_bound;

    IteratorItem,                    "iterator",                iterator;

    StackExhaustedLangItem,          "stack_exhausted",         stack_exhausted;
}