---

yaml
---
r: 60395
b: refs/heads/master
c: 305331c
h: refs/heads/master
i:
  60393: d85064c
  60391: dda1cc5
v: v3

Author: brson

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: cf8341fc9e1c18c973a6744ecd7ebb97adbd3025
+refs/heads/master: 305331c00fe0b3838479e536903915420c4274ef
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/.swo

@@ -1562,7 +1562,7 @@ Supported traits for `deriving` are:
 
 * Comparison traits: `Eq`, `TotalEq`, `Ord`, `TotalOrd`.
 * Serialization: `Encodable`, `Decodable`. These require `std`.
-* `Clone` and `DeepClone`, to perform (deep) copies.
+* `Clone`, to perform deep copies.
 * `IterBytes`, to iterate over the bytes in a data type.
 * `Rand`, to create a random instance of a data type.
 * `ToStr`, to convert to a string. For a type with this instance,

trunk/doc/rust.md

@@ -2308,8 +2308,8 @@ enum ABC { A, B, C }
 ~~~
 
 The full list of derivable traits is `Eq`, `TotalEq`, `Ord`,
-`TotalOrd`, `Encodable` `Decodable`, `Clone`, `DeepClone`,
-`IterBytes`, `Rand` and `ToStr`.
+`TotalOrd`, `Encodable` `Decodable`, `Clone`, `IterBytes`, `Rand` and
+`ToStr`.
 
 # Modules and crates
 

trunk/doc/tutorial.md

@@ -48,12 +48,6 @@ impl<T> Clone for @mut T {
     fn clone(&self) -> @mut T { *self }
 }
 
