Fall out of the std::sync rewrite

std: Rewrite the `sync` module

This commit is a reimplementation of `std::sync` to be based on the
system-provided primitives wherever possible. The previous implementation was
fundamentally built on top of channels, and as part of the runtime reform it has
become clear that this is not the level of abstraction that the standard level
should be providing. This rewrite aims to provide as thin of a shim as possible
on top of the system primitives in order to make them safe.

The overall interface of the `std::sync` module has in general not changed, but
there are a few important distinctions, highlighted below:

* The condition variable type, `Condvar`, has been separated out of a `Mutex`.
  A condition variable is now an entirely separate type. This separation
  benefits users who only use one mutex, and provides a clearer distinction of
  who's responsible for managing condition variables (the application).

* All of `Condvar`, `Mutex`, and `RWLock` are now directly built on top of
  system primitives rather than using a custom implementation. The `Once`,
  `Barrier`, and `Semaphore` types are still built upon these abstractions of
  the system primitives.

* The `Condvar`, `Mutex`, and `RWLock` types all have a new static type and
  constant initializer corresponding to them. These are provided primarily for C
  FFI interoperation, but are often useful to otherwise simply have a global
  lock. The types, however, will leak memory unless `destroy()` is called on
  them, which is clearly documented.

* The `Condvar` implementation for an `RWLock` write lock has been removed. This
  may be added back in the future with a userspace implementation, but this
  commit is focused on exposing the system primitives first.

* The fundamental architecture of this design is to provide two separate layers.
  The first layer is that exposed by `sys_common` which is a cross-platform
  bare-metal abstraction of the system synchronization primitives. No attempt is
  made at making this layer safe, and it is quite unsafe to use! It is currently
  not exported as part of the API of the standard library, but the stabilization
  of the `sys` module will ensure that these will be exposed in time. The
  purpose of this layer is to provide the core cross-platform abstractions if
  necessary to implementors.

  The second layer is the layer provided by `std::sync` which is intended to be
  the thinnest possible layer on top of `sys_common` which is entirely safe to
  use. There are a few concerns which need to be addressed when making these
  system primitives safe:

    * Once used, the OS primitives can never be **moved**. This means that they
      essentially need to have a stable address. The static primitives use
      `&'static self` to enforce this, and the non-static primitives all use a
      `Box` to provide this guarantee.

    * Poisoning is leveraged to ensure that invalid data is not accessible from
      other tasks after one has panicked.

  In addition to these overall blanket safety limitations, each primitive has a
  few restrictions of its own:

    * Mutexes and rwlocks can only be unlocked from the same thread that they
      were locked by. This is achieved through RAII lock guards which cannot be
      sent across threads.

    * Mutexes and rwlocks can only be unlocked if they were previously locked.
      This is achieved by not exposing an unlocking method.

    * A condition variable can only be waited on with a locked mutex. This is
      achieved by requiring a `MutexGuard` in the `wait()` method.

    * A condition variable cannot be used concurrently with more than one mutex.
      This is guaranteed by dynamically binding a condition variable to
      precisely one mutex for its entire lifecycle. This restriction may be able
      to be relaxed in the future (a mutex is unbound when no threads are
      waiting on the condvar), but for now it is sufficient to guarantee safety.

* Condvars now support timeouts for their blocking operations. The
  implementation for these operations is provided by the system.

Due to the modification of the `Condvar` API, removal of the `std::sync::mutex`
API, and reimplementation, this is a breaking change. Most code should be fairly
easy to port using the examples in the documentation of these primitives.

[breaking-change]

Closes #17094
Closes #18003

auto merge of #19303 : nodakai/rust/libsyntax-reject-dirs, r=alexcrichton

On *BSD systems, we can `open(2)` a directory and directly `read(2)` from it due to an old tradition.  We should avoid doing so by explicitly calling `fstat(2)` to check the type of the opened file.

Opening a directory as a module file can't always be avoided.  Even when there's no "path" attribute trick involved, there can always be a *directory* named `my_module.rs`.

