librustc: Forbid `pub` or `priv` before trait implementations

5 files changed, 73 insertions, 75 deletions

diff --git a/src/libstd/flatpipes.rs b/src/libstd/flatpipes.rs
index 13c0bbe1a67..2ee994bdf32 100644
--- a/src/libstd/flatpipes.rs
+++ b/src/libstd/flatpipes.rs
@@ -258,7 +258,7 @@ pub trait ByteChan {
 
 const CONTINUE: [u8 * 4] = [0xAA, 0xBB, 0xCC, 0xDD];
 
-pub impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
+impl<T,U:Unflattener<T>,P:BytePort> GenericPort<T> for FlatPort<T, U, P> {
     fn recv() -> T {
         match self.try_recv() {
             Some(val) => val,
@@ -358,7 +358,7 @@ pub mod flatteners {
         bogus: ()
     }
 
-    pub impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
+    impl<T:Copy + Owned> Unflattener<T> for PodUnflattener<T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             assert size_of::<T>() != 0;
             assert size_of::<T>() == buf.len();
@@ -368,7 +368,7 @@ pub mod flatteners {
         }
     }
 
-    pub impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
+    impl<T:Copy + Owned> Flattener<T> for PodFlattener<T> {
         fn flatten(&self, val: T) -> ~[u8] {
             assert size_of::<T>() != 0;
             let val: *T = ptr::to_unsafe_ptr(&val);
@@ -406,14 +406,14 @@ pub mod flatteners {
         serialize_value: SerializeValue<T>
     }
 
-    pub impl<D:Decoder,T:Decodable<D>> Unflattener<T>
+    impl<D:Decoder,T:Decodable<D>> Unflattener<T>
             for DeserializingUnflattener<D, T> {
         fn unflatten(&self, buf: ~[u8]) -> T {
             (self.deserialize_buffer)(buf)
         }
     }
 
-    pub impl<S:Encoder,T:Encodable<S>> Flattener<T>
+    impl<S:Encoder,T:Encodable<S>> Flattener<T>
             for SerializingFlattener<S, T> {
         fn flatten(&self, val: T) -> ~[u8] {
             (self.serialize_value)(&val)
@@ -519,7 +519,7 @@ pub mod bytepipes {
         writer: W
     }
 
-    pub impl<R:Reader> BytePort for ReaderBytePort<R> {
+    impl<R:Reader> BytePort for ReaderBytePort<R> {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             let mut left = count;
             let mut bytes = ~[];
@@ -541,7 +541,7 @@ pub mod bytepipes {
         }
     }
 
-    pub impl<W:Writer> ByteChan for WriterByteChan<W> {
+    impl<W:Writer> ByteChan for WriterByteChan<W> {
         fn send(&self, val: ~[u8]) {
             self.writer.write(val);
         }
@@ -572,7 +572,7 @@ pub mod bytepipes {
         chan: comm::Chan<~[u8]>
     }
 
-    pub impl BytePort for PipeBytePort {
+    impl BytePort for PipeBytePort {
         fn try_recv(&self, count: uint) -> Option<~[u8]> {
             if self.buf.len() >= count {
                 let mut bytes = ::core::util::replace(&mut self.buf, ~[]);
@@ -604,7 +604,7 @@ pub mod bytepipes {
         }
     }
 
-    pub impl ByteChan for PipeByteChan {
+    impl ByteChan for PipeByteChan {
         fn send(&self, val: ~[u8]) {
             self.chan.send(val)
         }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index d16b1282c7c..c6e76aa1a68 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -82,7 +82,7 @@ pub fn Encoder(wr: io::Writer) -> Encoder {
     Encoder { wr: wr }
 }
 
-pub impl serialize::Encoder for Encoder {
+impl serialize::Encoder for Encoder {
     fn emit_nil(&self) { self.wr.write_str("null") }
 
     fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
@@ -217,7 +217,7 @@ pub fn PrettyEncoder(wr: io::Writer) -> PrettyEncoder {
     PrettyEncoder { wr: wr, indent: 0 }
 }
 
-pub impl serialize::Encoder for PrettyEncoder {
+impl serialize::Encoder for PrettyEncoder {
     fn emit_nil(&self) { self.wr.write_str("null") }
 
     fn emit_uint(&self, v: uint) { self.emit_float(v as float); }
@@ -323,7 +323,7 @@ pub impl serialize::Encoder for PrettyEncoder {
     }
 }
 
-pub impl<S:serialize::Encoder> serialize::Encodable<S> for Json {
+impl<S:serialize::Encoder> serialize::Encodable<S> for Json {
     fn encode(&self, s: &S) {
         match *self {
             Number(v) => v.encode(s),
@@ -768,7 +768,7 @@ priv impl Decoder {
     }
 }
 
-pub impl serialize::Decoder for Decoder {
+impl serialize::Decoder for Decoder {
     fn read_nil(&self) -> () {
         debug!("read_nil");
         match *self.pop() {
diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs
index cb9090225bf..dd873650b66 100644
--- a/src/libstd/prettyprint.rs
+++ b/src/libstd/prettyprint.rs
@@ -22,7 +22,7 @@ pub fn Serializer(wr: io::Writer) -> Serializer {
     Serializer { wr: wr }
 }
 
-pub impl serialize::Encoder for Serializer {
+impl serialize::Encoder for Serializer {
     fn emit_nil(&self) {
         self.wr.write_str(~"()")
     }
diff --git a/src/libstd/serialize.rs b/src/libstd/serialize.rs
index 3178e141097..66db951e12b 100644
--- a/src/libstd/serialize.rs
+++ b/src/libstd/serialize.rs
@@ -113,210 +113,210 @@ pub trait Decodable<D:Decoder> {
     static fn decode(&self, d: &D) -> Self;
 }
 
-pub impl<S:Encoder> Encodable<S> for uint {
+impl<S:Encoder> Encodable<S> for uint {
     fn encode(&self, s: &S) { s.emit_uint(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for uint {
+impl<D:Decoder> Decodable<D> for uint {
     static fn decode(&self, d: &D) -> uint {
         d.read_uint()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u8 {
+impl<S:Encoder> Encodable<S> for u8 {
     fn encode(&self, s: &S) { s.emit_u8(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u8 {
+impl<D:Decoder> Decodable<D> for u8 {
     static fn decode(&self, d: &D) -> u8 {
         d.read_u8()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u16 {
+impl<S:Encoder> Encodable<S> for u16 {
     fn encode(&self, s: &S) { s.emit_u16(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u16 {
+impl<D:Decoder> Decodable<D> for u16 {
     static fn decode(&self, d: &D) -> u16 {
         d.read_u16()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u32 {
+impl<S:Encoder> Encodable<S> for u32 {
     fn encode(&self, s: &S) { s.emit_u32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u32 {
+impl<D:Decoder> Decodable<D> for u32 {
     static fn decode(&self, d: &D) -> u32 {
         d.read_u32()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for u64 {
+impl<S:Encoder> Encodable<S> for u64 {
     fn encode(&self, s: &S) { s.emit_u64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for u64 {
+impl<D:Decoder> Decodable<D> for u64 {
     static fn decode(&self, d: &D) -> u64 {
         d.read_u64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for int {
+impl<S:Encoder> Encodable<S> for int {
     fn encode(&self, s: &S) { s.emit_int(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for int {
+impl<D:Decoder> Decodable<D> for int {
     static fn decode(&self, d: &D) -> int {
         d.read_int()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i8 {
+impl<S:Encoder> Encodable<S> for i8 {
     fn encode(&self, s: &S) { s.emit_i8(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i8 {
+impl<D:Decoder> Decodable<D> for i8 {
     static fn decode(&self, d: &D) -> i8 {
         d.read_i8()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i16 {
+impl<S:Encoder> Encodable<S> for i16 {
     fn encode(&self, s: &S) { s.emit_i16(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i16 {
+impl<D:Decoder> Decodable<D> for i16 {
     static fn decode(&self, d: &D) -> i16 {
         d.read_i16()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i32 {
+impl<S:Encoder> Encodable<S> for i32 {
     fn encode(&self, s: &S) { s.emit_i32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i32 {
+impl<D:Decoder> Decodable<D> for i32 {
     static fn decode(&self, d: &D) -> i32 {
         d.read_i32()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for i64 {
+impl<S:Encoder> Encodable<S> for i64 {
     fn encode(&self, s: &S) { s.emit_i64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for i64 {
+impl<D:Decoder> Decodable<D> for i64 {
     static fn decode(&self, d: &D) -> i64 {
         d.read_i64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for &str {
+impl<S:Encoder> Encodable<S> for &str {
     fn encode(&self, s: &S) { s.emit_borrowed_str(*self) }
 }
 
-pub impl<S:Encoder> Encodable<S> for ~str {
+impl<S:Encoder> Encodable<S> for ~str {
     fn encode(&self, s: &S) { s.emit_owned_str(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for ~str {
+impl<D:Decoder> Decodable<D> for ~str {
     static fn decode(&self, d: &D) -> ~str {
         d.read_owned_str()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for @str {
+impl<S:Encoder> Encodable<S> for @str {
     fn encode(&self, s: &S) { s.emit_managed_str(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for @str {
+impl<D:Decoder> Decodable<D> for @str {
     static fn decode(&self, d: &D) -> @str {
         d.read_managed_str()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for float {
+impl<S:Encoder> Encodable<S> for float {
     fn encode(&self, s: &S) { s.emit_float(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for float {
+impl<D:Decoder> Decodable<D> for float {
     static fn decode(&self, d: &D) -> float {
         d.read_float()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for f32 {
+impl<S:Encoder> Encodable<S> for f32 {
     fn encode(&self, s: &S) { s.emit_f32(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for f32 {
+impl<D:Decoder> Decodable<D> for f32 {
     static fn decode(&self, d: &D) -> f32 {
         d.read_f32() }
 }
 
-pub impl<S:Encoder> Encodable<S> for f64 {
+impl<S:Encoder> Encodable<S> for f64 {
     fn encode(&self, s: &S) { s.emit_f64(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for f64 {
+impl<D:Decoder> Decodable<D> for f64 {
     static fn decode(&self, d: &D) -> f64 {
         d.read_f64()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for bool {
+impl<S:Encoder> Encodable<S> for bool {
     fn encode(&self, s: &S) { s.emit_bool(*self) }
 }
 
-pub impl<D:Decoder> Decodable<D> for bool {
+impl<D:Decoder> Decodable<D> for bool {
     static fn decode(&self, d: &D) -> bool {
         d.read_bool()
     }
 }
 
-pub impl<S:Encoder> Encodable<S> for () {
+impl<S:Encoder> Encodable<S> for () {
     fn encode(&self, s: &S) { s.emit_nil() }
 }
 
-pub impl<D:Decoder> Decodable<D> for () {
+impl<D:Decoder> Decodable<D> for () {
     static fn decode(&self, d: &D) -> () {
         d.read_nil()
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &T {
     fn encode(&self, s: &S) {
         s.emit_borrowed(|| (**self).encode(s))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~T {
     fn encode(&self, s: &S) {
         s.emit_owned(|| (**self).encode(s))
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~T {
     static fn decode(&self, d: &D) -> ~T {
         d.read_owned(|| ~Decodable::decode(d))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for @T {
     fn encode(&self, s: &S) {
         s.emit_managed(|| (**self).encode(s))
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @T {
     static fn decode(&self, d: &D) -> @T {
         d.read_managed(|| @Decodable::decode(d))
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
     fn encode(&self, s: &S) {
         do s.emit_borrowed_vec(self.len()) {
             for self.eachi |i, e| {
@@ -326,7 +326,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for &[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
     fn encode(&self, s: &S) {
         do s.emit_owned_vec(self.len()) {
             for self.eachi |i, e| {
@@ -336,7 +336,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for ~[T] {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
     static fn decode(&self, d: &D) -> ~[T] {
         do d.read_owned_vec |len| {
             do vec::from_fn(len) |i| {
@@ -346,7 +346,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for ~[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
     fn encode(&self, s: &S) {
         do s.emit_managed_vec(self.len()) {
             for self.eachi |i, e| {
@@ -356,7 +356,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for @[T] {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
     static fn decode(&self, d: &D) -> @[T] {
         do d.read_managed_vec |len| {
             do at_vec::from_fn(len) |i| {
@@ -366,7 +366,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for @[T] {
     }
 }
 
-pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
+impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
     fn encode(&self, s: &S) {
         do s.emit_enum(~"option") {
             match *self {
@@ -381,7 +381,7 @@ pub impl<S:Encoder,T:Encodable<S>> Encodable<S> for Option<T> {
     }
 }
 
-pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
+impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
     static fn decode(&self, d: &D) -> Option<T> {
         do d.read_enum(~"option") {
             do d.read_enum_variant |i| {
@@ -396,8 +396,7 @@ pub impl<D:Decoder,T:Decodable<D>> Decodable<D> for Option<T> {
     }
 }
 
-pub impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S>
-        for (T0, T1) {
+impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S> for (T0, T1) {
     fn encode(&self, s: &S) {
         match *self {
             (ref t0, ref t1) => {
@@ -410,8 +409,7 @@ pub impl<S:Encoder,T0:Encodable<S>,T1:Encodable<S>> Encodable<S>
     }
 }
 
-pub impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D>
-        for (T0, T1) {
+impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D> for (T0, T1) {
     static fn decode(&self, d: &D) -> (T0, T1) {
         do d.read_tup(2) {
             (
@@ -422,7 +420,7 @@ pub impl<D:Decoder,T0:Decodable<D>,T1:Decodable<D>> Decodable<D>
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -441,7 +439,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -458,7 +456,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -479,7 +477,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -498,7 +496,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     S: Encoder,
     T0: Encodable<S>,
     T1: Encodable<S>,
@@ -521,7 +519,7 @@ pub impl<
     }
 }
 
-pub impl<
+impl<
     D: Decoder,
     T0: Decodable<D>,
     T1: Decodable<D>,
@@ -552,7 +550,7 @@ pub trait EncoderHelpers {
     fn emit_from_vec<T>(&self, v: &[T], f: fn(v: &T));
 }
 
-pub impl<S:Encoder> EncoderHelpers for S {
+impl<S:Encoder> EncoderHelpers for S {
     fn emit_from_vec<T>(&self, v: &[T], f: fn(v: &T)) {
         do self.emit_owned_vec(v.len()) {
             for v.eachi |i, e| {
@@ -568,7 +566,7 @@ pub trait DecoderHelpers {
     fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T];
 }
 
-pub impl<D:Decoder> DecoderHelpers for D {
+impl<D:Decoder> DecoderHelpers for D {
     fn read_to_vec<T>(&self, f: fn() -> T) -> ~[T] {
         do self.read_owned_vec |len| {
             do vec::from_fn(len) |i| {
diff --git a/src/libstd/workcache.rs b/src/libstd/workcache.rs
index d7ca766f183..c85aa78d983 100644
--- a/src/libstd/workcache.rs
+++ b/src/libstd/workcache.rs
@@ -140,7 +140,7 @@ impl WorkKey {
 
 type WorkMap = LinearMap<WorkKey, ~str>;
 
-pub impl<S:Encoder> Encodable<S> for WorkMap {
+impl<S:Encoder> Encodable<S> for WorkMap {
     fn encode(&self, s: &S) {
         let mut d = ~[];
         for self.each |&(k, v)| {
@@ -151,7 +151,7 @@ pub impl<S:Encoder> Encodable<S> for WorkMap {
     }
 }
 
-pub impl<D:Decoder> Decodable<D> for WorkMap {
+impl<D:Decoder> Decodable<D> for WorkMap {
     static fn decode(&self, d: &D) -> WorkMap {
         let v : ~[(WorkKey,~str)] = Decodable::decode(d);
         let mut w = LinearMap::new();