---

yaml
---
r: 157460
b: refs/heads/snap-stage3
c: 6c18e50
h: refs/heads/master
v: v3

Author: dotdash

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 065caf34f5ff29e04605f95d9c5d511af219439a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 80e5fe1a56bb95e8e89d5f8f0ff5122583bb5336
+refs/heads/snap-stage3: 6c18e508f10aa5bf42dc80691654b9cde2a661cd
 refs/heads/try: 0ee4d8b0b112c608646fa75463ab4dc59132efd9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide.md

@@ -3466,14 +3466,13 @@ for destroying that resource as well. Given that we're discussing pointers
 right now, let's discuss this in the context of memory allocation, though
 it applies to other resources as well.
 
-When you allocate heap memory, you need a mechanism to free that memory. Many
-languages use a garbage collector to handle deallocation. This is a valid,
-time-tested strategy, but it's not without its drawbacks: it adds overhead, and
-can lead to unpredictable pauses in execution. Because the programmer does not
-have to think as much about deallocation, allocation becomes something
-commonplace, leading to more memory usage. And if you need precise control
-over when something is deallocated, leaving it up to your runtime can make this
-difficult.
+When you allocate heap memory, you need a mechanism to free that memory.  Many
+languages let the programmer control the allocation, and then use a garbage
+collector to handle the deallocation. This is a valid, time-tested strategy,
+but it's not without its drawbacks. Because the programmer does not have to
+think as much about deallocation, allocation becomes something commonplace,
+because it's easy. And if you need precise control over when something is
+deallocated, leaving it up to your runtime can make this difficult.
 
 Rust chooses a different path, and that path is called **ownership**. Any
 binding that creates a resource is the **owner** of that resource.
@@ -3499,19 +3498,17 @@ memory. The length of time that the borrower is borrowing the pointer
 from you is called a **lifetime**.
 
 If two distinct bindings share a pointer, and the memory that pointer points to
-is immutable, then there are no problems. But if it's mutable, the result of
-changing it can vary unpredictably depending on who happens to access it first,
-which is called a **race condition**. To avoid this, if someone wants to mutate
-something that they've borrowed from you, you must not have lent out that
-pointer to anyone else.
+is immutable, then there are no problems. But if it's mutable, both pointers
+can attempt to write to the memory at the same time, causing a **race
+condition**. Therefore, if someone wants to mutate something that they've
+borrowed from you, you must not have lent out that pointer to anyone else.
 
 Rust has a sophisticated system called the **borrow checker** to make sure that
 everyone plays by these rules. At compile time, it verifies that none of these
-rules are broken. If our program compiles successfully, Rust can guarantee it
-is free of data races and other memory errors, and there is no runtime overhead
-for any of this. The borrow checker works only at compile time. If the borrow
-checker did find a problem, it will report a **lifetime error**, and your
-program will refuse to compile.
+rules are broken. If there's no problem, our program compiles successfully, and
+there is no runtime overhead for any of this. The borrow checker works only at
+compile time. If the borrow checker did find a problem, it will report a
+**lifetime error**, and your program will refuse to compile.
 
 That's a lot to take in. It's also one of the _most_ important concepts in
 all of Rust. Let's see this syntax in action:

branches/snap-stage3/src/liballoc/heap.rs

@@ -112,10 +112,10 @@ unsafe fn exchange_free(ptr: *mut u8, size: uint, align: uint) {
 #[cfg(any(target_arch = "arm",
           target_arch = "mips",
           target_arch = "mipsel"))]
-static MIN_ALIGN: uint = 8;
+const MIN_ALIGN: uint = 8;
 #[cfg(any(target_arch = "x86",
           target_arch = "x86_64"))]