Incidentally, remove unnecessary mutability of `&self` from `io::fs::File::stat()`.

auto merge of #18980 : erickt/rust/reader, r=erickt

This continues the work @thestinger started in #18885 (which hasn't landed yet, so wait for that to land before landing this one). Instead of adding more methods to `BufReader`, this just allows a `&[u8]` to be used directly as a `Reader`. It also adds an impl of `Writer` for `&mut [u8]`.

core: fix a doctest

auto merge of #19170 : erickt/rust/rustup, r=erickt

This closes #19168.

Please be careful reviewing this since this gets used all over the place. I've tested all the options and everything appears to be working though.

auto merge of #19167 : japaric/rust/rhs-cmp, r=aturon

Comparison traits have gained an `Rhs` input parameter that defaults to `Self`. And now the comparison operators can be overloaded to work between different types. In particular, this PR allows the following operations (and their commutative versions):

- `&str` == `String` == `CowString`
- `&[A]` == `&mut [B]` == `Vec<C>` == `CowVec<D>` == `[E, ..N]` (for `N` up to 32)
- `&mut A` == `&B` (for `Sized` `A` and `B`)

Where `A`, `B`, `C`, `D`, `E` may be different types that implement `PartialEq`. For example, these comparisons are now valid: `string == "foo"`, and `vec_of_strings == ["Hello", "world"]`.

[breaking-change]s

Since the `==` may now work on different types, operations that relied on the old "same type restriction" to drive type inference, will need to be type annotated. These are the most common fallout cases:

- `some_vec == some_iter.collect()`: `collect` needs to be type annotated: `collect::<Vec<_>>()`
- `slice == &[a, b, c]`: RHS doesn't get coerced to an slice, use an array instead `[a, b, c]`
- `lhs == []`: Change expression to `lhs.is_empty()`
- `lhs == some_generic_function()`: Type annotate the RHS as necessary

cc #19148

r? @aturon

auto merge of #19449 : nikomatsakis/rust/unboxed-closure-fn-impl, r=pcwalton

Implement the `Fn` trait for bare fn pointers in the compiler rather
than doing it using hard-coded impls. This means that it works also
for more complex fn types involving bound regions.

Adjust nits from pcwalton.

Add a cache so we don't create so many shims.

Implement the `Fn` trait for bare fn pointers in the compiler rather than doing it using hard-coded impls. This means that it works also for more complex fn types involving bound regions. Fixes #19126.

auto merge of #18613 : steveklabnik/rust/ownership_guide, r=huonw

This is a work in progress, but this should get *extensive* review, so I'm putting it up early and often.

This is the start of a draft of the new 'ownership guide,' which explains ownership, borrowing, etc. I'm feeling better about this framing than last time's, but we'll see.

libstd: explicitly disallow io::fs::File to open a directory.

On *BSD systems, we can open(2) a directory and directly read(2) from
it due to an old tradition.  We should avoid doing so by explicitly
calling fstat(2) to check the type of the opened file.

Opening a directory as a module file can't always be avoided.
Even when there's no "path" attribute trick involved, there can always
be a *directory* named "my_module.rs".

Fix #12460

Signed-off-by: NODA, Kai <nodakai@gmail.com>

libstd: io::fs::File::stat() need not to take &mut self.

The same goes for sys::fs::FileDesc::fstat() on Windows.

Signed-off-by: NODA, Kai <nodakai@gmail.com>

auto merge of #18770 : pczarn/rust/hash_map-explicit-shrinking, r=Gankro

Part of enforcing capacity-related conventions, for #18424, the collections reform.

Implements `fn shrink_to_fit` for HashMap.
The `reserve` method now takes as an argument the *extra* space to reserve.

rustup: simplify downloading packages

rustup: extract the tarballs as part of installation

rustup: rewrite to protect against truncation

This closes #19168. It's possible that if the downloading of `rustup.sh`
is interrupted, bad things could happen, such as running a naked
"rm -rf /" instead of "rm -rf /path/to/tmpdir". This wraps rustup.sh's
functionality in a function that gets called at the last time that should
protect us from these truncation errors.

