Add ToCStr method .with_c_str()

.with_c_str() is a replacement for the old .as_c_str(), to avoid
unnecessary boilerplate.

Replace all usages of .to_c_str().with_ref() with .with_c_str().

Check for interior nulls in .to_c_str()

Previous dicussions about CString suggested that interior nulls should
throw an error. This was never implemented. Add this now, using a
condition (named null_byte) to allow for recovery.

Add method .to_c_str_unchecked() that skips this check.

Clarify docs on CString.unwrap()

CString.unwrap() drops ownership of the buffer on the floor. Put this in
the docs.

auto merge of #8452 : Kimundi/rust/stuff02, r=bstrie

- Methodyfied the string ascii extionsion functions - They got added recently, I wrapped them in a trait.
- Added `into_owned()` method for vectors - similar to `Str`'s `into_owned()` function, allows to convert to a owned vector without making a copy if the source is a owned vector.
- Added `or_some` method to option - similar to `unwrap_or_default`, but keeps the values wrapped in an `Option`. Useful for `Option` chains, eg Iterator impls.
- Added `DoubleEndedIterator` impl to `Option` - Just for compatibility with generic Iterator functions.
- Renamed nil.rs to unit.rs - the type got renamed ages ago, it's time the source file is as well.

auto merge of #8453 : dmanescu/rust/8451, r=cmr

I'm not sure that the supplied tests are suitable.

Methodyfied the string ascii extionsion functions
Added into_owned() method for vectors
Added DoubleEnded Iterator impl to Option
Renamed nil.rs to unit.rs

auto merge of #8440 : sfackler/rust/env-fix, r=pcwalton

The type of the result of option_env! was not fully specified in the
None case, leading to type check failures in the case where the variable
was not defined (e.g. option_env!("FOO").is_none()).

Also cleaned up some compilation warnings.

auto merge of #8439 : huonw/rust/hashset-clone, r=cmr

Closes #5581.

auto merge of #8477 : catamorphism/rust/issue-4096, r=msullivan

r? @msullivan ...e parameters

In this case, it's likely to be that the user forgot the `self` type, so
say so.

Closes #4096

auto merge of #8497 : nikomatsakis/rust/improvements-to-object-coercion, r=pcwalton

While looking over the code for object coercion, I realized that it wasn't quite handling freezing and reborrowing correctly. Tweak the code, adding tests for the relevant cases.

r? @pcwalton

auto merge of #8446 : alexcrichton/rust/ifmt++, r=graydon

This includes a number of improvements to `ifmt!`

