core: Wire up the unwinder to newsched again

This was some merge fallout

rustc: Drop the visitor object from the visitor glue

Recent demoding makes the visitor glue leak. It hasn't shown up in tests
because the box annihilator deletes the leaked boxes. This affects the
new scheduler though which does not yet have a box annihilator.

I don't think there's any great way to test this besides setting up
a task that doesn't run the box annihilator and I don't know that that's
a capability we want tasks to have.

mk: Fix pdf build

Merge remote-tracking branch 'brson/io'

Conflicts:
src/libcore/task/local_data_priv.rs

core: Turn off the local heap in newsched in stage0 to work around windows bustage

core won't compile in stage0 without.

auto merge of #6080 : pcwalton/rust/demode-everything, r=pcwalton

r? @brson

libstd: Fix merge fallout.

doc: XFAIL mysterious failure on bots

librustc: Fix merge fallout.

test: Fix more tests.

librustc: Forbid type implementations on typedefs.

librustc: Change labels to use the lifetime notation `'`.

test: Fix tests.

librustc: Remove the concept of modes from the compiler.

This commit does not remove `ty::arg`, although that should be
possible to do now.

librustc: Make `&fn` by-copy by default and remove the mode from `frame_address`.

test: Remove #[legacy_modes] from the test suite.

libfuzzer: De-mode the fuzzer.

librustc: Remove the legacy mode in the type visitor intrinsic.

librustc: Rename `reinterpret_cast` to `transmute_copy` and remove the intrinsic

librustc: Implement `reinterpret_cast` in terms of `transmute`.

librustc: Remove `ptr::addr_of`.

Revert "libcore: remove unnecessary deref"

This reverts commit 9860fe10a19cc4997e58861df905f8dbe4de3c5b.

auto merge of #6110 : bjz/rust/numeric-traits, r=pcwalton

As discussed on issue #4819, I have created four new traits: `Algebraic`, `Trigonometric`, `Exponential` and `Hyperbolic`, and moved the appropriate methods into them from `Real`.

~~~rust
pub trait Algebraic {
    fn pow(&self, n: Self) -> Self;
    fn sqrt(&self) -> Self;
    fn rsqrt(&self) -> Self;
    fn cbrt(&self) -> Self;
    fn hypot(&self, other: Self) -> Self;
}

pub trait Trigonometric {
    fn sin(&self) -> Self;
    fn cos(&self) -> Self;
    fn tan(&self) -> Self;
    fn asin(&self) -> Self;
    fn acos(&self) -> Self;
    fn atan(&self) -> Self;
    fn atan2(&self, other: Self) -> Self;
}

pub trait Exponential {
    fn exp(&self) -> Self;
    fn exp2(&self) -> Self;
    fn expm1(&self) -> Self;
    fn log(&self) -> Self;
    fn log2(&self) -> Self;
    fn log10(&self) -> Self;
}

pub trait Hyperbolic: Exponential {
    fn sinh(&self) -> Self;
    fn cosh(&self) -> Self;
    fn tanh(&self) -> Self;
}
~~~

There was some discussion over whether we should shorten the names, for example `Trig` and `Exp`. No abbreviations have been agreed on yet, but this could be considered in the future.

Additionally, `Integer::divisible_by` has been renamed to `Integer::is_multiple_of`.

auto merge of #6099 : danluu/rust/xfail_clone, r=catamorphism

One of the tests seems to have no current equivalent that's similar. Please let me know if that's incorrect, and I'll try fixing it instead of deleting it. I suppose a struct could be used instead of `any` and `match type`, but it seems like the original intent of the test was to exercise `match type`

Revert "Merge Exponential and Hyperbolic traits"

After discussions on IRC and #4819, we have decided to revert this change. This is due to the traits expressing different ideas and because hyperbolic functions are not trivially implementable from exponential functions for floating-point types.

Merge Exponential and Hyperbolic traits

The Hyperbolic Functions are trivially implemented in terms of `exp`, so it's  simpler to group them the Exponential trait. In the future these would have default implementations.

tutorial: Fix 'self' to 'Self'

tutorial: Fix 'self' to 'Self'

auto merge of #6083 : jbclements/rust/parser-cleanup, r=jbclements

r? @pcwalton

A month's worth of parser cleanup here. Much of this is new comments and renaming. A number of these commits also remove unneeded code.  Probably the biggest refactor here is splitting "parse_item_or_view_item" into two functions; it turns out that the only overlap between items in foreign modules and items in regular modules was macros, so this refactor should make things substantially easier for future maintenance.

Rename 'divisible_by' method to 'is_multiple_of', add tests for 'is_odd' and 'is_even'

add test case for enum disambiguation

fix typo in librstpkg tests, allowed by old parser

Implement Fractional for Ratio

