---

yaml
---
r: 61340
b: refs/heads/try
c: cda3ac9
h: refs/heads/master
v: v3

Author: thestinger

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: 4e4f90d4a0b887c45d1ced359657fbdb23ab2438
+refs/heads/try: cda3ac905a56dc6580429eea259143d30a7f3c02
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libcore/cell.rs

@@ -21,10 +21,17 @@ Similar to a mutable option type, but friendlier.
 */
 
 #[mutable]
+#[deriving(Clone)]
 pub struct Cell<T> {
     priv value: Option<T>
 }
 
+impl<T: DeepClone> DeepClone for Cell<T> {
+    fn deep_clone(&self) -> Cell<T> {
+        Cell{value: self.value.deep_clone()}
+    }
+}
+
 impl<T:cmp::Eq> cmp::Eq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
         (self.value) == (other.value)

branches/try/src/libcore/clone.rs

@@ -23,17 +23,12 @@ by convention implementing the `Clone` trait and calling the
 */
 
 pub trait Clone {
-    /// Return a deep copy of the owned object tree. Managed boxes are cloned with a shallow copy.
+    /// Return a deep copy of the owned object tree. Types with shared ownership like managed boxes
+    /// are cloned with a shallow copy.
     fn clone(&self) -> Self;
 }
 
