mk: Get rid of redundant LIBUV_FLAGS.

Fix up mingw64 target.

auto merge of #10583 : alexcrichton/rust/privacy-reexport, r=pcwalton

I added a test case which does not compile today, and required changes on
privacy's side of things to get right. Additionally, this moves a good bit of
logic which did not belong in reachability into privacy.

All of reachability should solely be responsible for determining what the
reachable surface area of a crate is given the exported surface area (where the
exported surface area is that which is usable by external crates).

Privacy will now correctly figure out what's exported by deeply looking
through reexports. Previously if a module were reexported under another name,
nothing in the module would actually get exported in the executable. I also
consolidated the phases of privacy to be clearer about what's an input to what.
The privacy checking pass no longer uses the notion of an "all public" path, and
the embargo visitor is no longer an input to the checking pass.

Currently the embargo visitor is built as a saturating analysis because it's
unknown what portions of the AST are going to get re-exported.

This also cracks down on exported methods from impl blocks and trait blocks. If you implement a private trait, none of the symbols are exported, and if you have an impl for a private type none of the symbols are exported either. On the other hand, if you implement a public trait for a private type, the symbols are still exported. I'm unclear on whether this last part is correct, but librustc will fail to link unless it's in place.

Move more of the exportation burden into privacy

I added a test case which does not compile today, and required changes on
privacy's side of things to get right. Additionally, this moves a good bit of
logic which did not belong in reachability into privacy.

All of reachability should solely be responsible for determining what the
reachable surface area of a crate is given the exported surface area (where the
exported surface area is that which is usable by external crates).

Privacy will now correctly figure out what's exported by deeply looking
through reexports. Previously if a module were reexported under another name,
nothing in the module would actually get exported in the executable. I also
consolidated the phases of privacy to be clearer about what's an input to what.
The privacy checking pass no longer uses the notion of an "all public" path, and
the embargo visitor is no longer an input to the checking pass.

Currently the embargo visitor is built as a saturating analysis because it's
unknown what portions of the AST are going to get re-exported.

auto merge of #10610 : thestinger/rust/breakpoint, r=pnkfelix

This can be used to grab the attention of a debugger, and unlike
`abort` execution can be resumed.

add a breakpoint intrinsic for debugging

This can be used to grab the attention of a debugger, and unlike
`abort` execution can be resumed.

auto merge of #10608 : thestinger/rust/managed, r=huonw

auto merge of #10606 : huonw/rust/lint-unsafe-in-macro, r=thestinger

Add a test for the case I mentioned on #10599.

minor rewording in the tutorial's `Rc` coverage

mention `Gc` in the managed box feature gate

auto merge of #10582 : g3xzh/rust/master, r=cmr

More new benchmark tests. some of them are benchmarking `starts_with` and `ends_with`.
Let me know if I am missing something.
Thanks in advance.

Add more benchmark tests to vec.rs

New benchmark tests in vec.rs:
`push`, `starts_with_same_vector`, `starts_with_single_element`,
`starts_with_diff_one_element_end`, `ends_with_same_vector`,
`ends_with_single_element`, `ends_with_diff_one_element_beginning` and
`contains_last_element`

test: test that the `unsafe_block` lint picks up `unsafe` blocks in
macros.

auto merge of #10588 : huonw/rust/un@mutilate-task_rng, r=alexcrichton

Replace with some unsafe code by storing a pointer into TLS-owned heap
data.

std::rand: move TaskRng off @mut.

Replace with some unsafe code by storing a pointer into TLS-owned heap
data.

auto merge of #10599 : thestinger/rust/unsafe, r=cmr

This is just meant to be for containing usage of `unsafe`, much like `heap_memory`.

auto merge of #10589 : thestinger/rust/doc, r=pcwalton

This replaces the old section on managed pointers because the syntax is
going to be removed and it's currently feature gated so the examples
don't work out-of-the-box. Dynamic mutability coverage can be added
after the `Mut<T>` work has landed.

tutorial: alternatives to ownership

This replaces the old section on managed pointers because the syntax is
going to be removed and it's currently feature gated so the examples
don't work out-of-the-box. Dynamic mutability coverage can be added
after the `Mut<T>` work has landed.

add lint for `unsafe` blocks

auto merge of #10598 : alexcrichton/rust/rustdoc, r=thestinger

This prevents an assertion from being tripped because the generics weren't
categorized.

Closes #10597

Process ffi generics in rustdoc

This prevents an assertion from being tripped because the generics weren't
categorized.

Closes #10597

auto merge of #10595 : hatahet/rust/master, r=thestinger

