Add x64 windows to platform.mk and mingw64 header fixes.

force LLVM clean

auto merge of #7542 : alexcrichton/rust/patch-rusti, r=cmr

Doesn't disable it completely, also removes the bogus `rc` file.

auto merge of #7534 : bblum/rust/soundness-messages, r=catamorphism

auto merge of #7566 : huonw/rust/vec-kill, r=cmr

The last remaining internal iterator in `vec` is `each_permutation`.

Convert vec::{as_imm_buf, as_mut_buf} to methods.

Convert vec::windowed to an external iterator, and add an n-at-a-time chunk iterator.

Convert vec::{split, splitn, rsplit, rsplitn} to external iterators.

Remove standalone comparison functions in vec, make the trait impls better.

Remove vec::reversed, replaced by iterators.

Remove vec::{filter, filtered, filter_map, filter_mapped}, replaced by iterators.

Implement consuming iterators for ~[], remove vec::{consume, consume_reverse, map_consume}.

auto merge of #7531 : sankha93/rust/master, r=bblum

This pull request fixes #7118.

auto merge of #7523 : huonw/rust/uppercase-statics-lint, r=cmr

Adds a lint for `static some_lowercase_name: uint = 1;`. Warning by default since it causes confusion, e.g. `static a: uint = 1; ... let a = 2;` => `error: only refutable patterns allowed here`.

auto merge of #7518 : graydon/rust/stats-improvements, r=catamorphism

auto merge of #7474 : Seldaek/rust/clean-iter, r=thestinger

I think it's WIP - but I wanted to ask for feedback (/cc @thestinger)

I had to move the impl of FromIter for vec into extra::iter because I don't think std can depend on extra, but that's a bit messed up. Similarly some FromIter uses are gone now, not sure if this is fixable or if I made a complete mess here..

auto merge of #7510 : Dretch/rust/missing-trait-message, r=catamorphism

auto merge of #7498 : luqmana/rust/cow, r=catamorphism

Either one works and wget is easier to setup on windows.

Merge pull request #7187 from nikomatsakis/issue-3238-defer-reasoning-about-regions

Defer reasoning about regions until after regionck

doc: Update links to 0.7

Completely disable rusti on 32-bit hosts

Ignore all rusti tests harder. #7541

Ignore all rusti tests. #7541

Correct merge errors, broken tests

Add copyright notice and kill broken test

Adjust documentation to describe how closures and closure bounds
affect things.

Move existing docs into doc.rs

convert region_inference into a module, so I can attach docs

move docs into doc.rs

Correct handling of if/match, and make explicit computation of
common supertypes.

This was breaking with the change to regions because of the
(now incorrect) assumpton that our inference code makes,
which is that if a <: b succeeds, there is no need to compute
the LUB/GLB.

Defer reasoning about region relationships until after regionck.

This patch makes error handling for region inference failures more
uniform by not reporting *any* region errors until the reigon inference
step. This requires threading through more information about what
caused a region constraint, so that we can still give informative
error messages.

I have only taken partial advantage of this information: when region
inference fails, we still report the same error we always did, despite
the fact that we now know precisely what caused the various constriants
and what the region variable represents, which we did not know before.

This change is required not only to improve error messages but
because the region hierarchy is not in fact fully known until regionck,
because it is not clear where closure bodies fit in (our current
treatment is unsound). Moreover, the relationships between free variables
cannot be fully determined until type inference is otherwise complete.

cc #3238.

Add a run-pass test for recursive copyable stack closures.

Fix filenames of some compile-fail tests.

Better error messages in report_use_of_moved_value; close #7286

Improve the attempted dynamic environment-capture error message

auto merge of #7409 : alexcrichton/rust/threadsafe, r=cmr

@catamorphism, this re-enables threadsafe rustpkg tests, @brson this will fail unless the bots have LLVM rebuilt, so this is a good indicator of whether that happened or not.

Turn on using LLVM threadsafely

auto merge of #7488 : yichoi/rust/sanitize_utf8, r=huonw

back::link::sanitize support escape_utf8
fix #7486

auto merge of #7443 : yjh0502/rust/fix_field_dup, r=huonw

Check if there is duplicated field names in struct.

auto merge of #7521 : thestinger/rust/vec, r=Aatch

continued from #7495

