Rename CopyableVector to CloneableVector
Rename OwnedCopyableVector to OwnedCloneableVector
Rename ImmutableCopyableVector to ImmutableCloneableVector
Rename CopyableTuple to CloneableTuple
Treat unary struct and enum variants as rvalues

Closes #11681
Fix SIMD bit shifts
stop making visit glue for closures and traits
Allow empty functional updating of structs

Fixes #8972
use a more efficient vtable representation

[TyDesc, ... methods] -> [destructor, ... methods]
Fixes temporary lifetime computation for static items

closes: #11854
auto merge of #11776 : FlaPer87/rust/issue-11681-static-lifetime, r=nikomatsakis

Closes #11681
Closes #11854
auto merge of #11893 : Armavica/rust/copyable-cloneable, r=huonw

I found awkward to have `MutableCloneableVector` and `CloneableIterator` on the one hand, and `CopyableVector` etc. on the other hand.

The concerned traits are:
* `CopyableVector` --> `CloneableVector`
* `OwnedCopyableVector` --> `OwnedCloneableVector`
* `ImmutableCopyableVector` --> `ImmutableCloneableVector`
* `CopyableTuple` --> `CloneableTuple`
Check enum and struct representability properly (issues #3008 and #3779)
Add compile-fail tests for non-representable structs and enums
Remove Times trait

`Times::times` was always a second-class loop because it did not support the `break` and `continue` operations. Its playful appeal was then lost after `do` was disabled for closures. It's time to let this one go.
auto merge of #11672 : bjz/rust/remove-times, r=brson

`Times::times` was always a second-class loop because it did not support the `break` and `continue` operations. Its playful appeal (which I liked) was then lost after `do` was disabled for closures. It's time to let this one go.
Consider types that contain fixed-length-zero vectors of themselves as non-representable until #11924 is resolved
auto merge of #11839 : typelist/rust/issue3008, r=huonw

It was possible to trigger a stack overflow in rustc because the routine used to verify enum representability,
type_structurally_contains, would recurse on inner types until hitting the original type. The overflow condition was when a different structurally recursive type (enum or struct) was contained in the type being checked.

I suspect my solution isn't as efficient as it could be. I pondered adding a cache of previously-seen types to avoid duplicating work (if enums A and B both contain type C, my code goes through C twice), but I didn't want to do anything that may not be necessary.

I'm a new contributor, so please pay particular attention to any unidiomatic code, misuse of terminology, bad naming of tests, or similar horribleness :)

Updated to verify struct representability as well.

Fixes #3008.
Fixes #3779.
Upgrade LLVM

This upgrade brings commit by @eddyb to help optimizations of virtual calls in
a few places (https://github.com/llvm-mirror/llvm/commit/6d2bd95) as well as a
commit by @c-a to *greatly* improve the runtime of the optimization passes
(https://github.com/rust-lang/llvm/pull/3).

Nice work to these guys!
auto merge of #11853 : alexcrichton/rust/up-llvm, r=brson

This upgrade brings commit by @eddyb to help optimizations of virtual calls in
a few places (https://github.com/llvm-mirror/llvm/commit/6d2bd95) as well as a
commit by @c-a to *greatly* improve the runtime of the optimization passes
(https://github.com/rust-lang/llvm/pull/3).

Nice work to these guys!