auto merge of #6113 : brson/rust/task-drop, r=graydon

auto merge of #6105 : Aatch/rust/linker-improv, r=pcwalton

Adds two extra flags: `--linker` which takes extra flags to pass to the linker, can be used multiple times and `--print-link-args` which prints out linker arguments. Currently `--print-link-args` needs execution to get past translation to get the `LinkMeta` data.

I haven't done tests or updated any extra documentation yet, so this pull request is currently here for review.

auto merge of #6103 : catamorphism/rust/nonfatal-errors, r=catamorphism

r? @nikomatsakis typeck::check::_match wasn't suppressing derived errors properly.
Fixed it. (This will fix #5100)

Fix error messages harder

auto merge of #6136 : jld/rust/simplifycfg-unrevert, r=thestinger

Also add the clearly marked test case that should have been there all along, and un-xfail the not-so-obvious doc test that was affected.

auto merge of #6134 : jld/rust/issue-6117, r=catamorphism

Cases like `Either<@int,()>` have a null case with at most one value but
a nonzero number of fields; if we misreport this, then bad things can
happen inside of, for example, pattern matching.

Closes #6117.

auto merge of #6118 : brson/rust/too-much-recursion, r=thestinger

I don't understand how this is still passing on the bots. This condition
should trigger an abort now.

Revert "doc: XFAIL mysterious failure on bots"

This reverts commit 2c6dae081b72d33a2c51b5f46436e6350bb3682f.

Reverse accidental src/llvm reversion in 876483dcf, and add test.

The test is reduced from a doc test, but making it separate ensures that
(1) unrelated changes to the docs won't leave this case uncovered, and
(2) the nature of any future failures will be more obvious to whoever
sees the tree on fire as a result.

The null case of a nullable-poiner enum might not be nullary.

Cases like `Either<@int,()>` have a null case with at most one value but
a nonzero number of fields; if we misreport this, then bad things can
happen inside of, for example, pattern matching.

Closes #6117.

auto merge of #6121 : luqmana/rust/newtype-cc, r=graydon

#6086

Change flags to -Z print-link-args and --link-args

auto merge of #6108 : gifnksm/rust/bigint-shift-bug, r=brson

`std::bigint` contains the following code.
```rust
borrow = *elem << (uint::bits - n_bits);
```
The code above contains a bug that the value of the right operand of the shift operator exceeds the size of the left operand,
because sizeof(*elem) == 32, and 0 <= n_bits < 32 in 64bit architecture.

If `--opt-level` option is not given to rustc, the code above runs as if the right operand is `(uint::bits - n_bits) % 32`,
but if --opt-level is given, `borrow` is always zero.

I wonder why this bug is not catched in the libstd's testsuite (I try the `rustc --test --opt-level=2 bigint.rs` before fixing the bug,
but the unittest passes normally.)

This pull request also removes the implicit vector copies in `bigint.rs`.

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

r? @brson This hopefully addresses your concerns about the termination condition, and adds more tests. With a bonus documentation commit.

rustc / test: Fix error message

auto merge of #6073 : huonw/rust/core-rust-isaac, r=pcwalton

This replaces the wrapper around the runtime RNG with a pure Rust implementation of the same algorithm. This is much faster (up to 5x), and is hopefully safer.

There is still (a little) room for optimisation: testing by summing 100,000,000 random `u32`s indicates this is about ~~40-50%~~ 10% slower than the pure C implementation (running as standalone executable, not in the runtime).

(Only 6d50d55 is part of this PR, the first two are from #6058, but are required for the rt rng to be correct to compare against in the tests.)

Add test for cross crate newtype struct in match pattern.

librustc: Fix pattern matching on cross crate newtype structs.

test: Remove run-pass/too-much-recursion.rs

I don't understand how this is still passing on the bots. This condition
should trigger an abort now.

core: add some inlining hints to methods/fns in rand.

core: a pure Rust implementation of the ISAAC RNG.

This replaces the wrapper around the runtime RNG with a pure Rust
implementation of the same algorithm. This is faster (up to 5x), and
is hopefully safer.

There is still much room for optimisation: testing by summing 100,000,000
random `u32`s indicates this is about 40-50% slower than the pure C
implementation (running as standalone executable, not in the runtime).

rustc: Change At to Managed and Uniq to Owned

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`.

core: Replace uses of 'drop' in task module with 'finally'. #5379

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

libstd: modify wrong shift width.

borrow = *elem << (uint::bits - n_bits);

The code above contains a bug that the value of the right operand of the shift operator exceeds the size of the left operand,
because sizeof(*elem) == 32, and 0 <= n_bits < 32 in 64bit architecture.

If `--opt-level` option is not given to rustc, the code above runs as if the right operand is `(uint::bits - n_bits) % 32`,
but if --opt-level is given, `borrow` is always zero.

I wonder why this bug is not catched in the libstd's testsuite (I try the `rustc --test --opt-level=2 bigint.rs` before fixing the bug,
but the unittest passes normally.)

libstd: remove implicit copying of BigInt/BigUint

core: Use a better termination condition in os::mkdir_recursive

Instead of checking whether the parent is "." or "/", check the
number of components.

Also, more tests.

core: Document core::path::GenericPath's trait methods

Adds '--print-link-args' that outputs linker arguments that would be used

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

rustc: Suppress derived pattern-match-checking errors

typeck::check::_match wasn't suppressing derived errors properly.
Fixed it.

Add `--linker` option to pass flags to the linker

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