rustc: add a lint to enforce uppercase statics.

lint: make the non_camel_case_types lint work with scripts without a upper/lowercase distinction.

auto merge of #7492 : yichoi/rust/fix_cleanllvm, r=luqmana

fix clean-llvm in mk/clean.mk for cross-compile

after #7442 landed, below error produced while android cross-compile
```
make[1]: *** No rule to make target `clean-llvmarm-linux-androideabi', needed by `clean-llvm'.  Stop.
make[1]: Leaving directory `/home/yichoi/rust_latest/build'
make: *** [rustllvm/llvm-auto-clean-stamp] Error 2
```

librustc: apply changes of char::escape_unicode

librustc: back::link::sanitize support esacpe_utf8

auto merge of #7487 : huonw/rust/vec-kill, r=cmr

Continuation of #7430.

I haven't removed the `map` method, since the replacement `v.iter().transform(f).collect::<~[SomeType]>()` is a little ridiculous at the moment.

Update verison numbers in README.md

pass exchange_malloc an alignment, not a tydesc

global_heap: inline get_box_size and align_to

vec: implement exchange vector reserve in Rust

global_heap: inline malloc_raw and add realloc_raw

auto merge of #7517 : brson/rust/0.7, r=brson

extra: docs, tests and new functionality for the extra::stats module

Move most iter functionality to extra, fixes #7343

Add an EnumSetIterator and EnumSet::iter

Bump version from 0.7-pre to 0.7

More 0.7 release notes

auto merge of #7495 : thestinger/rust/exchange, r=cmr

With these changes, exchange allocator headers are never initialized, read or written to. Removing the header will now just involve updating the code in trans using an offset to only do it if the type contained is managed.

The only thing blocking removing the initialization of the last field in the header was ~fn since it uses it to store the dynamic size/types due to captures. I temporarily switched it to a `closure_exchange_alloc` lang item (it uses the same `exchange_free`) and #7496 is filed about removing that.

Since the `exchange_free` call is now inlined all over the codebase, I don't think we should have an assert for null. It doesn't currently ever happen, but it would be fine if we started generating code that did do it. The `exchange_free` function also had a comment declaring that it must not fail, but a regular assert would cause a failure. I also removed the atomic counter because valgrind can already find these leaks, and we have valgrind bots now.

Note that exchange free does not currently print an error an out-of-memory when it aborts, because our `io` code may allocate. We could probably get away with a `#[rust_stack]` call to a `stdio` function but it would be better to make a write system call.

When an impl references an unknown trait, mention what
the trait is called in the error message.

add a closure_exchange_malloc lang item

this makes the exchange allocation header completely unused, and leaves
it uninitialized

stop copying the tydesc in unique box take glue

the only user of the tydesc is ~fn, and it doesn't use this glue code

managed: rm RC_EXCHANGE_UNIQUE constant

this is no longer used, exchange allocations do not set ref_count

stop initializing ref_count in exchange_alloc

this is never read anymore

rustpkg: Ignore a test that's failing on the dist-snap bot

auto merge of #7465 : alexcrichton/rust/issue-4432, r=cmr

This stems from trying to perform as few allocations as possible throughout the standard libraries.

This specializes the `ToStr` implementation for floats/ints separately because it's known that ints will have a maximum length (whereas floats could be very very large).

I also removed a `FIXME` to remove a malloc from the `to_str()` of floats in `repr.rs` because I think that this should be addressed elsewhere. I think that we may not be able to avoid it easily because floats can have such large representations, but regardless this should be a problem with the implementation of `float_to_str_bytes_common` now and not in the `Repr` module.

Specialize to_str_common for floats/integers in strconv

This allows the integral paths to avoid allocations on the heap

Closes #4424, #4423

Change char::escape_{default,unicode} to take callbacks instead of allocating
strings

Remove vec::{map, mapi, zip_map} and the methods, except for .map, since this
is very common, and the replacement (.iter().transform().collect()) is very
ugly.

auto merge of #7374 : Jeaye/rust/func_highlight, r=cmr

This allows for highlighting of function calls
for free floating, member, and static functions.

Convert vec::{grow, grow_fn, grow_set} to methods.

Convert vec::dedup to a method.

Convert vec::{bsearch, bsearch_elem} to methods.

