idx: index as u32,
name: ty_param.ident.name };
if !input_parameters.contains(¶m_ty) {
- if ty::has_attr(tcx, impl_def_id, "old_impl_check") {
- tcx.sess.span_warn(
- ty_param.span,
- &format!("the type parameter `{}` is not constrained by the \
- impl trait, self type, or predicates",
- param_ty.user_string(tcx)));
- } else {
- span_err!(tcx.sess, ty_param.span, E0207,
- "the type parameter `{}` is not constrained by the \
- impl trait, self type, or predicates",
- param_ty.user_string(tcx));
- }
+ span_err!(tcx.sess, ty_param.span, E0207,
+ "the type parameter `{}` is not constrained by the \
+ impl trait, self type, or predicates",
+ param_ty.user_string(tcx));
}
}
}
#![feature(lang_items)]
#![feature(libc)]
#![feature(linkage, thread_local, asm)]
-#![feature(old_impl_check)]
#![feature(optin_builtin_traits)]
#![feature(rand)]
#![feature(staged_api)]
/// connections.
///
/// Doing so produces some sort of Acceptor.
-pub trait Listener<T, A: Acceptor<T>>
- : PhantomFn<T,T> // FIXME should be an assoc type anyhow
-{
+pub trait Listener<A: Acceptor> {
/// Spin up the listener and start queuing incoming connections
///
/// # Error
}
/// An acceptor is a value that presents incoming connections
-pub trait Acceptor<T> {
+pub trait Acceptor {
+ /// Type of connection that is accepted by this acceptor.
+ type Connection;
+
/// Wait for and accept an incoming connection
///
/// # Error
///
/// Returns `Err` if an I/O error is encountered.
- fn accept(&mut self) -> IoResult<T>;
+ fn accept(&mut self) -> IoResult<Self::Connection>;
/// Create an iterator over incoming connection attempts.
///
inc: &'a mut A,
}
-#[old_impl_check]
-impl<'a, T, A: ?Sized + Acceptor<T>> Iterator for IncomingConnections<'a, A> {
- type Item = IoResult<T>;
+impl<'a, A: ?Sized + Acceptor> Iterator for IncomingConnections<'a, A> {
+ type Item = IoResult<A::Connection>;
- fn next(&mut self) -> Option<IoResult<T>> {
+ fn next(&mut self) -> Option<IoResult<A::Connection>> {
Some(self.inc.accept())
}
}
}
}
-impl Listener<UnixStream, UnixAcceptor> for UnixListener {
+impl Listener<UnixAcceptor> for UnixListener {
fn listen(self) -> IoResult<UnixAcceptor> {
self.inner.listen()
.map(|inner| UnixAcceptor { inner: inner })
}
}
-impl Acceptor<UnixStream> for UnixAcceptor {
+impl Acceptor for UnixAcceptor {
+ type Connection = UnixStream;
fn accept(&mut self) -> IoResult<UnixStream> {
self.inner.accept().map(|s| {
UnixStream { inner: s }
}
}
-impl Listener<TcpStream, TcpAcceptor> for TcpListener {
+impl Listener<TcpAcceptor> for TcpListener {
fn listen(self) -> IoResult<TcpAcceptor> {
self.inner.listen(128).map(|a| TcpAcceptor { inner: a })
}
}
}
-impl Acceptor<TcpStream> for TcpAcceptor {
+impl Acceptor for TcpAcceptor {
+ type Connection = TcpStream;
fn accept(&mut self) -> IoResult<TcpStream> {
self.inner.accept().map(TcpStream::new)
}
}
}
-impl<T, A: Acceptor<T>, L: Listener<T, A>> Listener<T, A> for IoResult<L> {
+impl<A: Acceptor, L: Listener<A>> Listener<A> for IoResult<L> {
fn listen(self) -> IoResult<A> {
match self {
Ok(listener) => listener.listen(),
}
}
-impl<T, A: Acceptor<T>> Acceptor<T> for IoResult<A> {
- fn accept(&mut self) -> IoResult<T> {
+impl<A: Acceptor> Acceptor for IoResult<A> {
+ type Connection = A::Connection;
+ fn accept(&mut self) -> IoResult<A::Connection> {
match *self {
Ok(ref mut acceptor) => acceptor.accept(),
Err(ref e) => Err(e.clone()),
// A way to temporarily opt out of the new orphan rules. This will *never* be accepted.
("old_orphan_check", "1.0.0", Deprecated),
- // A way to temporarily opt out of the new impl rules. This will *never* be accepted.
- ("old_impl_check", "1.0.0", Deprecated),
-
// OIBIT specific features
("optin_builtin_traits", "1.0.0", Active),
// FIXME: #19470 this shouldn't be needed forever
("old_orphan_check", Whitelisted),
- ("old_impl_check", Whitelisted),
("rustc_paren_sugar", Whitelisted), // FIXME: #18101 temporary unboxed closure hack
// Crate level attributes
i.span,
"the new orphan check rules will eventually be strictly enforced");
}
-
- if attr::contains_name(&i.attrs[..],
- "old_impl_check") {
- self.gate_feature("old_impl_check",
- i.span,
- "`#[old_impl_check]` will be removed in the future");
- }
}
_ => {}