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

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.

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.

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

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