---

yaml
---
r: 113630
b: refs/heads/snap-stage3
c: bcabcf5
h: refs/heads/master
v: v3

Author: lilyball

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: abdacecdf86b4b5a4f432560445a24e1c5f4751b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 63287eef27b1a23a1fc24a7b4453eb7bd8ec1f11
+refs/heads/snap-stage3: bcabcf53cfe2a86ebf02aa762b8ab7278060ce10
 refs/heads/try: 7c6c492fb2af9a85f21ff952942df3523b22fd17
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libcore/fmt/mod.rs

@@ -43,44 +43,16 @@ pub mod rt;
 
 pub type Result = result::Result<(), FormatError>;
 
-/// The error type which is returned from formatting a message into a stream.
-///
-/// This type does not support transmission of an error other than that an error
-/// occurred. Any extra information must be arranged to be transmitted through
-/// some other means.
+/// dox
 pub enum FormatError {
-    /// A generic write error occurred during formatting, no other information
-    /// is transmitted via this variant.
+    /// dox
     WriteError,
 }
 
-/// A collection of methods that are required to format a message into a stream.
-///
-/// This trait is the type which this modules requires when formatting
-/// information. This is similar to the standard library's `io::Writer` trait,
-/// but it is only intended for use in libcore.
-///
-/// This trait should generally not be implemented by consumers of the standard
-/// library. The `write!` macro accepts an instance of `io::Writer`, and the
-/// `io::Writer` trait is favored over implementing this trait.
+/// dox
 pub trait FormatWriter {
-    /// Writes a slice of bytes into this writer, returning whether the write
-    /// succeeded.
-    ///
-    /// This method can only succeed if the entire byte slice was successfully
-    /// written, and this method will not return until all data has been
-    /// written or an error occurs.
-    ///
-    /// # Errors
-    ///
-    /// This function will return an instance of `FormatError` on error.
+    /// dox
     fn write(&mut self, bytes: &[u8]) -> Result;
-
-    /// Glue for usage of the `write!` macro with implementors of this trait.
-    ///
-    /// This method should generally not be invoked manually, but rather through
-    /// the `write!` macro itself.
-    fn write_fmt(&mut self, args: &Arguments) -> Result { write(self, args) }
 }
 
 /// A struct to represent both where to emit formatting strings to and how they

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

@@ -10,23 +10,7 @@
 
 //! The core prelude
 //!
-//! This module is intended for users of libcore which do not link to libstd as
-//! well. This module is not imported by default, but using the entire contents
-//! of this module will provide all of the useful traits and types in libcore
-//! that one would expect from the standard library as well.
-//!
-//! There is no method to automatically inject this prelude, and this prelude is
-//! a subset of the standard library's prelude.
-//!
-//! # Example
-//!
-//! ```ignore
-//! # fn main() {
-//! #![feature(globs)]
-//!
-//! use core::prelude::*;
-//! # }
-//! ```
+//! For more information, see std::prelude.
 
 // Reexported core operators
 pub use kinds::{Copy, Send, Sized, Share};

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

