---

yaml
---
r: 50608
b: refs/heads/try
c: 66afa5d
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: f7a2371c176663d59062ec5158f39faecba45768
-refs/heads/try: 5d3d0890a7f380a453a6303bb96ba7bef28f6237
+refs/heads/try: 66afa5d17a0d157de38e749851ed75b48f8fc3c4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/RELEASES.txt

@@ -1,85 +1,8 @@
-Version 0.6 (March 2013)
+Version 0.6 (?)
 ---------------------------
 
-   * ~??? changes, numerous bugfixes
-
-   * TODO:
-      * Ord/Cmp
-      * Lifetime changes
-      * Implicit self
-      * Remove `static` keyword
-      * Static method syntax
-      * `as Trait`
-      * `copy` removed?
-
-   * Syntax changes
-      * The self type parameter in traits is now spelled `Self`
-      * Replaced the `Durable` trait with the `'static` lifetime
-      * The old closure type syntax with the trailing sigil has been
-        removed in favor of the more consistent leading sigil
-      * `super` is a keyword, and may be prefixed to paths
-      * Trait bounds are separated with `+` instead of whitespace
-      * Traits are implemented with `impl Trait for Type`
-        instead of `impl Type: Trait`
-      * The `export` keyword has finally been removed
-      * The `move` keyword has been removed (linear types move by default)
-      * The interior mutability qualifier on vectors, `[mut T]`, has been
-        removed. Use `&mut [T]`, etc.
-      * `mut` is no longer valid in `~mut T`. Use inherited mutability
-      * `fail` is no longer a keyword. Use `fail!()`
-      * `assert` is no longer a keyword. Use `assert!()`
-      * `log` is no longer a keyword. use `debug!`, etc.
-      * 1-tuples may be represented as `(T,)`
-      * Struct fields may no longer be `mut`. Use inherited mutability,
-        `@mut T`, `core::mut` or `core::cell`
-      * `extern mod { ... }` is no longer valid syntax for foreign
-        function modules. Use extern blocks: `extern { ... }`
-      * Newtype enums removed. Used tuple-structs.
-      * Trait implementations no longer support visibility modifiers
-
-   * Semantic changes
-      * Linear types move by default, eliminating the `move` keyword
-      * All foreign functions are considered unsafe
-      * &mut is now unaliasable
-      * Writes to borrowed @mut pointers are prevented dynamically
-      * () has size 0
-      * The name of the main function can be customized using #[main]
-      * The default type of an inferred closure is &fn instead of @fn
-      * Name resolution continues to be tweaked
-      * Method visibility is inherited from the implementation declaration
-
-   * Other language changes
-      * Structural records have been removed
-      * Many more types can be used in constants, including enums
-        `static lifetime pointers and vectors
-      * Pattern matching over vectors improved and expanded
-      * Typechecking of closure types has been overhauled to
-        improve inference and eliminate unsoundness
-
    * Libraries
-      * Lots of effort to organize the container API's around `core::container`
-      * `core::send_map` renamed to `core::hashmap`
-      * Added big integers to `std::bigint`
-      * Removed `core::oldcomm` module
-      * Added pipe-based `core::comm` module
-      * Reimplemented `std::treemap`
-      * Numeric traits have been reorganized under `core::num`
-      * `core::dvec` removed. Use `@mut ~[T]` or other language types
-      * `vec::slice` finally returns a slice
-      * `debug!` and friends don't require a format string, e.g. `debug!(Foo)`
-
-   * Tools
-      * Replaced the 'cargo' package manager with 'rustpkg'
-      * Added all-purpose 'rust' tool
-      * `rustc --test` now supports a benchmarks with the `#[bench]` attribute
-      * rustc now attempts to offer spelling suggestions
-
-   * Misc
-      * Improved support for ARM and Android
-      * Preliminary MIPS backend
-      * Improved foreign function ABI implementation for x86, x86_64
-      * Various and memory usage improvements
-      * Rust code may be embedded in foreign code under limited circumstances
+     * `core::send_map` renamed to `core::hashmap`
 
 Version 0.5 (December 2012)
 ---------------------------

branches/try/src/libcore/cell.rs

@@ -15,7 +15,6 @@ use prelude::*;
 ///
 /// Similar to a mutable option type, but friendlier.
 
