Making fields in std and extra : private #4386

74 files changed, 1286 insertions, 354 deletions

diff --git a/src/libstd/c_str.rs b/src/libstd/c_str.rs
index acfa02a4def..2f1ac2c6b6b 100644
--- a/src/libstd/c_str.rs
+++ b/src/libstd/c_str.rs
@@ -92,6 +92,7 @@ condition! {
 /// This structure wraps a `*libc::c_char`, and will automatically free the
 /// memory it is pointing to when it goes out of scope.
 pub struct CString {
+    // already priv
     priv buf: *libc::c_char,
     priv owns_buffer_: bool,
 }
@@ -332,6 +333,7 @@ fn check_for_null(v: &[u8], buf: *mut libc::c_char) {
 ///
 /// Use with the `std::iterator` module.
 pub struct CStringIterator<'self> {
+    // already priv
     priv ptr: *libc::c_char,
     priv lifetime: &'self libc::c_char, // FIXME: #5922
 }
diff --git a/src/libstd/cell.rs b/src/libstd/cell.rs
index a1459b780df..e1ba46e8f27 100644
--- a/src/libstd/cell.rs
+++ b/src/libstd/cell.rs
@@ -26,6 +26,7 @@ Similar to a mutable option type, but friendlier.
 #[deriving(Clone, DeepClone, Eq)]
 #[allow(missing_doc)]
 pub struct Cell<T> {
+    // already priv
     priv value: Option<T>
 }
 
diff --git a/src/libstd/condition.rs b/src/libstd/condition.rs
index cb9552b189c..346e8a51322 100644
--- a/src/libstd/condition.rs
+++ b/src/libstd/condition.rs
@@ -72,6 +72,7 @@ use unstable::raw::Closure;
 
 #[doc(hidden)]
 pub struct Handler<T, U> {
+    //already priv
     priv handle: Closure,
     priv prev: Option<@Handler<T, U>>,
 }
@@ -83,6 +84,7 @@ pub struct Handler<T, U> {
 /// This struct should never be created directly, but rather only through the
 /// `condition!` macro provided to all libraries using libstd.
 pub struct Condition<T, U> {
+    // all made priv by reedlepee
     /// Name of the condition handler
     name: &'static str,
     /// TLS key used to insert/remove values in TLS.
diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index e7fa81fc87a..b47559b6055 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -477,8 +477,9 @@ pub mod rt;
 /// should be formatted. A mutable version of this is passed to all formatting
 /// traits.
 pub struct Formatter<'self> {
+    // made by reedlepee
     /// Flags for formatting (packed version of rt::Flag)
-    flags: uint,
+     flags: uint,
     /// Character used as 'fill' whenever there is alignment
     fill: char,
     /// Boolean indication of whether the output should be left-aligned
@@ -486,11 +487,12 @@ pub struct Formatter<'self> {
     /// Optionally specified integer width that the output should be
     width: Option<uint>,
     /// Optionally specified precision for numeric types
-    precision: Option<uint>,
+     precision: Option<uint>,
 
     /// Output buffer.
     buf: &'self mut io::Writer,
 
+    // already priv
     priv curarg: vec::VecIterator<'self, Argument<'self>>,
     priv args: &'self [Argument<'self>],
 }
@@ -500,6 +502,7 @@ pub struct Formatter<'self> {
 /// compile time it is ensured that the function and the value have the correct
 /// types, and then this struct is used to canonicalize arguments to one type.
 pub struct Argument<'self> {
+    // already priv
     priv formatter: extern "Rust" fn(&util::Void, &mut Formatter),
     priv value: &'self util::Void,
 }
@@ -526,6 +529,7 @@ impl<'self> Arguments<'self> {
 /// string at compile-time so usage of the `write` and `format` functions can
 /// be safely performed.
 pub struct Arguments<'self> {
+    // already priv
     priv fmt: &'self [rt::Piece<'self>],
     priv args: &'self [Argument<'self>],
 }
diff --git a/src/libstd/fmt/parse.rs b/src/libstd/fmt/parse.rs
index 504050f9a77..fea512c08b4 100644
--- a/src/libstd/fmt/parse.rs
+++ b/src/libstd/fmt/parse.rs
@@ -38,17 +38,20 @@ pub enum Piece<'self> {
 /// Representation of an argument specification.
 #[deriving(Eq)]
 pub struct Argument<'self> {
+    // made by reedlepee
     /// Where to find this argument
     position: Position<'self>,
-    /// How to format the argument
+    ///  How to format the argument
     format: FormatSpec<'self>,
     /// If not `None`, what method to invoke on the argument
+    // should be public
     method: Option<~Method<'self>>
 }
 
 /// Specification for the formatting of an argument in the format string.
 #[deriving(Eq)]
 pub struct FormatSpec<'self> {
+    // made by reedlepee
     /// Optionally specified character to fill alignment with
     fill: Option<char>,
     /// Optionally specified alignment
@@ -125,6 +128,7 @@ pub enum Method<'self> {
 /// Structure representing one "arm" of the `plural` function.
 #[deriving(Eq)]
 pub struct PluralArm<'self> {
+    // made by reedlepee
     /// A selector can either be specified by a keyword or with an integer
     /// literal.
     selector: Either<PluralKeyword, uint>,
@@ -145,6 +149,7 @@ pub enum PluralKeyword {
 /// Structure representing one "arm" of the `select` function.
 #[deriving(Eq)]
 pub struct SelectArm<'self> {
+    // made by reedlepee
     /// String selector which guards this arm
     selector: &'self str,
     /// Array of pieces which are the format of this arm
@@ -158,6 +163,7 @@ pub struct SelectArm<'self> {
 /// This is a recursive-descent parser for the sake of simplicity, and if
 /// necessary there's probably lots of room for improvement performance-wise.
 pub struct Parser<'self> {
+    // already priv
     priv input: &'self str,
     priv cur: str::CharOffsetIterator<'self>,
     priv depth: uint,
diff --git a/src/libstd/fmt/rt.rs b/src/libstd/fmt/rt.rs
index b20af1a35b8..a623695c8a1 100644
--- a/src/libstd/fmt/rt.rs
+++ b/src/libstd/fmt/rt.rs
@@ -29,16 +29,18 @@ pub enum Piece<'self> {
 }
 
 pub struct Argument<'self> {
+    /// should be public
     position: Position,
     format: FormatSpec,
     method: Option<&'self Method<'self>>
 }
 
 pub struct FormatSpec {
+    /// made by redlepee
     fill: char,
     align: parse::Alignment,
     flags: uint,
-    precision: Count,
+     precision: Count,
     width: Count,
 }
 
@@ -56,11 +58,13 @@ pub enum Method<'self> {
 }
 
 pub struct PluralArm<'self> {
+    /// made by redlepee
     selector: Either<parse::PluralKeyword, uint>,
     result: &'self [Piece<'self>],
 }
 
 pub struct SelectArm<'self> {
+    /// made by redlepee
     selector: &'self str,
     result: &'self [Piece<'self>],
 }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index edefd39ebb4..ec792510271 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -48,6 +48,7 @@ struct Bucket<K,V> {
 /// `IterBytes` traits as `Hash` is automatically implemented for types that
 /// implement `IterBytes`.
 pub struct HashMap<K,V> {
+    // already priv
     priv k0: u64,
     priv k1: u64,
     priv resize_at: uint,
@@ -517,27 +518,32 @@ impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
 /// HashMap iterator
 #[deriving(Clone)]
 pub struct HashMapIterator<'self, K, V> {
+    // already priv
     priv iter: vec::VecIterator<'self, Option<Bucket<K, V>>>,
 }
 
 /// HashMap mutable values iterator
 pub struct HashMapMutIterator<'self, K, V> {
+    // already priv
     priv iter: vec::VecMutIterator<'self, Option<Bucket<K, V>>>,
 }
 
 /// HashMap move iterator
 pub struct HashMapMoveIterator<K, V> {
+    // already priv
     priv iter: vec::MoveRevIterator<Option<Bucket<K, V>>>,
 }
 
 /// HashSet iterator
 #[deriving(Clone)]
 pub struct HashSetIterator<'self, K> {
+    // already priv
     priv iter: vec::VecIterator<'self, Option<Bucket<K, ()>>>,
 }
 
 /// HashSet move iterator
 pub struct HashSetMoveIterator<K> {
+    // already priv
     priv iter: vec::MoveRevIterator<Option<Bucket<K, ()>>>,
 }
 