-static MIN_ALIGN: uint = 16;
+const MIN_ALIGN: uint = 16;
 
 #[cfg(jemalloc)]
 mod imp {

branches/snap-stage3/src/libcore/intrinsics.rs

@@ -260,17 +260,6 @@ extern "rust-intrinsic" {
     /// NB: This is very different from the `unreachable!()` macro!
     pub fn unreachable() -> !;
 
-    /// Inform the optimizer that a condition is always true.
-    /// If the condition is false, the behavior is undefined.
-    ///
-    /// No code is generated for this intrinsic, but the optimizer will try
-    /// to preserve it (and its condition) between passes, which may interfere
-    /// with optimization of surrounding code and reduce performance. It should
-    /// not be used if the invariant can be discovered by the optimizer on its
-    /// own, or if it does not enable any significant optimizations.
-    #[cfg(not(stage0))]
-    pub fn assume(b: bool);
-
     /// Execute a breakpoint trap, for inspection by a debugger.
     pub fn breakpoint();
 

branches/snap-stage3/src/librustc/diagnostics.rs

@@ -44,9 +44,11 @@ register_diagnostics!(
     E0025,
     E0026,
     E0027,
+    E0028,
     E0029,
     E0030,
     E0031,
+    E0032,
     E0033,
     E0034,
     E0035,

branches/snap-stage3/src/librustc/metadata/decoder.rs

@@ -673,14 +673,9 @@ pub fn get_enum_variants(intr: Rc<IdentInterner>, cdata: Cmd, id: ast::NodeId,
         let ctor_ty = item_type(ast::DefId { krate: cdata.cnum, node: id},
                                 item, tcx, cdata);
         let name = item_name(&*intr, item);
-        let (ctor_ty, arg_tys) = match ty::get(ctor_ty).sty {
-            ty::ty_bare_fn(ref f) =>
-                (Some(ctor_ty), f.sig.inputs.clone()),
-            _ => // Nullary or struct enum variant.
-                (None, get_struct_fields(intr.clone(), cdata, did.node)
-                    .iter()
-                    .map(|field_ty| get_type(cdata, field_ty.id.node, tcx).ty)
-                    .collect())
+        let arg_tys = match ty::get(ctor_ty).sty {
+            ty::ty_bare_fn(ref f) => f.sig.inputs.clone(),
+            _ => Vec::new(), // Nullary enum variant.
         };
         match variant_disr_val(item) {
             Some(val) => { disr_val = val; }

branches/snap-stage3/src/librustc/middle/privacy.rs

@@ -667,12 +667,21 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
 
         let struct_type = ty::lookup_item_type(self.tcx, id).ty;
         let struct_desc = match ty::get(struct_type).sty {
-            ty::ty_struct(_, _) =>
-                format!("struct `{}`", ty::item_path_str(self.tcx, id)),
-            ty::ty_enum(enum_id, _) =>
+            ty::ty_struct(_, _) => format!("struct `{}`", ty::item_path_str(self.tcx, id)),
+            ty::ty_bare_fn(ty::BareFnTy { sig: ty::FnSig { output, .. }, .. }) => {
+                // Struct `id` is really a struct variant of an enum,
+                // and we're really looking at the variant's constructor
+                // function. So get the return type for a detailed error
+                // message.
+                let enum_id = match ty::get(output).sty {
+                    ty::ty_enum(id, _) => id,
+                    _ => self.tcx.sess.span_bug(span, "enum variant doesn't \
+                                                       belong to an enum")
+                };
                 format!("variant `{}` of enum `{}`",
                         ty::with_path(self.tcx, id, |mut p| p.last().unwrap()),
-                        ty::item_path_str(self.tcx, enum_id)),
+                        ty::item_path_str(self.tcx, enum_id))
+            }
             _ => self.tcx.sess.span_bug(span, "can't find struct for field")
         };
         let msg = match name {

branches/snap-stage3/src/librustc/middle/resolve.rs

@@ -5077,6 +5077,7 @@ impl<'a> Resolver<'a> {
                 PatEnum(ref path, _) => {
                     // This must be an enum variant, struct or const.
                     match self.resolve_path(pat_id, path, ValueNS, false) {
+                        Some(def @ (DefFn(..), _))      |
                         Some(def @ (DefVariant(..), _)) |
                         Some(def @ (DefStruct(..), _))  |
                         Some(def @ (DefConst(..), _)) => {

branches/snap-stage3/src/librustc/middle/trans/context.rs

@@ -860,7 +860,6 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
     ifn!("llvm.lifetime.end" fn(t_i64, i8p) -> void);
 
     ifn!("llvm.expect.i1" fn(i1, i1) -> i1);
-    ifn!("llvm.assume" fn(i1) -> void);
 
     // Some intrinsics were introduced in later versions of LLVM, but they have
     // fallbacks in libc or libm and such. Currently, all of these intrinsics

branches/snap-stage3/src/librustc/middle/trans/intrinsic.rs

@@ -81,7 +81,6 @@ pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Opti
         "bswap16" => "llvm.bswap.i16",
         "bswap32" => "llvm.bswap.i32",
         "bswap64" => "llvm.bswap.i64",
-        "assume" => "llvm.assume",
         _ => return None
     };
     Some(ccx.get_intrinsic(&name))

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -50,7 +50,7 @@ use syntax::ast::{CrateNum, DefId, FnStyle, Ident, ItemTrait, LOCAL_CRATE};
 use syntax::ast::{MutImmutable, MutMutable, Name, NamedField, NodeId};
 use syntax::ast::{Onceness, StmtExpr, StmtSemi, StructField, UnnamedField};
 use syntax::ast::{Visibility};
-use syntax::ast_util::{mod, is_local, lit_is_str, local_def, PostExpansionMethod};
+use syntax::ast_util::{mod, PostExpansionMethod, is_local, lit_is_str};
 use syntax::attr::{mod, AttrMetaMethods};
 use syntax::codemap::Span;
 use syntax::parse::token::{mod, InternedString};
@@ -4221,7 +4221,7 @@ pub fn ty_to_def_id(ty: t) -> Option<ast::DefId> {
 pub struct VariantInfo {
     pub args: Vec<t>,
     pub arg_names: Option<Vec<ast::Ident> >,
-    pub ctor_ty: Option<t>,
+    pub ctor_ty: t,
     pub name: ast::Name,
     pub id: ast::DefId,
     pub disr_val: Disr,
@@ -4249,7 +4249,7 @@ impl VariantInfo {
                 return VariantInfo {
                     args: arg_tys,
                     arg_names: None,
-                    ctor_ty: Some(ctor_ty),
+                    ctor_ty: ctor_ty,
                     name: ast_variant.node.name.name,
                     id: ast_util::local_def(ast_variant.node.id),
                     disr_val: discriminant,
@@ -4262,8 +4262,7 @@ impl VariantInfo {
 
                 assert!(fields.len() > 0);
 
-                let arg_tys = struct_def.fields.iter()
-                    .map(|field| node_id_to_type(cx, field.node.id)).collect();
+                let arg_tys = ty_fn_args(ctor_ty).iter().map(|a| *a).collect();
                 let arg_names = fields.iter().map(|field| {
                     match field.node.kind {
                         NamedField(ident, _) => ident,
@@ -4275,7 +4274,7 @@ impl VariantInfo {
                 return VariantInfo {
                     args: arg_tys,
                     arg_names: Some(arg_names),
-                    ctor_ty: None,
+                    ctor_ty: ctor_ty,
                     name: ast_variant.node.name.name,
                     id: ast_util::local_def(ast_variant.node.id),
                     disr_val: discriminant,