Move appropriate functions out of Real and into separate Algebraic, Trigonometric, Exponential and Hyperbolic traits

auto merge of #6056 : thestinger/rust/iter, r=catamorphism

The existing adaptors like `map` in the `iter` module are very flawed because they only work for `BaseIter` implementations. There are many internal iterator implementations in the standard library like the set methods (`difference`, `symmetric_difference`, `intersection`, `union`) and the `range` functions that only share the `for` loop protocol in common.

The internal iterator adaptors should be implemented to work on any implementation of that protocol, rather than just a method called `each` taking `&self`.

This just moves `iter.rs` to `old_iter.rs` and begins work on documenting and implementing a nicer module.

make way for a new iter module

auto merge of #5646 : Aatch/rust/unwind-fix, r=brson

This fixes issue #5641

auto merge of #6092 : gifnksm/rust/impl-integer-bigint, r=graydon

This is a follow-up commit for #6041 (and depending on #6048).
Also adding `#[inline(always)]` for almost every methods in `std::bigint`.

Updated spawn / loop thread to work with current syntax

Remove test for any type -> match type, which doesn't seem to exist anymore

Update old xfailing spawn/bind/join test

parser comments

s/one_tuple/trailing_comma (more accurate name)

removed unneeded argument to parse_record

s/parse_purity/parse_unsafety

remove 3-line used-once function

rename parse_instance_var to parse_name_and_ty

the name no longer made sense. perhaps this could just be inlined.

remove obsolete semicolon from list of suggestions

rename parse_single_class_item as well

rename parse_class_item to parse_struct_decl_field

two problems with the old name: they're not called classes any more, and
the word "item" has a specific connotation in the parser

needs_comma was always true

fix for parsing x() as identifier pattern

hard to read the implied double negative

remove unused functions, fix tiny lexing bug

before this change, the parser would parse 14.a() as a method call, but
would parse 14.ø() as the floating-point number 14. followed by a function
call. This is because it was checking is_alpha, rather than ident_start,
and was therefore wrong with respect to unicode.

remove unused flag to parse_local fn

remove unused RESTRICT_NO_CALL_EXPRS restriction

undo abstraction over whether to parse attrs in a block

In principle, it seems like a nice idea to abstract over the two
functions that parse blocks (one with inner attrs allowed, one not).
However, the existing one wound up making things more complex than
just having two separate functions, especially after the obsolete
syntax is (will be) removed.

refactoring to split foreign_items from items

parser comments

parser comments

get rid of prec.rs

prec.rs no longer had much to do with precedence; the token->binop
function fits better in token.rs, and the one-liner defining the
precedence of 'as' can go next to the other precedence stuff in
ast_util.rs

reindent in parser

remove unnecessary function

simplify, based on invariant that items_allowed != foreign_items_allowed

adding parse_path

comments, helper function for tests, more informative error message

refactor parse_fn_decl

parser comments only

refactoring mod.rs

change stage1,stage2,stage2 into not(stage0)

With luck, this will allow rust to compile itself without --cfg flags again...

auto merge of #6097 : Blei/rust/fix-rand, r=pnkfelix

`self` has type `&@Rand`, so `*self` will be of type `@Rand` which causes
this same impl to be called again.

Fixes #6061

rand: Fix infinite recursion

`self` has type `&@Rand`, so `*self` will be of type `@Rand` which causes
this same impl to be called again.

auto merge of #6075 : thestinger/rust/no-no_core, r=brson

core injection works fine now

libstd: inlining almost every methods in bigint module.

libstd: impl Integer for BigUint/BigInt.

Also remove abs() method from the non-trait impl for BigInt/BigUint.
That method is provided in the Signed trait.

only use #[no_core] in libcore

auto merge of #6082 : catamorphism/rust/mkdir_recursive, r=brson

r? @brson mkdir_recursive creates a directory as well as any of its
parent directories that don't exist already. Seems like a useful
thing to have in core.

(Or r? anyone who gets to it first.)

auto merge of #6081 : brson/rust/out-of-stack, r=thestinger

People hit the recursion depth limit too often, it's not possible
to unwind reliably from out-of-stack.

Issues #3555, #3695

auto merge of #6072 : cmr/rust/better_import_error, r=graydon

auto merge of #6071 : bjz/rust/numeric-traits, r=graydon