* Implements formatting arguments -- `{:0.5x}` works now
* Formatting now works on all integer widths, not just `int` and `uint`
* Added a large doc block to `std::fmt` which should help explain what `ifmt!` is all about
* Added floating point formatters, although they have the same pitfalls from before (they're just proof-of-concept now)

Closed a couple of issues along the way, yay! Once this gets into a snapshot, I'll start looking into removing all of `fmt`

Add `f` formats to `ifmt!`

Currently the work just the same as the old `extfmt` versions

auto merge of #8329 : michaelwoerister/rust/lexical_scopes_alt, r=graydon

This pull request re-implements handling of visibility scopes and source code positions in debug info. It should now be very stable and properly handle

+ variable shadowing
+ expanded code (macros and the new for-loop de-sugaring, for example)
+ variables in the middle of nested scopes
+ bindings declared in the head of match statement arms.

all of which did not work at all or did not work reliably before. Those interested in a more detailed description of the problems at hand, I kindly refer to http://michaelwoerister.github.io/2013/08/03/visibility-scopes.html

Why doesn't the `populate_scope_map()` function use `syntax::visit`?
Because it would not improve this particular AST walker (see: https://github.com/michaelwoerister/rust/commit/69dc7908490b8b492e9730cb1c34fa83c2ef30eb#commitcomment-3781426)

Cheers,
Michael

auto merge of #8475 : kmcallister/rust/stack_segment, r=brson,brson

Servo needs to tell SpiderMonkey about the stack bounds.

r? @brson

Merge pull request #8432 from chris-morgan/remove-assert-eq-macro-fail-binary

Remove in-tree test binary.

Reborrow even when passing &Object to &Object, so as to permit freezing

Fix freezing of @mut Objects when passing as argument

Make rt::stack public

Fixes #8478.

auto merge of #8423 : alexcrichton/rust/less-priv-again, r=bstrie

Closes #5495

auto merge of #8411 : bblum/rust/assorted-fixes, r=brson

Each commit is pretty much what it says on the tin. r anybody.

auto merge of #7866 : sstewartgallus/rust/clean, r=cmr

Mostly I did simple transformations from imperative style loops to
more functional iterator based transformations.

debuginfo: Add some tests for visibiliy scopes within closures.

debuginfo: Add support for argument shadowing.

debuginfo: Implemented proper handling of lexical scopes and variable shadowing.

auto merge of #8487 : brson/rust/local-opts, r=brson

I did this once but acciddentally undid it in a later patch.

Forbid pub/priv where it has no effect

Closes #5495

Explain what ifmt! is all about

Correct the padding on integer types for formatting

Define integer formats for all widths

Closes #1653

Implement formatting arguments for strings and integers

Closes #1651

std: Re-optimize tls access on local allocation path

I did this once but acciddentally undid it in a later patch.

auto merge of #8476 : thestinger/rust/snapshot, r=brson

auto merge of #8450 : alexcrichton/rust/nopt-changes, r=graydon

Since the new runtime landed, the *-nopt builders have increased cycle time by roughly an hour. I have a feeling that this is because the entire runtime is in rust and it's not being optimized at all. In that past with an optimized C++ runtime it looks like things ran faster.

This adds the ability to disable optimizations in tests only, not for the entire compiler. This means that the entire compiler and associated libraries will be built with optimizations, but the tests themselves would be built and run without optimizations.

This isn't quite as good of a guarantee as disabling optimizations everywhere, but hopefully it'll improve cycle time for the *-nopt builds to move the queue along faster.

auto merge of #8419 : cmr/rust/fix-rtdebug, r=brson

It now actually does logging, and is compiled out when `--cfg rtdebug` is not
given to the libstd build, which it isn't by default. This makes the rt
benchmarks 18-50% faster.

rustc: Give a hint when a static method call has fewer than expected type parameters

In this case, it's likely to be that the user forgot the `self` type, so
say so.

Closes #4096

fix build with the new snapshot compiler

register snapshots

rt::task: Make current_stack_segment public

Servo needs to tell SpiderMonkey about the stack bounds.

Clean up transitionary glue in task/spawn.rs. Don't hold kill-little-lock for O(n) time, cf #3100, and optimize out several unneeded clone()s.

auto merge of #8400 : blake2-ppc/rust/seq-ord, r=cmr

Use Eq + Ord for lexicographical ordering of sequences.

For each of <, <=, >= or > as R, use::

    [x, ..xs] R [y, ..ys]  =  if x != y { x R y } else { xs R ys }

Previous code using `a < b` and then `!(b < a)` for short-circuiting
fails on cases such as  [1.0, 2.0] < [0.0/0.0, 3.0], where the first
element was effectively considered equal.

Containers like &[T] did also implement only one comparison operator `<`,
and derived the comparison results from this. This isn't correct either for
Ord.

Implement functions in `std::iterator::order::{lt,le,gt,ge,equal,cmp}` that all
iterable containers can use for lexical order.

We also visit tuple ordering, having the same problem and same solution
(but differing implementation).

Fix select() in light of the deschedule...and then race. Close #8347.

Make cell with_ref/with_mut_ref use finally. Close #7975.

Reorganise Select traits to not expose internal runtime types. Close #5160. Pending #8215.

Don't use unkillable in UnsafeArc dtor when there's no unwrapper. Close #8382.

auto merge of #8429 : catamorphism/rust/rustpkg-docs, r=catamorphism

auto merge of #8428 : blake2-ppc/rust/peekable-iterators, r=thestinger

Peekable changes by @SimonSapin and original PR is #8396

auto merge of #8418 : pnkfelix/rust/fsk-issue3192-improve-parse-error-for-empty-struct-init, r=pcwalton,me

Fix #3192.  r? anyone

There are 4 different new tests, to check some different scenarios for
what the parse context is at the time of recovery, becasue our
compile-fail infrastructure does not appear to handle verifying
error-recovery situations.

Differentiate between unit-like struct definition item and unit-like
struct construction in the error message.

----

More generally, outlines a more generic strategy for parse error
recovery: By committing to an expression/statement at set points in
the parser, we can then do some look-ahead to catch common mistakes
and skip over them.

One detail about this strategy is that you want to avoid emitting the
"helpful" message unless the input is reasonably close to the case of
interest.  (E.g. do not warn about a potential unit struct for an
input of the form `let hmm = do foo { } { };`)

To accomplish this, I added (partial) last_token tracking; used for
`commit_stmt` support.

The check_for_erroneous_unit_struct_expecting fn returns bool to
signal whether it "made progress"; currently unused; this is meant for
use to compose several such recovery checks together in a loop.

auto merge of #8410 : luqmana/rust/mcpu, r=sanxiyn

Adds `--target-cpu` flag which lets you choose a more specific target cpu instead of just passing the default, `generic`. It's more or less akin to `-mcpu`/`-mtune` in clang/gcc.

auto merge of #8427 : brson/rust/rustc-stack, r=thestinger

A lot of people are hitting stack overflows in rustc. This will make it
easier to experiment with stack size.

Cleanup librustpkg a little bit.

Mostly I did simple transformations from imperative style loops to
more functional iterator based transformations.

Fixed option_env! type

The type of the result of option_env! was not fully specified in the
None case, leading to type check failures in the case where the variable
was not defined (e.g. option_env!("FOO").is_none()).

auto merge of #8455 : nikomatsakis/rust/issue-5762-objects-dralston-d, r=graydon

Fix #5762 and various other aspects of object invocation.

r? @graydon

Convert from transform to map

tests: Add new tests for borrowck/objects and update some existing tests

Update type visitor to use &Visitor and not @Visitor

borrowck: Integrate AutoBorrowObj into borrowck / mem_categorization

Also cleanup the treatment of mutability in mem_categorization, which still
included the concept of interior mutability. At some point, we should
refactor the types to exclude the possibility of interior mutability rather
than just ignoring the mutability value in those cases.

typeck: Modify method resolution to use new object adjustments, and
to favor inherent methods over extension methods.

The reason to favor inherent methods is that otherwise an impl
like

    impl Foo for @Foo { fn method(&self) { self.method() } }

causes infinite recursion.  The current change to favor inherent methods is
rather hacky; the method resolution code is in need of a refactoring.

trans: Rely on new AutoBorrowObj adjustment to match up object receivers

Note: some portions of this commit written by @Sodel-the-Vociferous
(Daniel Ralston)

ty: Add (but do not yet use) AutoBorrowObject option to adjustments

Note: some portions of this commit written by @Sodel-the-Vociferous
(Daniel Ralston)

typeck/check/method: Remove `pub` from most methods

Misc small cleanups

Add a field `borrow_offset` to the type descriptor indicating
what amount a T* pointer must be adjusted to reach the contents
of the box. For `~T` types, this requires knowing the type `T`,
which is not known in the case of objects.

auto merge of #8420 : blake2-ppc/rust/shrink-token, r=cmr

`enum Token` was 192 bytes (64-bit), as pointed out by pnkfelix; the only
bloating variant being `INTERPOLATED(nonterminal)`.

Updating `enum nonterminal` to use ~ where variants included big types,
shrunk size_of(Token) to 32 bytes (64-bit).

I am unsure if the `nt_ident` variant should have an indirection, with
ast::ident being only 16 bytes (64-bit), but without this, enum Token
would be 40 bytes.

A dumb benchmark says that compilation time is unchanged, while peak
memory usage for compiling std.rs is down 3%

Before::

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc --cfg stage1 src/libstd/std.rs
    19.00user 0.39system 0:19.41elapsed 99%CPU (0avgtext+0avgdata 627820maxresident)k
    0inputs+28896outputs (0major+228665minor)pagefaults 0swaps
    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc -O --cfg stage1 src/libstd/std.rs
    31.64user 0.34system 0:32.02elapsed 99%CPU (0avgtext+0avgdata 629876maxresident)k
    0inputs+22432outputs (0major+229411minor)pagefaults 0swaps

After::

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc --cfg stage1 src/libstd/std.rs
    19.07user 0.45system 0:19.55elapsed 99%CPU (0avgtext+0avgdata 609384maxresident)k
    0inputs+28896outputs (0major+221997minor)pagefaults 0swaps

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc -O --cfg stage1 src/libstd/std.rs
    31.90user 0.34system 0:32.28elapsed 99%CPU (0avgtext+0avgdata 612080maxresident)k
    0inputs+22432outputs (0major+223726minor)pagefaults 0swaps

librustc: Convert from `@Object` to `@mut Object` as needed

libsyntax: Update from `@Object` to `@mut Object` as required

Fixed #8451 - extra::stats::write_boxplot() applied to negative or zero sample values

auto merge of #8421 : alexcrichton/rust/unnamed-addr, r=thestinger

This can be applied to statics and it will indicate that LLVM will attempt to
merge the constant in .data with other statics.

I have preliminarily applied this to all of the statics generated by the new
`ifmt!` syntax extension. I compiled a file with 1000 calls to `ifmt!` and a
separate file with 1000 calls to `fmt!` to compare the sizes, and the results
were:

```
fmt           310k
ifmt (before) 529k
ifmt (after)  202k
```

This now means that ifmt! is both faster and smaller than fmt!, yay!

auto merge of #8412 : thestinger/rust/vector-add, r=alexcrichton

auto merge of #8408 : thestinger/rust/checked, r=Aatch

Allow disabling optimizations in tests only

fix unused imports

move `strdup_uniq` lang item to std::str

str: optimize `with_capacity`

before:

test bench_with_capacity ... bench: 104 ns/iter (+/- 4)

after:

test bench_with_capacity ... bench: 56 ns/iter (+/- 1)

vec: optimize the Add implementation

before:

test add ... bench: 164 ns/iter (+/- 1)

after:

test add ... bench: 113 ns/iter (+/- 2)

disable 64-bit CheckedMul on 32-bit

code generation problem reported as issue #8449

add intrinsics for checked overflow add/sub/mul

syntax: Shrink enum Token and enum nonterminal

`enum Token` was 192 bytes (64-bit), as pointed out by pnkfelix; the only
bloating variant being `INTERPOLATED(nonterminal)`.

Updating `enum nonterminal` to use ~ where variants included big types,
shrunk size_of(Token) to 32 bytes (64-bit).

I am unsure if the `nt_ident` variant should have an indirection, with
ast::ident being only 16 bytes (64-bit), but without this, enum Token
would be 40 bytes.

A dumb benchmark says that compilation time is unchanged, while peak
memory usage for compiling std.rs is down 3%

Before::

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc --cfg stage1 src/libstd/std.rs
    19.00user 0.39system 0:19.41elapsed 99%CPU (0avgtext+0avgdata 627820maxresident)k
    0inputs+28896outputs (0major+228665minor)pagefaults 0swaps
    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc -O --cfg stage1 src/libstd/std.rs
    31.64user 0.34system 0:32.02elapsed 99%CPU (0avgtext+0avgdata 629876maxresident)k
    0inputs+22432outputs (0major+229411minor)pagefaults 0swaps

After::

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc --cfg stage1 src/libstd/std.rs
    19.07user 0.45system 0:19.55elapsed 99%CPU (0avgtext+0avgdata 609384maxresident)k
    0inputs+28896outputs (0major+221997minor)pagefaults 0swaps

    $ time ./x86_64-unknown-linux-gnu/stage1/bin/rustc -O --cfg stage1 src/libstd/std.rs
    31.90user 0.34system 0:32.28elapsed 99%CPU (0avgtext+0avgdata 612080maxresident)k
    0inputs+22432outputs (0major+223726minor)pagefaults 0swaps

auto merge of #8404 : stepancheg/rust/zero-unit-inline, r=alexcrichton

Follow-up to #8155

extra::treemap: Use IteratorUtil::peekable

Replace the previous equivalent iterator adaptor with .peekable().
Refactor the set operation iterators so that they are easier to read.

Add a "peekable" iterator adaptor, with a peek() method that returns the next element.

std::iterator: Rename .peek() to .inspect()

auto merge of #8444 : erickt/rust/rollup, r=cmr

This merges these PR together:

#8430: r=thestinger
#8370: r=thestinger
#8386: r=bstrie
#8388: r=thestinger
#8390: r=graydon
#8394: r=graydon
#8402: r=thestinger
#8403: r=catamorphism

rustc: Add --target-cpu flag to select a more specific processor instead of the default, 'generic'.

auto merge of #8430 : erickt/rust/cleanup-iterators, r=erickt

This PR does a bunch of cleaning up of various APIs. The major one is that it merges `Iterator` and `IteratorUtil`, and renames functions like `transform` into `map`. I also merged `DoubleEndedIterator` and `DoubleEndedIteratorUtil`, as well as I renamed various .consume* functions to .move_iter(). This helps to implement part of #7887.

Merge branch 'match' of https://github.com/msullivan/rust into rollup

Merge branch 'master' of https://github.com/MAnyKey/rust into rollup

Merge branch 'issue-8393-attributes-in-macros' of https://github.com/nikomatsakis/rust into rollup

Merge branch 'master' of https://github.com/p2j4d2c/rust into rollup

Merge branch 'trie-bound-iters' of https://github.com/dim-an/rust into rollup

Merge branch 'vec-exh' of https://github.com/stepancheg/rust into rollup

Merge branch 'enum-method-privacy' of https://github.com/michaelwoerister/rust into rollup

Conflicts:
src/libsyntax/opt_vec.rs

Merge remote-tracking branch 'remotes/origin/master' into cleanup-iterators

auto merge of #8327 : sstewartgallus/rust/factor_out_waitqueue, r=bblum

I'm a bit disappointed that I couldn't figure out how to factor out more of the code implementing `extra::sync` but I feel this is an okay start. Also I added some documentation explaining that `WaitQueue` isn't thread safe, and needs an exclusive lock.

@bblum

syntax and rustc: fix some warnings

std: fix the non-stage0 str::raw::slice_bytes which broke in a merge

std: Transform.find_ -> .find

std: Iterator.len_ -> .len

std: Iterator.last_ -> .last

std: Iterator.chain_ -> .chain

std: Iterator.flat_map_ -> .flat_map