-#[deriving_eq]
 pub struct Cell<T> {
     mut value: Option<T>
 }

branches/try/src/libcore/vec.rs

@@ -2145,20 +2145,6 @@ pub mod raw {
         f(*v)
     }
 
-    /**
-     * Form a slice from a pointer and length (as a number of units,
-     * not bytes).
-     */
-    #[inline(always)]
-    pub unsafe fn mut_buf_as_slice<T,U>(p: *mut T,
-                                        len: uint,
-                                        f: &fn(v: &mut [T]) -> U) -> U {
-        let pair = (p, len * sys::nonzero_size_of::<T>());
-        let v : *(&blk/mut [T]) =
-            ::cast::reinterpret_cast(&addr_of(&pair));
-        f(*v)
-    }
-
     /**
      * Unchecked vector indexing.
      */

branches/try/src/librustc/middle/trans/adt.rs

@@ -71,16 +71,18 @@ use util::ppaux::ty_to_str;
 
 /// Representations.
 pub enum Repr {
-    /// C-like enums; basically an int.
-    CEnum(int, int), // discriminant range
     /**
-     * Single-case variants, and structs/tuples/records.
-     *
-     * Structs with destructors need a dynamic destroyedness flag to
-     * avoid running the destructor too many times; this is included
-     * in the `Struct` if present.
+     * `Unit` exists only so that an enum with a single C-like variant
+     * can occupy no space, for ABI compatibility with rustc from
+     * before (and during) the creation of this module.  It may not be
+     * worth keeping around; `CEnum` and `Univariant` cover it
+     * overwise.
      */
-    Univariant(Struct, bool),
+    Unit(int),
+    /// C-like enums; basically an int.
+    CEnum(int, int), // discriminant range
+    /// Single-case variants, and structs/tuples/records.
+    Univariant(Struct, Destructor),
     /**
      * General-case enums: discriminant as int, followed by fields.
      * The fields start immediately after the discriminant, meaning
@@ -90,6 +92,18 @@ pub enum Repr {
     General(~[Struct])
 }
 
+/**
+ * Structs without destructors have historically had an extra layer of
+ * LLVM-struct to make accessing them work the same as structs with
+ * destructors.  This could probably be flattened to a boolean now
+ * that this module exists.
+ */
+enum Destructor {
+    StructWithDtor,
+    StructWithoutDtor,
+    NonStruct
+}
+
 /// For structs, and struct-like parts of anything fancier.
 struct Struct {
     size: u64,
@@ -115,17 +129,14 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
     }
     let repr = @match ty::get(t).sty {
         ty::ty_tup(ref elems) => {
-            Univariant(mk_struct(cx, *elems), false)
+            Univariant(mk_struct(cx, *elems), NonStruct)
         }
         ty::ty_struct(def_id, ref substs) => {
             let fields = ty::lookup_struct_fields(cx.tcx, def_id);
-            let ftys = do fields.map |field| {
+            let dt = ty::ty_dtor(cx.tcx, def_id).is_present();
+            Univariant(mk_struct(cx, fields.map(|field| {
                 ty::lookup_field_type(cx.tcx, def_id, field.id, substs)
-            };
-            let dtor = ty::ty_dtor(cx.tcx, def_id).is_present();
-            let ftys =
-                if dtor { ftys + [ty::mk_bool(cx.tcx)] } else { ftys };
-            Univariant(mk_struct(cx, ftys), dtor)
+            })), if dt { StructWithDtor } else { StructWithoutDtor })
         }
         ty::ty_enum(def_id, ref substs) => {
             struct Case { discr: int, tys: ~[ty::t] };
@@ -138,15 +149,18 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
             };
             if cases.len() == 0 {
                 // Uninhabitable; represent as unit
-                Univariant(mk_struct(cx, ~[]), false)
+                Unit(0)
+            } else if cases.len() == 1 && cases[0].tys.len() == 0 {
+                // `()`-like; see comment on definition of `Unit`.
+                Unit(cases[0].discr)
+            } else if cases.len() == 1 {
+                // Equivalent to a struct/tuple/newtype.
+                fail_unless!(cases[0].discr == 0);
+                Univariant(mk_struct(cx, cases[0].tys), NonStruct)
             } else if cases.all(|c| c.tys.len() == 0) {
                 // All bodies empty -> intlike
                 let discrs = cases.map(|c| c.discr);
                 CEnum(discrs.min(), discrs.max())
-            } else if cases.len() == 1 {
-                // Equivalent to a struct/tuple/newtype.
-                fail_unless!(cases[0].discr == 0);
-                Univariant(mk_struct(cx, cases[0].tys), false)
             } else {
                 // The general case.  Since there's at least one
                 // non-empty body, explicit discriminants should have
@@ -190,12 +204,18 @@ pub fn sizing_fields_of(cx: @CrateContext, r: &Repr) -> ~[TypeRef] {
 fn generic_fields_of(cx: @CrateContext, r: &Repr, sizing: bool)
     -> ~[TypeRef] {
     match *r {
+        Unit(*) => ~[],
         CEnum(*) => ~[T_enum_discrim(cx)],
-        Univariant(ref st, _dtor) => {
-            if sizing {
+        Univariant(ref st, dt) => {
+            let f = if sizing {
                 st.fields.map(|&ty| type_of::sizing_type_of(cx, ty))
             } else {
                 st.fields.map(|&ty| type_of::type_of(cx, ty))
+            };
+            match dt {
+                NonStruct => f,
+                StructWithoutDtor => ~[T_struct(f)],
+                StructWithDtor => ~[T_struct(f), T_i8()]
             }
         }
         General(ref sts) => {
@@ -217,7 +237,7 @@ pub fn trans_switch(bcx: block, r: &Repr, scrutinee: ValueRef)
         CEnum(*) | General(*) => {
             (_match::switch, Some(trans_get_discr(bcx, r, scrutinee)))
         }
-        Univariant(*) => {
+        Unit(*) | Univariant(*) => {
             (_match::single, None)
         }
     }
@@ -227,6 +247,7 @@ pub fn trans_switch(bcx: block, r: &Repr, scrutinee: ValueRef)
 pub fn trans_get_discr(bcx: block, r: &Repr, scrutinee: ValueRef)
     -> ValueRef {
     match *r {
+        Unit(the_disc) => C_int(bcx.ccx(), the_disc),
         CEnum(min, max) => load_discr(bcx, scrutinee, min, max),
         Univariant(*) => C_int(bcx.ccx(), 0),
         General(ref cases) => load_discr(bcx, scrutinee, 0,
@@ -264,7 +285,7 @@ pub fn trans_case(bcx: block, r: &Repr, discr: int) -> _match::opt_result {
         CEnum(*) => {
             _match::single_result(rslt(bcx, C_int(bcx.ccx(), discr)))
         }
-        Univariant(*)=> {
+        Unit(*) | Univariant(*)=> {
             bcx.ccx().sess.bug(~"no cases for univariants or structs")
         }
         General(*) => {
@@ -280,14 +301,16 @@ pub fn trans_case(bcx: block, r: &Repr, discr: int) -> _match::opt_result {
  */
 pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) {
     match *r {
+        Unit(the_discr) => {
+            fail_unless!(discr == the_discr);
+        }
         CEnum(min, max) => {
             fail_unless!(min <= discr && discr <= max);
             Store(bcx, C_int(bcx.ccx(), discr), GEPi(bcx, val, [0, 0]))
         }
-        Univariant(ref st, true) => {
+        Univariant(_, StructWithDtor) => {
             fail_unless!(discr == 0);
-            Store(bcx, C_bool(true),
-                  GEPi(bcx, val, [0, st.fields.len() - 1]))
+            Store(bcx, C_u8(1), GEPi(bcx, val, [0, 1]))
         }
         Univariant(*) => {
             fail_unless!(discr == 0);
@@ -304,11 +327,8 @@ pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) {
  */
 pub fn num_args(r: &Repr, discr: int) -> uint {
     match *r {
-        CEnum(*) => 0,
-        Univariant(ref st, dtor) => {
-            fail_unless!(discr == 0);
-            st.fields.len() - (if dtor { 1 } else { 0 })
-        }
+        Unit(*) | CEnum(*) => 0,
+        Univariant(ref st, _) => { fail_unless!(discr == 0); st.fields.len() }
         General(ref cases) => cases[discr as uint].fields.len()
     }
 }
@@ -320,11 +340,15 @@ pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int,
     // decide to do some kind of cdr-coding-like non-unique repr
     // someday), it will need to return a possibly-new bcx as well.
     match *r {
-        CEnum(*) => {
+        Unit(*) | CEnum(*) => {
             bcx.ccx().sess.bug(~"element access in C-like enum")
         }
-        Univariant(ref st, _dtor) => {
+        Univariant(ref st, dt) => {
             fail_unless!(discr == 0);
+            let val = match dt {
+                NonStruct => val,
+                StructWithDtor | StructWithoutDtor => GEPi(bcx, val, [0, 0])
+            };
             struct_field_ptr(bcx, st, val, ix, false)
         }
         General(ref cases) => {
@@ -352,7 +376,7 @@ fn struct_field_ptr(bcx: block, st: &Struct, val: ValueRef, ix: uint,
 /// Access the struct drop flag, if present.
 pub fn trans_drop_flag_ptr(bcx: block, r: &Repr, val: ValueRef) -> ValueRef {
     match *r {
-        Univariant(ref st, true) => GEPi(bcx, val, [0, st.fields.len() - 1]),
+        Univariant(_, StructWithDtor) => GEPi(bcx, val, [0, 1]),
         _ => bcx.ccx().sess.bug(~"tried to get drop flag of non-droppable \
                                   type")
     }
@@ -383,14 +407,23 @@ pub fn trans_drop_flag_ptr(bcx: block, r: &Repr, val: ValueRef) -> ValueRef {
 pub fn trans_const(ccx: @CrateContext, r: &Repr, discr: int,
                    vals: &[ValueRef]) -> ValueRef {
     match *r {
+        Unit(*) => {
+            C_struct(~[])
+        }
         CEnum(min, max) => {
             fail_unless!(vals.len() == 0);
             fail_unless!(min <= discr && discr <= max);
             C_int(ccx, discr)
         }
-        Univariant(ref st, _dro) => {
+        Univariant(ref st, dt) => {
             fail_unless!(discr == 0);
-            C_struct(build_const_struct(ccx, st, vals))
+            let s = C_struct(build_const_struct(ccx, st, vals));
+            match dt {
+                NonStruct => s,
+                // The actual destructor flag doesn't need to be present.
+                // But add an extra struct layer for compatibility.
+                StructWithDtor | StructWithoutDtor => C_struct(~[s])
+            }
         }
         General(ref cases) => {
             let case = &cases[discr as uint];
@@ -456,6 +489,7 @@ fn roundup(x: u64, a: u64) -> u64 { ((x + (a - 1)) / a) * a }
 pub fn const_get_discrim(ccx: @CrateContext, r: &Repr, val: ValueRef)
     -> int {
     match *r {
+        Unit(discr) => discr,
         CEnum(*) => const_to_int(val) as int,
         Univariant(*) => 0,
         General(*) => const_to_int(const_get_elt(ccx, val, [0])) as int,
@@ -472,9 +506,11 @@ pub fn const_get_discrim(ccx: @CrateContext, r: &Repr, val: ValueRef)
 pub fn const_get_field(ccx: @CrateContext, r: &Repr, val: ValueRef,
                        _discr: int, ix: uint) -> ValueRef {
     match *r {
-        CEnum(*) => ccx.sess.bug(~"element access in C-like enum \
+        Unit(*) | CEnum(*) => ccx.sess.bug(~"element access in C-like enum \
                                              const"),
-        Univariant(*) => const_struct_field(ccx, val, ix),
+        Univariant(_, NonStruct) => const_struct_field(ccx, val, ix),
+        Univariant(*) => const_struct_field(ccx, const_get_elt(ccx, val,
+                                                               [0]), ix),
         General(*) => const_struct_field(ccx, const_get_elt(ccx, val,
                                                             [1, 0]), ix)
     }
@@ -506,7 +542,8 @@ fn const_struct_field(ccx: @CrateContext, val: ValueRef, ix: uint)
 /// Is it safe to bitcast a value to the one field of its one variant?
 pub fn is_newtypeish(r: &Repr) -> bool {
     match *r {
-        Univariant(ref st, false) => st.fields.len() == 1,
+        Univariant(ref st, StructWithoutDtor)
+        | Univariant(ref st, NonStruct) => st.fields.len() == 1,
         _ => false
     }
 }