libstd: impl Clone for BigUint/BigInt and replace `copy` with `.clone()`

compiletest: stop ignoring all tests.

auto merge of #6148 : erickt/rust/remove-drop, r=pcwalton

The drop block has been deprecated for quite some time. This patch series removes support for parsing it and all the related machinery that made drop work.

As a side feature of all this, I also added the ability to annote fields in structs. This allows comments to be properly associated with an individual field. However, I didn't update `rustdoc` to integrate these comment blocks into the documentation it generates.

pipes: use finally to fix pipes::try_recv

rustdoc: Remove a now invalid test

remove some warnings

syntax: remove parse::token::{dtor,literally_dtor}

allow parsing attributes on struct fields

rustc: remove the rest of drop

Removes:

ast::struct_def::dtor
syntax::ast::ii_dtor
syntax::visit::fk_dtor
syntax::ast_map::node_dtor
syntax:struct_dtor

syntax: remove parsing destructors

core: Remove use of deprecated `drop`

auto merge of #6147 : bjz/rust/numeric-traits, r=brson

After much discussion on IRC and #4819, we have decided to revert to the old naming of the `/` operator. This does not change its behavior. In making this change, we also have had to rename some of the methods in the `Integer` trait. Here is a list of the methods that have changed:

- `Quot::quot` -> `Div::div`
- `Rem::rem` - stays the same
- `Integer::quot_rem` -> `Integer::div_rem`
- `Integer::div` -> `Integer::div_floor`
- `Integer::modulo` -> `Integer::mod_floor`
- `Integer::div_mod` -> `Integer::div_mod_floor`

auto merge of #6144 : catamorphism/rust/mkdir_recursive-breakage, r=thestinger

r? @brson or @thestinger : Added a change_dir_locked function to os, and use it in the
mkdir_recursive tests so that the tests don't clobber each other's
directory changes.

auto merge of #6139 : thestinger/rust/tmp, r=graydon

The `.tmp` files were missed before. I don't think there's a need to use
*.ext instead of just *.

Revert rename of Div to Quot

auto merge of #6131 : thestinger/rust/new_iter, r=graydon

auto merge of #6115 : jbclements/rust/test-case-fixes, r=jbclements

In developing the grammar a few weeks ago, I fixed up a bunch of test cases that had rotted to the point that they didn't parse.

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.

core/std: Fix race condition in os::mkdir_recursive tests

Added a change_dir_locked function to os, and use it in the
mkdir_recursive tests so that the tests don't clobber each other's
directory changes.

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)

fixed pattern, moved test to compile-fail

fixed up syntax

renamed issue-2185 to issue-3429

typestate is not planned for upcoming versions of rust....

fixed this test case too

fixed the test case, hope it's still testing something

after syntax fixes, these tests appear to pass

more commits on issue 2185

fixed up issue-2185, but now it has a trait failure

with syntax fixes, this test case now appears to pass

added test case for issue 5927

Test now passes

This test case now parses

I've done a slapdash job of fixing up the syntax; it didn't pass before,
and it doesn't pass now, but at least it parses...

this test still doesn't pass, but at least it parses...

Got test cases to pass, after some major surgery

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.

clear *everything* from the tmp directory

The .tmp files were missed before. I don't think there's a need to use
*.ext instead of just *.

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.

iter: add max and min functions

changed to impl trait for type stx

This test case is obsolete for two reasons

First, it refers to a feature (trait bounds on type parameters) that's
apparently no longer in the language. Second, if I understand the issue
correctly, it should never have been a "run-pass" test because it was
supposed to fail.

this issue is a dup of another one that has a correct test case

this test case has rotted wrt modern syntax. fortunately, this issue
was a dup of another one, and that one still ICEs.

remove (non-parsing) test related to impl d for d feature

deleted two tests intended to test RUST_CC_ZEAL, an apparently defunct flag for the cycle collector

iter: add a find function

char: fix unused import warning

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.