Closes #10579

`std::ptr::read_ptr` now takes `*T` instead of `*mut T`

Closes #10579

auto merge of #10587 : thestinger/rust/stack, r=pcwalton

remove segmented stacks from the manual

auto merge of #10584 : klutzy/rust/local-rust-root, r=alexcrichton

Fixes #8756.

auto merge of #10590 : sanxiyn/rust/ty-mac, r=thestinger

Remove ty_mac

auto merge of #10567 : sanxiyn/rust/bytepos, r=alexcrichton

auto merge of #10585 : idupree/rust/master, r=catamorphism

update manual to reflect &'lifetime syntax

Fix --local-rust-root option on Windows

auto merge of #10576 : thestinger/rust/gc, r=pcwalton

This isn't very useful yet, but it does replace most functionality of `@T`. The `Mut<T>` type will make it unnecessary to have a `GcMut<T>` so I haven't included one. Obviously it doesn't work for trait objects but that needs to be figured out for `Rc<T>` too.

auto merge of #10527 : eholk/rust/win64, r=alexcrichton

This was needed to access UEFI boot services in my new Boot2Rust experiment.

I also realized that Rust functions declared as extern always use the C calling convention regardless of how they were declared, so this pull request fixes that as well.

Fix parsing tests

Make BytePos 32-bit

add an initial `Gc<T>` stub with the API

auto merge of #10575 : sfackler/rust/non-copyable, r=huonw

The issue that required it has been fixed.

Remove NonCopyable::new

The issue that required it has been fixed.

auto merge of #10568 : pcwalton/rust/more-bars, r=alexcrichton

r? @alexcrichton

librustc: Change most uses of `&fn()` to `||`.

libsyntax: Change all uses of `&fn` to `||`.

libextra: Convert uses of `&fn(A)->B` to `|A|->B`.

libstd: Change all uses of `&fn(A)->B` over to `|A|->B` in libstd

auto merge of #10495 : alexcrichton/rust/more-native-io, r=brson

This implements a fair amount of the unimpl() functionality in io::native
relating to filesystem operations. I've also modified all io::fs tests to run in
both a native and uv environment (so everything is actually tested).

There are a few bits of remaining functionality which I was unable to get
working:

* truncate on windows
* change_file_times on windows
* lstat on windows

I think that change_file_times may just need a better interface, but the other
two have large implementations in libuv which I didn't want to tackle trying to
copy. I found a `chsize` function to work for truncate on windows, but it
doesn't quite seem to be working out.

Implement more native file I/O

This implements a fair amount of the unimpl() functionality in io::native
relating to filesystem operations. I've also modified all io::fs tests to run in
both a native and uv environment (so everything is actually tested).

There are a two bits of remaining functionality which I was unable to get
working:

* change_file_times on windows
* lstat on windows

I think that change_file_times may just need a better interface, but lstat has a
large implementation in libuv which I didn't want to tackle trying to copy.

Don't use win64 calling convention on 32-bit machines.

auto merge of #10558 : alexcrichton/rust/faster-stdout, r=pcwalton,pcwalton

There are issues with reading stdin when it is actually attached to a pipe, but
I have run into no problems in writing to stdout/stderr when they are attached
to pipes.

auto merge of #10557 : huonw/rust/inline-deriving, r=pcwalton

ToStr, Encodable and Decodable are not marked as such, since they're
already expensive, and lead to large methods, so inlining will bloat the
metadata & the binaries.

This means that something like

    #[deriving(Eq)]
    struct A { x: int }

creates an instance like

    #[doc = "Automatically derived."]
    impl ::std::cmp::Eq for A {
        #[inline]
        fn eq(&self, __arg_0: &A) -> ::bool {
            match *__arg_0 {
                A{x: ref __self_1_0} =>
                match *self {
                    A{x: ref __self_0_0} => true && __self_0_0.eq(__self_1_0)
                }
            }
        }
        #[inline]
        fn ne(&self, __arg_0: &A) -> ::bool {
            match *__arg_0 {
                A{x: ref __self_1_0} =>
                match *self {
                    A{x: ref __self_0_0} => false || __self_0_0.ne(__self_1_0)
                }
            }
        }
    }

(The change being the `#[inline]` attributes.)

auto merge of #10542 : huonw/rust/open01, r=alexcrichton

Provide `Closed01` and `Open01` that generate directly from the
closed/open intervals from 0 to 1, in contrast to the plain impls for
f32 and f64 which generate the half-open [0,1).

Fixes #7755.

auto merge of #10561 : pcwalton/rust/procify, r=alexcrichton