etc: update etc/unicode.py for the changes made to std::unicode.

Convert vec::{reverse, swap} to methods.

Convert vec::{rposition, rposition_elem, position_elem, contains} to methods.

Remove vec::[r]position_between, replaced by slices & iterators.

Remove vec::{rfind, rfind_between, find_between}, replaced by slices and iterator adapators.

auto merge of #7468 : cmr/rust/great_renaming, r=pcwalton

vec: use contains_managed instead of box header

add a contains_managed intrinsic

simplify the exchange allocator

* stop using an atomic counter, this has a significant cost and
  valgrind will already catch these leaks
* remove the extra layer of function calls
* remove the assert of non-null in free, freeing null is well defined
  but throwing a failure from free will not be
* stop initializing the `prev`/`next` pointers
* abort on out-of-memory, failing won't necessarily work

auto merge of #7490 : mozilla/rust/rollup, r=thestinger

603137c r=cmr
fe10db2 r=bstrie

configure: Require one of wget or curl.

auto merge of #7475 : Seldaek/rust/fixsplit, r=cmr

I almost got locked out of my machine because I misunderstood the purpose of the function and called it with a limit of uint::max_value, which turned this function into an almost endless loop.

mk: clean-llvm for cross-compile

auto merge of #7457 : Blei/rust/fix-ffi-floats, r=cmr

Also contains a fix to help ctag pick up macro definitions.

Fixes #7377

auto merge of #7452 : dotdash/rust/self_indirection, r=cmr

Currently we pass all "self" arguments by reference, for the pointer
variants this means that we end up with double indirection which causes
a unnecessary performance hit.

The fix itself is pretty straight-forward and just means that "self"
needs to be handled like any other argument, except for by-value "self"
which still needs to be passed by reference. This is because
non-pointer types can't just be stuffed into the environment slot which
is used to pass "self".

What made things tricky is that there was also a bug in the typechecker
where the method map entries are created. For type impls, that stored
the base type instead of the actual self-type in the method map, e.g.
Foo instead of &Foo for &self. That worked with pass-by-reference, but
fails with pass-by-value which needs the real type.

Code that makes use of methods seems to be about 10% faster with this
change. Also, build times are reduced by about 4%.

Fixes #4355, #4402, #5280, #4406 and #7285

minor vec cleanup

* hide the rustrt module in the docs
* remove the useless `traits` module wrapping the `Add` impl

Add -v/--version support to rust binary

fix code block syntax in two docstrings

auto merge of #7449 : yichoi/rust/std_test, r=cmr

adjust run.rs test for android to pass check std

auto merge of #7342 : alexcrichton/rust/assort-cleanup, r=cmr

This removes usage of `&const` throughout the standard libraries/compiler, and it removes some extraneous fields in the AST now that unique boxes always inherit their mutability.

Avoid double indirection for the "self" arg in methods

Currently we pass all "self" arguments by reference, for the pointer
variants this means that we end up with double indirection which causes
a unnecessary performance hit.

The fix itself is pretty straight-forward and just means that "self"
needs to be handled like any other argument, except for by-value "self"
which still needs to be passed by reference. This is because
non-pointer types can't just be stuffed into the environment slot which
is used to pass "self".

What made things tricky is that there was also a bug in the typechecker
where the method map entries are created. For type impls, that stored
the base type instead of the actual self-type in the method map, e.g.
Foo instead of &Foo for &self. That worked with pass-by-reference, but
fails with pass-by-value which needs the real type.

Code that makes use of methods seems to be about 10% faster with this
change. Also, build times are reduced by about 4%.

Fixes #4355, #4402, #5280, #4406 and #7285

Fix handling of temp cleanups for the "self" argument

The code that tried to revoke the cleanup for the self argument tried
to use "llself" to do so, but the cleanup might actually be registered
with a different ValueRef due to e.g. casting. Currently, this is
worked around by early revocation of the cleanup for self in
trans_self_arg.

To handle this correctly, we have to put the ValueRef for the cleanup
into the MethodData, so trans_call_inner can use it to revoke the
cleanup when it's actually supposed to.

Remove mutability from unique boxes in the AST

Removing a lot of usage of '&const'

Warning cleanup

Fix merge fallout

Great renaming: propagate throughout the rest of the codebase