rustup: factor out installing packages into a function

rustup: factor out downloading and extracting the snapshot tarballs

auto merge of #18749 : nikomatsakis/rust/builtin-bounds-like-other-traits, r=pcwalton

Treat builtin bounds like all other kinds of trait matches. Introduce a simple hashset in the fulfillment context to catch cases where we register the exact same obligation twice. This helps prevent duplicate error reports but also handles the recursive obligations created by builtin bounds.

r? @pcwalton
cc @FlaPer87

rustup: factor out the install flags into a CFG_INSTALL_FLAGS variable

rustup: rename TMP_DIR to CFG_TMP_DIR

rustup: add a RUST_ prefix to the rust-specific variables

rustup: probe for the existance of tar

rustup: make rustup executable

whitespace cleanup

auto merge of #19502 : alexcrichton/rust/issue-19501, r=sfackler

I don't have enough time to investigate this thoroughly, so for now let's get
the queue moving by ignoring this test.

cc #19501

test: Ignore issue-19501 pretty for now

I don't have enough time to investigate this thoroughly, so for now let's get
the queue moving by ignoring this test.

cc #19501

Deprecate Equiv

Fix fallout

Remove unused transmutes from tests

Replace `equiv` method calls with `==` operator sugar

Overload the `==` operator

- String == &str == CowString
- Vec ==  &[T] ==  &mut [T] == [T, ..N] == CowVec
- InternedString == &str

New Guide: Ownership

This replaces the previous "Lifetimes guide," since we are discussing
things from an owernship perspective now.