@@ -85,18 +85,6 @@ pub enum Repr {
      * all start with a field for the discriminant.
      */
     General(IntType, Vec<Struct>),
-    /**
-     * Two cases distinguished by a nullable pointer: the case with discriminant
-     * `nndiscr` must have single field which is known to be nonnull due to its type.
-     * The other case is known to be zero sized. Hence we represent the enum
-     * as simply a nullable pointer: if not null it indicates the `nndiscr` variant,
-     * otherwise it indicates the other case.
-     */
-    RawNullablePointer {
-        pub nndiscr: Disr,
-        pub nnty: ty::t,
-        pub nullfields: Vec<ty::t>
-    },
     /**
      * Two cases distinguished by a nullable pointer: the case with discriminant
      * `nndiscr` is represented by the struct `nonnull`, where the `ptrfield`th
@@ -108,7 +96,7 @@ pub enum Repr {
      * is represented such that `None` is a null pointer and `Some` is the
      * identity function.
      */
-    StructWrappedNullablePointer {
+    NullablePointer {
         pub nonnull: Struct,
         pub nndiscr: Disr,
         pub ptrfield: uint,
@@ -212,23 +200,17 @@ fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr {
                     if cases.get(1 - discr).is_zerolen(cx) {
                         match cases.get(discr).find_ptr() {
                             Some(ptrfield) => {
-                                let st = mk_struct(cx, cases.get(discr).tys.as_slice(),
-                                                   false);
-
-                                return if st.fields.len() == 1 {
-                                    RawNullablePointer {
-                                        nndiscr: discr as Disr,
-                                        nnty: *st.fields.get(0),
-                                        nullfields: cases.get(1 - discr).tys.clone()
-                                    }
-                                } else {
-                                    StructWrappedNullablePointer {
-                                        nndiscr: discr as Disr,
-                                        nonnull: st,
-                                        ptrfield: ptrfield,
-                                        nullfields: cases.get(1 - discr).tys.clone()
-                                    }
-                                };
+                                return NullablePointer {
+                                    nndiscr: discr as u64,
+                                    nonnull: mk_struct(cx,
+                                                       cases.get(discr)
+                                                            .tys
+                                                            .as_slice(),
+                                                       false),
+                                    ptrfield: ptrfield,
+                                    nullfields: cases.get(1 - discr).tys
+                                                                    .clone()
+                                }
                             }
                             None => { }
                         }
@@ -431,8 +413,8 @@ pub fn incomplete_type_of(cx: &CrateContext, r: &Repr, name: &str) -> Type {
 }
 pub fn finish_type_of(cx: &CrateContext, r: &Repr, llty: &mut Type) {
     match *r {
-        CEnum(..) | General(..) | RawNullablePointer { .. } => { }
-        Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } =>
+        CEnum(..) | General(..) => { }
+        Univariant(ref st, _) | NullablePointer{ nonnull: ref st, .. } =>
             llty.set_struct_body(struct_llfields(cx, st, false).as_slice(),
                                  st.packed)
     }
@@ -441,8 +423,7 @@ pub fn finish_type_of(cx: &CrateContext, r: &Repr, llty: &mut Type) {
 fn generic_type_of(cx: &CrateContext, r: &Repr, name: Option<&str>, sizing: bool) -> Type {
     match *r {
         CEnum(ity, _, _) => ll_inttype(cx, ity),
-        RawNullablePointer { nnty, .. } => type_of::sizing_type_of(cx, nnty),
-        Univariant(ref st, _) | StructWrappedNullablePointer { nonnull: ref st, .. } => {
+        Univariant(ref st, _) | NullablePointer{ nonnull: ref st, .. } => {
             match name {
                 None => {
                     Type::struct_(cx, struct_llfields(cx, st, sizing).as_slice(),
@@ -514,10 +495,12 @@ fn struct_llfields(cx: &CrateContext, st: &Struct, sizing: bool) -> Vec<Type> {
 pub fn trans_switch(bcx: &Block, r: &Repr, scrutinee: ValueRef)
     -> (_match::branch_kind, Option<ValueRef>) {
     match *r {
-        CEnum(..) | General(..) |
-        RawNullablePointer { .. } | StructWrappedNullablePointer { .. } => {
+        CEnum(..) | General(..) => {
             (_match::switch, Some(trans_get_discr(bcx, r, scrutinee, None)))
         }
+        NullablePointer{ nonnull: ref nonnull, nndiscr, ptrfield, .. } => {
+            (_match::switch, Some(nullable_bitdiscr(bcx, nonnull, nndiscr, ptrfield, scrutinee)))
+        }
         Univariant(..) => {
             (_match::single, None)
         }
@@ -545,14 +528,8 @@ pub fn trans_get_discr(bcx: &Block, r: &Repr, scrutinee: ValueRef, cast_to: Opti
             val = C_u8(bcx.ccx(), 0);
             signed = false;
         }
-        RawNullablePointer { nndiscr, nnty, .. } =>  {
-            let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
-            let llptrty = type_of::sizing_type_of(bcx.ccx(), nnty);
-            val = ICmp(bcx, cmp, Load(bcx, scrutinee), C_null(llptrty));
-            signed = false;
-        }
-        StructWrappedNullablePointer { nonnull: ref nonnull, nndiscr, ptrfield, .. } => {
-            val = struct_wrapped_nullable_bitdiscr(bcx, nonnull, nndiscr, ptrfield, scrutinee);
+        NullablePointer{ nonnull: ref nonnull, nndiscr, ptrfield, .. } => {
+            val = nullable_bitdiscr(bcx, nonnull, nndiscr, ptrfield, scrutinee);
             signed = false;
         }
     }
@@ -562,10 +539,10 @@ pub fn trans_get_discr(bcx: &Block, r: &Repr, scrutinee: ValueRef, cast_to: Opti
     }
 }
 
-fn struct_wrapped_nullable_bitdiscr(bcx: &Block, nonnull: &Struct, nndiscr: Disr, ptrfield: uint,
-                                    scrutinee: ValueRef) -> ValueRef {
-    let llptr = Load(bcx, GEPi(bcx, scrutinee, [0, ptrfield]));
+fn nullable_bitdiscr(bcx: &Block, nonnull: &Struct, nndiscr: Disr, ptrfield: uint,
+                     scrutinee: ValueRef) -> ValueRef {
     let cmp = if nndiscr == 0 { IntEQ } else { IntNE };
+    let llptr = Load(bcx, GEPi(bcx, scrutinee, [0, ptrfield]));
     let llptrty = type_of::type_of(bcx.ccx(), *nonnull.fields.get(ptrfield));
     ICmp(bcx, cmp, llptr, C_null(llptrty))
 }
@@ -613,8 +590,7 @@ pub fn trans_case<'a>(bcx: &'a Block<'a>, r: &Repr, discr: Disr)
         Univariant(..) => {
             bcx.ccx().sess().bug("no cases for univariants or structs")
         }
-        RawNullablePointer { .. } |
-        StructWrappedNullablePointer { .. } => {
+        NullablePointer{ .. } => {
             assert!(discr == 0 || discr == 1);
             _match::single_result(Result::new(bcx, C_i1(bcx.ccx(), discr != 0)))
         }
@@ -645,13 +621,7 @@ pub fn trans_start_init(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr) {
         Univariant(..) => {
             assert_eq!(discr, 0);
         }
-        RawNullablePointer { nndiscr, nnty, ..} => {
-            if discr != nndiscr {
-                let llptrty = type_of::sizing_type_of(bcx.ccx(), nnty);
-                Store(bcx, C_null(llptrty), val)
-            }
-        }
-        StructWrappedNullablePointer { nonnull: ref nonnull, nndiscr, ptrfield, .. } => {
+        NullablePointer{ nonnull: ref nonnull, nndiscr, ptrfield, .. } => {
             if discr != nndiscr {
                 let llptrptr = GEPi(bcx, val, [0, ptrfield]);
                 let llptrty = type_of::type_of(bcx.ccx(),
@@ -681,11 +651,8 @@ pub fn num_args(r: &Repr, discr: Disr) -> uint {
             st.fields.len() - (if dtor { 1 } else { 0 })
         }
         General(_, ref cases) => cases.get(discr as uint).fields.len() - 1,
-        RawNullablePointer { nndiscr, ref nullfields, .. } => {
-            if discr == nndiscr { 1 } else { nullfields.len() }
-        }
-        StructWrappedNullablePointer { nonnull: ref nonnull, nndiscr,
-                                       nullfields: ref nullfields, .. } => {
+        NullablePointer{ nonnull: ref nonnull, nndiscr,
+                         nullfields: ref nullfields, .. } => {
             if discr == nndiscr { nonnull.fields.len() } else { nullfields.len() }
         }
     }
@@ -708,25 +675,19 @@ pub fn trans_field_ptr(bcx: &Block, r: &Repr, val: ValueRef, discr: Disr,
         General(_, ref cases) => {
             struct_field_ptr(bcx, cases.get(discr as uint), val, ix + 1, true)
         }
-        RawNullablePointer { nndiscr, ref nullfields, .. } |
-        StructWrappedNullablePointer { nndiscr, ref nullfields, .. } if discr != nndiscr => {
-            // The unit-like case might have a nonzero number of unit-like fields.
-            // (e.d., Result of Either with (), as one side.)
-            let ty = type_of::type_of(bcx.ccx(), *nullfields.get(ix));
-            assert_eq!(machine::llsize_of_alloc(bcx.ccx(), ty), 0);
-            // The contents of memory at this pointer can't matter, but use
-            // the value that's "reasonable" in case of pointer comparision.
-            PointerCast(bcx, val, ty.ptr_to())
-        }
-        RawNullablePointer { nndiscr, nnty, .. } => {
-            assert_eq!(ix, 0);
-            assert_eq!(discr, nndiscr);
-            let ty = type_of::type_of(bcx.ccx(), nnty);
-            PointerCast(bcx, val, ty.ptr_to())
-        }
-        StructWrappedNullablePointer { ref nonnull, nndiscr, .. } => {
-            assert_eq!(discr, nndiscr);
-            struct_field_ptr(bcx, nonnull, val, ix, false)
+        NullablePointer{ nonnull: ref nonnull, nullfields: ref nullfields,
+                         nndiscr, .. } => {
+            if discr == nndiscr {
+                struct_field_ptr(bcx, nonnull, val, ix, false)
+            } else {
+                // The unit-like case might have a nonzero number of unit-like fields.
+                // (e.g., Result or Either with () as one side.)
+                let ty = type_of::type_of(bcx.ccx(), *nullfields.get(ix));
+                assert_eq!(machine::llsize_of_alloc(bcx.ccx(), ty), 0);
+                // The contents of memory at this pointer can't matter, but use
+                // the value that's "reasonable" in case of pointer comparison.
+                PointerCast(bcx, val, ty.ptr_to())
+            }
         }
     }
 }
@@ -798,15 +759,7 @@ pub fn trans_const(ccx: &CrateContext, r: &Repr, discr: Disr,
             let contents = build_const_struct(ccx, st, vals);
             C_struct(ccx, contents.as_slice(), st.packed)
         }
-        RawNullablePointer { nndiscr, nnty, .. } => {
-            if discr == nndiscr {
-                assert_eq!(vals.len(), 1);
-                vals[0]
-            } else {
-                C_null(type_of::sizing_type_of(ccx, nnty))
-            }
-        }
-        StructWrappedNullablePointer { nonnull: ref nonnull, nndiscr, .. } => {
+        NullablePointer{ nonnull: ref nonnull, nndiscr, .. } => {
             if discr == nndiscr {
                 C_struct(ccx, build_const_struct(ccx,
                                                  nonnull,
@@ -914,15 +867,7 @@ pub fn const_get_discrim(ccx: &CrateContext, r: &Repr, val: ValueRef)
             }
         }
         Univariant(..) => 0,
-        RawNullablePointer { nndiscr, .. } => {
-            if is_null(val) {
-                /* subtraction as uint is ok because nndiscr is either 0 or 1 */
-                (1 - nndiscr) as Disr
-            } else {
-                nndiscr
-            }
-        }
-        StructWrappedNullablePointer { nndiscr, ptrfield, .. } => {
+        NullablePointer{ nndiscr, ptrfield, .. } => {
             if is_null(const_struct_field(ccx, val, ptrfield)) {
                 /* subtraction as uint is ok because nndiscr is either 0 or 1 */
                 (1 - nndiscr) as Disr
@@ -946,11 +891,7 @@ pub fn const_get_field(ccx: &CrateContext, r: &Repr, val: ValueRef,
         CEnum(..) => ccx.sess().bug("element access in C-like enum const"),
         Univariant(..) => const_struct_field(ccx, val, ix),
         General(..) => const_struct_field(ccx, val, ix + 1),
-        RawNullablePointer { .. } => {
-            assert_eq!(ix, 0);
-            val
-        }
-        StructWrappedNullablePointer{ .. } => const_struct_field(ccx, val, ix)
+        NullablePointer{ .. } => const_struct_field(ccx, val, ix)
     }
 }
 

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

@@ -1675,10 +1675,7 @@ fn prepare_enum_metadata(cx: &CrateContext,
                 }),
             }
         }
-        adt::RawNullablePointer { nnty, .. } => {
-            FinalMetadata(type_metadata(cx, nnty, span))
-        }
-        adt::StructWrappedNullablePointer { nonnull: ref struct_def, nndiscr, .. } => {
+        adt::NullablePointer { nonnull: ref struct_def, nndiscr, .. } => {
             let (metadata_stub,
                  variant_llvm_type,
                  member_description_factory) =

branches/snap-stage3/src/librustc/middle/typeck/astconv.rs

@@ -653,7 +653,7 @@ pub fn ast_ty_to_ty<AC:AstConv, RS:RegionScope>(
                         tcx.sess.span_err(
                             ast_ty.span,
                             format!("reference to trait `{name}` where a type is expected; \
-                                    try `Box<{name}>` or `&{name}`", name=path_str));
+                                    try `~{name}` or `&{name}`", name=path_str));
                         ty::mk_err()
                     }
                     ast::DefTy(did) | ast::DefStruct(did) => {