-impl Clone for () {
-    /// Return a copy of the value.
-    #[inline(always)]
-    fn clone(&self) -> () { () }
-}
-
-impl<T:Clone> Clone for ~T {
+impl<T: Clone> Clone for ~T {
     /// Return a deep copy of the owned box.
     #[inline(always)]
     fn clone(&self) -> ~T { ~(**self).clone() }
@@ -54,7 +49,7 @@ impl<T> Clone for @mut T {
 macro_rules! clone_impl(
     ($t:ty) => {
         impl Clone for $t {
-            /// Return a copy of the value.
+            /// Return a deep copy of the value.
             #[inline(always)]
             fn clone(&self) -> $t { *self }
         }
@@ -77,9 +72,53 @@ clone_impl!(float)
 clone_impl!(f32)
 clone_impl!(f64)
 
+clone_impl!(())
 clone_impl!(bool)
 clone_impl!(char)
 
+pub trait DeepClone {
+    /// Return a deep copy of the object tree. Types with shared ownership are also copied via a
+    /// deep copy, unlike `Clone`. Note that this is currently unimplemented for managed boxes, as
+    /// it would need to handle cycles.
+    fn deep_clone(&self) -> Self;
+}
+
+macro_rules! deep_clone_impl(
+    ($t:ty) => {
+        impl DeepClone for $t {
+            /// Return a deep copy of the value.
+            #[inline(always)]
+            fn deep_clone(&self) -> $t { *self }
+        }
+    }
+)
+
+impl<T: DeepClone> DeepClone for ~T {
+    /// Return a deep copy of the owned box.
+    #[inline(always)]
+    fn deep_clone(&self) -> ~T { ~(**self).deep_clone() }
+}
+
+deep_clone_impl!(int)
+deep_clone_impl!(i8)
+deep_clone_impl!(i16)
+deep_clone_impl!(i32)
+deep_clone_impl!(i64)
+
+deep_clone_impl!(uint)
+deep_clone_impl!(u8)
+deep_clone_impl!(u16)
+deep_clone_impl!(u32)
+deep_clone_impl!(u64)
+
+deep_clone_impl!(float)
+deep_clone_impl!(f32)
+deep_clone_impl!(f64)
+
+deep_clone_impl!(())
+deep_clone_impl!(bool)
+deep_clone_impl!(char)
+
 #[test]
 fn test_owned_clone() {
     let a: ~int = ~5i;

branches/try/src/libcore/option.rs

@@ -49,6 +49,7 @@ use num::Zero;
 use old_iter::{BaseIter, MutableIter, ExtendedIter};
 use old_iter;
 use str::StrSlice;
+use clone::DeepClone;
 
 #[cfg(test)] use str;
 
@@ -59,6 +60,15 @@ pub enum Option<T> {
     Some(T),
 }
 
+impl<T: DeepClone> DeepClone for Option<T> {
+    fn deep_clone(&self) -> Option<T> {
+        match *self {
+            Some(ref x) => Some(x.deep_clone()),
+            None => None
+        }
+    }
+}
+
 impl<T:Ord> Ord for Option<T> {
     fn lt(&self, other: &Option<T>) -> bool {
         match (self, other) {

branches/try/src/libcore/prelude.rs

@@ -27,7 +27,7 @@ pub use io::{print, println};
 
 /* Reexported types and traits */
 
-pub use clone::Clone;
+pub use clone::{Clone, DeepClone};
 pub use cmp::{Eq, ApproxEq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater, Equiv};
 pub use container::{Container, Mutable, Map, Set};
 pub use hash::Hash;

branches/try/src/libcore/to_bytes.rs

@@ -458,7 +458,6 @@ pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
     b.iter_bytes(lsb0, |bytes| {flag = z(bytes); flag});
 }
 #[cfg(not(stage0))]
-#[inline(always)]
 pub fn iter_bytes_2<A:IterBytes,B:IterBytes>(a: &A, b: &B,
                                              lsb0: bool, z: Cb) -> bool {
     a.iter_bytes(lsb0, z) && b.iter_bytes(lsb0, z)

branches/try/src/librustc/metadata/common.rs

@@ -100,7 +100,7 @@ pub static tag_mod_impl_trait: uint = 0x47u;
   different tags.
  */
 pub static tag_item_impl_method: uint = 0x48u;
-pub static tag_item_trait_method_explicit_self: uint = 0x4b;
+pub static tag_item_trait_method_self_ty: uint = 0x4b;
 pub static tag_item_trait_method_self_ty_region: uint = 0x4c;
 
 

branches/try/src/librustc/metadata/csearch.rs

@@ -22,7 +22,7 @@ use syntax::ast_map;
 use syntax::diagnostic::expect;
 
 pub struct ProvidedTraitMethodInfo {
-    ty: ty::Method,
+    ty: ty::method,
     def_id: ast::def_id
 }
 
@@ -129,18 +129,17 @@ pub fn get_impls_for_mod(cstore: @mut cstore::CStore, def: ast::def_id,
 }
 
 pub fn get_method(tcx: ty::ctxt,
-                  def: ast::def_id) -> ty::Method
+                  def: ast::def_id) -> ty::method
 {
     let cdata = cstore::get_crate_data(tcx.cstore, def.crate);
     decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
 }
 
-pub fn get_method_name_and_explicit_self(cstore: @mut cstore::CStore,
-                                         def: ast::def_id)
-                                     -> (ast::ident, ast::explicit_self_)
+pub fn get_method_name_and_self_ty(cstore: @mut cstore::CStore,
+                                   def: ast::def_id) -> (ast::ident, ast::self_ty_)
 {
     let cdata = cstore::get_crate_data(cstore, def.crate);
-    decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node)
+    decoder::get_method_name_and_self_ty(cstore.intr, cdata, def.node)
 }
 
 pub fn get_trait_method_def_ids(cstore: @mut cstore::CStore,

branches/try/src/librustc/metadata/decoder.rs

@@ -653,7 +653,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
                                 item, tcx, cdata);
         let name = item_name(intr, item);
         let arg_tys = match ty::get(ctor_ty).sty {
-          ty::ty_bare_fn(ref f) => copy f.sig.inputs,
+          ty::ty_bare_fn(ref f) => f.sig.inputs.map(|a| a.ty),
           _ => ~[], // Nullary enum variant.
         };
         match variant_disr_val(item) {
@@ -670,7 +670,7 @@ pub fn get_enum_variants(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     return infos;
 }
 
-fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
+fn get_self_ty(item: ebml::Doc) -> ast::self_ty_ {
     fn get_mutability(ch: u8) -> ast::mutability {
         match ch as char {
             'i' => { ast::m_imm }
@@ -682,11 +682,11 @@ fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
         }
     }
 
-    let explicit_self_doc = reader::get_doc(item, tag_item_trait_method_explicit_self);
-    let string = reader::doc_as_str(explicit_self_doc);
+    let self_type_doc = reader::get_doc(item, tag_item_trait_method_self_ty);
+    let string = reader::doc_as_str(self_type_doc);
 
-    let explicit_self_kind = string[0];
-    match explicit_self_kind as char {
+    let self_ty_kind = string[0];
+    match self_ty_kind as char {
         's' => { return ast::sty_static; }
         'v' => { return ast::sty_value; }
         '@' => { return ast::sty_box(get_mutability(string[1])); }
@@ -696,7 +696,7 @@ fn get_explicit_self(item: ebml::Doc) -> ast::explicit_self_ {
             return ast::sty_region(None, get_mutability(string[1]));
         }
         _ => {
-            fail!("unknown self type code: `%c`", explicit_self_kind as char);
+            fail!("unknown self type code: `%c`", self_ty_kind as char);
         }
     }
 }
@@ -707,12 +707,12 @@ fn item_impl_methods(intr: @ident_interner, cdata: cmd, item: ebml::Doc,
     for reader::tagged_docs(item, tag_item_impl_method) |doc| {
         let m_did = reader::with_doc_data(doc, |d| parse_def_id(d));
         let mth_item = lookup_item(m_did.node, cdata.data);
-        let explicit_self = get_explicit_self(mth_item);
+        let self_ty = get_self_ty(mth_item);
         rslt.push(@resolve::MethodInfo {
                     did: translate_def_id(cdata, m_did),
                     n_tps: item_ty_param_count(mth_item) - base_tps,
                     ident: item_name(intr, mth_item),
-                    explicit_self: explicit_self});
+                    self_type: self_ty});
     }
     rslt
 }
@@ -748,19 +748,19 @@ pub fn get_impls_for_mod(intr: @ident_interner,
     @result
 }
 
-pub fn get_method_name_and_explicit_self(
+pub fn get_method_name_and_self_ty(
     intr: @ident_interner,
     cdata: cmd,
-    id: ast::node_id) -> (ast::ident, ast::explicit_self_)
+    id: ast::node_id) -> (ast::ident, ast::self_ty_)
 {
     let method_doc = lookup_item(id, cdata.data);
     let name = item_name(intr, method_doc);
-    let explicit_self = get_explicit_self(method_doc);
-    (name, explicit_self)
+    let self_ty = get_self_ty(method_doc);
+    (name, self_ty)
 }
 
 pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
-                  tcx: ty::ctxt) -> ty::Method
+                  tcx: ty::ctxt) -> ty::method
 {
     let method_doc = lookup_item(id, cdata.data);
     let def_id = item_def_id(method_doc, cdata);
@@ -770,20 +770,19 @@ pub fn get_method(intr: @ident_interner, cdata: cmd, id: ast::node_id,
     let transformed_self_ty = doc_transformed_self_ty(method_doc, tcx, cdata);
     let fty = doc_method_fty(method_doc, tcx, cdata);
     let vis = item_visibility(method_doc);
-    let explicit_self = get_explicit_self(method_doc);
-
-    ty::Method::new(
-        name,
-        ty::Generics {
+    let self_ty = get_self_ty(method_doc);
+    ty::method {
+        ident: name,
+        generics: ty::Generics {
             type_param_defs: type_param_defs,
             region_param: None
         },
-        transformed_self_ty,
-        fty,
-        explicit_self,
-        vis,
-        def_id
-    )
+        transformed_self_ty: transformed_self_ty,
+        fty: fty,
+        self_ty: self_ty,
+        vis: vis,
+        def_id: def_id
+    }
 }
 
 pub fn get_trait_method_def_ids(cdata: cmd,
@@ -824,20 +823,19 @@ pub fn get_provided_trait_methods(intr: @ident_interner, cdata: cmd,
         };
 
         let transformed_self_ty = doc_transformed_self_ty(mth, tcx, cdata);
-        let explicit_self = get_explicit_self(mth);
-
-        let ty_method = ty::Method::new(
-            name,
-            ty::Generics {
+        let self_ty = get_self_ty(mth);
+        let ty_method = ty::method {
+            ident: name,
+            generics: ty::Generics {
                 type_param_defs: type_param_defs,
                 region_param: None
             },
-            transformed_self_ty,
-            fty,
-            explicit_self,
-            ast::public,
-            did
-        );
+            transformed_self_ty: transformed_self_ty,
+            fty: fty,
+            self_ty: self_ty,
+            vis: ast::public,
+            def_id: did
+        };
         let provided_trait_method_info = ProvidedTraitMethodInfo {
             ty: ty_method,
             def_id: did