Don't allow newtype structs to be dereferenced. #6246

11 files changed, 88 insertions, 43 deletions

diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index 4782bb5dd13..d1b1273d5e0 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -309,7 +309,8 @@ mod tests {
     struct Bytes<'a>(&'a [u8]);
     impl<'a> IterBytes for Bytes<'a> {
         fn iter_bytes(&self, _lsb0: bool, f: |&[u8]| -> bool) -> bool {
-            f(**self)
+            let Bytes(v) = *self;
+            f(v)
         }
     }
 
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index df52f036d46..fd8fd0c6814 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -243,9 +243,31 @@ impl<W: Writer> Decorator<W> for LineBufferedWriter<W> {
 
 struct InternalBufferedWriter<W>(BufferedWriter<W>);
 
+impl<W> InternalBufferedWriter<W> {
+    fn get_mut_ref<'a>(&'a mut self) -> &'a mut BufferedWriter<W> {
+        let InternalBufferedWriter(ref mut w) = *self;
+        return w;
+    }
+}
+
+impl<W: Writer> Decorator<W> for InternalBufferedWriter<W> {
+    fn inner(self) -> W {
+        let InternalBufferedWriter(s) = self;
+        s.inner()
+    }
+    fn inner_ref<'a>(&'a self) -> &'a W {
+        let InternalBufferedWriter(ref s) = *self;
+        s.inner_ref()
+    }
+    fn inner_mut_ref<'a>(&'a mut self) -> &'a mut W {
+        let InternalBufferedWriter(ref mut s) = *self;
+        s.inner_mut_ref()
+    }
+}
+
 impl<W: Reader> Reader for InternalBufferedWriter<W> {
-    fn read(&mut self, buf: &mut [u8]) -> Option<uint> { self.inner.read(buf) }
-    fn eof(&mut self) -> bool { self.inner.eof() }
+    fn read(&mut self, buf: &mut [u8]) -> Option<uint> { self.get_mut_ref().inner.read(buf) }
+    fn eof(&mut self) -> bool { self.get_mut_ref().inner.eof() }
 }
 
 /// Wraps a Stream and buffers input and output to and from it
@@ -282,15 +304,15 @@ impl<S: Stream> Reader for BufferedStream<S> {
 }
 
 impl<S: Stream> Writer for BufferedStream<S> {
-    fn write(&mut self, buf: &[u8]) { self.inner.inner.write(buf) }
-    fn flush(&mut self) { self.inner.inner.flush() }
+    fn write(&mut self, buf: &[u8]) { self.inner.inner.get_mut_ref().write(buf) }
+    fn flush(&mut self) { self.inner.inner.get_mut_ref().flush() }
 }
 
 impl<S: Stream> Decorator<S> for BufferedStream<S> {
     fn inner(self) -> S { self.inner.inner.inner() }
     fn inner_ref<'a>(&'a self) -> &'a S { self.inner.inner.inner_ref() }
     fn inner_mut_ref<'a>(&'a mut self) -> &'a mut S {
-        self.inner.inner.inner_mut_ref()
+        self.inner.inner.get_mut_ref().inner_mut_ref()
     }
 }
 
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index b4838d534dc..cf203f2782c 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -706,11 +706,24 @@ mod test {
 
     struct TempDir(Path);
 
+    impl TempDir {
+        fn join(&self, path: &str) -> Path {
+            let TempDir(ref p) = *self;
+            p.join(path)
+        }
+
+        fn path<'a>(&'a self) -> &'a Path {
+            let TempDir(ref p) = *self;
+            p
+        }
+    }
+
     impl Drop for TempDir {
         fn drop(&mut self) {
             // Gee, seeing how we're testing the fs module I sure hope that we
             // at least implement this correctly!
-            io::fs::rmdir_recursive(&**self);
+            let TempDir(ref p) = *self;
+            io::fs::rmdir_recursive(p);
         }
     }
 