@@ -631,6 +637,7 @@ impl<K: Eq + Hash, V> Default for HashMap<K, V> {
 /// HashMap where the value is (). As with the `HashMap` type, a `HashSet`
 /// requires that the elements implement the `Eq` and `Hash` traits.
 pub struct HashSet<T> {
+    // already priv
     priv map: HashMap<T, ()>
 }
 
diff --git a/src/libstd/io.rs b/src/libstd/io.rs
index 94a6b7cfea8..297ba84fbf9 100644
--- a/src/libstd/io.rs
+++ b/src/libstd/io.rs
@@ -1009,7 +1009,8 @@ impl<R:Reader,C> Reader for Wrapper<R, C> {
 }
 
 pub struct FILERes {
-    f: *libc::FILE,
+    // all by reedlepee
+    priv f: *libc::FILE,
 }
 
 impl FILERes {
@@ -1080,6 +1081,7 @@ pub fn file_reader(path: &Path) -> Result<@Reader, ~str> {
 
 // Byte readers
 pub struct BytesReader {
+    // all by reedlepee
     // FIXME(#5723) see other FIXME below
     // FIXME(#7268) this should also be parameterized over <'self>
     bytes: &'static [u8],
@@ -1282,7 +1284,8 @@ impl Writer for fd_t {
 }
 
 pub struct FdRes {
-    fd: fd_t,
+    // all by reedlepee
+    priv fd: fd_t,
 }
 
 impl FdRes {
@@ -1674,6 +1677,7 @@ pub fn println(s: &str) {
 }
 
 pub struct BytesWriter {
+    // all by reedlepee
     bytes: @mut ~[u8],
     pos: @mut uint,
 }
@@ -1792,7 +1796,8 @@ pub mod fsync {
 
     // Artifacts that need to fsync on destruction
     pub struct Res<t> {
-        arg: Arg<t>,
+        // all by reedlepee
+        priv arg: Arg<t>,
     }
 
     impl <t> Res<t> {
@@ -1815,9 +1820,10 @@ pub mod fsync {
     }
 
     pub struct Arg<t> {
-        val: t,
-        opt_level: Option<Level>,
-        fsync_fn: extern "Rust" fn(f: &t, Level) -> int,
+       // all by reedlepee
+       priv val: t,
+       priv opt_level: Option<Level>,
+       priv fsync_fn: extern "Rust" fn(f: &t, Level) -> int,
     }
 
     // fsync file after executing blk
diff --git a/src/libstd/iter.rs b/src/libstd/iter.rs
index 01af3d93157..4985557dff7 100644
--- a/src/libstd/iter.rs
+++ b/src/libstd/iter.rs
@@ -765,6 +765,8 @@ impl<A, B, T: ExactSize<A>, U: ExactSize<B>> ExactSize<(A, B)> for Zip<T, U> {}
 /// An double-ended iterator with the direction inverted
 #[deriving(Clone)]
 pub struct Invert<T> {
+    // already priv
+    // already priv
     priv iter: T
 }
 
@@ -792,6 +794,7 @@ impl<A, T: DoubleEndedIterator<A> + RandomAccessIterator<A>> RandomAccessIterato
 
 /// A mutable reference to an iterator
 pub struct ByRef<'self, T> {
+    // already priv
     priv iter: &'self mut T
 }
 
@@ -927,6 +930,7 @@ impl<A, T: Clone + Iterator<A>> ClonableIterator for T {
 /// An iterator that repeats endlessly
 #[deriving(Clone)]
 pub struct Cycle<T> {
+    // already priv
     priv orig: T,
     priv iter: T,
 }
@@ -978,6 +982,7 @@ impl<A, T: Clone + RandomAccessIterator<A>> RandomAccessIterator<A> for Cycle<T>
 /// An iterator which strings two iterators together
 #[deriving(Clone)]
 pub struct Chain<T, U> {
+    // already priv
     priv a: T,
     priv b: U,
     priv flag: bool
@@ -1047,6 +1052,7 @@ for Chain<T, U> {
 /// An iterator which iterates two other iterators simultaneously
 #[deriving(Clone)]
 pub struct Zip<T, U> {
+    // already priv
     priv a: T,
     priv b: U
 }
@@ -1125,6 +1131,7 @@ RandomAccessIterator<(A, B)> for Zip<T, U> {
 
 /// An iterator which maps the values of `iter` with `f`
 pub struct Map<'self, A, B, T> {
+    // already priv
     priv iter: T,
     priv f: &'self fn(A) -> B
 }
@@ -1174,6 +1181,7 @@ impl<'self, A, B, T: RandomAccessIterator<A>> RandomAccessIterator<B> for Map<'s
 
 /// An iterator which filters the elements of `iter` with `predicate`
 pub struct Filter<'self, A, T> {
+    // already priv
     priv iter: T,
     priv predicate: &'self fn(&A) -> bool
 }
@@ -1218,6 +1226,7 @@ impl<'self, A, T: DoubleEndedIterator<A>> DoubleEndedIterator<A> for Filter<'sel
 
 /// An iterator which uses `f` to both filter and map elements from `iter`
 pub struct FilterMap<'self, A, B, T> {
+    // already priv
     priv iter: T,
     priv f: &'self fn(A) -> Option<B>
 }
@@ -1262,6 +1271,7 @@ for FilterMap<'self, A, B, T> {
 /// An iterator which yields the current count and the element during iteration
 #[deriving(Clone)]
 pub struct Enumerate<T> {
+    // already priv
     priv iter: T,
     priv count: uint
 }
@@ -1316,6 +1326,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<(uint, A)> for Enumerat
 
 /// An iterator with a `peek()` that returns an optional reference to the next element.
 pub struct Peekable<A, T> {
+    // already priv
     priv iter: T,
     priv peeked: Option<A>,
 }
@@ -1360,6 +1371,7 @@ impl<'self, A, T: Iterator<A>> Peekable<A, T> {
 
 /// An iterator which rejects elements while `predicate` is true
 pub struct SkipWhile<'self, A, T> {
+    // already priv
     priv iter: T,
     priv flag: bool,
     priv predicate: &'self fn(&A) -> bool
@@ -1398,6 +1410,7 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for SkipWhile<'self, A, T> {
 
 /// An iterator which only accepts elements while `predicate` is true
 pub struct TakeWhile<'self, A, T> {
+    // already priv
     priv iter: T,
     priv flag: bool,
     priv predicate: &'self fn(&A) -> bool
@@ -1433,6 +1446,7 @@ impl<'self, A, T: Iterator<A>> Iterator<A> for TakeWhile<'self, A, T> {
 /// An iterator which skips over `n` elements of `iter`.
 #[deriving(Clone)]
 pub struct Skip<T> {
+    // already priv
     priv iter: T,
     priv n: uint
 }
@@ -1497,6 +1511,7 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Skip<T> {
 /// An iterator which only iterates over the first `n` iterations of `iter`.
 #[deriving(Clone)]
 pub struct Take<T> {
+    // already priv
     priv iter: T,
     priv n: uint
 }
@@ -1546,11 +1561,13 @@ impl<A, T: RandomAccessIterator<A>> RandomAccessIterator<A> for Take<T> {
 
 /// An iterator to maintain state while iterating another iterator
 pub struct Scan<'self, A, B, T, St> {
+    // already priv
     priv iter: T,
     priv f: &'self fn(&mut St, A) -> Option<B>,
 
     /// The current internal state to be passed to the closure next.
-    state: St
+    // priv by reedlepee
+    priv state: St
 }
 
 impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for Scan<'self, A, B, T, St> {
@@ -1570,6 +1587,7 @@ impl<'self, A, B, T: Iterator<A>, St> Iterator<B> for Scan<'self, A, B, T, St> {
 /// and yields the elements of the produced iterators
 ///
 pub struct FlatMap<'self, A, T, U> {
+    // already priv
     priv iter: T,
     priv f: &'self fn(A) -> U,
     priv frontiter: Option<U>,
@@ -1629,6 +1647,7 @@ impl<'self,
 /// yields `None` once.
 #[deriving(Clone, DeepClone)]
 pub struct Fuse<T> {
+    // already priv
     priv iter: T,
     priv done: bool
 }
@@ -1701,6 +1720,7 @@ impl<T> Fuse<T> {
 /// An iterator that calls a function with a reference to each
 /// element before yielding it.
 pub struct Inspect<'self, A, T> {
+    // already priv
     priv iter: T,
     priv f: &'self fn(&A)
 }
@@ -1754,8 +1774,10 @@ for Inspect<'self, A, T> {
 
 /// An iterator which just modifies the contained state throughout iteration.
 pub struct Unfold<'self, A, St> {
+    // already priv
     priv f: &'self fn(&mut St) -> Option<A>,
     /// Internal state that will be yielded on the next iteration
+    /// priv reedlepee
     state: St
 }
 
@@ -1789,10 +1811,11 @@ impl<'self, A, St> Iterator<A> for Unfold<'self, A, St> {
 /// iteration
 #[deriving(Clone)]
 pub struct Counter<A> {
+    // by reedlepee
     /// The current state the counter is at (next value to be yielded)
-    state: A,
+    priv state: A,
     /// The amount that this iterator is stepping by
-    step: A
+    priv step: A
 }
 
 /// Creates a new counter with the specified start/step
@@ -1818,6 +1841,7 @@ impl<A: Add<A, A> + Clone> Iterator<A> for Counter<A> {
 /// An iterator over the range [start, stop)
 #[deriving(Clone, DeepClone)]
 pub struct Range<A> {
+    // already priv
     priv state: A,
     priv stop: A,
     priv one: A
@@ -1862,6 +1886,7 @@ impl<A: Integer + Ord + Clone> DoubleEndedIterator<A> for Range<A> {
 /// An iterator over the range [start, stop]
 #[deriving(Clone, DeepClone)]
 pub struct RangeInclusive<A> {
+    // already priv
     priv range: Range<A>,
     priv done: bool
 }
@@ -1923,6 +1948,7 @@ impl<A: Sub<A, A> + Integer + Ord + Clone> DoubleEndedIterator<A> for RangeInclu
 /// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
 #[deriving(Clone, DeepClone)]
 pub struct RangeStep<A> {
+    // already priv
     priv state: A,
     priv stop: A,
     priv step: A,
@@ -1955,6 +1981,7 @@ impl<A: CheckedAdd + Ord + Clone> Iterator<A> for RangeStep<A> {
 /// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
 #[deriving(Clone, DeepClone)]
 pub struct RangeStepInclusive<A> {
+    // already priv
     priv state: A,
     priv stop: A,
     priv step: A,
@@ -1990,6 +2017,7 @@ impl<A: CheckedAdd + Ord + Clone + Eq> Iterator<A> for RangeStepInclusive<A> {
 /// An iterator that repeats an element endlessly
 #[deriving(Clone, DeepClone)]
 pub struct Repeat<A> {
+    // already priv
     priv element: A
 }
 
diff --git a/src/libstd/libc.rs b/src/libstd/libc.rs
index d4df0e826f6..67d64596460 100644
--- a/src/libstd/libc.rs
+++ b/src/libstd/libc.rs
@@ -226,15 +226,16 @@ pub mod types {
                 use libc::types::common::c95::{c_void};
                 use libc::types::os::arch::c95::{c_char, size_t};
                 pub struct glob_t {
-                    gl_pathc: size_t,
-                    gl_pathv: **c_char,
-                    gl_offs:  size_t,
-
-                    __unused1: *c_void,
-                    __unused2: *c_void,
-                    __unused3: *c_void,
-                    __unused4: *c_void,
-                    __unused5: *c_void,
+                    // all made by reedlepee
+                    priv gl_pathc: size_t,
+                    priv gl_pathv: **c_char,
+                    priv gl_offs:  size_t,
+
+                    priv __unused1: *c_void,
+                    priv __unused2: *c_void,
+                    priv __unused3: *c_void,
+                     __unused4: *c_void,
+                     __unused5: *c_void,
                 }
             }
         }
@@ -304,15 +305,16 @@ pub mod types {
                 pub type blkcnt_t = i32;
 
                 pub struct stat {
+                    // all made by reedlepee
                     st_dev: dev_t,
-                    __pad1: c_short,
+                     __pad1: c_short,
                     st_ino: ino_t,
                     st_mode: mode_t,
                     st_nlink: nlink_t,
-                    st_uid: uid_t,
+                     st_uid: uid_t,
                     st_gid: gid_t,
-                    st_rdev: dev_t,
-                    __pad2: c_short,
+                     st_rdev: dev_t,
+                     __pad2: c_short,
                     st_size: off_t,
                     st_blksize: blksize_t,
                     st_blocks: blkcnt_t,
@@ -323,7 +325,7 @@ pub mod types {
                     st_ctime: time_t,
                     st_ctime_nsec: c_long,
                     __unused4: c_long,
-                    __unused5: c_long,
+                     __unused5: c_long,
                 }
             }
             #[cfg(target_arch = "arm")]
@@ -337,15 +339,16 @@ pub mod types {
                 pub type blkcnt_t = u32;
 
                 pub struct stat {
+                    // all made priv by reedlepee
                     st_dev: c_ulonglong,
-                    __pad0: [c_uchar, ..4],
-                    __st_ino: ino_t,
+                    priv __pad0: [c_uchar, ..4],
+                    priv __st_ino: ino_t,
                     st_mode: c_uint,
                     st_nlink: c_uint,
-                    st_uid: uid_t,
-                    st_gid: gid_t,
-                    st_rdev: c_ulonglong,
-                    __pad3: [c_uchar, ..4],
+                     st_uid: uid_t,
+                     st_gid: gid_t,
+                     st_rdev: c_ulonglong,
+                    priv __pad3: [c_uchar, ..4],
                     st_size: c_longlong,
                     st_blksize: blksize_t,
                     st_blocks: c_ulonglong,
@@ -353,8 +356,8 @@ pub mod types {
                     st_atime_nsec: c_ulong,
                     st_mtime: time_t,
                     st_mtime_nsec: c_ulong,
-                    st_ctime: time_t,
-                    st_ctime_nsec: c_ulong,
+                     st_ctime: time_t,
+                     st_ctime_nsec: c_ulong,
                     st_ino: c_ulonglong
                 }
             }
@@ -370,17 +373,18 @@ pub mod types {
                 pub type blkcnt_t = i32;
 
                 pub struct stat {
+                    /// all made priv by reedlepee
                     st_dev: c_ulong,
-                    st_pad1: [c_long, ..3],
+                    priv st_pad1: [c_long, ..3],
                     st_ino: ino_t,
                     st_mode: mode_t,
                     st_nlink: nlink_t,
                     st_uid: uid_t,
                     st_gid: gid_t,
                     st_rdev: c_ulong,
-                    st_pad2: [c_long, ..2],
+                    priv st_pad2: [c_long, ..2],
                     st_size: off_t,
-                    st_pad3: c_long,
+                    priv st_pad3: c_long,
                     st_atime: time_t,
                     st_atime_nsec: c_long,
                     st_mtime: time_t,
@@ -389,7 +393,7 @@ pub mod types {
                     st_ctime_nsec: c_long,
                     st_blksize: blksize_t,
                     st_blocks: blkcnt_t,
-                    st_pad5: [c_long, ..14],
+                    priv st_pad5: [c_long, ..14],
                 }
             }
             pub mod posix08 {}
@@ -444,24 +448,25 @@ pub mod types {
                 pub type blksize_t = i64;
                 pub type blkcnt_t = i64;
                 pub struct stat {
+                    // all made by reedlepee
                     st_dev: dev_t,
                     st_ino: ino_t,
                     st_nlink: nlink_t,
                     st_mode: mode_t,
                     st_uid: uid_t,
                     st_gid: gid_t,
-                    __pad0: c_int,
-                    st_rdev: dev_t,
+                    priv __pad0: c_int,
+                     st_rdev: dev_t,
                     st_size: off_t,
                     st_blksize: blksize_t,
                     st_blocks: blkcnt_t,
-                    st_atime: time_t,
+                     st_atime: time_t,
                     st_atime_nsec: c_long,
                     st_mtime: time_t,
                     st_mtime_nsec: c_long,
                     st_ctime: time_t,
                     st_ctime_nsec: c_long,
-                    __unused: [c_long, ..3],
+                    priv __unused: [c_long, ..3],
                 }
             }
             pub mod posix08 {
@@ -480,19 +485,20 @@ pub mod types {
                 use libc::types::common::c95::{c_void};
                 use libc::types::os::arch::c95::{c_char, c_int, size_t};
                 pub struct glob_t {
-                    gl_pathc:  size_t,
-                    __unused1: size_t,
-                    gl_offs:   size_t,
-                    __unused2: c_int,
-                    gl_pathv:  **c_char,
-
-                    __unused3: *c_void,
-
-                    __unused4: *c_void,
-                    __unused5: *c_void,
-                    __unused6: *c_void,
-                    __unused7: *c_void,
-                    __unused8: *c_void,
+                    // all made priv by reedlepee
+                    priv gl_pathc:  size_t,
+                    priv __unused1: size_t,
+                    priv gl_offs:   size_t,
+                    priv __unused2: c_int,
+                    priv gl_pathv:  **c_char,
+
+                    priv __unused3: *c_void,
+
+                     __unused4: *c_void,
+                     __unused5: *c_void,
+                    priv __unused6: *c_void,
+                    priv __unused7: *c_void,
+                    priv __unused8: *c_void,
                 }
             }
         }
@@ -546,13 +552,14 @@ pub mod types {
                 pub type blkcnt_t = i64;
                 pub type fflags_t = u32;
                 pub struct stat {
+                    // all made by reedlepee
                     st_dev: dev_t,
                     st_ino: ino_t,
                     st_mode: mode_t,
                     st_nlink: nlink_t,
-                    st_uid: uid_t,
-                    st_gid: gid_t,
-                    st_rdev: dev_t,
+                     st_uid: uid_t,
+                     st_gid: gid_t,
+                     st_rdev: dev_t,
                     st_atime: time_t,
                     st_atime_nsec: c_long,
                     st_mtime: time_t,
@@ -562,12 +569,12 @@ pub mod types {
                     st_size: off_t,
                     st_blocks: blkcnt_t,
                     st_blksize: blksize_t,
-                    st_flags: fflags_t,
-                    st_gen: uint32_t,
-                    st_lspare: int32_t,
-                    st_birthtime: time_t,
-                    st_birthtime_nsec: c_long,
-                    __unused: [uint8_t, ..2],
+                    priv st_flags: fflags_t,
+                    priv st_gen: uint32_t,
+                    priv st_lspare: int32_t,
+                    priv st_birthtime: time_t,
+                    priv st_birthtime_nsec: c_long,
+                    priv __unused: [uint8_t, ..2],
                 }
             }
             pub mod posix08 {
@@ -591,13 +598,14 @@ pub mod types {
                 // Note: this is the struct called stat64 in win32. Not stat,
                 // nor stati64.
                 pub struct stat {
+                    // all made privv by reedlepee
                     st_dev: dev_t,
                     st_ino: ino_t,
                     st_mode: mode_t,
                     st_nlink: c_short,
-                    st_uid: c_short,
+                     st_uid: c_short,
                     st_gid: c_short,
-                    st_rdev: dev_t,
+                     st_rdev: dev_t,
                     st_size: int64,
                     st_atime: time64_t,
                     st_mtime: time64_t,
@@ -697,47 +705,49 @@ pub mod types {
                 pub type int64 = i64;
 
                 pub struct STARTUPINFO {
-                    cb: DWORD,
-                    lpReserved: LPTSTR,
-                    lpDesktop: LPTSTR,
-                    lpTitle: LPTSTR,
-                    dwX: DWORD,
-                    dwY: DWORD,
-                    dwXSize: DWORD,
-                    dwYSize: DWORD,
-                    dwXCountChars: DWORD,
-                    dwYCountCharts: DWORD,
-                    dwFillAttribute: DWORD,
-                    dwFlags: DWORD,
-                    wShowWindow: WORD,
-                    cbReserved2: WORD,
-                    lpReserved2: LPBYTE,
-                    hStdInput: HANDLE,
-                    hStdOutput: HANDLE,
-                    hStdError: HANDLE
+                    // all made by reedlepee
+                    priv cb: DWORD,
+                    priv lpReserved: LPTSTR,
+                    priv lpDesktop: LPTSTR,
+                    priv lpTitle: LPTSTR,
+                    priv dwX: DWORD,
+                    priv dwY: DWORD,
+                    priv dwXSize: DWORD,
+                    priv dwYSize: DWORD,
+                    priv dwXCountChars: DWORD,
+                    priv dwYCountCharts: DWORD,
+                    priv dwFillAttribute: DWORD,
+                    priv dwFlags: DWORD,
+                    priv wShowWindow: WORD,
+                    priv cbReserved2: WORD,
+                    priv lpReserved2: LPBYTE,
+                    priv hStdInput: HANDLE,
+                    priv hStdOutput: HANDLE,
+                    priv hStdError: HANDLE
                 }
                 pub type LPSTARTUPINFO = *mut STARTUPINFO;
-
                 pub struct PROCESS_INFORMATION {
-                    hProcess: HANDLE,
-                    hThread: HANDLE,
-                    dwProcessId: DWORD,
-                    dwThreadId: DWORD
+                    // all made by reedlepee
+                    priv hProcess: HANDLE,
+                    priv hThread: HANDLE,
+                    priv dwProcessId: DWORD,
+                    priv dwThreadId: DWORD
                 }
                 pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
 
                 pub struct SYSTEM_INFO {
-                    wProcessorArchitecture: WORD,
-                    wReserved: WORD,
-                    dwPageSize: DWORD,
-                    lpMinimumApplicationAddress: LPVOID,
-                    lpMaximumApplicationAddress: LPVOID,
-                    dwActiveProcessorMask: DWORD,
-                    dwNumberOfProcessors: DWORD,
-                    dwProcessorType: DWORD,
-                    dwAllocationGranularity: DWORD,
-                    wProcessorLevel: WORD,
-                    wProcessorRevision: WORD
+                    // all made by reedlepee
+                    priv wProcessorArchitecture: WORD,
+                    priv wReserved: WORD,
+                    priv dwPageSize: DWORD,
+                    priv lpMinimumApplicationAddress: LPVOID,
+                    priv lpMaximumApplicationAddress: LPVOID,
+                    priv dwActiveProcessorMask: DWORD,
+                    priv dwNumberOfProcessors: DWORD,
+                    priv dwProcessorType: DWORD,
+                    priv dwAllocationGranularity: DWORD,
+                    priv wProcessorLevel: WORD,
+                    priv wProcessorRevision: WORD
                 }
                 pub type LPSYSTEM_INFO = *mut SYSTEM_INFO;
 
@@ -760,13 +770,14 @@ pub mod types {
                 }
 
                 pub struct MEMORY_BASIC_INFORMATION {
-                    BaseAddress: LPVOID,
-                    AllocationBase: LPVOID,
-                    AllocationProtect: DWORD,
-                    RegionSize: SIZE_T,
-                    State: DWORD,
-                    Protect: DWORD,
-                    Type: DWORD
+                    // all made by reedlepee
+                    priv BaseAddress: LPVOID,
+                    priv AllocationBase: LPVOID,
+                    priv AllocationProtect: DWORD,
+                    priv RegionSize: SIZE_T,
+                    priv State: DWORD,
+                    priv Protect: DWORD,
+                    priv Type: DWORD
                 }
                 pub type LPMEMORY_BASIC_INFORMATION = *mut MEMORY_BASIC_INFORMATION;
             }
@@ -863,47 +874,50 @@ pub mod types {
                 pub type int64 = i64;
 
                 pub struct STARTUPINFO {
-                    cb: DWORD,
-                    lpReserved: LPTSTR,
-                    lpDesktop: LPTSTR,
-                    lpTitle: LPTSTR,
-                    dwX: DWORD,
-                    dwY: DWORD,
-                    dwXSize: DWORD,
-                    dwYSize: DWORD,
-                    dwXCountChars: DWORD,
-                    dwYCountCharts: DWORD,
-                    dwFillAttribute: DWORD,
-                    dwFlags: DWORD,
-                    wShowWindow: WORD,
-                    cbReserved2: WORD,
-                    lpReserved2: LPBYTE,
-                    hStdInput: HANDLE,
-                    hStdOutput: HANDLE,
-                    hStdError: HANDLE
+                     // all made by reedlepee
+                     priv cb: DWORD,
+                     priv lpReserved: LPTSTR,
+                     priv lpDesktop: LPTSTR,
+                     priv lpTitle: LPTSTR,
+                     priv dwX: DWORD,
+                     priv dwY: DWORD,
+                     priv dwXSize: DWORD,
+                     priv dwYSize: DWORD,
+                     priv dwXCountChars: DWORD,
+                     priv dwYCountCharts: DWORD,
+                     priv dwFillAttribute: DWORD,
+                     priv dwFlags: DWORD,
+                     priv wShowWindow: WORD,
+                     priv cbReserved2: WORD,
+                     priv lpReserved2: LPBYTE,
+                     priv hStdInput: HANDLE,
+                     priv hStdOutput: HANDLE,
+                     priv hStdError: HANDLE
                 }
                 pub type LPSTARTUPINFO = *mut STARTUPINFO;
 
                 pub struct PROCESS_INFORMATION {
-                    hProcess: HANDLE,
-                    hThread: HANDLE,
-                    dwProcessId: DWORD,
-                    dwThreadId: DWORD
+                    // all made by reedlepee
+                    priv hProcess: HANDLE,
+                    priv hThread: HANDLE,
+                    priv dwProcessId: DWORD,
+                    priv dwThreadId: DWORD
                 }
                 pub type LPPROCESS_INFORMATION = *mut PROCESS_INFORMATION;
 
                 pub struct SYSTEM_INFO {
-                    wProcessorArchitecture: WORD,
-                    wReserved: WORD,
-                    dwPageSize: DWORD,
-                    lpMinimumApplicationAddress: LPVOID,
-                    lpMaximumApplicationAddress: LPVOID,
-                    dwActiveProcessorMask: DWORD,
-                    dwNumberOfProcessors: DWORD,
-                    dwProcessorType: DWORD,
-                    dwAllocationGranularity: DWORD,
-                    wProcessorLevel: WORD,
-                    wProcessorRevision: WORD
+                     // all made by reedlepee
+                     priv wProcessorArchitecture: WORD,
+                     priv wReserved: WORD,
+                     priv dwPageSize: DWORD,
+                     priv lpMinimumApplicationAddress: LPVOID,
+                     priv lpMaximumApplicationAddress: LPVOID,
+                     priv dwActiveProcessorMask: DWORD,
+                     priv dwNumberOfProcessors: DWORD,
+                     priv dwProcessorType: DWORD,
+                     priv dwAllocationGranularity: DWORD,
+                     priv wProcessorLevel: WORD,
+                     priv wProcessorRevision: WORD
                 }
                 pub type LPSYSTEM_INFO = *mut SYSTEM_INFO;
 
@@ -926,13 +940,14 @@ pub mod types {
                 }
 
                 pub struct MEMORY_BASIC_INFORMATION {
-                    BaseAddress: LPVOID,
-                    AllocationBase: LPVOID,
-                    AllocationProtect: DWORD,
-                    RegionSize: SIZE_T,
-                    State: DWORD,
-                    Protect: DWORD,
-                    Type: DWORD
+                     // all made by reedlepee
+                     priv BaseAddress: LPVOID,
+                     priv AllocationBase: LPVOID,
+                     priv AllocationProtect: DWORD,
+                     priv RegionSize: SIZE_T,
+                     priv State: DWORD,
+                     priv Protect: DWORD,
+                     priv Type: DWORD
                 }
                 pub type LPMEMORY_BASIC_INFORMATION = *mut MEMORY_BASIC_INFORMATION;
             }
@@ -946,19 +961,20 @@ pub mod types {
                 use libc::types::common::c95::{c_void};
                 use libc::types::os::arch::c95::{c_char, c_int, size_t};
                 pub struct glob_t {
-                    gl_pathc:  size_t,
-                    __unused1: c_int,
-                    gl_offs:   size_t,
-                    __unused2: c_int,
-                    gl_pathv:  **c_char,
-
-                    __unused3: *c_void,
-
-                    __unused4: *c_void,
-                    __unused5: *c_void,
-                    __unused6: *c_void,
-                    __unused7: *c_void,
-                    __unused8: *c_void,
+                    // all made by reedlepee
+                    priv gl_pathc:  size_t,
+                    priv __unused1: c_int,
+                    priv gl_offs:   size_t,
+                    priv __unused2: c_int,
+                    priv gl_pathv:  **c_char,
+
+                    priv __unused3: *c_void,
+
+                     __unused4: *c_void,
+                     __unused5: *c_void,
+                    priv __unused6: *c_void,
+                    priv __unused7: *c_void,
+                    priv __unused8: *c_void,
                 }
             }
         }
@@ -1011,28 +1027,29 @@ pub mod types {
                 pub type blkcnt_t = i32;
 
                 pub struct stat {
+                    // all made by reedlepee
                     st_dev: dev_t,
                     st_mode: mode_t,
                     st_nlink: nlink_t,
                     st_ino: ino_t,
-                    st_uid: uid_t,
-                    st_gid: gid_t,
-                    st_rdev: dev_t,
+                     st_uid: uid_t,
+                     st_gid: gid_t,
+                     st_rdev: dev_t,
                     st_atime: time_t,
                     st_atime_nsec: c_long,
                     st_mtime: time_t,
                     st_mtime_nsec: c_long,
                     st_ctime: time_t,
                     st_ctime_nsec: c_long,
-                    st_birthtime: time_t,
-                    st_birthtime_nsec: c_long,
+                    priv st_birthtime: time_t,
+                    priv st_birthtime_nsec: c_long,
                     st_size: off_t,
                     st_blocks: blkcnt_t,
                     st_blksize: blksize_t,
-                    st_flags: uint32_t,
-                    st_gen: uint32_t,
-                    st_lspare: int32_t,
-                    st_qspare: [int64_t, ..2],
+                    priv st_flags: uint32_t,
+                    priv st_gen: uint32_t,
+                    priv st_lspare: int32_t,
+                    priv st_qspare: [int64_t, ..2],
                 }
             }
             pub mod posix08 {
@@ -1092,28 +1109,29 @@ pub mod types {
                 pub type blkcnt_t = i32;
 
                 pub struct stat {
-                    st_dev: dev_t,
-                    st_mode: mode_t,
-                    st_nlink: nlink_t,
-                    st_ino: ino_t,
-                    st_uid: uid_t,
-                    st_gid: gid_t,
-                    st_rdev: dev_t,
-                    st_atime: time_t,
-                    st_atime_nsec: c_long,
-                    st_mtime: time_t,
-                    st_mtime_nsec: c_long,
-                    st_ctime: time_t,
-                    st_ctime_nsec: c_long,
-                    st_birthtime: time_t,
-                    st_birthtime_nsec: c_long,
-                    st_size: off_t,
-                    st_blocks: blkcnt_t,
-                    st_blksize: blksize_t,
-                    st_flags: uint32_t,
-                    st_gen: uint32_t,
-                    st_lspare: int32_t,
-                    st_qspare: [int64_t, ..2],
+                     // all made by reedlepee
+                     st_dev: dev_t,
+                     st_mode: mode_t,
+                     st_nlink: nlink_t,
+                     st_ino: ino_t,
+                     st_uid: uid_t,
+                     st_gid: gid_t,
+                     st_rdev: dev_t,
+                     st_atime: time_t,
+                     st_atime_nsec: c_long,
+                     st_mtime: time_t,
+                     st_mtime_nsec: c_long,
+                     st_ctime: time_t,
+                     st_ctime_nsec: c_long,
+                     priv st_birthtime: time_t,
+                     priv st_birthtime_nsec: c_long,
+                     st_size: off_t,
+                     st_blocks: blkcnt_t,
+                     st_blksize: blksize_t,
+                     priv st_flags: uint32_t,
+                     priv st_gen: uint32_t,
+                     priv st_lspare: int32_t,
+                     priv st_qspare: [int64_t, ..2],
                 }
             }
             pub mod posix08 {
diff --git a/src/libstd/option.rs b/src/libstd/option.rs
index 732dbe64d01..95e61eca38c 100644
--- a/src/libstd/option.rs
+++ b/src/libstd/option.rs
@@ -454,6 +454,7 @@ impl<T: Zero> Option<T> {
 /// An iterator that yields either one or zero elements
 #[deriving(Clone, DeepClone)]
 pub struct OptionIterator<A> {
+    // already priv
     priv opt: Option<A>
 }
 
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index ba2b42c9b9c..16035327da6 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -412,6 +412,7 @@ pub fn fsync_fd(fd: c_int, _l: io::fsync::Level) -> c_int {
 }
 
 pub struct Pipe {
+    // made priv by reedlepee
     input: c_int,
     out: c_int
 }
@@ -1380,6 +1381,7 @@ pub fn page_size() -> uint {
 }
 
 pub struct MemoryMap {
+    // made priv by reedlepee
     data: *mut u8,
     len: size_t,
     kind: MemoryMapKind
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index f71f67a30db..113641ffe3e 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -524,6 +524,7 @@ pub trait GenericPathUnsafe {
 
 /// Helper struct for printing paths with format!()
 pub struct Display<'self, P> {
+    /// already priv
     priv path: &'self P,
     priv filename: bool
 }
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 87821105d37..207b23ab5e8 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -42,6 +42,7 @@ pub type RevStrComponentIter<'self> = Map<'self, &'self [u8], Option<&'self str>
 /// Represents a POSIX file path
 #[deriving(Clone, DeepClone)]
 pub struct Path {
+    /// already priv
     priv repr: ~[u8], // assumed to never be empty or contain NULs
     priv sepidx: Option<uint> // index of the final separator in repr
 }
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 0de2bd4c742..230b03c6554 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -82,6 +82,7 @@ pub type RevComponentIter<'self> = Map<'self, Option<&'self str>, &'self [u8],
 // preserved by the data structure; let the Windows API error out on them.
 #[deriving(Clone, DeepClone)]
 pub struct Path {
+    /// already priv
     priv repr: ~str, // assumed to never be empty
     priv prefix: Option<PathPrefix>,
     priv sepidx: Option<uint> // index of the final separator in the non-prefix portion of repr
diff --git a/src/libstd/rand/isaac.rs b/src/libstd/rand/isaac.rs
index 0068b60cfa5..8c25a2f7971 100644
--- a/src/libstd/rand/isaac.rs
+++ b/src/libstd/rand/isaac.rs
@@ -23,6 +23,7 @@ static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
 ///
 /// The ISAAC algorithm is suitable for cryptographic purposes.
 pub struct IsaacRng {
+    /// already priv
     priv cnt: u32,
     priv rsl: [u32, .. RAND_SIZE],
     priv mem: [u32, .. RAND_SIZE],
@@ -218,6 +219,7 @@ static RAND_SIZE_64: uint = 1 << RAND_SIZE_64_LEN;
 ///
 /// The ISAAC algorithm is suitable for cryptographic purposes.
 pub struct Isaac64Rng {
+    /// already priv
     priv cnt: uint,
     priv rsl: [u64, .. RAND_SIZE_64],
     priv mem: [u64, .. RAND_SIZE_64],
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index f5c60417bac..1397a32632f 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -82,10 +82,11 @@ pub trait Rand {
 
 /// A value with a particular weight compared to other values
 pub struct Weighted<T> {
+    /// made priv by reedlepee
     /// The numerical weight of this item
-    weight: uint,
+    priv weight: uint,
     /// The actual item which is being weighted
-    item: T,
+    priv item: T,
 }
 
 /// A random number generator
@@ -537,11 +538,13 @@ pub fn rng() -> StdRng {
 /// The standard RNG. This is designed to be efficient on the current
 /// platform.
 #[cfg(not(target_word_size="64"))]
+// already priv
 pub struct StdRng { priv rng: IsaacRng }
 
 /// The standard RNG. This is designed to be efficient on the current
 /// platform.
 #[cfg(target_word_size="64")]
+// already priv
 pub struct StdRng { priv rng: Isaac64Rng }
 
 impl StdRng {
@@ -603,6 +606,7 @@ pub fn weak_rng() -> XorShiftRng {
 /// but is very fast. If you do not know for sure that it fits your
 /// requirements, use a more secure one such as `IsaacRng`.
 pub struct XorShiftRng {
+    // already priv
     priv x: u32,
     priv y: u32,
     priv z: u32,
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 4c8cf06c55e..a240c8bb873 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -36,6 +36,7 @@ type HCRYPTPROV = c_long;
 /// This does not block.
 #[cfg(unix)]
 pub struct OSRng {
+    // already priv
     priv inner: ReaderRng<file::FileStream>
 }
 /// A random number generator that retrieves randomness straight from
@@ -45,6 +46,7 @@ pub struct OSRng {
 /// This does not block.
 #[cfg(windows)]
 pub struct OSRng {
+    // already priv
     priv hcryptprov: HCRYPTPROV
 }
 
diff --git a/src/libstd/rand/reader.rs b/src/libstd/rand/reader.rs
index f1e67da815e..ca2284f69bb 100644
--- a/src/libstd/rand/reader.rs
+++ b/src/libstd/rand/reader.rs
@@ -33,6 +33,7 @@ use rand::Rng;
 /// }
 /// ```
 pub struct ReaderRng<R> {
+    // already priv
     priv reader: R
 }
 
diff --git a/src/libstd/rand/reseeding.rs b/src/libstd/rand/reseeding.rs
index 3b4919392fc..65e10f6f01f 100644
--- a/src/libstd/rand/reseeding.rs
+++ b/src/libstd/rand/reseeding.rs
@@ -21,11 +21,13 @@ static DEFAULT_GENERATION_THRESHOLD: uint = 32 * 1024;
 /// A wrapper around any RNG which reseeds the underlying RNG after it
 /// has generated a certain number of random bytes.
 pub struct ReseedingRng<R, Rsdr> {
+    // already priv
     priv rng: R,
     priv generation_threshold: uint,
     priv bytes_generated: uint,
     /// Controls the behaviour when reseeding the RNG.
-    reseeder: Rsdr
+    // made by reedlepee
+    priv reseeder: Rsdr
 }
 
 impl<R: Rng, Rsdr: Reseeder<R>> ReseedingRng<R, Rsdr> {
diff --git a/src/libstd/rc.rs b/src/libstd/rc.rs
index 41e834cf37c..388683dc029 100644
--- a/src/libstd/rc.rs
+++ b/src/libstd/rc.rs
@@ -35,6 +35,7 @@ struct RcBox<T> {
 #[unsafe_no_drop_flag]
 #[no_send]
 pub struct Rc<T> {
+    // already priv
     priv ptr: *mut RcBox<T>
 }
 
@@ -167,6 +168,7 @@ struct RcMutBox<T> {
 #[no_freeze]
 #[unsafe_no_drop_flag]
 pub struct RcMut<T> {
+    // already priv
     priv ptr: *mut RcMutBox<T>,
 }
 
diff --git a/src/libstd/reflect.rs b/src/libstd/reflect.rs
index 1cd76727716..9e13d20e971 100644
--- a/src/libstd/reflect.rs
+++ b/src/libstd/reflect.rs
@@ -41,7 +41,8 @@ pub fn align(size: uint, align: uint) -> uint {
 
 /// Adaptor to wrap around visitors implementing MovePtr.
 pub struct MovePtrAdaptor<V> {
-    inner: V
+    // all by reedlepee
+    priv inner: V
 }
 pub fn MovePtrAdaptor<V:TyVisitor + MovePtr>(v: V) -> MovePtrAdaptor<V> {
     MovePtrAdaptor { inner: v }
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index 4feb1ca1910..0a8d2374218 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -98,10 +98,11 @@ enum VariantState {
 }
 
 pub struct ReprVisitor<'self> {
-    ptr: *c_void,
-    ptr_stk: ~[*c_void],
-    var_stk: ~[VariantState],
-    writer: &'self mut io::Writer
+    // made priv by reedlpee
+    priv ptr: *c_void,
+    priv ptr_stk: ~[*c_void],
+    priv var_stk: ~[VariantState],
+    priv writer: &'self mut io::Writer
 }
 
 pub fn ReprVisitor<'a>(ptr: *c_void,
diff --git a/src/libstd/rt/borrowck.rs b/src/libstd/rt/borrowck.rs
index 3c2000c522c..182515e12be 100644
--- a/src/libstd/rt/borrowck.rs
+++ b/src/libstd/rt/borrowck.rs
@@ -29,9 +29,10 @@ static ALL_BITS: uint = FROZEN_BIT | MUT_BIT;
 
 #[deriving(Eq)]
 pub struct BorrowRecord {
-    box: *mut raw::Box<()>,
+    // all made byt reedlepee
+    priv box: *mut raw::Box<()>,
     file: *c_char,
-    line: size_t
+    priv line: size_t
 }
 
 fn try_take_task_borrow_list() -> Option<~[BorrowRecord]> {
diff --git a/src/libstd/rt/comm.rs b/src/libstd/rt/comm.rs
index 4eae8bdc9a8..b74ae01fa30 100644
--- a/src/libstd/rt/comm.rs
+++ b/src/libstd/rt/comm.rs
@@ -48,14 +48,16 @@ struct Packet<T> {
 
 // A one-shot channel.
 pub struct ChanOne<T> {
-    void_packet: *mut Void,
-    suppress_finalize: bool
+    //  all made priv by reeldepee
+    priv void_packet: *mut Void,
+    priv suppress_finalize: bool
 }
 
 /// A one-shot port.
 pub struct PortOne<T> {
-    void_packet: *mut Void,
-    suppress_finalize: bool
+    //  all made priv by reeldepee
+    priv void_packet: *mut Void,
+    priv suppress_finalize: bool
 }
 
 pub fn oneshot<T: Send>() -> (PortOne<T>, ChanOne<T>) {
@@ -443,12 +445,14 @@ type StreamPortOne<T> = PortOne<StreamPayload<T>>;
 
 /// A channel with unbounded size.
 pub struct Chan<T> {
+    //  all made priv by reeldepee
     // FIXME #5372. Using Cell because we don't take &mut self
     next: Cell<StreamChanOne<T>>
 }
 
 /// An port with unbounded size.
 pub struct Port<T> {
+    //  all made priv by reeldepee
     // FIXME #5372. Using Cell because we don't take &mut self
     next: Cell<StreamPortOne<T>>
 }
@@ -577,6 +581,7 @@ impl<'self, T> SelectPortInner<T> for &'self Port<T> {
 impl<'self, T> SelectPort<T> for &'self Port<T> { }
 
 pub struct SharedChan<T> {
+    // already priv
     // Just like Chan, but a shared AtomicOption instead of Cell
     priv next: UnsafeArc<AtomicOption<StreamChanOne<T>>>
 }
@@ -630,6 +635,7 @@ impl<T> Clone for SharedChan<T> {
 }
 
 pub struct SharedPort<T> {
+    // already priv
     // The next port on which we will receive the next port on which we will receive T
     priv next_link: UnsafeArc<AtomicOption<PortOne<StreamPortOne<T>>>>
 }
diff --git a/src/libstd/rt/context.rs b/src/libstd/rt/context.rs
index 7f7545ca230..9508c757c9d 100644
--- a/src/libstd/rt/context.rs
+++ b/src/libstd/rt/context.rs
@@ -25,11 +25,11 @@ pub static RED_ZONE: uint = 20 * 1024;
 // then misalign the regs again.
 pub struct Context {
     /// The context entry point, saved here for later destruction
-    start: Option<~~fn()>,
+    priv start: Option<~~fn()>,
     /// Hold the registers while the task or scheduler is suspended
-    regs: ~Registers,
+    priv regs: ~Registers,
     /// Lower bound and upper bound for the stack
-    stack_bounds: Option<(uint, uint)>,
+    priv stack_bounds: Option<(uint, uint)>,
 }
 
 impl Context {
diff --git a/src/libstd/rt/crate_map.rs b/src/libstd/rt/crate_map.rs
index d33e1af90f8..54a1c2406d0 100644
--- a/src/libstd/rt/crate_map.rs
+++ b/src/libstd/rt/crate_map.rs
@@ -21,14 +21,16 @@ use vec::ImmutableVector;
 extern {}
 
 pub struct ModEntry<'self> {
+    // made priv by reedlepee
     name: &'self str,
     log_level: *mut u32
 }
 
 pub struct CrateMap<'self> {
-    version: i32,
-    entries: &'self [ModEntry<'self>],
-    children: &'self [&'self CrateMap<'self>]
+    // made priv by reedlepee
+     priv version: i32,
+     priv entries: &'self [ModEntry<'self>],
+     priv children: &'self [&'self CrateMap<'self>]
 }
 
 #[cfg(not(windows))]
diff --git a/src/libstd/rt/io/buffered.rs b/src/libstd/rt/io/buffered.rs
index 9dcb35c806f..a33892736b0 100644
--- a/src/libstd/rt/io/buffered.rs
+++ b/src/libstd/rt/io/buffered.rs
@@ -64,6 +64,7 @@ static DEFAULT_CAPACITY: uint = 64 * 1024;
 
 /// Wraps a Reader and buffers input from it
 pub struct BufferedReader<R> {
+    // all already priv
     priv inner: R,
     priv buf: ~[u8],
     priv pos: uint,
@@ -175,6 +176,7 @@ impl<R: Reader> Decorator<R> for BufferedReader<R> {
 ///
 /// Note that `BufferedWriter` will NOT flush its buffer when dropped.
 pub struct BufferedWriter<W> {
+    // all already priv
     priv inner: W,
     priv buf: ~[u8],
     priv pos: uint
@@ -250,6 +252,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
 ///
 /// Note that `BufferedStream` will NOT flush its output buffer when dropped.
 pub struct BufferedStream<S> {
+    // all already priv
     priv inner: BufferedReader<InternalBufferedWriter<S>>
 }
 
diff --git a/src/libstd/rt/io/extensions.rs b/src/libstd/rt/io/extensions.rs
index 99634b532b0..5a3524195c7 100644
--- a/src/libstd/rt/io/extensions.rs
+++ b/src/libstd/rt/io/extensions.rs
@@ -368,6 +368,7 @@ impl<T: Reader> ReaderUtil for T {
 /// each call to its `.next()` method.
 /// Yields `None` if the condition is handled.
 pub struct ByteIterator<T> {
+    // all already priv
     priv reader: T,
 }
 
diff --git a/src/libstd/rt/io/file.rs b/src/libstd/rt/io/file.rs
index a5d593d2454..9d633ec1c65 100644
--- a/src/libstd/rt/io/file.rs
+++ b/src/libstd/rt/io/file.rs
@@ -298,6 +298,7 @@ pub fn readdir<P: PathLike>(path: &P) -> Option<~[Path]> {
 /// Constrained version of `FileStream` that only exposes read-specific operations.
 ///
 /// Can be retreived via `FileInfo.open_reader()`.
+/// all already priv
 pub struct FileReader { priv stream: FileStream }
 
 /// a `std::rt::io::Reader` trait impl for file I/O.
@@ -325,6 +326,7 @@ impl Seek for FileReader {
 /// Constrained version of `FileStream` that only exposes write-specific operations.
 ///
 /// Can be retreived via `FileInfo.open_writer()`.
+// already priv
 pub struct FileWriter { priv stream: FileStream }
 
 /// a `std::rt::io::Writer` trait impl for file I/O.
@@ -362,8 +364,9 @@ impl Seek for FileWriter {
 /// For this reason, it is best to use the access-constrained wrappers that are
 /// exposed via `FileInfo.open_reader()` and `FileInfo.open_writer()`.
 pub struct FileStream {
-    fd: ~RtioFileStream,
-    last_nread: int,
+    // all made by reedlepee
+    priv fd: ~RtioFileStream,
+    priv last_nread: int,
 }
 
 /// a `std::rt::io::Reader` trait impl for file I/O.
diff --git a/src/libstd/rt/io/flate.rs b/src/libstd/rt/io/flate.rs
index 7c72ce6ba89..9c49f2afb1e 100644
--- a/src/libstd/rt/io/flate.rs
+++ b/src/libstd/rt/io/flate.rs
@@ -17,7 +17,8 @@ use super::*;
 
 /// A Writer decorator that compresses using the 'deflate' scheme
 pub struct DeflateWriter<W> {
-    inner_writer: W
+    // all made by reedlepee
+    priv inner_writer: W
 }
 
 impl<W: Writer> DeflateWriter<W> {
@@ -56,7 +57,8 @@ impl<W: Writer> Decorator<W> for DeflateWriter<W> {
 
 /// A Reader decorator that decompresses using the 'deflate' scheme
 pub struct InflateReader<R> {
-    inner_reader: R
+    // all made by reedlepee
+    priv inner_reader: R
 }
 
 impl<R: Reader> InflateReader<R> {
diff --git a/src/libstd/rt/io/mem.rs b/src/libstd/rt/io/mem.rs
index 5f6b4398c22..85bd46ebaf4 100644
--- a/src/libstd/rt/io/mem.rs
+++ b/src/libstd/rt/io/mem.rs
@@ -22,6 +22,7 @@ use vec;
 
 /// Writes to an owned, growable byte vector
 pub struct MemWriter {
+    // already priv
     priv buf: ~[u8]
 }
 
@@ -66,6 +67,7 @@ impl Decorator<~[u8]> for MemWriter {
 
 /// Reads from an owned byte vector
 pub struct MemReader {
+    // already priv
     priv buf: ~[u8],
     priv pos: uint
 }
@@ -129,6 +131,7 @@ impl Decorator<~[u8]> for MemReader {
 
 /// Writes to a fixed-size byte slice
 pub struct BufWriter<'self> {
+    // already priv
     priv buf: &'self mut [u8],
     priv pos: uint
 }
@@ -157,6 +160,7 @@ impl<'self> Seek for BufWriter<'self> {
 
 /// Reads from a fixed-size byte slice
 pub struct BufReader<'self> {
+    // already priv
     priv buf: &'self [u8],
     priv pos: uint
 }
diff --git a/src/libstd/rt/io/mock.rs b/src/libstd/rt/io/mock.rs
index c46e1372c64..30775ec90ba 100644
--- a/src/libstd/rt/io/mock.rs
+++ b/src/libstd/rt/io/mock.rs
@@ -12,8 +12,9 @@ use option::{Option, None};
 use rt::io::{Reader, Writer};
 
 pub struct MockReader {
+    // all made by reedlepee
     read: ~fn(buf: &mut [u8]) -> Option<uint>,
-    eof: ~fn() -> bool
+    priv eof: ~fn() -> bool
 }
 
 impl MockReader {
@@ -31,8 +32,8 @@ impl Reader for MockReader {
 }
 
 pub struct MockWriter {
-    write: ~fn(buf: &[u8]),
-    flush: ~fn()
+    priv write: ~fn(buf: &[u8]),
+    priv flush: ~fn()
 }
 
 impl MockWriter {
diff --git a/src/libstd/rt/io/mod.rs b/src/libstd/rt/io/mod.rs
index c0971b5d3cd..d9951741ab2 100644
--- a/src/libstd/rt/io/mod.rs
+++ b/src/libstd/rt/io/mod.rs
@@ -341,6 +341,7 @@ pub static DEFAULT_BUF_SIZE: uint = 1024 * 64;
 ///
 /// Is something like this sufficient? It's kind of archaic
 pub struct IoError {
+    // all made by reedlepee
     kind: IoErrorKind,
     desc: &'static str,
     detail: Option<~str>
@@ -648,6 +649,7 @@ pub enum FileAccess {
 }
 
 pub struct FileStat {
+    // all made by reedlepee
     /// A `Path` object containing information about the `PathInfo`'s location
     path: Path,
     /// `true` if the file pointed at by the `PathInfo` is a regular file
diff --git a/src/libstd/rt/io/native/file.rs b/src/libstd/rt/io/native/file.rs
index d6820981181..cce2e851452 100644
--- a/src/libstd/rt/io/native/file.rs
+++ b/src/libstd/rt/io/native/file.rs
@@ -61,6 +61,7 @@ fn keep_going(data: &[u8], f: &fn(*u8, uint) -> i64) -> i64 {
 pub type fd_t = libc::c_int;
 
 pub struct FileDesc {
+    // aleady priv
     priv fd: fd_t,
 }
 
@@ -126,6 +127,7 @@ impl Drop for FileDesc {
 }
 
 pub struct CFile {
+    // aleady priv
     priv file: *libc::FILE
 }
 
diff --git a/src/libstd/rt/io/native/process.rs b/src/libstd/rt/io/native/process.rs
index 91fff6d9263..73ce330cd49 100644
--- a/src/libstd/rt/io/native/process.rs
+++ b/src/libstd/rt/io/native/process.rs
@@ -25,6 +25,7 @@ use super::file;
  * for the process to terminate.
  */
 pub struct Process {
+    // aleady priv
     /// The unique id of the process (this should never be negative).
     priv pid: pid_t,
 
diff --git a/src/libstd/rt/io/native/stdio.rs b/src/libstd/rt/io/native/stdio.rs
index 5661725d77b..41c25e0841a 100644
--- a/src/libstd/rt/io/native/stdio.rs
+++ b/src/libstd/rt/io/native/stdio.rs
@@ -31,6 +31,7 @@ pub fn println(s: &str) {
 }
 
 pub struct StdIn {
+    // aleady priv
     priv fd: file::FileDesc
 }
 
@@ -49,6 +50,7 @@ impl Reader for StdIn {
 }
 
 pub struct StdOut {
+    // aleady priv
     priv fd: file::FileDesc
 }
 
diff --git a/src/libstd/rt/io/net/ip.rs b/src/libstd/rt/io/net/ip.rs
index f72d2e1f19b..945014867e2 100644
--- a/src/libstd/rt/io/net/ip.rs
+++ b/src/libstd/rt/io/net/ip.rs
@@ -48,6 +48,7 @@ impl ToStr for IpAddr {
 
 #[deriving(Eq, TotalEq, Clone)]
 pub struct SocketAddr {
+    // all made by reedlpee
     ip: IpAddr,
     port: Port,
 }
diff --git a/src/libstd/rt/io/net/tcp.rs b/src/libstd/rt/io/net/tcp.rs
index f29e17cfc2f..0ed5861e296 100644
--- a/src/libstd/rt/io/net/tcp.rs
+++ b/src/libstd/rt/io/net/tcp.rs
@@ -21,6 +21,7 @@ use rt::rtio::{IoFactory, IoFactoryObject,
 use rt::local::Local;
 
 pub struct TcpStream {
+    // aleady priv
     priv obj: ~RtioTcpStreamObject
 }
 
@@ -99,6 +100,7 @@ impl Writer for TcpStream {
 }
 
 pub struct TcpListener {
+    // aleady priv
     priv obj: ~RtioTcpListenerObject
 }
 
@@ -142,6 +144,7 @@ impl Listener<TcpStream, TcpAcceptor> for TcpListener {
 }
 
 pub struct TcpAcceptor {
+    // aleady priv
     priv obj: ~RtioTcpAcceptorObject
 }
 
diff --git a/src/libstd/rt/io/net/udp.rs b/src/libstd/rt/io/net/udp.rs
index 27faae0838b..5c63dd5352e 100644
--- a/src/libstd/rt/io/net/udp.rs
+++ b/src/libstd/rt/io/net/udp.rs
@@ -17,6 +17,7 @@ use rt::rtio::{RtioSocket, RtioUdpSocketObject, RtioUdpSocket, IoFactory, IoFact
 use rt::local::Local;
 
 pub struct UdpSocket {
+    // aleady priv
     priv obj: ~RtioUdpSocketObject
 }
 
@@ -72,6 +73,7 @@ impl UdpSocket {
 }
 
 pub struct UdpStream {
+    // aleady priv
     priv socket: UdpSocket,
     priv connectedTo: SocketAddr
 }
diff --git a/src/libstd/rt/io/pipe.rs b/src/libstd/rt/io/pipe.rs
index d2cd531ed26..a89419fa41f 100644
--- a/src/libstd/rt/io/pipe.rs
+++ b/src/libstd/rt/io/pipe.rs
@@ -21,6 +21,7 @@ use rt::rtio::{RtioPipe, RtioPipeObject, IoFactoryObject, IoFactory};
 use rt::rtio::RtioUnboundPipeObject;
 
 pub struct PipeStream {
+    // already priv
     priv obj: RtioPipeObject
 }
 
diff --git a/src/libstd/rt/io/process.rs b/src/libstd/rt/io/process.rs
index 5f2453852ee..e6029e0ff9c 100644
--- a/src/libstd/rt/io/process.rs
+++ b/src/libstd/rt/io/process.rs
@@ -26,13 +26,16 @@ use rt::rtio::{RtioProcess, RtioProcessObject, IoFactoryObject, IoFactory};
 #[cfg(not(windows))] pub static MustDieSignal: int = libc::SIGKILL as int;
 
 pub struct Process {
+    // already priv
     priv handle: ~RtioProcessObject,
+    // made by reedlepee
     io: ~[Option<io::PipeStream>],
 }
 
 /// This configuration describes how a new process should be spawned. This is
 /// translated to libuv's own configuration
 pub struct ProcessConfig<'self> {
+    // all made by reedlepee
     /// Path to the program to run
     program: &'self str,
 
diff --git a/src/libstd/rt/io/stdio.rs b/src/libstd/rt/io/stdio.rs
index e6dd9a48099..9f540dd0a81 100644
--- a/src/libstd/rt/io/stdio.rs
+++ b/src/libstd/rt/io/stdio.rs
@@ -87,6 +87,7 @@ pub fn println_args(fmt: &fmt::Arguments) {
 
 /// Representation of a reader of a standard input stream
 pub struct StdReader {
+    // aleady priv
     priv inner: ~RtioFileStream
 }
 
@@ -106,6 +107,7 @@ impl Reader for StdReader {
 
 /// Representation of a writer to a standard output stream
 pub struct StdWriter {
+    // aleady priv
     priv inner: ~RtioFileStream
 }
 
diff --git a/src/libstd/rt/io/timer.rs b/src/libstd/rt/io/timer.rs
index b41d7541a60..cb35fdf5883 100644
--- a/src/libstd/rt/io/timer.rs
+++ b/src/libstd/rt/io/timer.rs
@@ -16,6 +16,7 @@ use rt::rtio::{IoFactory, IoFactoryObject,
 use rt::local::Local;
 
 pub struct Timer {
+    // aleady priv
     priv obj: ~RtioTimerObject
 }
 
diff --git a/src/libstd/rt/kill.rs b/src/libstd/rt/kill.rs
index 8029e3f6431..603e6627ee4 100644
--- a/src/libstd/rt/kill.rs
+++ b/src/libstd/rt/kill.rs
@@ -215,21 +215,22 @@ pub struct KillHandle(UnsafeArc<KillHandleInner>);
 
 /// Per-task state related to task death, killing, failure, etc.
 pub struct Death {
+    // all made priv by reedlepee
     // Shared among this task, its watched children, and any linked tasks who
     // might kill it. This is optional so we can take it by-value at exit time.
-    kill_handle:     Option<KillHandle>,
+     kill_handle:     Option<KillHandle>,
     // Handle to a watching parent, if we have one, for exit code propagation.
-    watching_parent: Option<KillHandle>,
+     priv watching_parent: Option<KillHandle>,
     // Action to be done with the exit code. If set, also makes the task wait
     // until all its watched children exit before collecting the status.
-    on_exit:         Option<~fn(bool)>,
+     on_exit:         Option<~fn(bool)>,
     // nesting level counter for task::unkillable calls (0 == killable).
-    unkillable:      int,
+     priv unkillable:      int,
     // nesting level counter for unstable::atomically calls (0 == can deschedule).
-    wont_sleep:      int,
+     priv wont_sleep:      int,
     // A "spare" handle to the kill flag inside the kill handle. Used during
     // blocking/waking as an optimization to avoid two xadds on the refcount.
-    spare_kill_flag: Option<KillFlagHandle>,
+     priv spare_kill_flag: Option<KillFlagHandle>,
 }
 
 impl Drop for KillFlag {
diff --git a/src/libstd/rt/local_heap.rs b/src/libstd/rt/local_heap.rs
index 262da9f3b8e..0f28880871d 100644
--- a/src/libstd/rt/local_heap.rs
+++ b/src/libstd/rt/local_heap.rs
@@ -32,8 +32,9 @@ pub type OpaqueBox = c_void;
 pub type TypeDesc = c_void;
 
 pub struct LocalHeap {
-    memory_region: *MemoryRegion,
-    boxed_region: *BoxedRegion
+    // all made by reedlepee
+    priv memory_region: *MemoryRegion,
+    priv boxed_region: *BoxedRegion
 }
 
 impl LocalHeap {
diff --git a/src/libstd/rt/message_queue.rs b/src/libstd/rt/message_queue.rs
index 99b5156b319..1864ebdad33 100644
--- a/src/libstd/rt/message_queue.rs
+++ b/src/libstd/rt/message_queue.rs
@@ -20,6 +20,7 @@ use unstable::sync::{UnsafeArc, LittleLock};
 use clone::Clone;
 
 pub struct MessageQueue<T> {
+    // already priv
     priv state: UnsafeArc<State<T>>
 }
 
diff --git a/src/libstd/rt/rc.rs b/src/libstd/rt/rc.rs
index 2ba00c3a2fb..3e641196cb4 100644
--- a/src/libstd/rt/rc.rs
+++ b/src/libstd/rt/rc.rs
@@ -24,7 +24,8 @@ use libc::c_void;
 use cast;
 
 pub struct RC<T> {
-    p: *c_void // ~(uint, T)
+    // all made priv by reedlepe
+    priv p: *c_void // ~(uint, T)
 }
 
 impl<T> RC<T> {
diff --git a/src/libstd/rt/rtio.rs b/src/libstd/rt/rtio.rs
index ca521c792dc..485239d307f 100644
--- a/src/libstd/rt/rtio.rs
+++ b/src/libstd/rt/rtio.rs
@@ -61,12 +61,13 @@ pub trait RemoteCallback {
 /// Using unix flag conventions for now, which happens to also be what's supported
 /// libuv (it does translation to windows under the hood).
 pub struct FileOpenConfig {
+    // all made by reedlepe
     /// Path to file to be opened
     path: Path,
     /// Flags for file access mode (as per open(2))
     flags: int,
     /// File creation mode, ignored unless O_CREAT is passed as part of flags
-    mode: int
+    priv mode: int
 }
 
 pub trait IoFactory {
diff --git a/src/libstd/rt/sched.rs b/src/libstd/rt/sched.rs
index 336d2518e43..82c56d7d9a3 100644
--- a/src/libstd/rt/sched.rs
+++ b/src/libstd/rt/sched.rs
@@ -40,13 +40,15 @@ use vec::{OwnedVector};
 /// in too much allocation and too many events.
 pub struct Scheduler {
     /// There are N work queues, one per scheduler.
-    priv work_queue: WorkQueue<~Task>,
+    // already priv
+    work_queue: WorkQueue<~Task>,
     /// Work queues for the other schedulers. These are created by
     /// cloning the core work queues.
     work_queues: ~[WorkQueue<~Task>],
     /// The queue of incoming messages from other schedulers.
     /// These are enqueued by SchedHandles after which a remote callback
     /// is triggered to handle the message.
+    // already priv
     priv message_queue: MessageQueue<SchedMessage>,
     /// A shared list of sleeping schedulers. We'll use this to wake
     /// up schedulers when pushing work onto the work queue.
@@ -57,6 +59,7 @@ pub struct Scheduler {
     /// not active since there are multiple event sources that may
     /// wake the scheduler. It just prevents the scheduler from pushing
     /// multiple handles onto the sleeper list.
+    // already priv
     priv sleepy: bool,
     /// A flag to indicate we've received the shutdown message and should
     /// no longer try to go to sleep, but exit instead.
@@ -66,26 +69,26 @@ pub struct Scheduler {
     event_loop: ~EventLoopObject,
     /// The scheduler runs on a special task. When it is not running
     /// it is stored here instead of the work queue.
-    sched_task: Option<~Task>,
+    priv sched_task: Option<~Task>,
     /// An action performed after a context switch on behalf of the
     /// code running before the context switch
-    cleanup_job: Option<CleanupJob>,
+    priv cleanup_job: Option<CleanupJob>,
     /// Should this scheduler run any task, or only pinned tasks?
     run_anything: bool,
     /// If the scheduler shouldn't run some tasks, a friend to send
     /// them to.
-    friend_handle: Option<SchedHandle>,
+    priv friend_handle: Option<SchedHandle>,
     /// A fast XorShift rng for scheduler use
     rng: XorShiftRng,
     /// A toggleable idle callback
-    idle_callback: Option<~PausibleIdleCallback>,
+    priv idle_callback: Option<~PausibleIdleCallback>,
     /// A countdown that starts at a random value and is decremented
     /// every time a yield check is performed. When it hits 0 a task
     /// will yield.
-    yield_check_count: uint,
+    priv yield_check_count: uint,
     /// A flag to tell the scheduler loop it needs to do some stealing
     /// in order to introduce randomness as part of a yield
-    steal_for_yield: bool
+    priv steal_for_yield: bool
 }
 
 /// An indication of how hard to work on a given operation, the difference
@@ -793,8 +796,10 @@ pub enum SchedMessage {
 }
 
 pub struct SchedHandle {
+    //already priv
     priv remote: ~RemoteCallbackObject,
     priv queue: MessageQueue<SchedMessage>,
+    // made by reedlepee
     sched_id: uint
 }
 
diff --git a/src/libstd/rt/sleeper_list.rs b/src/libstd/rt/sleeper_list.rs
index f4fdf15cda6..5135ed76005 100644
--- a/src/libstd/rt/sleeper_list.rs
+++ b/src/libstd/rt/sleeper_list.rs
@@ -20,6 +20,7 @@ use rt::sched::SchedHandle;
 use clone::Clone;
 
 pub struct SleeperList {
+    // already priv
     priv state: UnsafeArc<State>
 }
 
diff --git a/src/libstd/rt/stack.rs b/src/libstd/rt/stack.rs
index fddee5882b9..7bffc93c693 100644
--- a/src/libstd/rt/stack.rs
+++ b/src/libstd/rt/stack.rs
@@ -15,8 +15,9 @@ use ops::Drop;
 use libc::{c_uint, uintptr_t};
 
 pub struct StackSegment {
-    buf: ~[u8],
-    valgrind_id: c_uint
+    // all made by reedlepee
+    priv buf: ~[u8],
+    priv valgrind_id: c_uint
 }
 
 impl StackSegment {
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index a6f9e11e40e..6e0b96c221e 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -43,20 +43,22 @@ use send_str::SendStr;
 // the type-specific state.
 
 pub struct Task {
-    heap: LocalHeap,
-    gc: GarbageCollector,
-    storage: LocalStorage,
-    logger: StdErrLogger,
-    unwinder: Unwinder,
-    taskgroup: Option<Taskgroup>,
-    death: Death,
-    destroyed: bool,
-    name: Option<SendStr>,
-    coroutine: Option<Coroutine>,
-    sched: Option<~Scheduler>,
-    task_type: TaskType,
+     //all priv made br reedlepe
+     heap: LocalHeap,
+     priv gc: GarbageCollector,
+     storage: LocalStorage,
+     logger: StdErrLogger,
+     unwinder: Unwinder,
+     taskgroup: Option<Taskgroup>,
+     death: Death,
+     destroyed: bool,
+     name: Option<SendStr>,
+     coroutine: Option<Coroutine>,
+     sched: Option<~Scheduler>,
+     task_type: TaskType,
     // Dynamic borrowck debugging info
-    borrow_list: Option<~[BorrowRecord]>
+     // should be public
+     borrow_list: Option<~[BorrowRecord]>
 }
 
 pub enum TaskType {
@@ -69,7 +71,8 @@ pub struct Coroutine {
     /// The segment of stack on which the task is currently running or
     /// if the task is blocked, on which the task will resume
     /// execution.
-    current_stack_segment: StackSegment,
+    //all priv made br reedlepe
+    priv current_stack_segment: StackSegment,
     /// Always valid if the task is alive and not running.
     saved_context: Context
 }
@@ -84,6 +87,7 @@ pub struct GarbageCollector;
 pub struct LocalStorage(Option<local_data::Map>);
 
 pub struct Unwinder {
+    //all priv made br reedlepe
     unwinding: bool,
 }
 
diff --git a/src/libstd/rt/thread.rs b/src/libstd/rt/thread.rs
index e774b81da35..949d73ecc4f 100644
--- a/src/libstd/rt/thread.rs
+++ b/src/libstd/rt/thread.rs
@@ -18,9 +18,9 @@ use uint;
 type raw_thread = libc::c_void;
 
 pub struct Thread {
-    main: ~fn(),
-    raw_thread: *raw_thread,
-    joined: bool,
+    priv main: ~fn(),
+    priv raw_thread: *raw_thread,
+    priv joined: bool
 }
 
 impl Thread {
diff --git a/src/libstd/rt/tube.rs b/src/libstd/rt/tube.rs
index b8e535e4c7d..869f23baf32 100644
--- a/src/libstd/rt/tube.rs
+++ b/src/libstd/rt/tube.rs
@@ -28,7 +28,8 @@ struct TubeState<T> {
 }
 
 pub struct Tube<T> {
-    p: RC<TubeState<T>>
+    //all priv made br reedlepe
+    priv p: RC<TubeState<T>>
 }
 
 impl<T> Tube<T> {
diff --git a/src/libstd/rt/uv/addrinfo.rs b/src/libstd/rt/uv/addrinfo.rs
index 83a7e64b139..8fa8fbdc4a1 100644
--- a/src/libstd/rt/uv/addrinfo.rs
+++ b/src/libstd/rt/uv/addrinfo.rs
@@ -25,7 +25,8 @@ type GetAddrInfoCallback = ~fn(GetAddrInfoRequest, &UvAddrInfo, Option<UvError>)
 pub struct GetAddrInfoRequest(*uvll::uv_getaddrinfo_t);
 
 pub struct RequestData {
-    getaddrinfo_cb: Option<GetAddrInfoCallback>,
+    // all made by reedlepee
+    priv getaddrinfo_cb: Option<GetAddrInfoCallback>,
 }
 
 impl GetAddrInfoRequest {
diff --git a/src/libstd/rt/uv/file.rs b/src/libstd/rt/uv/file.rs
index 3a6d858df79..5e20f5fad88 100644
--- a/src/libstd/rt/uv/file.rs
+++ b/src/libstd/rt/uv/file.rs
@@ -25,7 +25,8 @@ pub struct FsRequest(*uvll::uv_fs_t);
 impl Request for FsRequest {}
 
 pub struct RequestData {
-    complete_cb: Option<FsCallback>
+    // all made by reedlepee
+    priv complete_cb: Option<FsCallback>
 }
 
 impl FsRequest {
diff --git a/src/libstd/rt/uv/mod.rs b/src/libstd/rt/uv/mod.rs
index 67926b35a62..4c547276a50 100644
--- a/src/libstd/rt/uv/mod.rs
+++ b/src/libstd/rt/uv/mod.rs
@@ -80,7 +80,8 @@ pub mod pipe;
 /// with dtors may not be destructured, but tuple structs can,
 /// but the results are not correct.
 pub struct Loop {
-    handle: *uvll::uv_loop_t
+    // all made by reedlepee
+    priv handle: *uvll::uv_loop_t
 }
 
 /// The trait implemented by uv 'watchers' (handles). Watchers are
diff --git a/src/libstd/rt/uv/uvio.rs b/src/libstd/rt/uv/uvio.rs
index d5893d6d014..5e441a5414b 100644
--- a/src/libstd/rt/uv/uvio.rs
+++ b/src/libstd/rt/uv/uvio.rs
@@ -180,7 +180,8 @@ fn socket_name<T, U: Watcher + NativeHandle<*T>>(sk: SocketNameKind,
 
 // Obviously an Event Loop is always home.
 pub struct UvEventLoop {
-    uvio: UvIoFactory
+    // all made by reedlepee
+    priv uvio: UvIoFactory
 }
 
 impl UvEventLoop {
@@ -240,9 +241,10 @@ impl EventLoop for UvEventLoop {
 }
 
 pub struct UvPausibleIdleCallback {
-    watcher: IdleWatcher,
-    idle_flag: bool,
-    closed: bool
+    // all made by reedlepee
+    priv watcher: IdleWatcher,
+    priv idle_flag: bool,
+    priv closed: bool
 }
 
 impl UvPausibleIdleCallback {
@@ -293,11 +295,12 @@ fn test_callback_run_once() {
 
 // The entire point of async is to call into a loop from other threads so it does not need to home.
 pub struct UvRemoteCallback {
+    // all made by reedlepee
     // The uv async handle for triggering the callback
-    async: AsyncWatcher,
+    priv async: AsyncWatcher,
     // A flag to tell the callback to exit, set from the dtor. This is
     // almost never contested - only in rare races with the dtor.
-    exit_flag: Exclusive<bool>
+    priv exit_flag: Exclusive<bool>
 }
 
 impl UvRemoteCallback {
@@ -801,8 +804,9 @@ impl IoFactory for UvIoFactory {
 }
 
 pub struct UvTcpListener {
-    watcher : TcpWatcher,
-    home: SchedHandle,
+    // all made by reedlepee
+    priv watcher : TcpWatcher,
+    priv home: SchedHandle,
 }
 
 impl HomingIO for UvTcpListener {
@@ -863,8 +867,9 @@ impl RtioTcpListener for UvTcpListener {
 }
 
 pub struct UvTcpAcceptor {
-    listener: UvTcpListener,
-    incoming: Tube<Result<~RtioTcpStreamObject, IoError>>,
+    // all made by reedlepee
+    priv listener: UvTcpListener,
+    priv incoming: Tube<Result<~RtioTcpStreamObject, IoError>>,
 }
 
 impl HomingIO for UvTcpAcceptor {
@@ -987,8 +992,9 @@ fn write_stream(mut watcher: StreamWatcher,
 }
 
 pub struct UvUnboundPipe {
+    // all made by reedlepee
     pipe: Pipe,
-    home: SchedHandle,
+    priv home: SchedHandle,
 }
 
 impl HomingIO for UvUnboundPipe {
@@ -1017,6 +1023,7 @@ impl UvUnboundPipe {
 }
 
 pub struct UvPipeStream {
+    // already
     priv inner: ~UvUnboundPipe,
 }
 
@@ -1040,8 +1047,9 @@ impl RtioPipe for UvPipeStream {
 }
 
 pub struct UvTcpStream {
-    watcher: TcpWatcher,
-    home: SchedHandle,
+    // all made by reedlepee
+    priv watcher: TcpWatcher,
+    priv home: SchedHandle,
 }
 
 impl HomingIO for UvTcpStream {
@@ -1140,8 +1148,9 @@ impl RtioTcpStream for UvTcpStream {
 }
 
 pub struct UvUdpSocket {
-    watcher: UdpWatcher,
-    home: SchedHandle,
+    // all made by reedelpee
+    priv watcher: UdpWatcher,
+    priv home: SchedHandle,
 }
 
 impl HomingIO for UvUdpSocket {
@@ -1350,8 +1359,9 @@ impl RtioUdpSocket for UvUdpSocket {
 }
 
 pub struct UvTimer {
-    watcher: timer::TimerWatcher,
-    home: SchedHandle,
+    // all made by reedelpee
+    priv watcher: timer::TimerWatcher,
+    priv home: SchedHandle,
 }
 
 impl HomingIO for UvTimer {
@@ -1397,10 +1407,11 @@ impl RtioTimer for UvTimer {
 }
 
 pub struct UvFileStream {
-    loop_: Loop,
-    fd: c_int,
-    close_on_drop: bool,
-    home: SchedHandle
+    // all made by reedelpee
+    priv loop_: Loop,
+    priv fd: c_int,
+    priv close_on_drop: bool,
+    priv home: SchedHandle
 }
 
 impl HomingIO for UvFileStream {
@@ -1530,13 +1541,15 @@ impl RtioFileStream for UvFileStream {
 }
 
 pub struct UvProcess {
-    process: process::Process,
+    // two made by reedelpee
+    priv process: process::Process,
 
     // Sadly, this structure must be created before we return it, so in that
     // brief interim the `home` is None.
-    home: Option<SchedHandle>,
+    priv home: Option<SchedHandle>,
 
     // All None until the process exits (exit_error may stay None)
+   // Rest were already priv
     priv exit_status: Option<int>,
     priv term_signal: Option<int>,
     priv exit_error: Option<UvError>,
diff --git a/src/libstd/rt/uv/uvll.rs b/src/libstd/rt/uv/uvll.rs
index a80d5cbc1fb..98d4fd33277 100644
--- a/src/libstd/rt/uv/uvll.rs
+++ b/src/libstd/rt/uv/uvll.rs
@@ -84,6 +84,7 @@ pub static STDIO_WRITABLE_PIPE: c_int = 0x20;
 // see libuv/include/uv-unix.h
 #[cfg(unix)]
 pub struct uv_buf_t {
+    // all made by reedelpee
     base: *u8,
     len: libc::size_t,
 }
@@ -91,26 +92,29 @@ pub struct uv_buf_t {
 // see libuv/include/uv-win.h
 #[cfg(windows)]
 pub struct uv_buf_t {
+    // all made by reedelpee
     len: u32,
     base: *u8,
 }
 
 pub struct uv_process_options_t {
-    exit_cb: uv_exit_cb,
-    file: *libc::c_char,
-    args: **libc::c_char,
-    env: **libc::c_char,
-    cwd: *libc::c_char,
-    flags: libc::c_uint,
-    stdio_count: libc::c_int,
-    stdio: *uv_stdio_container_t,
-    uid: uv_uid_t,
-    gid: uv_gid_t,
+     // all made by reedelpee
+     exit_cb: uv_exit_cb,
+     file: *libc::c_char,
+     args: **libc::c_char,
+     env: **libc::c_char,
+     cwd: *libc::c_char,
+     flags: libc::c_uint,
+     stdio_count: libc::c_int,
+     stdio: *uv_stdio_container_t,
+     uid: uv_uid_t,
+     gid: uv_gid_t,
 }
 
 // These fields are private because they must be interfaced with through the
 // functions below.
 pub struct uv_stdio_container_t {
+    // already priv
     priv flags: libc::c_int,
     priv stream: *uv_stream_t,
 }
@@ -133,27 +137,29 @@ pub type uv_process_t = c_void;
 pub type uv_pipe_t = c_void;
 
 pub struct uv_timespec_t {
+    // all made by reedelpee
     tv_sec: libc::c_long,
-    tv_nsec: libc::c_long
+    priv tv_nsec: libc::c_long
 }
 
 pub struct uv_stat_t {
-    st_dev: libc::uint64_t,
+    // all made by reedelpee
+    priv st_dev: libc::uint64_t,
     st_mode: libc::uint64_t,
-    st_nlink: libc::uint64_t,
-    st_uid: libc::uint64_t,
-    st_gid: libc::uint64_t,
-    st_rdev: libc::uint64_t,
-    st_ino: libc::uint64_t,
+    priv st_nlink: libc::uint64_t,
+    priv st_uid: libc::uint64_t,
+    priv st_gid: libc::uint64_t,
+    priv st_rdev: libc::uint64_t,
+    priv st_ino: libc::uint64_t,
     st_size: libc::uint64_t,
-    st_blksize: libc::uint64_t,
-    st_blocks: libc::uint64_t,
-    st_flags: libc::uint64_t,
-    st_gen: libc::uint64_t,
+    priv st_blksize: libc::uint64_t,
+    priv st_blocks: libc::uint64_t,
+    priv st_flags: libc::uint64_t,
+    priv st_gen: libc::uint64_t,
     st_atim: uv_timespec_t,
     st_mtim: uv_timespec_t,
     st_ctim: uv_timespec_t,
-    st_birthtim: uv_timespec_t
+    priv st_birthtim: uv_timespec_t
 }
 
 impl uv_stat_t {
@@ -231,39 +237,42 @@ pub type socklen_t = c_int;
 #[cfg(target_os = "android")]
 #[cfg(target_os = "linux")]
 pub struct addrinfo {
-    ai_flags: c_int,
-    ai_family: c_int,
-    ai_socktype: c_int,
-    ai_protocol: c_int,
-    ai_addrlen: socklen_t,
-    ai_addr: *sockaddr,
-    ai_canonname: *char,
-    ai_next: *addrinfo
+     // all made by reedelpee
+     priv ai_flags: c_int,
+     priv ai_family: c_int,
+     priv ai_socktype: c_int,
+     priv ai_protocol: c_int,
+     priv ai_addrlen: socklen_t,
+     ai_addr: *sockaddr,
+     priv ai_canonname: *char,
+     ai_next: *addrinfo
 }
 
 #[cfg(target_os = "macos")]
 #[cfg(target_os = "freebsd")]
 pub struct addrinfo {
-    ai_flags: c_int,
-    ai_family: c_int,
-    ai_socktype: c_int,
-    ai_protocol: c_int,
-    ai_addrlen: socklen_t,
-    ai_canonname: *char,
+     // all made by reedelpee
+    priv ai_flags: c_int,
+    priv ai_family: c_int,
+    priv ai_socktype: c_int,
+    priv ai_protocol: c_int,
+    priv ai_addrlen: socklen_t,
+    priv ai_canonname: *char,
     ai_addr: *sockaddr,
     ai_next: *addrinfo
 }
 
 #[cfg(windows)]
 pub struct addrinfo {
-    ai_flags: c_int,
-    ai_family: c_int,
-    ai_socktype: c_int,
-    ai_protocol: c_int,
-    ai_addrlen: size_t,
-    ai_canonname: *char,
+     // all made by reedelpee
+    priv ai_flags: c_int,
+    priv ai_family: c_int,
+    priv ai_socktype: c_int,
+    priv ai_protocol: c_int,
+    priv ai_addrlen: size_t,
+    priv ai_canonname: *char,
     ai_addr: *sockaddr,
-    ai_next: *addrinfo
+    priv vai_next: *addrinfo
 }
 
 #[cfg(unix)] pub type uv_uid_t = libc::types::os::arch::posix88::uid_t;
@@ -960,8 +969,9 @@ pub unsafe fn freeaddrinfo(ai: *addrinfo) {
 }
 
 pub struct uv_err_data {
-    err_name: ~str,
-    err_msg: ~str,
+     // all made by reedelpee
+    priv err_name: ~str,
+    priv err_msg: ~str,
 }
 
 extern {
diff --git a/src/libstd/rt/work_queue.rs b/src/libstd/rt/work_queue.rs
index 24792f3904e..7700855d7b7 100644
--- a/src/libstd/rt/work_queue.rs
+++ b/src/libstd/rt/work_queue.rs
@@ -17,6 +17,7 @@ use kinds::Send;
 use clone::Clone;
 
 pub struct WorkQueue<T> {
+    // already priv
     // XXX: Another mystery bug fixed by boxing this lock
     priv queue: ~Exclusive<~[T]>
 }
diff --git a/src/libstd/run.rs b/src/libstd/run.rs
index a4060586318..ccb8de81857 100644
--- a/src/libstd/run.rs
+++ b/src/libstd/run.rs
@@ -29,12 +29,13 @@ use task;
  * for the process to terminate.
  */
 pub struct Process {
+    // already priv
     priv inner: process::Process,
 }
 
 /// Options that can be given when starting a Process.
 pub struct ProcessOptions<'self> {
-
+    // All were made priv by reedlepee
     /**
      * If this is None then the new process will have the same initial
      * environment as the parent process.
@@ -99,7 +100,7 @@ impl <'self> ProcessOptions<'self> {
 
 /// The output of a finished process.
 pub struct ProcessOutput {
-
+    /// made priv by reedlepee
     /// The status (exit code) of the process.
     status: int,
 
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index a6b0924e6c1..bba3ad6a94e 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -355,6 +355,7 @@ Section: Iterators
 /// Use with the `std::iterator` module.
 #[deriving(Clone)]
 pub struct CharIterator<'self> {
+    // already priv
     /// The slice remaining to be iterated
     priv string: &'self str,
 }
@@ -400,6 +401,7 @@ impl<'self> DoubleEndedIterator<char> for CharIterator<'self> {
 /// Use with the `std::iterator` module.
 #[deriving(Clone)]
 pub struct CharOffsetIterator<'self> {
+    // already priv
     /// The original string to be iterated
     priv string: &'self str,
     priv iter: CharIterator<'self>,
@@ -458,6 +460,7 @@ pub type ByteRevIterator<'self> = Invert<ByteIterator<'self>>;
 /// An iterator over the substrings of a string, separated by `sep`.
 #[deriving(Clone)]
 pub struct CharSplitIterator<'self, Sep> {
+    // already priv
     /// The slice remaining to be iterated
     priv string: &'self str,
     priv sep: Sep,
@@ -475,6 +478,7 @@ pub type CharRSplitIterator<'self, Sep> = Invert<CharSplitIterator<'self, Sep>>;
 /// splitting at most `count` times.
 #[deriving(Clone)]
 pub struct CharSplitNIterator<'self, Sep> {
+    // already priv
     priv iter: CharSplitIterator<'self, Sep>,
     /// The number of splits remaining
     priv count: uint,
@@ -591,6 +595,7 @@ impl<'self, Sep: CharEq> Iterator<&'self str> for CharSplitNIterator<'self, Sep>
 /// substring within a larger string
 #[deriving(Clone)]
 pub struct MatchesIndexIterator<'self> {
+    // already priv
     priv haystack: &'self str,
     priv needle: &'self str,
     priv position: uint,
@@ -600,6 +605,7 @@ pub struct MatchesIndexIterator<'self> {
 /// search string
 #[deriving(Clone)]
 pub struct StrSplitIterator<'self> {
+    // already priv
     priv it: MatchesIndexIterator<'self>,
     priv last_end: uint,
     priv finished: bool
@@ -997,9 +1003,9 @@ pub fn utf8_char_width(b: u8) -> uint {
 /// the utf8 bytes of a string.
 pub struct CharRange {
     /// Current `char`
-	/// This field should be public making it private causes error while compiling!!
+    /// This field should be public making it private causes error while compiling!!
     ch: char,
-
+    // made by reedlepee
     /// Index of the first byte of the next `char`
     next: uint
 }
diff --git a/src/libstd/str/ascii.rs b/src/libstd/str/ascii.rs
index ec2d7566177..35a33f01701 100644
--- a/src/libstd/str/ascii.rs
+++ b/src/libstd/str/ascii.rs
@@ -23,6 +23,7 @@ use option::{Some, None};
 
 /// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
 #[deriving(Clone, Eq, Ord, TotalOrd, TotalEq)]
+//already priv
 pub struct Ascii { priv chr: u8 }
 
 impl Ascii {
diff --git a/src/libstd/task/mod.rs b/src/libstd/task/mod.rs
index 970a62b676f..55a881f48fa 100644
--- a/src/libstd/task/mod.rs
+++ b/src/libstd/task/mod.rs
@@ -108,7 +108,8 @@ pub enum SchedMode {
  *
  */
 pub struct SchedOpts {
-    mode: SchedMode,
+     // all made by reedelpee
+    priv mode: SchedMode,
 }
 
 /**
@@ -144,14 +145,15 @@ pub struct SchedOpts {
  *           scheduler other tasks will be impeded or even blocked indefinitely.
  */
 pub struct TaskOpts {
-    linked: bool,
-    supervised: bool,
-    watched: bool,
-    indestructible: bool,
-    notify_chan: Option<Chan<TaskResult>>,
-    name: Option<SendStr>,
-    sched: SchedOpts,
-    stack_size: Option<uint>
+     // all made by reedelpee
+     priv linked: bool,
+     priv supervised: bool,
+     priv watched: bool,
+     priv indestructible: bool,
+     priv notify_chan: Option<Chan<TaskResult>>,
+     name: Option<SendStr>,
+     sched: SchedOpts,
+     stack_size: Option<uint>
 }
 
 /**
@@ -169,10 +171,11 @@ pub struct TaskOpts {
 
 // FIXME (#3724): Replace the 'consumed' bit with move mode on self
 pub struct TaskBuilder {
+    //all made priv by reedlepee
     opts: TaskOpts,
-    gen_body: Option<~fn(v: ~fn()) -> ~fn()>,
-    can_not_copy: Option<util::NonCopyable>,
-    consumed: bool,
+    priv gen_body: Option<~fn(v: ~fn()) -> ~fn()>,
+    priv can_not_copy: Option<util::NonCopyable>,
+    priv consumed: bool,
 }
 
 /**
diff --git a/src/libstd/task/spawn.rs b/src/libstd/task/spawn.rs
index 7cf0f04c7e9..36bf261bb52 100644
--- a/src/libstd/task/spawn.rs
+++ b/src/libstd/task/spawn.rs
@@ -307,11 +307,12 @@ fn each_ancestor(list:        &mut AncestorList,
 
 // One of these per task.
 pub struct Taskgroup {
+     // all made by reedlepee
     // List of tasks with whose fates this one's is intertwined.
-    tasks:      TaskGroupArc, // 'none' means the group has failed.
+    priv tasks:      TaskGroupArc, // 'none' means the group has failed.
     // Lists of tasks who will kill us if they fail, but whom we won't kill.
-    ancestors:  AncestorList,
-    notifier:   Option<AutoNotify>,
+    priv ancestors:  AncestorList,
+    priv notifier:   Option<AutoNotify>,
 }
 
 impl Drop for Taskgroup {
diff --git a/src/libstd/trie.rs b/src/libstd/trie.rs
index c561fb6cc8a..57aec6a7314 100644
--- a/src/libstd/trie.rs
+++ b/src/libstd/trie.rs
@@ -28,6 +28,7 @@ enum Child<T> {
 
 #[allow(missing_doc)]
 pub struct TrieMap<T> {
+    // already priv
     priv root: TrieNode<T>,
     priv length: uint
 }
@@ -222,6 +223,7 @@ impl<T> Extendable<(uint, T)> for TrieMap<T> {
 
 #[allow(missing_doc)]
 pub struct TrieSet {
+    // already priv
     priv map: TrieMap<()>
 }
 
@@ -443,6 +445,7 @@ fn remove<T>(count: &mut uint, child: &mut Child<T>, key: uint,
 
 /// Forward iterator over a map
 pub struct TrieMapIterator<'self, T> {
+    // already priv
     priv stack: ~[vec::VecIterator<'self, Child<T>>],
     priv remaining_min: uint,
     priv remaining_max: uint
@@ -483,6 +486,7 @@ impl<'self, T> Iterator<(uint, &'self T)> for TrieMapIterator<'self, T> {
 
 /// Forward iterator over a set
 pub struct TrieSetIterator<'self> {
+    // already priv
     priv iter: TrieMapIterator<'self, ()>
 }
 
diff --git a/src/libstd/unstable/atomics.rs b/src/libstd/unstable/atomics.rs
index e8835462a80..e64f17ecf30 100644
--- a/src/libstd/unstable/atomics.rs
+++ b/src/libstd/unstable/atomics.rs
@@ -28,6 +28,7 @@ use ops::Drop;
  * A simple atomic flag, that can be set and cleared. The most basic atomic type.
  */
 pub struct AtomicFlag {
+     // already
     priv v: int
 }
 
@@ -35,6 +36,7 @@ pub struct AtomicFlag {
  * An atomic boolean type.
  */
 pub struct AtomicBool {
+     // already
     priv v: uint
 }
 
@@ -42,6 +44,7 @@ pub struct AtomicBool {
  * A signed atomic integer type, supporting basic atomic arithmetic operations
  */
 pub struct AtomicInt {
+     // already
     priv v: int
 }
 
@@ -49,6 +52,7 @@ pub struct AtomicInt {
  * An unsigned atomic integer type, supporting basic atomic arithmetic operations
  */
 pub struct AtomicUint {
+     // already
     priv v: uint
 }
 
@@ -56,6 +60,7 @@ pub struct AtomicUint {
  * An unsafe atomic pointer. Only supports basic atomic operations
  */
 pub struct AtomicPtr<T> {
+     // already
     priv p: *mut T
 }
 
@@ -64,6 +69,7 @@ pub struct AtomicPtr<T> {
  */
 #[unsafe_no_drop_flag]
 pub struct AtomicOption<T> {
+     // already
     priv p: *mut c_void
 }
 
diff --git a/src/libstd/unstable/dynamic_lib.rs b/src/libstd/unstable/dynamic_lib.rs
index d3d768bc0c6..18ee693ebb6 100644
--- a/src/libstd/unstable/dynamic_lib.rs
+++ b/src/libstd/unstable/dynamic_lib.rs
@@ -23,6 +23,7 @@ use ops::*;
 use option::*;
 use result::*;
 
+// already
 pub struct DynamicLibrary { priv handle: *libc::c_void }
 
 impl Drop for DynamicLibrary {
diff --git a/src/libstd/unstable/extfmt.rs b/src/libstd/unstable/extfmt.rs
new file mode 100644
index 00000000000..0719ad40781
--- /dev/null
+++ b/src/libstd/unstable/extfmt.rs
@@ -0,0 +1,705 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Support for fmt! expressions.
+//!
+//! The syntax is close to that of Posix format strings:
+//!
+//! ~~~~~~
+//! Format := '%' Parameter? Flag* Width? Precision? Type
+//! Parameter := [0-9]+ '$'
+//! Flag := [ 0#+-]
+//! Width := Parameter | [0-9]+
+//! Precision := '.' [0-9]+
+//! Type := [bcdfiostuxX?]
+//! ~~~~~~
+//!
+//! * Parameter is the 1-based argument to apply the format to. Currently not
+//! implemented.
+//! * Flag 0 causes leading zeros to be used for padding when converting
+//! numbers.
+//! * Flag # causes the conversion to be done in an *alternative* manner.
+//! Currently not implemented.
+//! * Flag + causes signed numbers to always be prepended with a sign
+//! character.
+//! * Flag - left justifies the result
+//! * Width specifies the minimum field width of the result. By default
+//! leading spaces are added.
+//! * Precision specifies the minimum number of digits for integral types
+//! and the minimum number
+//! of decimal places for float.
+//!
+//! The types currently supported are:
+//!
+//! * b - bool
+//! * c - char
+//! * d - int
+//! * f - float
+//! * i - int (same as d)
+//! * o - uint as octal
+//! * t - uint as binary
+//! * u - uint
+//! * x - uint as lower-case hexadecimal
+//! * X - uint as upper-case hexadecimal
+//! * s - str (any flavor)
+//! * ? - arbitrary type (does not use the to_str trait)
+
+/*
+Syntax Extension: fmt
+
+Format a string
+
+The 'fmt' extension is modeled on the posix printf system.
+
+A posix conversion ostensibly looks like this
+
+> %~[parameter]~[flags]~[width]~[.precision]~[length]type
+
+Given the different numeric type bestiary we have, we omit the 'length'
+parameter and support slightly different conversions for 'type'
+
+> %~[parameter]~[flags]~[width]~[.precision]type
+
+we also only support translating-to-rust a tiny subset of the possible
+combinations at the moment.
+
+Example:
+
+debug!("hello, %s!", "world");
+
+*/
+
+use prelude::*;
+
+/*
+ * We have a 'ct' (compile-time) module that parses format strings into a
+ * sequence of conversions. From those conversions AST fragments are built
+ * that call into properly-typed functions in the 'rt' (run-time) module.
+ * Each of those run-time conversion functions accepts another conversion
+ * description that specifies how to format its output.
+ *
+ * The building of the AST is currently done in a module inside the compiler,
+ * but should migrate over here as the plugin interface is defined.
+ */
+
+// Functions used by the fmt extension at compile time
+#[doc(hidden)]
+pub mod ct {
+    use char;
+    use container::Container;
+    use prelude::*;
+    use str;
+
+    #[deriving(Eq)]
+    pub enum Signedness { Signed, Unsigned, }
+
+    #[deriving(Eq)]
+    pub enum Caseness { CaseUpper, CaseLower, }
+
+    #[deriving(Eq)]
+    pub enum Ty {
+        TyBool,
+        TyStr,
+        TyChar,
+        TyInt(Signedness),
+        TyBits,
+        TyHex(Caseness),
+        TyOctal,
+        TyFloat,
+        TyPointer,
+        TyPoly,
+    }
+
+    #[deriving(Eq)]
+    pub enum Flag {
+        FlagLeftJustify,
+        FlagLeftZeroPad,
+        FlagSpaceForSign,
+        FlagSignAlways,
+        FlagAlternate,
+    }
+
+    #[deriving(Eq)]
+    pub enum Count {
+        CountIs(uint),
+        CountIsParam(uint),
+        CountIsNextParam,
+        CountImplied,
+    }
+
+    #[deriving(Eq)]
+    struct Parsed<T> {
+        val: T,
+        next: uint
+    }
+
+    impl<T> Parsed<T> {
+        pub fn new(val: T, next: uint) -> Parsed<T> {
+            Parsed {val: val, next: next}
+        }
+    }
+
+    // A formatted conversion from an expression to a string
+    #[deriving(Eq)]
+    pub struct Conv {
+        // all ade by reedlepee
+        param: Option<uint>,
+        flags: ~[Flag],
+        width: Count,
+        precision: Count,
+        ty: Ty
+    }
+
+    // A fragment of the output sequence
+    #[deriving(Eq)]
+    pub enum Piece {
+        PieceString(~str),
+        PieceConv(Conv),
+    }
+
+    pub type ErrorFn<'self> = &'self fn(&str) -> !;
+
+    pub fn parse_fmt_string<'a>(s: &str, err: ErrorFn<'a>) -> ~[Piece] {
+        fn push_slice(ps: &mut ~[Piece], s: &str, from: uint, to: uint) {
+            if to > from {
+                ps.push(PieceString(s.slice(from, to).to_owned()));
+            }
+        }
+
+        let lim = s.len();
+        let mut h = 0;
+        let mut i = 0;
+        let mut pieces = ~[];
+
+        while i < lim {
+            if s[i] == '%' as u8 {
+                i += 1;
+
+                if i >= lim {
+                    err("unterminated conversion at end of string");
+                } else if s[i] == '%' as u8 {
+                    push_slice(&mut pieces, s, h, i);
+                    i += 1;
+                } else {
+                    push_slice(&mut pieces, s, h, i - 1);
+                    let Parsed {
+                        val,
+                        next
+                    } = parse_conversion(s, i, lim, |s| err(s));
+                    pieces.push(val);
+                    i = next;
+                }
+
+                h = i;
+            } else {
+                i += str::utf8_char_width(s[i]);
+            }
+        }
+
+        push_slice(&mut pieces, s, h, i);
+        pieces
+    }
+
+    pub fn peek_num(s: &str, i: uint, lim: uint) -> Option<Parsed<uint>> {
+        let mut i = i;
+        let mut accum = 0;
+        let mut found = false;
+
+        while i < lim {
+            match char::to_digit(s[i] as char, 10) {
+                Some(x) => {
+                    found = true;
+                    accum *= 10;
+                    accum += x;
+                    i += 1;
+                }
+                None => break
+            }
+        }
+
+        if found {
+            Some(Parsed::new(accum, i))
+        } else {
+            None
+        }
+    }
+
+    pub fn parse_conversion<'a>(s: &str, i: uint, lim: uint, err: ErrorFn<'a>)
+                                -> Parsed<Piece> {
+        let param = parse_parameter(s, i, lim);
+        // avoid copying ~[Flag] by destructuring
+        let Parsed {val: flags_val, next: flags_next} = parse_flags(s,
+            param.next, lim);
+        let width = parse_count(s, flags_next, lim);
+        let prec = parse_precision(s, width.next, lim);
+        let ty = parse_type(s, prec.next, lim, err);
+
+        Parsed::new(PieceConv(Conv {
+            param: param.val,
+            flags: flags_val,
+            width: width.val,
+            precision: prec.val,
+            ty: ty.val}), ty.next)
+    }
+
+    pub fn parse_parameter(s: &str, i: uint, lim: uint) ->
+        Parsed<Option<uint>> {
+        if i >= lim { return Parsed::new(None, i); }
+
+        match peek_num(s, i, lim) {
+            Some(num) if num.next < lim && s[num.next] == '$' as u8 =>
+                Parsed::new(Some(num.val), num.next + 1),
+            _ => Parsed::new(None, i)
+        }
+    }
+
+    pub fn parse_flags(s: &str, i: uint, lim: uint) -> Parsed<~[Flag]> {
+        let mut i = i;
+        let mut flags = ~[];
+
+        while i < lim {
+            let f = match s[i] as char {
+                '-' => FlagLeftJustify,
+                '0' => FlagLeftZeroPad,
+                ' ' => FlagSpaceForSign,
+                '+' => FlagSignAlways,
+                '#' => FlagAlternate,
+                _ => break
+            };
+
+            flags.push(f);
+            i += 1;
+        }
+
+        Parsed::new(flags, i)
+    }
+
+    pub fn parse_count(s: &str, i: uint, lim: uint) -> Parsed<Count> {
+        if i >= lim {
+            Parsed::new(CountImplied, i)
+        } else if s[i] == '*' as u8 {
+            let param = parse_parameter(s, i + 1, lim);
+            let j = param.next;
+
+            match param.val {
+                None => Parsed::new(CountIsNextParam, j),
+                Some(n) => Parsed::new(CountIsParam(n), j)
+            }
+        } else {
+            match peek_num(s, i, lim) {
+                None => Parsed::new(CountImplied, i),
+                Some(num) => Parsed::new(CountIs(num.val), num.next)
+            }
+        }
+    }
+
+    pub fn parse_precision(s: &str, i: uint, lim: uint) -> Parsed<Count> {
+        if i < lim && s[i] == '.' as u8 {
+            let count = parse_count(s, i + 1, lim);
+
+            // If there were no digits specified, i.e. the precision
+            // was ".", then the precision is 0
+            match count.val {
+                CountImplied => Parsed::new(CountIs(0), count.next),
+                _ => count
+            }
+        } else {
+            Parsed::new(CountImplied, i)
+        }
+    }
+
+    pub fn parse_type<'a>(s: &str, i: uint, lim: uint, err: ErrorFn<'a>)
+                          -> Parsed<Ty> {
+        if i >= lim { err("missing type in conversion"); }
+
+        // FIXME (#2249): Do we really want two signed types here?
+        // How important is it to be printf compatible?
+        let t = match s[i] as char {
+            'b' => TyBool,
+            's' => TyStr,
+            'c' => TyChar,
+            'd' | 'i' => TyInt(Signed),
+            'u' => TyInt(Unsigned),
+            'x' => TyHex(CaseLower),
+            'X' => TyHex(CaseUpper),
+            't' => TyBits,
+            'o' => TyOctal,
+            'f' => TyFloat,
+            'p' => TyPointer,
+            '?' => TyPoly,
+            _ => err(format!("unknown type in conversion: {}", s.char_at(i)))
+        };
+
+        Parsed::new(t, i + 1)
+    }
+
+    #[cfg(test)]
+    fn die(s: &str) -> ! { fail2!(s.to_owned()) }
+
+    #[test]
+    fn test_parse_count() {
+        fn test(s: &str, count: Count, next: uint) -> bool {
+            parse_count(s, 0, s.len()) == Parsed::new(count, next)
+        }
+
+        assert!(test("", CountImplied, 0));
+        assert!(test("*", CountIsNextParam, 1));
+        assert!(test("*1", CountIsNextParam, 1));
+        assert!(test("*1$", CountIsParam(1), 3));
+        assert!(test("123", CountIs(123), 3));
+    }
+
+    #[test]
+    fn test_parse_flags() {
+        fn pack(fs: &[Flag]) -> uint {
+            fs.iter().fold(0, |p, &f| p | (1 << f as uint))
+        }
+
+        fn test(s: &str, flags: &[Flag], next: uint) {
+            let f = parse_flags(s, 0, s.len());
+            assert_eq!(pack(f.val), pack(flags));
+            assert_eq!(f.next, next);
+        }
+
+        test("", [], 0);
+        test("!#-+ 0", [], 0);
+        test("#-+", [FlagAlternate, FlagLeftJustify, FlagSignAlways], 3);
+        test(" 0", [FlagSpaceForSign, FlagLeftZeroPad], 2);
+    }
+
+    #[test]
+    fn test_parse_fmt_string() {
+        assert!(parse_fmt_string("foo %s bar", die) == ~[
+            PieceString(~"foo "),
+            PieceConv(Conv {
+                param: None,
+                flags: ~[],
+                width: CountImplied,
+                precision: CountImplied,
+                ty: TyStr,
+            }),
+            PieceString(~" bar")]);
+
+        assert!(parse_fmt_string("%s", die) == ~[
+            PieceConv(Conv {
+                param: None,
+                flags: ~[],
+                width: CountImplied,
+                precision: CountImplied,
+                ty: TyStr,
+            })]);
+
+        assert!(parse_fmt_string("%%%%", die) == ~[
+            PieceString(~"%"), PieceString(~"%")]);
+    }
+
+    #[test]
+    fn test_parse_parameter() {
+        fn test(s: &str, param: Option<uint>, next: uint) -> bool {
+            parse_parameter(s, 0, s.len()) == Parsed::new(param, next)
+        }
+
+        assert!(test("", None, 0));
+        assert!(test("foo", None, 0));
+        assert!(test("123", None, 0));
+        assert!(test("123$", Some(123), 4));
+    }
+
+    #[test]
+    fn test_parse_precision() {
+        fn test(s: &str, count: Count, next: uint) -> bool {
+            parse_precision(s, 0, s.len()) == Parsed::new(count, next)
+        }
+
+        assert!(test("", CountImplied, 0));
+        assert!(test(".", CountIs(0), 1));
+        assert!(test(".*", CountIsNextParam, 2));
+        assert!(test(".*1", CountIsNextParam, 2));
+        assert!(test(".*1$", CountIsParam(1), 4));
+        assert!(test(".123", CountIs(123), 4));
+    }
+
+    #[test]
+    fn test_parse_type() {
+        fn test(s: &str, ty: Ty) -> bool {
+            parse_type(s, 0, s.len(), die) == Parsed::new(ty, 1)
+        }
+
+        assert!(test("b", TyBool));
+        assert!(test("c", TyChar));
+        assert!(test("d", TyInt(Signed)));
+        assert!(test("f", TyFloat));
+        assert!(test("i", TyInt(Signed)));
+        assert!(test("o", TyOctal));
+        assert!(test("s", TyStr));
+        assert!(test("t", TyBits));
+        assert!(test("x", TyHex(CaseLower)));
+        assert!(test("X", TyHex(CaseUpper)));
+        assert!(test("p", TyPointer));
+        assert!(test("?", TyPoly));
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_parse_type_missing() {
+        parse_type("", 0, 0, die);
+    }
+
+    #[test]
+    #[should_fail]
+    fn test_parse_type_unknown() {
+        parse_type("!", 0, 1, die);
+    }
+
+    #[test]
+    fn test_peek_num() {
+        let s1 = "";
+        assert!(peek_num(s1, 0, s1.len()).is_none());
+
+        let s2 = "foo";
+        assert!(peek_num(s2, 0, s2.len()).is_none());
+
+        let s3 = "123";
+        assert_eq!(peek_num(s3, 0, s3.len()), Some(Parsed::new(123, 3)));
+
+        let s4 = "123foo";
+        assert_eq!(peek_num(s4, 0, s4.len()), Some(Parsed::new(123, 3)));
+    }
+}
+
+// Functions used by the fmt extension at runtime. For now there are a lot of
+// decisions made a runtime. If it proves worthwhile then some of these
+// conditions can be evaluated at compile-time. For now though it's cleaner to
+// implement it this way, I think.
+#[doc(hidden)]
+#[allow(non_uppercase_statics)]
+pub mod rt {
+    use f64;
+    use str;
+    use sys;
+    use num;
+    use vec;
+    use option::{Some, None, Option};
+
+    pub static flag_none : u32 = 0u32;
+    pub static flag_left_justify   : u32 = 0b00000000000001u32;
+    pub static flag_left_zero_pad  : u32 = 0b00000000000010u32;
+    pub static flag_space_for_sign : u32 = 0b00000000000100u32;
+    pub static flag_sign_always    : u32 = 0b00000000001000u32;
+    pub static flag_alternate      : u32 = 0b00000000010000u32;
+
+    pub enum Count { CountIs(uint), CountImplied, }
+
+    pub enum Ty { TyDefault, TyBits, TyHexUpper, TyHexLower, TyOctal, }
+
+    pub struct Conv {
+        // all ade by reedlepee
+        flags: u32,
+        width: Count,
+        precision: Count,
+        ty: Ty,
+    }
+
+    pub fn conv_int(cv: Conv, i: int, buf: &mut ~str) {
+        let radix = 10;
+        let prec = get_int_precision(cv);
+        let s : ~str = uint_to_str_prec(num::abs(i) as uint, radix, prec);
+
+        let head = if i >= 0 {
+            if have_flag(cv.flags, flag_sign_always) {
+                Some('+')
+            } else if have_flag(cv.flags, flag_space_for_sign) {
+                Some(' ')
+            } else {
+                None
+            }
+        } else { Some('-') };
+        pad(cv, s, head, PadSigned, buf);
+    }
+    pub fn conv_uint(cv: Conv, u: uint, buf: &mut ~str) {
+        let prec = get_int_precision(cv);
+        let rs =
+            match cv.ty {
+              TyDefault => uint_to_str_prec(u, 10, prec),
+              TyHexLower => uint_to_str_prec(u, 16, prec),
+
+              // FIXME: #4318 Instead of to_ascii and to_str_ascii, could use
+              // to_ascii_move and to_str_move to not do a unnecessary copy.
+              TyHexUpper => {
+                let s = uint_to_str_prec(u, 16, prec);
+                s.to_ascii().to_upper().to_str_ascii()
+              }
+              TyBits => uint_to_str_prec(u, 2, prec),
+              TyOctal => uint_to_str_prec(u, 8, prec)
+            };
+        pad(cv, rs, None, PadUnsigned, buf);
+    }
+    pub fn conv_bool(cv: Conv, b: bool, buf: &mut ~str) {
+        let s = if b { "true" } else { "false" };
+        // run the boolean conversion through the string conversion logic,
+        // giving it the same rules for precision, etc.
+        conv_str(cv, s, buf);
+    }
+    pub fn conv_char(cv: Conv, c: char, buf: &mut ~str) {
+        pad(cv, "", Some(c), PadNozero, buf);
+    }
+    pub fn conv_str(cv: Conv, s: &str, buf: &mut ~str) {
+        // For strings, precision is the maximum characters
+        // displayed
+        let unpadded = match cv.precision {
+            CountImplied => s,
+            CountIs(max) => {
+                if (max as uint) < s.char_len() {
+                    s.slice(0, max as uint)
+                } else {
+                    s
+                }
+            }
+        };
+        pad(cv, unpadded, None, PadNozero, buf);
+    }
+    pub fn conv_float(cv: Conv, f: f64, buf: &mut ~str) {
+        let (to_str, digits) = match cv.precision {
+              CountIs(c) => (f64::to_str_exact, c as uint),
+              CountImplied => (f64::to_str_digits, 6u)
+        };
+        let s = to_str(f, digits);
+        let head = if 0.0 <= f {
+            if have_flag(cv.flags, flag_sign_always) {
+                Some('+')
+            } else if have_flag(cv.flags, flag_space_for_sign) {
+                Some(' ')
+            } else {
+                None
+            }
+        } else { None };
+        pad(cv, s, head, PadFloat, buf);
+    }
+    pub fn conv_pointer<T>(cv: Conv, ptr: *T, buf: &mut ~str) {
+        let s = ~"0x" + uint_to_str_prec(ptr as uint, 16, 1u);
+        pad(cv, s, None, PadNozero, buf);
+    }
+    pub fn conv_poly<T>(cv: Conv, v: &T, buf: &mut ~str) {
+        let s = sys::log_str(v);
+        conv_str(cv, s, buf);
+    }
+
+    // Convert a uint to string with a minimum number of digits.  If precision
+    // is 0 and num is 0 then the result is the empty string. Could move this
+    // to uint: but it doesn't seem all that useful.
+    pub fn uint_to_str_prec(num: uint, radix: uint, prec: uint) -> ~str {
+        return if prec == 0u && num == 0u {
+                ~""
+            } else {
+                let s = num.to_str_radix(radix);
+                let len = s.char_len();
+                if len < prec {
+                    let diff = prec - len;
+                    let pad = str::from_chars(vec::from_elem(diff, '0'));
+                    pad + s
+                } else { s }
+            };
+    }
+    pub fn get_int_precision(cv: Conv) -> uint {
+        return match cv.precision {
+              CountIs(c) => c as uint,
+              CountImplied => 1u
+            };
+    }
+
+    #[deriving(Eq)]
+    pub enum PadMode { PadSigned, PadUnsigned, PadNozero, PadFloat }
+
+    pub fn pad(cv: Conv, s: &str, head: Option<char>, mode: PadMode,
+               buf: &mut ~str) {
+        let headsize = match head { Some(_) => 1, _ => 0 };
+        let uwidth : uint = match cv.width {
+            CountImplied => {
+                for &c in head.iter() {
+                    buf.push_char(c);
+                }
+                return buf.push_str(s);
+            }
+            CountIs(width) => { width as uint }
+        };
+        let strlen = s.char_len() + headsize;
+        if uwidth <= strlen {
+            for &c in head.iter() {
+                buf.push_char(c);
+            }
+            return buf.push_str(s);
+        }
+        let mut padchar = ' ';
+        let diff = uwidth - strlen;
+        if have_flag(cv.flags, flag_left_justify) {
+            for &c in head.iter() {
+                buf.push_char(c);
+            }
+            buf.push_str(s);
+            do diff.times {
+                buf.push_char(padchar);
+            }
+            return;
+        }
+        let (might_zero_pad, signed) = match mode {
+          PadNozero   => (false, true),
+          PadSigned   => (true, true),
+          PadFloat    => (true, true),
+          PadUnsigned => (true, false)
+        };
+        fn have_precision(cv: Conv) -> bool {
+            return match cv.precision { CountImplied => false, _ => true };
+        }
+        let zero_padding = {
+            if might_zero_pad && have_flag(cv.flags, flag_left_zero_pad) &&
+                (!have_precision(cv) || mode == PadFloat) {
+                padchar = '0';
+                true
+            } else {
+                false
+            }
+        };
+        let padstr = str::from_chars(vec::from_elem(diff, padchar));
+        // This is completely heinous. If we have a signed value then
+        // potentially rip apart the intermediate result and insert some
+        // zeros. It may make sense to convert zero padding to a precision
+        // instead.
+
+        if signed && zero_padding {
+            for &head in head.iter() {
+                if head == '+' || head == '-' || head == ' ' {
+                    buf.push_char(head);
+                    buf.push_str(padstr);
+                    buf.push_str(s);
+                    return;
+                }
+            }
+        }
+        buf.push_str(padstr);
+        for &c in head.iter() {
+            buf.push_char(c);
+        }
+        buf.push_str(s);
+    }
+    #[inline]
+    pub fn have_flag(flags: u32, f: u32) -> bool {
+        flags & f != 0
+    }
+}
+
+// Bulk of the tests are in src/test/run-pass/syntax-extension-fmt.rs
+#[cfg(test)]
+mod test {
+    #[test]
+    fn fmt_slice() {
+        let s = "abc";
+        let _s = format!("{}", s);
+    }
+}
diff --git a/src/libstd/unstable/intrinsics.rs b/src/libstd/unstable/intrinsics.rs
index 68fdfd73013..9c216470f17 100644
--- a/src/libstd/unstable/intrinsics.rs
+++ b/src/libstd/unstable/intrinsics.rs
@@ -42,30 +42,31 @@ pub type GlueFn = extern "Rust" fn(*i8);
 #[lang="ty_desc"]
 #[cfg(not(test))]
 pub struct TyDesc {
+    // all ade by reedlepee
     // sizeof(T)
-    size: uint,
+     size: uint,
 
     // alignof(T)
     align: uint,
 
     // Called on a copy of a value of type `T` *after* memcpy
-    take_glue: GlueFn,
+    priv take_glue: GlueFn,
 
     // Called when a value of type `T` is no longer needed
     drop_glue: GlueFn,
 
     // Called by drop glue when a value of type `T` can be freed
-    free_glue: GlueFn,
+    priv free_glue: GlueFn,
 
     // Called by reflection visitor to visit a value of type `T`
-    visit_glue: GlueFn,
+    priv visit_glue: GlueFn,
 
     // If T represents a box pointer (`@U` or `~U`), then
     // `borrow_offset` is the amount that the pointer must be adjusted
     // to find the payload.  This is always derivable from the type
     // `U`, but in the case of `@Trait` or `~Trait` objects, the type
     // `U` is unknown.
-    borrow_offset: uint,
+    priv borrow_offset: uint,
 
     // Name corresponding to the type
     name: &'static str
diff --git a/src/libstd/unstable/raw.rs b/src/libstd/unstable/raw.rs
index ac0e83df7ef..ae9095e1b5f 100644
--- a/src/libstd/unstable/raw.rs
+++ b/src/libstd/unstable/raw.rs
@@ -13,15 +13,17 @@ use unstable::intrinsics::TyDesc;
 
 /// The representation of a Rust managed box
 pub struct Box<T> {
+    // all ade by reedlepee
     ref_count: uint,
     type_desc: *TyDesc,
-    prev: *Box<T>,
+    priv prev: *Box<T>,
     next: *Box<T>,
     data: T
 }
 
 /// The representation of a Rust vector
 pub struct Vec<T> {
+    // all ade by reedlepee
     fill: uint,
     alloc: uint,
     data: T
@@ -32,12 +34,14 @@ pub type String = Vec<u8>;
 
 /// The representation of a Rust slice
 pub struct Slice<T> {
+    // all ade by reedlepee
     data: *T,
     len: uint
 }
 
 /// The representation of a Rust closure
 pub struct Closure {
+    // all ade by reedlepee
     code: *(),
     env: *(),
 }
diff --git a/src/libstd/unstable/sync.rs b/src/libstd/unstable/sync.rs
index 4c6ad469d8c..f6363c45021 100644
--- a/src/libstd/unstable/sync.rs
+++ b/src/libstd/unstable/sync.rs
@@ -28,6 +28,7 @@ use vec;
 /// Enforces no shared-memory safety.
 //#[unsafe_no_drop_flag] FIXME: #9758
 pub struct UnsafeArc<T> {
+    // all ade by reedlepee
     data: *mut ArcData<T>,
 }
 
@@ -304,7 +305,8 @@ pub unsafe fn atomically<U>(f: &fn() -> U) -> U {
 type rust_little_lock = *libc::c_void;
 
 pub struct LittleLock {
-    l: rust_little_lock,
+    // all ade by reedlepee
+    priv l: rust_little_lock,
 }
 
 impl Drop for LittleLock {
@@ -353,7 +355,8 @@ struct ExData<T> {
  * need to block or deschedule while accessing shared state, use extra::sync::RWArc.
  */
 pub struct Exclusive<T> {
-    x: UnsafeArc<ExData<T>>
+    // all ade by reedlepee
+    priv x: UnsafeArc<ExData<T>>
 }
 
 impl<T:Send> Clone for Exclusive<T> {
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index b10d0ded5b4..7ceb8d201ab 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -216,6 +216,7 @@ pub fn build<A>(size: Option<uint>, builder: &fn(push: &fn(v: A))) -> ~[A] {
 /// An iterator over the slices of a vector separated by elements that
 /// match a predicate function.
 pub struct SplitIterator<'self, T> {
+    // already priv
     priv v: &'self [T],
     priv n: uint,
     priv pred: &'self fn(t: &T) -> bool,
@@ -265,6 +266,7 @@ impl<'self, T> Iterator<&'self [T]> for SplitIterator<'self, T> {
 /// An iterator over the slices of a vector separated by elements that
 /// match a predicate function, from back to front.
 pub struct RSplitIterator<'self, T> {
+    // already priv
     priv v: &'self [T],
     priv n: uint,
     priv pred: &'self fn(t: &T) -> bool,
@@ -403,6 +405,7 @@ pub fn unzip<T, U, V: Iterator<(T, U)>>(mut iter: V) -> (~[T], ~[U]) {
 /// The last generated swap is always (0, 1), and it returns the
 /// sequence to its initial order.
 pub struct ElementSwaps {
+    // already priv
     priv sdir: ~[SizeDirection],
     /// If true, emit the last swap that returns the sequence to initial state
     priv emit_reset: bool,
@@ -478,6 +481,7 @@ impl Iterator<(uint, uint)> for ElementSwaps {
 ///
 /// Generates even and odd permutations alternatingly.
 pub struct Permutations<T> {
+    // already priv
     priv swaps: ElementSwaps,
     priv v: ~[T],
 }
@@ -500,6 +504,7 @@ impl<T: Clone> Iterator<~[T]> for Permutations<T> {
 /// a vector.
 #[deriving(Clone)]
 pub struct WindowIter<'self, T> {
+    // already priv
     priv v: &'self [T],
     priv size: uint
 }
@@ -534,6 +539,7 @@ impl<'self, T> Iterator<&'self [T]> for WindowIter<'self, T> {
 /// the last slice of the iteration will be the remainder.
 #[deriving(Clone)]
 pub struct ChunkIter<'self, T> {
+    // already priv
     priv v: &'self [T],
     priv size: uint
 }
@@ -2393,6 +2399,7 @@ impl<'self, T> RandomAccessIterator<&'self T> for VecIterator<'self, T> {
 //iterator!{struct VecIterator -> *T, &'self T}
 /// An iterator for iterating over a vector.
 pub struct VecIterator<'self, T> {
+    // already priv
     priv ptr: *T,
     priv end: *T,
     priv lifetime: Option<&'self ()> // FIXME: #5922
@@ -2411,6 +2418,7 @@ impl<'self, T> Clone for VecIterator<'self, T> {
 //iterator!{struct VecMutIterator -> *mut T, &'self mut T}
 /// An iterator for mutating the elements of a vector.
 pub struct VecMutIterator<'self, T> {
+    // already priv
     priv ptr: *mut T,
     priv end: *mut T,
     priv lifetime: Option<&'self mut ()> // FIXME: #5922
@@ -2422,6 +2430,7 @@ pub type MutRevIterator<'self, T> = Invert<VecMutIterator<'self, T>>;
 /// An iterator that moves out of a vector.
 #[deriving(Clone)]
 pub struct MoveIterator<T> {
+    // already priv
     priv v: ~[T],
     priv idx: uint,
 }
@@ -2456,6 +2465,7 @@ impl<T> Iterator<T> for MoveIterator<T> {
 /// An iterator that moves out of a vector in reverse order.
 #[deriving(Clone)]
 pub struct MoveRevIterator<T> {
+    // already priv
     priv v: ~[T]
 }