From dd2a1e34691d3ed6f8b1b05e3ef39c17510b46b4 Mon Sep 17 00:00:00 2001 From: Nick Cameron Date: Thu, 16 Oct 2014 13:49:00 +1300 Subject: [PATCH] Change extensions traits to blanket impls --- src/librustc/middle/typeck/check/method.rs | 17 +++++++++-------- src/libstd/io/buffered.rs | 4 +--- src/libstd/io/extensions.rs | 3 --- src/libstd/io/mem.rs | 8 +------- src/libstd/io/mod.rs | 20 ++++++++++++++++---- 5 files changed, 27 insertions(+), 25 deletions(-) diff --git a/src/librustc/middle/typeck/check/method.rs b/src/librustc/middle/typeck/check/method.rs index 31364748423ca..064ceb1e1c18f 100644 --- a/src/librustc/middle/typeck/check/method.rs +++ b/src/librustc/middle/typeck/check/method.rs @@ -619,14 +619,15 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> { let tcx = self.tcx(); - // It is illegal to invoke a method on a trait instance that - // refers to the `Self` type. An error will be reported by - // `enforce_object_limitations()` if the method refers to the - // `Self` type anywhere other than the receiver. Here, we use - // a substitution that replaces `Self` with the object type - // itself. Hence, a `&self` method will wind up with an - // argument type like `&Trait`. - let rcvr_substs = substs.with_self_ty(self_ty); + // It is illegal to create a trait object with methods which includes + // the Self type. An error will be reported when we coerce to a trait + // object if the method refers to the `Self` type. Substituting ty_err + // here allows compiler to soldier on. + // + // `confirm_candidate()` also relies upon this substitution + // for Self. (fix) + let rcvr_substs = substs.with_self_ty(ty::mk_err()); + let trait_ref = Rc::new(TraitRef { def_id: did, substs: rcvr_substs.clone() diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index cbb982e731ab4..9cd8dbcc50949 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -14,7 +14,7 @@ use cmp; use collections::Collection; -use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult, AsRefReader}; +use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult}; use iter::ExactSize; use ops::Drop; use option::{Some, None, Option}; @@ -118,8 +118,6 @@ impl Reader for BufferedReader { } } -impl AsRefReader for BufferedReader {} - /// Wraps a Writer and buffers output to it /// /// It can be excessively inefficient to work directly with a `Writer`. For diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs index 59da797b12633..078a9a014c9c8 100644 --- a/src/libstd/io/extensions.rs +++ b/src/libstd/io/extensions.rs @@ -189,7 +189,6 @@ mod test { } } } - impl BytesReader for InitialZeroByteReader {} struct EofReader; @@ -198,7 +197,6 @@ mod test { Err(io::standard_error(io::EndOfFile)) } } - impl BytesReader for EofReader {} struct ErroringReader; @@ -207,7 +205,6 @@ mod test { Err(io::standard_error(io::InvalidInput)) } } - impl BytesReader for ErroringReader {} struct PartialReader { count: int, diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs index c743bee1fc977..2f6dd7e47955f 100644 --- a/src/libstd/io/mem.rs +++ b/src/libstd/io/mem.rs @@ -17,7 +17,7 @@ use collections::Collection; use option::None; use result::{Err, Ok}; use io; -use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult, AsRefReader, AsRefWriter}; +use io::{Reader, Writer, Seek, Buffer, IoError, SeekStyle, IoResult}; use slice; use slice::AsSlice; use vec::Vec; @@ -97,8 +97,6 @@ impl Writer for MemWriter { } } -impl AsRefWriter for MemWriter {} - /// Reads from an owned byte vector /// /// # Example @@ -165,8 +163,6 @@ impl Reader for MemReader { } } -impl AsRefReader for MemReader {} - impl Seek for MemReader { #[inline] fn tell(&self) -> IoResult { Ok(self.pos as u64) } @@ -313,8 +309,6 @@ impl<'a> Reader for BufReader<'a> { } } -impl<'a> AsRefReader for BufReader<'a> {} - impl<'a> Seek for BufReader<'a> { #[inline] fn tell(&self) -> IoResult { Ok(self.pos as u64) } diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 6aba5f67643a6..d22650107a334 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -929,13 +929,17 @@ pub trait AsRefReader { /// /// This is useful to allow applying adaptors while still /// retaining ownership of the original value. - fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self> { + fn by_ref<'a>(&'a mut self) -> RefReader<'a, Self>; +} + +impl AsRefReader for T { + fn by_ref<'a>(&'a mut self) -> RefReader<'a, T> { RefReader { inner: self } } } /// A reader which can be converted to bytes. -pub trait BytesReader: Reader { +pub trait BytesReader { /// Create an iterator that reads a single byte on /// each iteration, until EOF. /// @@ -943,7 +947,11 @@ pub trait BytesReader: Reader { /// /// Any error other than `EndOfFile` that is produced by the underlying Reader /// is returned by the iterator and should be handled by the caller. - fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, Self> { + fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, Self>; +} + +impl BytesReader for T { + fn bytes<'r>(&'r mut self) -> extensions::Bytes<'r, T> { extensions::Bytes::new(self) } } @@ -1284,7 +1292,11 @@ pub trait AsRefWriter { /// This is useful to allow applying wrappers while still /// retaining ownership of the original value. #[inline] - fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self> { + fn by_ref<'a>(&'a mut self) -> RefWriter<'a, Self>; +} + +impl AsRefWriter for T { + fn by_ref<'a>(&'a mut self) -> RefWriter<'a, T> { RefWriter { inner: self } } }