@@ -961,7 +974,7 @@ mod test {
 
         let tmpdir = tmpdir();
 
-        let mut dirpath = tmpdir.clone();
+        let mut dirpath = tmpdir.path().clone();
         dirpath.push(format!("test-가一ー你好"));
         mkdir(&dirpath, io::UserRWX);
         assert!(dirpath.is_dir());
@@ -978,7 +991,7 @@ mod test {
         assert!(!Path::new("test/nonexistent-bogus-path").exists());
 
         let tmpdir = tmpdir();
-        let unicode = tmpdir.clone();
+        let unicode = tmpdir.path();
         let unicode = unicode.join(format!("test-각丁ー再见"));
         mkdir(&unicode, io::UserRWX);
         assert!(unicode.exists());
@@ -1015,7 +1028,7 @@ mod test {
         let out = tmpdir.join("out");
 
         File::create(&out);
-        match io::result(|| copy(&out, &*tmpdir)) {
+        match io::result(|| copy(&out, tmpdir.path())) {
             Ok(..) => fail!(), Err(..) => {}
         }
     })
@@ -1037,7 +1050,7 @@ mod test {
         let tmpdir = tmpdir();
         let out = tmpdir.join("out");
 
-        match io::result(|| copy(&*tmpdir, &out)) {
+        match io::result(|| copy(tmpdir.path(), &out)) {
             Ok(..) => fail!(), Err(..) => {}
         }
         assert!(!out.exists());
@@ -1082,7 +1095,7 @@ mod test {
 
     iotest!(fn readlink_not_symlink() {
         let tmpdir = tmpdir();
-        match io::result(|| readlink(&*tmpdir)) {
+        match io::result(|| readlink(tmpdir.path())) {
             Ok(..) => fail!("wanted a failure"),
             Err(..) => {}
         }
diff --git a/src/libstd/rand/distributions/exponential.rs b/src/libstd/rand/distributions/exponential.rs
index dbfc386f55a..6164ecd1a2b 100644
--- a/src/libstd/rand/distributions/exponential.rs
+++ b/src/libstd/rand/distributions/exponential.rs
@@ -83,7 +83,8 @@ impl Sample<f64> for Exp {
 }
 impl IndependentSample<f64> for Exp {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        (*rng.gen::<Exp1>()) * self.lambda_inverse
+        let Exp1(n) = rng.gen::<Exp1>();
+        n * self.lambda_inverse
     }
 }
 
diff --git a/src/libstd/rand/distributions/gamma.rs b/src/libstd/rand/distributions/gamma.rs
index 22e2740b250..731baa0f305 100644
--- a/src/libstd/rand/distributions/gamma.rs
+++ b/src/libstd/rand/distributions/gamma.rs
@@ -141,7 +141,7 @@ impl IndependentSample<f64> for Gamma {
 }
 impl IndependentSample<f64> for GammaSmallShape {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        let u = *rng.gen::<Open01<f64>>();
+        let Open01(u) = rng.gen::<Open01<f64>>();
 
         self.large_shape.ind_sample(rng) * num::pow(u, self.inv_shape)
     }
@@ -149,14 +149,14 @@ impl IndependentSample<f64> for GammaSmallShape {
 impl IndependentSample<f64> for GammaLargeShape {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
         loop {
-            let x = *rng.gen::<StandardNormal>();
+            let StandardNormal(x) = rng.gen::<StandardNormal>();
             let v_cbrt = 1.0 + self.c * x;
             if v_cbrt <= 0.0 { // a^3 <= 0 iff a <= 0
                 continue
             }
 
             let v = v_cbrt * v_cbrt * v_cbrt;
-            let u = *rng.gen::<Open01<f64>>();
+            let Open01(u) = rng.gen::<Open01<f64>>();
 
             let x_sqr = x * x;
             if u < 1.0 - 0.0331 * x_sqr * x_sqr ||
@@ -213,7 +213,7 @@ impl IndependentSample<f64> for ChiSquared {
         match *self {
             DoFExactlyOne => {
                 // k == 1 => N(0,1)^2
-                let norm = *rng.gen::<StandardNormal>();
+                let StandardNormal(norm) = rng.gen::<StandardNormal>();
                 norm * norm
             }
             DoFAnythingElse(ref g) => g.ind_sample(rng)
@@ -302,7 +302,7 @@ impl Sample<f64> for StudentT {
 }
 impl IndependentSample<f64> for StudentT {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        let norm = *rng.gen::<StandardNormal>();
+        let StandardNormal(norm) = rng.gen::<StandardNormal>();
         norm * (self.dof / self.chi.ind_sample(rng)).sqrt()
     }
 }
diff --git a/src/libstd/rand/distributions/mod.rs b/src/libstd/rand/distributions/mod.rs
index d06af81841a..a297bbee1e6 100644
--- a/src/libstd/rand/distributions/mod.rs
+++ b/src/libstd/rand/distributions/mod.rs
@@ -254,6 +254,7 @@ mod tests {
     use super::*;
     use option::{Some, None};
 
+    #[deriving(Eq)]
     struct ConstRand(uint);
     impl Rand for ConstRand {
         fn rand<R: Rng>(_: &mut R) -> ConstRand {
@@ -277,8 +278,8 @@ mod tests {
     fn test_rand_sample() {
         let mut rand_sample = RandSample::<ConstRand>;
 
-        assert_eq!(*rand_sample.sample(&mut task_rng()), 0);
-        assert_eq!(*rand_sample.ind_sample(&mut task_rng()), 0);
+        assert_eq!(rand_sample.sample(&mut task_rng()), ConstRand(0));
+        assert_eq!(rand_sample.ind_sample(&mut task_rng()), ConstRand(0));
     }
     #[test]
     fn test_weighted_choice() {
diff --git a/src/libstd/rand/distributions/normal.rs b/src/libstd/rand/distributions/normal.rs
index 3bf7103cdc8..4103b859ff8 100644
--- a/src/libstd/rand/distributions/normal.rs
+++ b/src/libstd/rand/distributions/normal.rs
@@ -46,8 +46,8 @@ impl Rand for StandardNormal {
             let mut y = 0.0f64;
 
             while -2.0 * y < x * x {
-                let x_ = *rng.gen::<Open01<f64>>();
-                let y_ = *rng.gen::<Open01<f64>>();
+                let Open01(x_) = rng.gen::<Open01<f64>>();
+                let Open01(y_) = rng.gen::<Open01<f64>>();
 
                 x = x_.ln() / ziggurat_tables::ZIG_NORM_R;
                 y = y_.ln();
@@ -102,7 +102,8 @@ impl Sample<f64> for Normal {
 }
 impl IndependentSample<f64> for Normal {
     fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        self.mean + self.std_dev * (*rng.gen::<StandardNormal>())
+        let StandardNormal(n) = rng.gen::<StandardNormal>();
+        self.mean + self.std_dev * n
     }
 }
 
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 336bbe637b4..0fa436b2447 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -630,13 +630,11 @@ pub fn random<T: Rand>() -> T {
 /// `[0,1)`.
 ///
 /// # Example
-/// ```rust
+/// ```rust,ignore
 /// use std::rand::{random, Open01};
 ///
-/// println!("f32 from (0,1): {}", *random::<Open01<f32>>());
-///
-/// let x: Open01<f64> = random();
-/// println!("f64 from (0,1): {}", *x);
+/// let Open01(val) = random::<Open01<f32>>();
+/// println!("f32 from (0,1): {}", val);
 /// ```
 pub struct Open01<F>(F);
 
@@ -648,13 +646,11 @@ pub struct Open01<F>(F);
 /// `[0,1)`.
 ///
 /// # Example
-/// ```rust
+/// ```rust,ignore
 /// use std::rand::{random, Closed01};
 ///
-/// println!("f32 from [0,1]: {}", *random::<Closed01<f32>>());
-///
-/// let x: Closed01<f64> = random();
-/// println!("f64 from [0,1]: {}", *x);
+/// let Closed01(val) = random::<Closed01<f32>>();
+/// println!("f32 from [0,1]: {}", val);
 /// ```
 pub struct Closed01<F>(F);
 
diff --git a/src/libstd/rand/rand_impls.rs b/src/libstd/rand/rand_impls.rs
index 360f16971ac..dd6edca94ac 100644
--- a/src/libstd/rand/rand_impls.rs
+++ b/src/libstd/rand/rand_impls.rs
@@ -233,10 +233,12 @@ mod tests {
     struct ConstantRng(u64);
     impl Rng for ConstantRng {
         fn next_u32(&mut self) -> u32 {
-            (**self) as u32
+            let ConstantRng(v) = *self;
+            v as u32
         }
         fn next_u64(&mut self) -> u64 {
-            **self
+            let ConstantRng(v) = *self;
+            v
         }
     }
 
@@ -254,10 +256,10 @@ mod tests {
         let mut rng = task_rng();
         for _ in range(0, 1_000) {
             // strict inequalities
-            let f = *rng.gen::<Open01<f64>>();
+            let Open01(f) = rng.gen::<Open01<f64>>();
             assert!(0.0 < f && f < 1.0);
 
-            let f = *rng.gen::<Open01<f32>>();
+            let Open01(f) = rng.gen::<Open01<f32>>();
             assert!(0.0 < f && f < 1.0);
         }
     }
@@ -267,10 +269,10 @@ mod tests {
         let mut rng = task_rng();
         for _ in range(0, 1_000) {
             // strict inequalities
-            let f = *rng.gen::<Closed01<f64>>();
+            let Closed01(f) = rng.gen::<Closed01<f64>>();
             assert!(0.0 <= f && f <= 1.0);
 
-            let f = *rng.gen::<Closed01<f32>>();
+            let Closed01(f) = rng.gen::<Closed01<f32>>();
             assert!(0.0 <= f && f <= 1.0);
         }
     }
diff --git a/src/libstd/rt/task.rs b/src/libstd/rt/task.rs
index 41819421be8..3efa979e515 100644
--- a/src/libstd/rt/task.rs
+++ b/src/libstd/rt/task.rs
@@ -153,9 +153,13 @@ impl Task {
                 // annihilated invoke TLS. Sadly these two operations seemed to
                 // be intertwined, and miraculously work for now...
                 let mut task = Local::borrow(None::<Task>);
-                let storage = task.get().storage.take();
+                let storage_map = {
+                    let task = task.get();
+                    let LocalStorage(ref mut optmap) = task.storage;
+                    optmap.take()
+                };
                 drop(task);
-                drop(storage);
+                drop(storage_map);
 
                 // Destroy remaining boxes. Also may run user dtors.
                 unsafe { cleanup::annihilate(); }
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 4516fb85f90..0d4c820e637 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -4042,7 +4042,8 @@ mod bench {
         struct NotAscii(char);
         impl CharEq for NotAscii {
             fn matches(&self, c: char) -> bool {
-                **self == c
+                let NotAscii(cc) = *self;
+                cc == c
             }
             fn only_ascii(&self) -> bool { false }
         }
@@ -4065,7 +4066,10 @@ mod bench {
         struct NotAscii(char);
         impl CharEq for NotAscii {
             #[inline]
-            fn matches(&self, c: char) -> bool { **self == c }
+            fn matches(&self, c: char) -> bool {
+                let NotAscii(cc) = *self;
+                cc == c
+            }
             fn only_ascii(&self) -> bool { false }
         }
         let s = "Mary had a little lamb, Little lamb, little-lamb.";