---

yaml
---
r: 236108
b: refs/heads/stable
c: 5f02de3
h: refs/heads/master
v: v3

Author: Gankra

[refs]

@@ -29,7 +29,7 @@ refs/heads/tmp: afae2ff723393b3ab4ccffef6ac7c6d1809e2da0
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f
 refs/tags/homu-tmp: f859507de8c410b648d934d8f5ec1c52daac971d
 refs/tags/1.0.0-beta: 8cbb92b53468ee2b0c2d3eeb8567005953d40828
-refs/heads/stable: 14bc45477085222dcf2b87bef75ca3e7d0b5274a
+refs/heads/stable: 5f02de3c226bce60c58ce2bc436e69c55b90a616
 refs/tags/1.0.0: 55bd4f8ff2b323f317ae89e254ce87162d52a375
 refs/tags/1.1.0: bc3c16f09287e5545c1d3f76b7abd54f2eca868b
 refs/tags/1.2.0: f557861f822c34f07270347b94b5280de20a597e

branches/stable/src/doc/tarpl/casts.md

@@ -9,7 +9,9 @@ using the `as` keyword: `expr as Type`.
 True casts generally revolve around raw pointers and the primitive numeric
 types. Even though they're dangerous, these casts are *infallible* at runtime.
 If a cast triggers some subtle corner case no indication will be given that
-this occurred. The cast will simply succeed.
+this occurred. The cast will simply succeed. That said, casts must be valid
+at the type level, or else they will be prevented statically. For instance,
+`7u8 as bool` will not compile.
 
 That said, casts aren't `unsafe` because they generally can't violate memory
 safety *on their own*. For instance, converting an integer to a raw pointer can

branches/stable/src/doc/tarpl/repr-rust.md

@@ -12,7 +12,11 @@ An enum is said to be *C-like* if none of its variants have associated data.
 For all these, individual fields are aligned to their preferred alignment. For
 primitives this is usually equal to their size. For instance, a u32 will be
 aligned to a multiple of 32 bits, and a u16 will be aligned to a multiple of 16
-bits. Composite structures will have a preferred alignment equal to the maximum
+bits. Note that some primitives may be emulated on different platforms, and as
+such may have strange alignment. For instance, a u64 on x86 may actually be
+emulated as a pair of u32s, and thus only have 32-bit alignment.
+
+Composite structures will have a preferred alignment equal to the maximum
 of their fields' preferred alignment, and a size equal to a multiple of their
 preferred alignment. This ensures that arrays of T can be correctly iterated
 by offsetting by their size. So for instance,