r? @alexcrichton

auto merge of #10479 : alexcrichton/rust/native-mutex.rs, r=cmr

This adds a new `std::unstable::mutex` module which contains bindings to the platform-provided mutexes. This module is pretty much entirely unsafe to use, but is critical for the runtime and dropping our C++ dependency.

The actual implementation is to do a compare-and-swap on an initially uninitialized pointer. Pthreads does allow for static initialization, so this wouldn't be necessary if we had all the proper headers and whatnot, but windows it looks like will always require some sort of compare-and-swap operation. For now, I didn't want to have to define all the pthreads headers, so I continue to just malloc the pthreads lock/cvar.

After this, there's only one remaining C++ component of rust, and that's unwinding.

Move runtime files to C instead of C++

Explicitly have the only C++ portion of the runtime be one file with exception
handling. All other runtime files must now live in C and be fully defined in C.

Remove the C++ lock_and_signal type

A the same time this purges all runtime support needed for statically
initialized mutexes, moving all users over to the new Mutex type instead.

Implement a native mutex type

This mutex is built on top of pthreads for unix and the related windows apis on
windows. This is a straight port of the lock_and_signal type from C++ to rust.
Almost all operations on the type are unsafe, and it's definitely not
recommended for general use.

Closes #9105

auto merge of #10458 : yichoi/rust/make_check_pass_android2, r=brson

To enable test on android bot #9120

 workcache::test disabled and run-pass/core-run-destroy.rs fixed on android

libsyntax: Remove `~fn()` from the language

librustc: Convert `~fn()` to `proc()` everywhere.

librustc: Remove the one use of `~fn()`

libextra: Remove `~fn()` from libextra.

libstd: Change all `~fn()`s to `proc`s in the standard library.

This makes `Cell`s no longer necessary in most cases.

auto merge of #10440 : brson/rust/cnamespace, r=bstrie

auto merge of #10366 : brson/rust/ignore-patterns, r=alexcrichton

This replaces `*` with `..` in enums, `_` with `..` in structs, and `.._` with `..` in vectors. It adds obsolete syntax warnings for the old forms but doesn't turn them on yet because we need a snapshot.

#5830

Allow piped stdout/stderr use uv_tty_t

There are issues with reading stdin when it is actually attached to a pipe, but
I have run into no problems in writing to stdout/stderr when they are attached
to pipes.

Use the correct calling convention for extern rust functions.

Add Win64 calling convention.

Use '..' as slice wildcard in vectors

Use '..' as multi-field wildcard in enums and structs.

Mark some derived methods as #[inline].

ToStr, Encodable and Decodable are not marked as such, since they're
already expensive, and lead to large methods, so inlining will bloat the
metadata & the binaries.

This means that something like

    #[deriving(Eq)]
    struct A { x: int }

creates an instance like

    #[doc = "Automatically derived."]
    impl ::std::cmp::Eq for A {
        #[inline]
        fn eq(&self, __arg_0: &A) -> ::bool {
            match *__arg_0 {
                A{x: ref __self_1_0} =>
                match *self {
                    A{x: ref __self_0_0} => true && __self_0_0.eq(__self_1_0)
                }
            }
        }
        #[inline]
        fn ne(&self, __arg_0: &A) -> ::bool {
            match *__arg_0 {
                A{x: ref __self_1_0} =>
                match *self {
                    A{x: ref __self_0_0} => false || __self_0_0.ne(__self_1_0)
                }
            }
        }
    }

(The change being the `#[inline]` attributes.)

rt: Namespace all C functions under rust_

android support added to test case

add path environments

fix #10450

temporarily disable tests on android and tagging issue number #10455

auto merge of #10552 : michaelwoerister/rust/ifstepping, r=brson

This PR improves the single-stepping experience for if-expression (no more jumping into the *else* branch before entering the *then* branch, no more jumping to the end of the *else* branch after finishing the *then* branch). Unfortunately I don't know of a straight-forward way of writing automated tests for this. Suggestions welcome!

auto merge of #10555 : TeXitoi/rust/pidigits-resurected, r=alexcrichton

Changes:
* default value when no args
* license
* removed libc printing
* use extra::bigint instead of handmade gmp binding

The drawback is that it's 2 order of magnitude slower, the good news is that there is a good bench for extra::bigint.

pidigits resurected

Changes:
* default value when no args
* license
* removed libc printing
* use extra::bigint instead of handmade gmp binding

auto merge of #10539 : alexcrichton/rust/external-linkage, r=pcwalton

