Improved the tags impl regex
Sort trait bounds.

Closes #6334
collections, unicode: Add support for NFC and NFKC
Guide: testing
Library changes for RFC #43
Add two helper functions for dealing with OwnedPtr paths
Implement RFC #43

Remove the ability of the borrow checker to determine that repeated
dereferences of a Box<T> refer to the same memory object. This will
usually require one of two workarounds:

1) The interior of a Box<T> will sometimes need to be moved / borrowed
into a temporary before moving / borrowing individual derived paths.

2) A `ref x` pattern will have to be replaced with a `box ref x`
pattern.

Fixes #16094.

[breaking-change]
Add a new test for borrow checker Box<T> behavior
Add comment about speed in FAQ.

Fixes #11174.
Guide: pointers

Not the pointer guide, but the guide section on pointers.

Adding a section about patterns for after this, as well.
Be more consistent with "Hello, world!"
Correct RFC reference in time::Tm::rfc3339 docs

Fixes #16158
Change strptime::match_strs to use borrowed rather than owned strings

Also modernise a few constructs in match_strs().
rustdoc: Use --crate-name with --test

This ensures that the name of the crate is set from the command line for tests
so the auto-injection of `extern crate <name>` in doc tests works correctly.
Fix API docs css reversing elements that it shouldn't

remove unneeded `pre.rust a' selector

move transform into `.test-arrow`

fixes #16138
auto merge of #16157 : alexcrichton/rust/rustdoc-tests, r=huonw

This ensures that the name of the crate is set from the command line for tests
so the auto-injection of `extern crate <name>` in doc tests works correctly.
librustc: Forbid pattern bindings after `@`s, for memory safety.

This is an alternative to upgrading the way rvalues are handled in the
borrow check. Making rvalues handled more like lvalues in the borrow
check caused numerous problems related to double mutable borrows and
rvalue scopes. Rather than come up with more borrow check rules to try
to solve these problems, I decided to just forbid pattern bindings after
`@`. This affected fewer than 10 lines of code in the compiler and
libraries.

This breaks code like:

    match x {
        y @ z => { ... }
    }

    match a {
        b @ Some(c) => { ... }
    }

Change this code to use nested `match` or `let` expressions. For
example:

    match x {
        y => {
            let z = y;
            ...
        }
    }

    match a {
        Some(c) => {
            let b = Some(c);
            ...
        }
    }

Closes #14587.

[breaking-change]
auto merge of #16053 : pcwalton/rust/at-pattern-bindings, r=pnkfelix

This is an alternative to upgrading the way rvalues are handled in the
borrow check. Making rvalues handled more like lvalues in the borrow
check caused numerous problems related to double mutable borrows and
rvalue scopes. Rather than come up with more borrow check rules to try
to solve these problems, I decided to just forbid pattern bindings after
`@`. This affected fewer than 10 lines of code in the compiler and
libraries.

This breaks code like:

    match x {
        y @ z => { ... }
    }

    match a {
        b @ Some(c) => { ... }
    }

Change this code to use nested `match` or `let` expressions. For
example:

    match x {
        y => {
            let z = y;
            ...
        }
    }

    match a {
        Some(c) => {
            let b = Some(c);
            ...
        }
    }

Closes #14587.

[breaking-change]

May need discussion at the meeting, but r? @nikomatsakis anyway
auto merge of #16102 : zwarich/rust/borrowck-unboxed, r=pcwalton

This removes the ability of the borrow checker to determine that repeated dereferences of a Box<T> refer to the same memory object.
libsync: Add safer abstraction for SPSC queue.

The current spsc implementation doesn't enforce single-producer
single-consumer usage and also allows unsafe memory use through
peek & pop.

For safer usage, `spsc_queue::queue` now returns a pair of owned objects which
only allow consumer or producer behaviours through an `Arc`.
Through restricting the mutability of the receiver to `mut` the
peek and pop behaviour becomes safe again, with the compiler
complaining about usage which could lead to problems.

To fix code broken from this, update:
Queue::new(x) -> unsafe { Queue::new(x) }

[breaking-change]