-impl<'self, T> Clone for &'self T {
-    /// Return a shallow copy of the borrowed pointer.
-    #[inline(always)]
-    fn clone(&self) -> &'self T { *self }
-}
-
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {
@@ -172,11 +166,3 @@ fn test_managed_mut_clone() {
     *b = 10;
     assert!(a == b);
 }
-
-#[test]
-fn test_borrowed_clone() {
-    let x = 5i;
-    let y: &int = &x;
-    let z: &int = (&y).clone();
-    assert_eq!(*z, 5);
-}

trunk/src/libcore/clone.rs

@@ -8,62 +8,119 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-/*!
-An attempt to move all intrinsic declarations to a single place,
-as mentioned in #3369
-The intrinsics are defined in librustc/middle/trans/foreign.rs.
+/*! rustc compiler intrinsics.
+
+The corresponding definitions are in librustc/middle/trans/foreign.rs.
+
+# Atomics
+
+The atomic intrinsics provide common atomic operations on machine
+words, with multiple possible memory orderings. They obey the same
+semantics as C++0x. See the LLVM documentation on [[atomics]].
+
+[atomics]: http://llvm.org/docs/Atomics.html
+
+A quick refresher on memory ordering:
+
+* Acquire - a barrier for aquiring a lock. Subsequent reads and writes
+  take place after the barrier.
+* Release - a barrier for releasing a lock. Preceding reads and writes
+  take place before the barrier.
+* Sequentially consistent - sequentially consistent operations are
+  guaranteed to happen in order. This is the standard mode for working
+  with atomic types and is equivalent to Java's `volatile`.
+
 */
 
 #[abi = "rust-intrinsic"]
 pub extern "rust-intrinsic" {
+
+    /// Atomic compare and exchange, sequentially consistent.
     pub fn atomic_cxchg(dst: &mut int, old: int, src: int) -> int;
+    /// Atomic compare and exchange, acquire ordering.
     pub fn atomic_cxchg_acq(dst: &mut int, old: int, src: int) -> int;
+    /// Atomic compare and exchange, release ordering.
     pub fn atomic_cxchg_rel(dst: &mut int, old: int, src: int) -> int;
 
+    /// Atomic load, sequentially consistent.
     #[cfg(not(stage0))]
     pub fn atomic_load(src: &int) -> int;
+    /// Atomic load, acquire ordering.
     #[cfg(not(stage0))]
     pub fn atomic_load_acq(src: &int) -> int;
 
+    /// Atomic store, sequentially consistent.
     #[cfg(not(stage0))]
     pub fn atomic_store(dst: &mut int, val: int);
+    /// Atomic store, release ordering.
     #[cfg(not(stage0))]
     pub fn atomic_store_rel(dst: &mut int, val: int);
 
+    /// Atomic exchange, sequentially consistent.
     pub fn atomic_xchg(dst: &mut int, src: int) -> int;
+    /// Atomic exchange, acquire ordering.
     pub fn atomic_xchg_acq(dst: &mut int, src: int) -> int;
+    /// Atomic exchange, release ordering.
     pub fn atomic_xchg_rel(dst: &mut int, src: int) -> int;
 
+    /// Atomic addition, sequentially consistent.
     pub fn atomic_xadd(dst: &mut int, src: int) -> int;
+    /// Atomic addition, acquire ordering.
     pub fn atomic_xadd_acq(dst: &mut int, src: int) -> int;
+    /// Atomic addition, release ordering.
     pub fn atomic_xadd_rel(dst: &mut int, src: int) -> int;
 
+    /// Atomic subtraction, sequentially consistent.
     pub fn atomic_xsub(dst: &mut int, src: int) -> int;
+    /// Atomic subtraction, acquire ordering.
     pub fn atomic_xsub_acq(dst: &mut int, src: int) -> int;
+    /// Atomic subtraction, release ordering.
     pub fn atomic_xsub_rel(dst: &mut int, src: int) -> int;
 
+    /// The size of a type in bytes.
+    ///
+    /// This is the exact number of bytes in memory taken up by a
+    /// value of the given type. In other words, a memset of this size
+    /// would *exactly* overwrite a value. When laid out in vectors
+    /// and structures there may be additional padding between
+    /// elements.
     pub fn size_of<T>() -> uint;
 
+    /// Move a value to a memory location containing a value.
+    ///
+    /// Drop glue is run on the destination, which must contain a
+    /// valid Rust value.
     pub fn move_val<T>(dst: &mut T, src: T);
+
+    /// Move a value to an uninitialized memory location.
+    ///
+    /// Drop glue is not run on the destination.
     pub fn move_val_init<T>(dst: &mut T, src: T);
 
     pub fn min_align_of<T>() -> uint;
     pub fn pref_align_of<T>() -> uint;
 
+    /// Get a static pointer to a type descriptor.
     pub fn get_tydesc<T>() -> *();
 
-    /// init is unsafe because it returns a zeroed-out datum,
+    /// Create a value initialized to zero.
+    ///
+    /// `init` is unsafe because it returns a zeroed-out datum,
     /// which is unsafe unless T is POD. We don't have a POD
-    /// kind yet. (See #4074)
+    /// kind yet. (See #4074).
     pub unsafe fn init<T>() -> T;
 
+    /// Create an uninitialized value.
     #[cfg(not(stage0))]
     pub unsafe fn uninit<T>() -> T;
 
-    /// forget is unsafe because the caller is responsible for
-    /// ensuring the argument is deallocated already
+    /// Move a value out of scope without running drop glue.
+    ///
+    /// `forget` is unsafe because the caller is responsible for
+    /// ensuring the argument is deallocated already.
     pub unsafe fn forget<T>(_: T) -> ();
 
+    /// Returns `true` if a type requires drop glue.
     pub fn needs_drop<T>() -> bool;
 
     // XXX: intrinsic uses legacy modes and has reference to TyDesc
@@ -72,9 +129,12 @@ pub extern "rust-intrinsic" {
     // XXX: intrinsic uses legacy modes
     //fn frame_address(f: &once fn(*u8));
 
+    /// Get the address of the `__morestack` stack growth function.
     pub fn morestack_addr() -> *();
 
+    /// Equivalent to the `llvm.memmove.p0i8.0i8.i32` intrinsic.
     pub fn memmove32(dst: *mut u8, src: *u8, size: u32);
+    /// Equivalent to the `llvm.memmove.p0i8.0i8.i64` intrinsic.
     pub fn memmove64(dst: *mut u8, src: *u8, size: u64);
 
     pub fn sqrtf32(x: f32) -> f32;

trunk/src/libcore/unstable/intrinsics.rs

@@ -470,14 +470,12 @@ fn parse_closure_ty(st: @mut PState, conv: conv_did) -> ty::ClosureTy {
     let purity = parse_purity(next(st));
     let onceness = parse_onceness(next(st));
     let region = parse_region(st);
-    let bounds = parse_bounds(st, conv);
     let sig = parse_sig(st, conv);
     ty::ClosureTy {
         purity: purity,
         sigil: sigil,
         onceness: onceness,
         region: region,
-        bounds: bounds.builtin_bounds,
         sig: sig
     }
 }
@@ -542,10 +540,10 @@ pub fn parse_type_param_def_data(data: @~[u8], start: uint,
 
 fn parse_type_param_def(st: @mut PState, conv: conv_did) -> ty::TypeParameterDef {
     ty::TypeParameterDef {def_id: parse_def(st, NominalType, conv),
-                          bounds: @parse_bounds(st, conv)}
+                          bounds: parse_bounds(st, conv)}
 }
 
-fn parse_bounds(st: @mut PState, conv: conv_did) -> ty::ParamBounds {
+fn parse_bounds(st: @mut PState, conv: conv_did) -> @ty::ParamBounds {
     let mut param_bounds = ty::ParamBounds {
         builtin_bounds: ty::EmptyBuiltinBounds(),
         trait_bounds: ~[]
@@ -568,7 +566,7 @@ fn parse_bounds(st: @mut PState, conv: conv_did) -> ty::ParamBounds {
                 param_bounds.trait_bounds.push(@parse_trait_ref(st, conv));
             }
             '.' => {
-                return param_bounds;
+                return @param_bounds;
             }
             _ => {
                 fail!("parse_bounds: bad bounds")

trunk/src/librustc/metadata/tydecode.rs

@@ -380,9 +380,6 @@ fn enc_closure_ty(w: @io::Writer, cx: @ctxt, ft: &ty::ClosureTy) {
     enc_purity(w, ft.purity);
     enc_onceness(w, ft.onceness);
     enc_region(w, cx, ft.region);
-    let bounds = ty::ParamBounds {builtin_bounds: ft.bounds,
-                                  trait_bounds: ~[]};
-    enc_bounds(w, cx, &bounds);
     enc_fn_sig(w, cx, &ft.sig);
 }
 
@@ -395,7 +392,7 @@ fn enc_fn_sig(w: @io::Writer, cx: @ctxt, fsig: &ty::FnSig) {
     enc_ty(w, cx, fsig.output);
 }
 
-fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: &ty::ParamBounds) {
+fn enc_bounds(w: @io::Writer, cx: @ctxt, bs: @ty::ParamBounds) {
     for bs.builtin_bounds.each |bound| {
         match bound {
             ty::BoundOwned => w.write_char('S'),

trunk/src/librustc/metadata/tyencode.rs

@@ -20,7 +20,6 @@ use middle::lint::{allow, level, unused_imports};
 use middle::lint::{get_lint_level, get_lint_settings_level};
 use middle::pat_util::pat_bindings;
 
-use syntax::ast::{TyParamBound, ty_closure};
 use syntax::ast::{RegionTyParamBound, TraitTyParamBound, _mod, add, arm};
 use syntax::ast::{binding_mode, bitand, bitor, bitxor, blk};
 use syntax::ast::{bind_infer, bind_by_ref, bind_by_copy};
@@ -3733,20 +3732,14 @@ pub impl Resolver {
                                type_parameters: &OptVec<TyParam>,
                                visitor: ResolveVisitor) {
         for type_parameters.each |type_parameter| {
-            for type_parameter.bounds.each |bound| {
-                self.resolve_type_parameter_bound(bound, visitor);
-            }
-        }
-    }
-
-    fn resolve_type_parameter_bound(@mut self,
-                                    type_parameter_bound: &TyParamBound,
-                                    visitor: ResolveVisitor) {
-        match *type_parameter_bound {
-            TraitTyParamBound(tref) => {
-                self.resolve_trait_reference(tref, visitor)
+            for type_parameter.bounds.each |&bound| {
+                match bound {
+                    TraitTyParamBound(tref) => {
+                        self.resolve_trait_reference(tref, visitor)
+                    }
+                    RegionTyParamBound => {}
+                }
             }
-            RegionTyParamBound => {}
         }
     }
 
@@ -4077,13 +4070,6 @@ pub impl Resolver {
                 }
             }
 
-            ty_closure(c) => {
-                for c.bounds.each |bound| {
-                    self.resolve_type_parameter_bound(bound, visitor);
-                }
-                visit_ty(ty, (), visitor);
-            }
-
             _ => {
                 // Just resolve embedded types.
                 visit_ty(ty, (), visitor);

trunk/src/librustc/middle/resolve.rs

@@ -818,7 +818,6 @@ pub fn trans_intrinsic(ccx: @CrateContext,
                 sigil: ast::BorrowedSigil,
                 onceness: ast::Many,
                 region: ty::re_bound(ty::br_anon(0)),
-                bounds: ty::EmptyBuiltinBounds(),
                 sig: FnSig {
                     bound_lifetime_names: opt_vec::Empty,
                     inputs: ~[ star_u8 ],

trunk/src/librustc/middle/trans/foreign.rs

@@ -330,7 +330,6 @@ pub fn normalize_for_monomorphization(tcx: ty::ctxt,
                 sigil: sigil,
                 onceness: ast::Many,
                 region: ty::re_static,
-                bounds: ty::EmptyBuiltinBounds(),
                 sig: ty::FnSig {bound_lifetime_names: opt_vec::Empty,
                                 inputs: ~[],
                                 output: ty::mk_nil()}})

trunk/src/librustc/middle/trans/monomorphize.rs

@@ -22,7 +22,7 @@ use middle::typeck;
 use middle;
 use util::ppaux::{note_and_explain_region, bound_region_to_str};
 use util::ppaux::{trait_store_to_str, ty_to_str, vstore_to_str};
-use util::ppaux::{Repr, UserString};
+use util::ppaux::Repr;
 use util::common::{indenter};
 use util::enum_set::{EnumSet, CLike};
 
@@ -390,8 +390,7 @@ pub struct ClosureTy {
     sigil: ast::Sigil,
     onceness: ast::Onceness,
     region: Region,
-    bounds: BuiltinBounds,
-    sig: FnSig,
+    sig: FnSig
 }
 
 /**
@@ -686,7 +685,6 @@ pub enum type_err {
     terr_int_mismatch(expected_found<IntVarValue>),
     terr_float_mismatch(expected_found<ast::float_ty>),
     terr_traits(expected_found<ast::def_id>),
-    terr_builtin_bounds(expected_found<BuiltinBounds>),
 }
 
 #[deriving(Eq, IterBytes)]
@@ -709,15 +707,6 @@ pub fn EmptyBuiltinBounds() -> BuiltinBounds {
     EnumSet::empty()
 }
 
-pub fn AllBuiltinBounds() -> BuiltinBounds {
-    let mut set = EnumSet::empty();
-    set.add(BoundCopy);
-    set.add(BoundStatic);
-    set.add(BoundOwned);
-    set.add(BoundConst);
-    set
-}
-
 impl CLike for BuiltinBound {
     pub fn to_uint(&self) -> uint {
         *self as uint
@@ -3180,7 +3169,6 @@ pub fn adjust_ty(cx: ctxt,
                                        sigil: s,
                                        onceness: ast::Many,
                                        region: r,
-                                       bounds: ty::AllBuiltinBounds(),
                                        sig: copy b.sig})
                 }
                 ref b => {
@@ -3709,19 +3697,6 @@ pub fn type_err_to_str(cx: ctxt, err: &type_err) -> ~str {
                  item_path_str(cx, values.expected),
                  item_path_str(cx, values.found))
         }
-        terr_builtin_bounds(values) => {
-            if values.expected.is_empty() {
-                fmt!("expected no bounds but found `%s`",
-                     values.found.user_string(cx))
-            } else if values.found.is_empty() {
-                fmt!("expected bounds `%s` but found no bounds",
-                     values.expected.user_string(cx))
-            } else {
-                fmt!("expected bounds `%s` but found bounds `%s`",
-                     values.expected.user_string(cx),
-                     values.found.user_string(cx))
-            }
-        }
         terr_self_substs => {
             ~"inconsistent self substitution" // XXX this is more of a bug
         }