65d1f83d2c
Clippy helpfully warns about code like this, telling you that you
probably meant "write_all":
fn say_hi<W:Write>(w: &mut W) {
w.write(b"hello").unwrap();
}
This patch attempts to extend the lint so it also covers this
case:
async fn say_hi<W:AsyncWrite>(w: &mut W) {
w.write(b"hello").await.unwrap();
}
(I've run into this second case several times in my own programming,
and so have my coworkers, so unless we're especially accident-prone
in this area, it's probably worth addressing?)
This patch covers the Async{Read,Write}Ext traits in futures-rs,
and in tokio, since both are quite widely used.
changelog: [`unused_io_amount`] now supports AsyncReadExt and AsyncWriteExt.
118 lines
3.2 KiB
Rust
118 lines
3.2 KiB
Rust
#![allow(dead_code)]
|
|
#![warn(clippy::unused_io_amount)]
|
|
|
|
extern crate futures;
|
|
use futures::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
|
|
use std::io::{self, Read};
|
|
|
|
fn question_mark<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
|
|
s.write(b"test")?;
|
|
let mut buf = [0u8; 4];
|
|
s.read(&mut buf)?;
|
|
Ok(())
|
|
}
|
|
|
|
fn unwrap<T: io::Read + io::Write>(s: &mut T) {
|
|
s.write(b"test").unwrap();
|
|
let mut buf = [0u8; 4];
|
|
s.read(&mut buf).unwrap();
|
|
}
|
|
|
|
fn vectored<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
|
|
s.read_vectored(&mut [io::IoSliceMut::new(&mut [])])?;
|
|
s.write_vectored(&[io::IoSlice::new(&[])])?;
|
|
Ok(())
|
|
}
|
|
|
|
fn ok(file: &str) -> Option<()> {
|
|
let mut reader = std::fs::File::open(file).ok()?;
|
|
let mut result = [0u8; 0];
|
|
reader.read(&mut result).ok()?;
|
|
Some(())
|
|
}
|
|
|
|
#[allow(clippy::redundant_closure)]
|
|
#[allow(clippy::bind_instead_of_map)]
|
|
fn or_else(file: &str) -> io::Result<()> {
|
|
let mut reader = std::fs::File::open(file)?;
|
|
let mut result = [0u8; 0];
|
|
reader.read(&mut result).or_else(|err| Err(err))?;
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
enum Error {
|
|
Kind,
|
|
}
|
|
|
|
fn or(file: &str) -> Result<(), Error> {
|
|
let mut reader = std::fs::File::open(file).unwrap();
|
|
let mut result = [0u8; 0];
|
|
reader.read(&mut result).or(Err(Error::Kind))?;
|
|
Ok(())
|
|
}
|
|
|
|
fn combine_or(file: &str) -> Result<(), Error> {
|
|
let mut reader = std::fs::File::open(file).unwrap();
|
|
let mut result = [0u8; 0];
|
|
reader
|
|
.read(&mut result)
|
|
.or(Err(Error::Kind))
|
|
.or(Err(Error::Kind))
|
|
.expect("error");
|
|
Ok(())
|
|
}
|
|
|
|
async fn bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
|
|
w.write(b"hello world").await.unwrap();
|
|
}
|
|
|
|
async fn bad_async_read<R: AsyncRead + Unpin>(r: &mut R) {
|
|
let mut buf = [0u8; 0];
|
|
r.read(&mut buf[..]).await.unwrap();
|
|
}
|
|
|
|
async fn io_not_ignored_async_write<W: AsyncWrite + Unpin>(mut w: W) {
|
|
// Here we're forgetting to await the future, so we should get a
|
|
// warning about _that_ (or we would, if it were enabled), but we
|
|
// won't get one about ignoring the return value.
|
|
w.write(b"hello world");
|
|
}
|
|
|
|
fn bad_async_write_closure<W: AsyncWrite + Unpin + 'static>(w: W) -> impl futures::Future<Output = io::Result<()>> {
|
|
let mut w = w;
|
|
async move {
|
|
w.write(b"hello world").await?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
async fn async_read_nested_or<R: AsyncRead + Unpin>(r: &mut R, do_it: bool) -> Result<[u8; 1], Error> {
|
|
let mut buf = [0u8; 1];
|
|
if do_it {
|
|
r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
|
|
}
|
|
Ok(buf)
|
|
}
|
|
|
|
use tokio::io::{AsyncRead as TokioAsyncRead, AsyncReadExt as _, AsyncWrite as TokioAsyncWrite, AsyncWriteExt as _};
|
|
|
|
async fn bad_async_write_tokio<W: TokioAsyncWrite + Unpin>(w: &mut W) {
|
|
w.write(b"hello world").await.unwrap();
|
|
}
|
|
|
|
async fn bad_async_read_tokio<R: TokioAsyncRead + Unpin>(r: &mut R) {
|
|
let mut buf = [0u8; 0];
|
|
r.read(&mut buf[..]).await.unwrap();
|
|
}
|
|
|
|
async fn undetected_bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
|
|
// It would be good to detect this case some day, but the current lint
|
|
// doesn't handle it. (The documentation says that this lint "detects
|
|
// only common patterns".)
|
|
let future = w.write(b"Hello world");
|
|
future.await.unwrap();
|
|
}
|
|
|
|
fn main() {}
|