rustc: Convert statics to constants

rustrt: Convert statics to constants

serialize: Convert statics to constants

syntax: Convert statics to constants

native: Convert statics to constants

log: Convert statics to constants

regex: Convert statics to constants

This require a bit of finesse to work around the changes with libunicode, but
nothing too major!

alloc: Convert statics to constants

term: Convert statics to constants

std: Convert statics to constants

This commit repurposes most statics as constants in the standard library itself,
with the exception of TLS keys which precisely have their own memory location as
an implementation detail.

This commit also rewrites the bitflags syntax to use `const` instead of
`static`. All invocations will need to replace the word `static` with `const`
when declaring flags.

Due to the modification of the `bitflags!` syntax, this is a:

[breaking-change]

rand: Convert statics to constants

This leaves the ziggurat tables as `pub static` as they're likely too large to
want to go into the metadata anyway.

libc: Convert all statics to constant

This crate is largely just one giant header file, so there's no need for any of
these values to actually have a memory location, they're all just basically a
regular #define.

collections: Convert statics to constants

unicode: Make statics legal

The tables in libunicode are far too large to want to be inlined into any other
program, so these tables are all going to remain `static`. For them to be legal,
they cannot reference one another by value, but instead use references now.

This commit also modifies the src/etc/unicode.py script to generate the right
tables.

sync: Convert statics to constants

core: Convert statics to constants

rustc: Add `const` globals to the language

This change is an implementation of [RFC 69][rfc] which adds a third kind of
global to the language, `const`. This global is most similar to what the old
`static` was, and if you're unsure about what to use then you should use a
`const`.

The semantics of these three kinds of globals are:

