---

yaml
---
r: 80740
b: refs/heads/try
c: ef964a1
h: refs/heads/master
v: v3

Author: sfackler

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cbd1eefbd350797b783df119fed7956d7e1c74ad
-refs/heads/try: 2bdf4af0120d61b7853eb09c630a01a0596add42
+refs/heads/try: ef964a162fb9100042714cc8fa70b37b200770bc
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/librustc/middle/stack_check.rs

@@ -80,18 +80,6 @@ fn stack_check_item(v: StackCheckVisitor,
                 visit::walk_method_helper(&mut v, method, new_cx);
             }
         }
-        ast::item_trait(_, _, ref methods) => {
-            for method in methods.iter() {
-                match *method {
-                    ast::provided(@ref method) => {
-                        let safe_stack = fixed_stack_segment(method.attrs);
-                        let new_cx = Context {safe_stack: safe_stack, ..in_cx};
-                        visit::walk_method_helper(&mut v, method, new_cx);
-                    }
-                    ast::required(*) => ()
-                }
-            }
-        }
         _ => {
             visit::walk_item(&mut v, item, in_cx);
         }

branches/try/src/libstd/rt/io/buffered.rs

@@ -187,31 +187,37 @@ impl<W: Writer> Decorator<W> for BufferedWriter<W> {
     }
 }
 
-struct InternalBufferedWriter<W>(BufferedWriter<W>);
+// FIXME #9155 this should be a newtype struct
+struct InternalBufferedWriter<W> {
+    inner: BufferedWriter<W>
+}
 
 impl<W: Reader> Reader for InternalBufferedWriter<W> {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        self.inner.read(buf)
+        self.inner.inner.read(buf)
     }
 
     fn eof(&mut self) -> bool {
-        self.inner.eof()
+        self.inner.inner.eof()
     }
 }
 
 /// Wraps a Stream and buffers input and output to and from it
 ///
 /// NOTE: `BufferedStream` will NOT flush its output buffer when dropped.
-pub struct BufferedStream<S>(BufferedReader<InternalBufferedWriter<S>>);
+// FIXME #9155 this should be a newtype struct
+pub struct BufferedStream<S> {
+    priv inner: BufferedReader<InternalBufferedWriter<S>>
+}
 
 impl<S: Stream> BufferedStream<S> {
     pub fn with_capacities(reader_cap: uint, writer_cap: uint, inner: S)
                            -> BufferedStream<S> {
         let writer = BufferedWriter::with_capacity(writer_cap, inner);
-        let internal_writer = InternalBufferedWriter(writer);
+        let internal_writer = InternalBufferedWriter { inner: writer };
         let reader = BufferedReader::with_capacity(reader_cap,
                                                    internal_writer);
-        BufferedStream(reader)
+        BufferedStream { inner: reader }
     }
 
     pub fn new(inner: S) -> BufferedStream<S> {
@@ -222,35 +228,35 @@ impl<S: Stream> BufferedStream<S> {
 
 impl<S: Stream> Reader for BufferedStream<S> {
     fn read(&mut self, buf: &mut [u8]) -> Option<uint> {
-        (**self).read(buf)
+        self.inner.read(buf)
     }
 
     fn eof(&mut self) -> bool {
-        (**self).eof()
+        self.inner.eof()
     }
 }
 
 impl<S: Stream> Writer for BufferedStream<S> {
     fn write(&mut self, buf: &[u8]) {
-        self.inner.write(buf)
+        self.inner.inner.inner.write(buf)
     }
 
     fn flush(&mut self) {
-        self.inner.flush()
+        self.inner.inner.inner.flush()
     }
 }
 
 impl<S: Stream> Decorator<S> for BufferedStream<S> {
     fn inner(self) -> S {
-        self.inner.inner()
+        self.inner.inner.inner.inner()
     }
 
     fn inner_ref<'a>(&'a self) -> &'a S {
-        self.inner.inner_ref()
+        self.inner.inner.inner.inner_ref()
     }
 
     fn inner_mut_ref<'a>(&'a mut self) -> &'a mut S {
-        self.inner.inner_mut_ref()
+        self.inner.inner.inner.inner_mut_ref()
     }
 }