As part of the numeric trait reform (see issue #4819), I have added the following traits to `core::num` and implemented them for Rust's primitive numeric types:

~~~rust
pub trait Bitwise: Not<Self>
                 + BitAnd<Self,Self>
                 + BitOr<Self,Self>
                 + BitXor<Self,Self>
                 + Shl<Self,Self>
                 + Shr<Self,Self> {}

pub trait BitCount {
    fn population_count(&self) -> Self;
    fn leading_zeros(&self) -> Self;
    fn trailing_zeros(&self) -> Self;
}

pub trait Bounded {
    fn min_value() -> Self;
    fn max_value() -> Self;
}

pub trait Primitive: Num
                   + NumCast
                   + Bounded
                   + Neg<Self>
                   + Add<Self,Self>
                   + Sub<Self,Self>
                   + Mul<Self,Self>
                   + Quot<Self,Self>
                   + Rem<Self,Self> {
    fn bits() -> uint;
    fn bytes() -> uint;
}

pub trait Int: Integer
             + Primitive
             + Bitwise
             + BitCount {}

pub trait Float: Real
               + Signed
               + Primitive {
    fn NaN() -> Self;
    fn infinity() -> Self;
    fn neg_infinity() -> Self;
    fn neg_zero() -> Self;

    fn is_NaN(&self) -> bool;
    fn is_infinite(&self) -> bool;
    fn is_finite(&self) -> bool;

    fn mantissa_digits() -> uint;
    fn digits() -> uint;
    fn epsilon() -> Self;
    fn min_exp() -> int;
    fn max_exp() -> int;
    fn min_10_exp() -> int;
    fn max_10_exp() -> int;

    fn mul_add(&self, a: Self, b: Self) -> Self;
    fn next_after(&self, other: Self) -> Self;
}
~~~
Note: I'm not sure my implementation for `BitCount::trailing_zeros` and `BitCount::leading_zeros` is correct for uints. I also need some assistance creating appropriate unit tests for them.

More work needs to be done in implementing specialized primitive floating-point and integer methods, but I'm beginning to reach the limits of my knowledge. Please leave your suggestions/critiques/ideas on #4819 if you have them – I'd very much appreciate hearing them.

I have also added an `Orderable` trait:

~~~rust
pub trait Orderable: Ord {
    fn min(&self, other: &Self) -> Self;
    fn max(&self, other: &Self) -> Self;
    fn clamp(&self, mn: &Self, mx: &Self) -> Self;
}
~~~

This is a temporary trait until we have default methods. We don't want to encumber all implementors of Ord by requiring them to implement these functions, but at the same time we want to be able to take advantage of the speed of the specific numeric functions (like the `fmin` and `fmax` intrinsics).

auto merge of #6070 : thestinger/rust/tutorial, r=pcwalton

auto merge of #6066 : djui/rust/patch-1, r=graydon

auto merge of #6064 : thestinger/rust/char, r=catamorphism

auto merge of #6059 : Kimundi/rust/nice-fail, r=pcwalton

r? @brson

Unwinding through macros now happens as a call to the trait function `FailWithCause::fail_with()`, which consumes self, allowing to use a more generic failure object in the future.

auto merge of #6058 : huonw/rust/rt-isaac-update, r=graydon

The "unsigned 4 byte" `ub4`s are actually 8 bytes on 64-bit platforms
which mean that some bits > 2**32 were retained in calculations, these
would then "reappear" after a right shift and so the stream of random numbers
would differ on 32 bit vs 64 bit platforms.

http://burtleburtle.net/bob/c/randport.c

Propagate NaNs for Orderable methods impled on floating-point primitives

Fix copy-paste mistakes

auto merge of #6057 : cmr/rust/map_zip, r=graydon

I think the name is more clear, and fits with filter_map etc.

Remove unnecessary fallbacks

The `target_word_size` attribute is always available at compile time, so there is no need for a fallback.

Rename `nextafter` to `next_after` to match method name in Float

auto merge of #6077 : brson/rust/valgrind, r=brson

Add additional constants to primitive floating point numbers

These follow the values defined in the C99 standard

core: Move mkdir_recursive from rustpkg into core::os

mkdir_recursive creates a directory as well as any of its
parent directories that don't exist already. Seems like a useful
thing to have in core.

rt: Set the stack depth limit to 1GB. Abort on error.

People hit the recursion depth limit too often, it's not possible
to unwind reliably from out-of-stack.

Issues #3555, #3695

Suppress all 'cond' errors in valgrind. #5856

tutorial-ffi: add example of a custom destructor

tutorial: rework the section on destructors

This removes the comparison to manual memory management examples,
because it requires too much existing knowledge. Implementing custom
destructors can be covered in the FFI tutorial, where `unsafe` is
already well explained.

Add mul_add and next_after methods to Float

Add Orderable trait

This is a temporary trait until we have default methods. We don't want to encumber all implementors of Ord by requiring them to implement these functions, but at the same time we want to be able to take advantage of the speed of the specific numeric functions (like the `fmin` and `fmax` intrinsics).

rt: use the [u]int[nn]_t types in the RNG.

This means that `ub4`s are always 4 bytes, rather than being 8 bytes on
x64. (Suggested but not implemented by upstream: "Porting it to a 64-bit
machine [...] may just need an adjustment of the definition of ub4")

Fix typo