FIXME(#19481) -- workaround valgrind cleanup failure (but the code is nicer this way anyhow)

Correct various compile-fail tests. Most of the changes are because we
now don't print duplicate errors within one context, so I sometimes
had to break functions into two functions.

Treat builtin bounds like all other kinds of trait matches. Introduce a simple hashset in the fulfillment context to catch cases where we register the exact same obligation twice. This helps prevent duplicate error reports but also handles the recursive obligations created by builtin bounds.

Test PartialEq multidispatch

libcore: add `Rhs` input parameter to comparison traits

auto merge of #19460 : steveklabnik/rust/conf_fixes, r=alexcrichton

remove two unneccesary directories from configure

auto merge of #19443 : nodakai/rust/another-missing-extracflags, r=alexcrichton

rust-lang/rust@102b1a5bf1a60eeafb752844e5c98fe5f4e3b992 was not enough!

auto merge of #19357 : michaelwoerister/rust/fix-issue-18791, r=alexcrichton

One negative side-effect of this change is that there might be quite a bit of copying strings out of the codemap, i.e. one copy for every block that gets translated, just for taking a look at the last character of the block. If this turns out to cause a performance problem then `CodeMap::span_to_snippet()` could be changed return `Option<&str>` instead of `Option<String>`.

Fixes #18791

auto merge of #19427 : scialex/rust/doc-attr-macros, r=sfackler

this allows one to, for example, use #[doc = $macro_var ] in macros.

auto merge of #19450 : jbapple/rust/pq-pop-time, r=Gankro

pop calls siftdown, siftdown calls siftdown_range, and siftdown_range
loops on an index that can start as low as 0 and approximately doubles
each iteration.

Pop on binary heaps does not have constant time complexity.

pop calls siftdown, siftdown calls siftdown_range, and siftdown_range
loops on an index that can start as low as 0 and approximately doubles
each iteration.

debuginfo: Fix multi-byte character related bug in cleanup scope handling.

Also see issue #18791.

auto merge of #19439 : nodakai/rust/liblibc-getsid, r=acrichto

```
#include <unistd.h>

pid_t getsid(pid_t pid);

CONFORMING TO
       SVr4, POSIX.1-2001.
```

auto merge of #19405 : jfager/rust/de-match-pyramid, r=bstrie

No semantic changes, no enabling `if let` where it wasn't already enabled.

test/run-make: another missing $(EXTRACFLAGS).

rust-lang/rust@102b1a5bf1a60eeafb752844e5c98fe5f4e3b992 was not enough!

Signed-off-by: NODA, Kai <nodakai@gmail.com>

liblibc: getsid() was missing though setsid() was already there.

include <unistd.h>

pid_t getsid(pid_t pid);

CONFORMING TO
       SVr4, POSIX.1-2001.

Signed-off-by: NODA, Kai <nodakai@gmail.com>

auto merge of #19436 : lifthrasiir/rust/rustdoc-short-src-paths, r=alexcrichton

Before: `doc/src/collections/home/lifthrasiir/git/rust/src/libcollections/vec.rs.html`
After: `doc/src/collections/vec.rs.html`

If the source code is in the parent dirs relative to the crate root, `..` is replaced with `up` as expected. Any other error like non-UTF-8 paths or drive-relative paths falls back to the absolute path.

There might be a way to improve on false negatives, but this alone should be enough for fixing #18370.

added negative test for macro expansion in attributes

rustdoc: Use relative paths in source renders.

Before: doc/src/collections/home/lifthrasiir/git/rust/src/libcollections/vec.rs.html
After: doc/src/collections/vec.rs.html

If the source code is in the parent dirs relative to the crate root,
`..` is replaced with `up` as expected. Any other error like non-UTF-8
paths or drive-relative paths falls back to the absolute path.

There might be a way to improve on false negatives, but this alone
should be enough for fixing #18370.

auto merge of #19417 : alexcrichton/rust/issue-19383, r=huonw

We only build LLVM for the host architecture, not the target architecture, so
this was just a minor typo in the parameters uses.

Closes #19383

auto merge of #19425 : frewsxcv/rust/patch-1, r=steveklabnik


Add test for expanding doc strings in macros.

auto merge of #19418 : P1start/rust/unsafe-extern-trait, r=alexcrichton

Fixes #19398.

std: add Reader impl for &[u8]

std: add tests for the Vec<u8> Writer impl

fix missed switch pointed out in review plus a few others

std: Change the behavior of `reserve` for HashMap.

HashMap's `reserve` method now takes as an argument the *extra* space
to reserve.

[breaking-change]

std: Remove implicit shrinking from hash_map.

Implements fn shrink_to_fit for HashMap.

auto merge of #19415 : P1start/rust/error-message-fixes, r=alexcrichton

This is the style followed by most other error messages.

auto merge of #19411 : lifthrasiir/rust/asm-clobbers-expanded, r=alexcrichton

I.e. we should not prematurely build operand constraints at the expansion time. Otherwise `--pretty expanded` diverges:

```
$ cat t.rs
#![feature(asm)]

pub fn main() { unsafe { asm!("" : : : "hello", "world") }; }

$ rustc t.rs --pretty
#![feature(asm)]

pub fn main() { unsafe { asm!("" : : : "hello" , "world") }; }

$ rustc t.rs --pretty expanded
#![feature(asm)]
#![feature(phase)]
#![no_std]
#![feature(globs)]
#[phase(plugin, link)]
extern crate "std" as std;
#[prelude_import]
use std::prelude::*;

pub fn main() { unsafe { asm!("":  :  : "~{hello},~{world}") }; }
```

(The last code *does* compile, but won't do the expected thing.)

allow macro expansions in attributes

Fix typo in tests makefile

auto merge of #19369 : seanmonstar/rust/cow-str, r=alexcrichton

This implementation existed on MaybeOwned, but has been lost in the
transition to Cows. Let's put it back.

@aturon r?

trans: Eliminated redundant allocations.

Fix the ordering of `unsafe` and `extern` in methods

This breaks code that looks like this:

    trait Foo {
        extern "C" unsafe fn foo();
    }

    impl Foo for Bar {
        extern "C" unsafe fn foo() { ... }
    }

Change such code to look like this:

    trait Foo {
        unsafe extern "C" fn foo();
    }

    impl Foo for Bar {
        unsafe extern "C" fn foo() { ... }
    }

Fixes #19398.

[breaking-change]

mk: Use host llvm linkage paths, not target ones

We only build LLVM for the host architecture, not the target architecture, so
this was just a minor typo in the parameters uses.

Closes #19383

Adjust some error messages to start with a lowercase letter and not finish with a full stop

auto merge of #19365 : frewsxcv/rust/getopts-cleanup, r=alexcrichton

* Remove public reexports, as a part of #19253
* Rename getopts::Fail_ to getopts::Fail
 * Didn't see a reason for the suffixed '_'
* Removed getopts::FailType
 * Looked like it was only beings used for tests; refactored the tests
   to stop requiring it
* A few other non-breaking trivial refactoring changes

[breaking-change]

syntax: Make `asm!` clobbers a proper vector.

Otherwise `--pretty expanded` diverges.

auto merge of #19392 : murarth/rust/rustc-compile-twice, r=nick29581

Closes #19371

Replace some verbose match statements with their `if let` equivalent.

No semantic changes, no enabling `if let` where it wasn't already enabled.

auto merge of #19401 : MatejLach/rust/guide_are_fix, r=steveklabnik

Fixes a small omission of `are` in the sentence:
`There also a few things you can do with a tuple as a whole, without...`
r @steveklabnik?

Fix rustc panic on second compile_input

Fix a simple typo

auto merge of #19345 : steveklabnik/rust/gh19344, r=alexcrichton

Fixes #19344

reword faq to remove reference to indexing strings

Fixes #19344

auto merge of #19366 : liigo/rust/mipsel-linux, r=alexcrichton

Since #19076 was merged, I believe mipsel + linux maybe need add to the list here, too.

auto merge of #19363 : michaelwoerister/rust/support-unboxed-closures, r=alexcrichton

This PR lets `rustc` generate debuginfo for variables captured by unboxed closures.

Fixes #19356

@nikomatsakis This PR will probably conflict with #19338. If this gets merged before, you should be able to just leave the test case as it is (maybe remove the `#![feature(unboxed_closures)]` directive).

auto merge of #19360 : olivren/rust/master, r=Gankro

The previous code was giving an incorrect result (not x/3).

Also, this function does not work with signed integers. It now accepts `u32` instead of `i32`.

impl Str for CowString

This implementation existed on MaybeOwned, but has been lost in the
transition to Cows. Let's put it back.

auto merge of #19355 : vhbit/rust/ios-backtrace-fix, r=alexcrichton

librustrt: stack_overflow support mipsel linux

auto merge of #19354 : barosl/rust/strconv-doc-fix, r=steveklabnik

- `int_to_str_bytes_common()` doesn't have a return value.
- `float_to_str_bytes_common()` has an old-style doc comment.

auto merge of #19349 : tomjakubowski/rust/rustdoc-struct-variant-vis, r=sfackler

Teach rustdoc that struct variant fields have inherited visibility.

Fix #19048

getopts: cleanup, renames, remove reexports

* Remove public reexports, as a part of #19253
* Rename getopts::Fail_ to getopts::Fail
 * Didn't see a reason for the suffixed '_'
* Removed getopts::FailType
 * Looked like it was only beings used for tests; refactored the tests
   to stop requiring it
* A few other non-breaking trivial refactoring changes

[breaking-change]

auto merge of #19112 : steveklabnik/rust/doc_rc, r=Gankro

debuginfo: Make variables captured in unboxed closures available in debuginfo.

Fix example code for unreachable!

The previous code was giving an incorrect result (not x/3).

auto merge of #19348 : SimonSapin/rust/patch-9, r=huonw

Fixed iOS build after Iter stab

Documentation fix for std::num::strconv

- int_to_str_bytes_common() doesn't have a return value.
- float_to_str_bytes_common() has an old-style doc comment.

auto merge of #19343 : sfackler/rust/less-special-attrs, r=alexcrichton

Descriptions and licenses are handled by Cargo now, so there's no reason
to keep these attributes around.

auto merge of #19342 : alexcrichton/rust/rollup, r=alexcrichton

More test fixes and rebase conflicts!