If a function is marked as external, then it's likely desired for use with some
native library, so we're not really accomplishing a whole lot by internalizing
all of these symbols.

Don't mark reachable extern fns as internal

If a function is marked as external, then it's likely desired for use with some
native library, so we're not really accomplishing a whole lot by internalizing
all of these symbols.

debuginfo: Improved stepping for if-expressions

std::rand: wrappers for floats from [0,1] and (0,1).

Provide `Closed01` and `Open01` that generate directly from the
closed/open intervals from 0 to 1, in contrast to the plain impls for
f32 and f64 which generate the half-open [0,1).

Fixes #7755.

auto merge of #10508 : chris-morgan/rust/tags-improvements, r=cmr

Largely, this is just being more specific about where tags get searched
for to remove external dependencies like src/llvm, which reduces the
number of tags *enormously* and significantly increases the usefulness
of the tags file as it is then focusing on 240K lines of Rust code
and 4.5K of C++ rather than just shy of 1M lines of C++ code (mostly
from LLVM) and another 100K lines of Rust tests and a diverse collection
of other languages.

src/rustllvm/RustWrapper.cpp and src/rustllvm/PassWrapper.cpp are
getting tags made, but I'm not sure if that's desirable or not. At
worst, it's not a significant wrong.

A future, desirable step is producing tags for just libstd and libextra
for the use of people using Rust-the-language rather than working on
Rust itself.

auto merge of #10443 : alexcrichton/rust/meaninless-pub-priv, r=cmr

Closes #10111

Forbid privacy in inner functions

Closes #10111

auto merge of #10526 : itdaniher/rust/master, r=pcwalton

This commit fixes issue #10468.

It propagate optimization level from PkgSrc to compile_crate as a rustc::driver::session::OptLevel enum.

The 'opt' argument to compile_crate was previously hardcoded as boolean false, such that calls to session::options would always result in the session::No flag being used.

auto merge of #10363 : astrieanna/rust/fix-x86stdcall, r=huonw

* moved `extern` inside module
* changed `extern "stdcall"` to `extern "system"`
* changed `cfg(target_os="win32")` to `cfg(windows)`
* only run on Windows && x86, (not x86_64)
* updated copyright dates

Fix XFailed test x86stdcall

There was a syntax error because the `extern "stdcall"` was outside the module instead of inside it.

* moved `extern` inside module
* change `extern "stdcall"` to `extern "system"`
* change `cfg(target_os="win32")` to `cfg(windows)`
* updated copyright dates
* changed log(error, ...) => info!(....)
* added `pub` keyword to kernel32 functions

auto merge of #10533 : tautologico/rust/fixdocs, r=huonw

This fixes a number of bugs in the doc comments for a bunch of functions in libstd/iter.rs, mostly updating to use unwrap() instead of get() on options. Also fixes the docs for advance() (trait Iterator) which was not making sense, though if it is not useful anymore maybe it should be removed.

Fixed docs for advance() in Iterator trait

Fixed uses of get() to unwrap() in doc examples in std::iter

auto merge of #10511 : cmr/rust/addtests, r=huonw

Commit messages have all

Better error message when using vectors in statics

Closes #10487

Add a test for #6976

Closes #6976

auto merge of #10532 : dhodder/rust/master, r=alexcrichton

Hello.  This is just a tiny doc update -- I'm new here, so apologies if I'm doing it wrong.

auto merge of #10531 : TeXitoi/rust/mandelbrot-resurected, r=cmr

Changes:
* add licence;
* remove usage of libc and unsafe;
* use BufferedWriter to improve performance;
* use a DummyWriter to cancel binary output in test.

Add doc comment for extra::url::query_to_str

auto merge of #10523 : huonw/rust/10522, r=cmr

If any of the digits was one past the maximum (e.g. 10**9 for base 10),
then this wasn't detected correctly and so the length of the digit was
one more than expected, causing a very large allocation.

Fixes #10522.
Fixes #10288.

auto merge of #10518 : huonw/rust/6911, r=alexcrichton

Bringing it into line with the unused-variable one,

    fn main() {
        let mut _a = 1;
    }

will not warn that `_a` is never used mutably.

Fixes #6911.

auto merge of #10510 : chris-morgan/rust/fix-num_lit-grammar-in-the-reference-manaul, r=cmr

- Cause `0` to be considered a valid integer literal (it is).
- Add octal literals (missed from #10243).

I have *not* modified doc/po/rust.md.pot or doc/po/ja/rust.md.po at all;
they already seem to be out of date so it's easier to ignore them for
myself. I can update them if desired, of course.

Prettier long string breaking.