* A `const` does not represent a memory location, but only a value. Constants
  are translated as rvalues, which means that their values are directly inlined
  at usage location (similar to a #define in C/C++). Constant values are, well,
  constant, and can not be modified. Any "modification" is actually a
  modification to a local value on the stack rather than the actual constant
  itself.

  Almost all values are allowed inside constants, whether they have interior
  mutability or not. There are a few minor restrictions listed in the RFC, but
  they should in general not come up too often.

* A `static` now always represents a memory location (unconditionally). Any
  references to the same `static` are actually a reference to the same memory
  location. Only values whose types ascribe to `Sync` are allowed in a `static`.
  This restriction is in place because many threads may access a `static`
  concurrently. Lifting this restriction (and allowing unsafe access) is a
  future extension not implemented at this time.

* A `static mut` continues to always represent a memory location. All references
  to a `static mut` continue to be `unsafe`.

This is a large breaking change, and many programs will need to be updated
accordingly. A summary of the breaking changes is:

* Statics may no longer be used in patterns. Statics now always represent a
  memory location, which can sometimes be modified. To fix code, repurpose the
  matched-on-`static` to a `const`.

      static FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

  change this code to:

      const FOO: uint = 4;
      match n {
          FOO => { /* ... */ }
          _ => { /* ... */ }
      }

* Statics may no longer refer to other statics by value. Due to statics being
  able to change at runtime, allowing them to reference one another could
  possibly lead to confusing semantics. If you are in this situation, use a
  constant initializer instead. Note, however, that statics may reference other
  statics by address, however.

* Statics may no longer be used in constant expressions, such as array lengths.
  This is due to the same restrictions as listed above. Use a `const` instead.

[breaking-change]

[rfc]: https://github.com/rust-lang/rfcs/pull/246

rustc: Reformat check_const with modern style

Remove a bunch of two-space tabs

Merge tag '0.12.0'

0.12.0 release

In sieve example, end iteration sooner

The Sieve algorithm only requires checking all elements up to and including the square root of the maximum prime you're looking for. After that, the remaining elements are guaranteed to be prime.

auto merge of #17875 : dotdash/rust/static_bool, r=alexcrichton

While booleans are represented as i1 in SSA values, LLVM expects them
to be stored/loaded as i8 values. Using i1 as we do now works, but
kills some optimizations, so we should switch to i8, just like we do
everywhere else.

Fixes #16959.

auto merge of #17870 : thestinger/rust/alloc, r=eddyb

Using reallocate(old_ptr, old_size, new_size, align) makes a lot more
sense than reallocate(old_ptr, new_size, align, old_size) and matches up
with the order used by existing platform APIs like mremap.

Closes #17837

[breaking-change]

Properly translate boolean statics to be stored as i8

While booleans are represented as i1 in SSA values, LLVM expects them
to be stored/loaded as i8 values. Using i1 as we do now works, but
kills some optimizations, so we should switch to i8, just like we do
everywhere else.

Fixes #16959.

auto merge of #17784 : bkoropoff/rust/issue-17780, r=pcwalton

This fixes a soundness problem where `Fn` unboxed closures can mutate free variables in the environment.
The following presently builds:

```rust
#![feature(unboxed_closures, overloaded_calls)]

fn main() {
    let mut x = 0u;
    let _f = |&:| x = 42;
}
```

However, this is equivalent to writing the following, which borrowck rightly rejects:

```rust
struct F<'a> {
    x: &'a mut uint
}

impl<'a> Fn<(),()> for F<'a> {
    #[rust_call_abi_hack]
    fn call(&self, _: ()) {
        *self.x = 42; // error: cannot assign to data in a `&` reference
    }
}

fn main() {
    let mut x = 0u;
    let _f = F { x: &mut x };
}
```

This problem is unique to unboxed closures; boxed closures cannot be invoked through an immutable reference and are not subject to it.

This change marks upvars of `Fn` unboxed closures as freely aliasable in mem_categorization, which causes borrowck to reject attempts to mutate or mutably borrow them.

@zwarich pointed out that even with this change, there are remaining soundness issues related to regionck (issue #17403).  This region issue affects boxed closures as well.

Closes issue #17780

librustc: Forbid duplicate name bindings in the same parameter or type
parameter list.

This breaks code like:

    fn f(a: int, a: int) { ... }
    fn g<T,T>(a: T) { ... }

Change this code to not use the same name for a parameter. For example:

    fn f(a: int, b: int) { ... }
    fn g<T,U>(a: T) { ... }

Code like this is *not* affected, since `_` is not an identifier:

    fn f(_: int, _: int) { ... } // OK

Closes #17568.

[breaking-change]

auto merge of #17873 : steveklabnik/rust/gh16413, r=alexcrichton

A fix for the issues mentioned in https://github.com/rust-lang/rust/issues/16413

auto merge of #17871 : michaelwoerister/rust/lldb-versioning, r=alexcrichton

Apart from making the build system determine the LLDB version, this PR also fixes an issue with enums in LLDB pretty printers. In order for GDB's pretty printers to know for sure if a field of some value is an enum discriminant, I had rustc mark discriminant fields with the `artificial` DWARF tag. This worked out nicely for GDB but it turns out that one can't access artificial fields from LLDB. So I changed the debuginfo representation so that enum discriminants are marked by the special field name `RUST$ENUM$DISR` instead, which works in both cases.

The PR does not activate the LLDB test suite yet.

Clean up the implementations of Bitv and BitvSet.

Functions that add bits now ensure that any unused bits are set to 0.
`into_bitv` sanitizes the nbits of the Bitv/BitvSet it returns by setting the nbits to the current capacity.
Fix a bug with `union_with` and `symmetric_difference` with due to not updating nbits properly
Add test cases to the _with functions
Remove `get_mut_ref`

This is a [breaking-change]. The things you will need to fix are:

1. BitvSet's `unwrap()` has been renamed to `into_bitv`
2. BitvSet's `get_mut_ref()` has been removed. Use `into_bitv()` and `from_bitv()` instead.

auto merge of #17867 : jbcrail/rust/unclear-macros-doc, r=alexcrichton

I rearranged one sentence in the macros guide to make it less awkward.

auto merge of #17748 : mahkoh/rust/int_slice, r=aturon

add mention of test attribute

Fixes #16413

remove crate_id attribute, add crate_name one

this is true as of https://github.com/rust-lang/rust/pull/15319

add {Imm,M}utableIntSlice

auto merge of #17843 : coffeejunk/rust/guide-macros, r=steveklabnik

The old version switched in between examples from the value `5i` to `"Hello"` and back.

Additionally, the code generated by `rustc print.rs --pretty=expanded` is not as verbose anymore.

saner parameter order for reallocation functions

Using reallocate(old_ptr, old_size, new_size, align) makes a lot more
sense than reallocate(old_ptr, new_size, align, old_size) and matches up
with the order used by existing platform APIs like mremap.

Closes #17837

[breaking-change]

auto merge of #17866 : jgallagher/rust/reserve-inheritance-keywords, r=huonw

Closes #17862

librustdoc/html: recognize slices not to nest A tags.

1. A slice of parametrized type, say
   BorrowedRef { ... Vector(Generic(T)) }, is rendered as
   "<a href='primitive.slice.html'>&amp;[T]</a>"
2. A slice of other types, say
   BorrowedRef { ... Vector(int) }, is rendered as
   "<a href='primitive.slice.html'>&amp;[</a>
    <a href='primitive.int.html'>int</a>
    <a href='primitive.slice.html'>]</a>"
3. Other cases, say BorrowedRef { ... int }, are
   rendered as same as before:
   "&<a href='primitive.int.html'>int</a>"

Relevant W3C specs:
- http://www.w3.org/TR/html401/struct/links.html#h-12.2.2
  12.2.2 Nested links are illegal
- http://www.w3.org/TR/html5/text-level-semantics.html#the-a-element
  states A tag must not enclose any "interactive contents"
  which include A tags themselves.

auto merge of #17855 : steveklabnik/rust/fix_table_reference, r=alexcrichton

Markdown tables require a header, and we don't want one.

Fixes #17528

debuginfo: Don't mark struct fields as artificial.

LLDB doesn't allow for reading 'artifical' fields (fields that are generated by the compiler). So do not mark, slice fields, enum discriminants, and GcBox value fields as artificial.

auto merge of #17447 : thestinger/rust/silly_string, r=aturon

This provides a way to pass `&[T]` to functions taking `&U` where `U` is
a `Vec<T>`. This is useful in many cases not covered by the Equiv trait
or methods like `find_with` on TreeMap.

add #[experimental] as_string/as_vec functions

This provides a way to pass `&[T]` to functions taking `&U` where `U` is
a `Vec<T>`. This is useful in many cases not covered by the Equiv trait
or methods like `find_with` on TreeMap.

debuginfo: Add LLDB version handling to test infrastructure.

auto merge of #17840 : Sawyer47/rust/issue-17751, r=huonw

Closes #17751

auto merge of #17838 : vadimcn/rust/macros, r=alexcrichton

Add tests for new reserved keywords `abstract`,`final`,`override`

Add `abstract`, `final`, and `override` to rust.vim keyword list

Remove use of `final` and `override` (now reserved)

Fix unclear macros documentation.

Add `abstract`, `final`, and `override` to reserved keywords

auto merge of #17836 : typelist/rust/guide-tuples, r=steveklabnik

Currently, the Guide says tuples "are only equivalent if the arity, types, and values are all identical", before presenting an example that uses `==` to compare two tuples whose arity and contained types match. This is misleading, because it implies that `==` can dynamically check whether two tuples have the same arity and contained types, whereas trying to do this would lead to a compiler error.

I tried to avoid destroying the flow of this section, but I'm not sure if I've been successful.

auto merge of #17787 : bgamari/rust/fix-quote-method, r=huonw

The previous fix introduced in 75d49c8203405ab0af7a2b8b8698af02868fdbc2 neglected to parse outer attributes as described in #17782.

auto merge of #17834 : sfackler/rust/rustdoc-cfgs, r=alexcrichton,alexcrichton

Rustdoc would previously improperly handle key="value" style cfgs, which
are notably used for Cargo features.

More relnotes tweaks

Fix keyword table

Markdown tables require a header, and we don't want one.

Fixes #17528

Update html_root_url for 0.12.0 release

Update per feedback

Update AUTHORS.txt for 0.12.0

Update RELEASES.md for 0.12.0

Rename RELEASES.txt to RELEASES.md. It's markdown.

auto merge of #16641 : steveklabnik/rust/intro_redux, r=alexcrichton

Because my '30 minute intro' was originally a blog post, the tone was a bit too light. It also was written a long time ago, and deserves a bit of a refresher for modern Rust. now that my work on the Guide is wrapping up, I want to give it a quick re-write as well.

This is not yet done, but I'm submitting it for feedback so far. I'd really like some comments on the ownership part in particular, which gets lower level than before, but is not strictly 100% accurate. Trying to strike a balance.

In general, I'm not sure I go into enough detail for those without systems experience, but am afraid of too much detail for those that do.

Rendered view: https://github.com/steveklabnik/rust/blob/intro_redux/src/doc/intro.md

/cc @wycats @nikomatsakis @brson etc

auto merge of #17832 : brson/rust/updateversion, r=alexcrichton

Guide: Fix inconsistency in 'Marcos' section

The old version switched in between examples from the value `5i` to `"Hello"`
and back. Additionally, the code generated by `rustc print.rs
--pretty=expanded` is not as verbose anymore.

auto merge of #17802 : Gankro/rust/collection-docs-redux, r=aturon

Adds a high-level discussion of "what collection should you use for what", as well as some general discussion of correct/efficient usage of the capacity, iterator, and entry APIs.

Still building docs to confirm this renders right and the examples are good, but the content can be reviewed now.

Fix the most egregious instances of "local ambiguity: multiple parsing options..." error in macros, which often occurs when trying to match parts of Rust syntax.
For example, this matcher: `fn $name:ident( $($param:ident : $pty:ty),* )` would fail when parsing `fn foo()`, because macro parser wouldn't realize that an ident cannot start with `)`.

This resolves #5902, and at least partially mitigates #9364 and #3232.

Re-exports core::str::Utf16CodeUnits in std::str

Closes #17751

auto merge of #17807 : nick29581/rust/slice6, r=aturon

r? @aturon

Clarify that assigning/comparing different tuple types to one another won't compile

auto merge of #17745 : aturon/rust/revert-any-private, r=alexcrichton

[Previously](https://github.com/rust-lang/rust/commit/e5da6a71a6a0b46dd3630fc8326e6d5906a1fde6), the `Any` trait was split into a private portion and an (empty) public portion, in order to hide the implementation strategy used for downcasting. However, the [new rules](https://github.com/rust-lang/rust/commit/e9ad12c0cae5c43ada6641c7dc840a0fbe5010a2) for privacy forbid `AnyPrivate` from actually being private.

This patch thus reverts the introduction of `AnyPrivate`.

Although this is unlikely to break any real code, it removes a public trait and is therefore a:

[breaking-change]

add missing btree re-exports

library-level docs for collections

Reinstate AsSlice impls for Option and Result

Rename slicing methods

Rename slice::Slice

Put slicing syntax behind a feature gate.

[breaking-change]

If you are using slicing syntax you will need to add #![feature(slicing_syntax)] to your crate.

Use slice syntax instead of slice_to, etc.

Properly handle cfgs in rustdoc

Rustdoc would previously improperly handle key="value" style cfgs, which
are notably used for Cargo features.

doc fixups

Revise DST test to not require duplicate errors.

Remove core::any::AnyPrivate

[Previously](https://github.com/rust-lang/rust/commit/e5da6a71a6a0b46dd3630fc8326e6d5906a1fde6),
the `Any` trait was split into a private portion and an (empty) public
portion, in order to hide the implementation strategy used for
downcasting. However, the [new
rules](https://github.com/rust-lang/rust/commit/e9ad12c0cae5c43ada6641c7dc840a0fbe5010a2)
for privacy forbid `AnyPrivate` from actually being private.

This patch thus reverts the introduction of `AnyPrivate`.

Although this is unlikely to break any real code, it removes a public
trait and is therefore a:

[breaking-change]

doc: Update output of `rustc --version`

auto merge of #17820 : pnkfelix/rust/fsk-improve-binary_search-doc2, r=alexcrichton

Add example to doc for `slice::ImmutableSlice::binary_search`.

Fix #17817.

auto merge of #17692 : brson/rust/copywut, r=alexcrichton

Update COPYRIGHT to better reflect the current repo

auto merge of #17798 : tomjakubowski/rust/rustdoc-fix-bounds, r=alexcrichton

This PR adds support in rustdoc for properly naming lifetimes in bounds, instead of just showing `'static` for everything. It also adds support for unboxed function sugar bounds, which were also previously rendered as `'static`.

auto merge of #17796 : tomjakubowski/rust/rustdoc-ice-17736, r=alexcrichton

Previously, external code might call `markdown::render()` without having
called `markdown::reset_headers()`, meaning the TLS key
`used_header_map` was unset.  Now `markdown::render()` ensures that
`used_header_map` is set by calling `reset_headers` if necessary.

Fix #17736

syntax: Parse outer attributes in quote_method!

Fixes #17782.

Add example to doc for `slice::ImmutableSlice::binary_search`.

Fix #17817.

rustdoc: Include lifetimes in re-exported bounds

Fix #17818

auto merge of #17814 : vhbit/rust/ios-build-fix, r=huonw

auto merge of #17812 : thestinger/rust/jemalloc, r=alexcrichton

This includes optimizations to the thread cache and support for
shrinking and expanding huge (>4M) allocations in-place.

rustdoc: Remove dummy UnknownBound variant

auto merge of #17803 : bkoropoff/rust/issue-17021, r=alexcrichton

This closes issue #17021.

rustdoc: Support unboxed fn sugar in bounds

rustdoc: Correctly name lifetimes in bounds

Fix #16518

rustdoc: make calls of markdown::render safer

Previously, external code might call `markdown::render()` without having
called `markdown::reset_headers()`, meaning the TLS key
`used_header_map` was unset.  Now `markdown::render()` ensures that
`used_header_map` is set by calling `reset_headers` if necessary.

Fix #17736

auto merge of #17781 : P1start/rust/bitflags-lints, r=alexcrichton

Closes #17773.

Fixed iOS build (statics name lint)

Remove the #[allow(non_uppercase_statics)] attr from bitflags!

Rename the file permission statics in std::io to be uppercase

For example, this renames `GroupRWX` to `GROUP_RWX`, and deprecates the old
name. Code using these statics should be updated accordingly.

auto merge of #17414 : jakub-/rust/issue-17405, r=alexcrichton

Fixes #17405.
Fixes #17518.
Fixes #17800.