Sep 10, 2024 · Jan 23, 2025
diff --git a/src/fs/file.rs b/src/fs/file.rs
        // file. This call should not block because it doesn't touch the actual file on disk.
        if pos == SeekFrom::Current(0) {
            // Poll the internal file cursor.
            let internal = (&*self.file).seek(SeekFrom::Current(0))?;
            let internal = (&*self.file).stream_position()?;

            // Factor in the difference caused by caching.
            let actual = match self.mode {
                if let Some(new) = (start as i64).checked_add(diff) {
                    if 0 <= new && new <= self.cache.len() as i64 {
                        // Poll the internal file cursor.
                        let internal = (&*self.file).seek(SeekFrom::Current(0))?;
                        let internal = (&*self.file).stream_position()?;

                        // Adjust the current position in the read cache.
                        self.mode = Mode::Reading(new as usize);
diff --git a/src/future/poll_fn.rs b/src/future/poll_fn.rs
    type Output = T;

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
        (&mutself.f)(cx)
        (self.f)(cx)
    }
 }
diff --git a/src/io/buf_read/lines.rs b/src/io/buf_read/lines.rs
                this.buf.pop();
            }
        }
        Poll::Ready(Some(Ok(mem::replace(this.buf, String::new()))))
        Poll::Ready(Some(Ok(mem::take(this.buf))))
    }
 }

    read: &mut usize,
 ) -> Poll<io::Result<usize>> {
    let ret = futures_core::ready!(read_until_internal(reader, cx, b'\n', bytes, read));
    if str::from_utf8(&bytes).is_err() {
    if str::from_utf8(bytes).is_err() {
        Poll::Ready(ret.and_then(|_| {
            Err(io::Error::new(
                io::ErrorKind::InvalidData,
diff --git a/src/io/buf_read/mod.rs b/src/io/buf_read/mod.rs
    {
        ReadLineFuture {
            reader: self,
            bytes: unsafe { mem::replace(buf.as_mut_vec(), Vec::new()) },
            bytes: unsafe {std::mem::take(buf.as_mut_vec()) },
            buf,
            read: 0,
        }
diff --git a/src/io/buf_read/read_line.rs b/src/io/buf_read/read_line.rs
        let reader = Pin::new(reader);

        let ret = futures_core::ready!(read_until_internal(reader, cx, b'\n', bytes, read));
        if str::from_utf8(&bytes).is_err() {
        if str::from_utf8(bytes).is_err() {
            Poll::Ready(ret.and_then(|_| {
                Err(io::Error::new(
                    io::ErrorKind::InvalidData,
diff --git a/src/io/buf_read/split.rs b/src/io/buf_read/split.rs
        if this.buf[this.buf.len() - 1] == *this.delim {
            this.buf.pop();
        }
        Poll::Ready(Some(Ok(mem::replace(this.buf, vec![]))))
        Poll::Ready(Some(Ok(mem::take(this.buf))))
    }
 }
diff --git a/src/io/read/chain.rs b/src/io/read/chain.rs
        let this = self.project();
        if !*this.done_first {
            match futures_core::ready!(this.first.poll_fill_buf(cx)) {
                Ok(buf) if buf.is_empty() => {
                Ok([]) => {
                    *this.done_first = true;
                }
                Ok(buf) => return Poll::Ready(Ok(buf)),
diff --git a/src/io/read/mod.rs b/src/io/read/mod.rs
        let start_len = buf.len();
        ReadToStringFuture {
            reader: self,
            bytes: unsafe { mem::replace(buf.as_mut_vec(), Vec::new()) },
            bytes: unsafe { mem::take(buf.as_mut_vec()) },
            buf,
            start_len,
        }
diff --git a/src/io/read/read_exact.rs b/src/io/read/read_exact.rs

        while !buf.is_empty() {
            let n = futures_core::ready!(Pin::new(&mut *reader).poll_read(cx, buf))?;
            let (_, rest) = mem::replace(buf, &mut []).split_at_mut(n);
            let (_, rest) = mem::take(buf).split_at_mut(n);
            *buf = rest;

            if n == 0 {
diff --git a/src/io/read/read_to_string.rs b/src/io/read/read_to_string.rs
        let reader = Pin::new(reader);

        let ret = futures_core::ready!(read_to_end_internal(reader, cx, bytes, *start_len));
        if str::from_utf8(&bytes).is_err() {
        if str::from_utf8(bytes).is_err() {
            Poll::Ready(ret.and_then(|_| {
                Err(io::Error::new(
                    io::ErrorKind::InvalidData,
diff --git a/src/io/write/write_all.rs b/src/io/write/write_all.rs

        while !buf.is_empty() {
            let n = futures_core::ready!(Pin::new(&mut **writer).poll_write(cx, buf))?;
            let (_, rest) = mem::replace(buf, &[]).split_at(n);
            let (_, rest) = mem::take(buf).split_at(n);
            *buf = rest;

            if n == 0 {
diff --git a/src/net/addr.rs b/src/net/addr.rs
        impl Future<Output = Self::Iter>,
        ToSocketAddrsFuture<Self::Iter>
    ) {
        (&**self).to_socket_addrs()
        (**self).to_socket_addrs()
    }
 }
diff --git a/src/path/path.rs b/src/path/path.rs
    /// assert_eq!(ancestors.next(), None);
    /// ```
    pub fn ancestors(&self) -> Ancestors<'_> {
        Ancestors { next: Some(&self) }
        Ancestors { next: Some(self) }
    }

    /// Returns the final component of the `Path`, if there is one.

 impl<'a> From<&'a std::path::Path> for &'a Path {
    fn from(path: &'a std::path::Path) -> &'a Path {
 &Path::new(path.as_os_str())
        Path::new(path.as_os_str())
    }
 }

 impl<'a>Into<&'astd::path::Path> for &'a Path {
    fninto(self) ->&'astd::path::Path {
        std::path::Path::new(&self.inner)
 impl<'a>From<&'a Path> for &'astd::path::Path {
    fnfrom(val:&'a Path) -> Self {
        std::path::Path::new(&val.inner)
    }
 }

diff --git a/src/path/pathbuf.rs b/src/path/pathbuf.rs
    }
 }

 implInto<std::path::PathBuf> forPathBuf {
    fninto(self) ->std::path::PathBuf {
 self.inner
 implFrom<PathBuf> forstd::path::PathBuf {
    fnfrom(val: PathBuf) ->Self {
 val.inner
    }
 }

diff --git a/src/stream/from_fn.rs b/src/stream/from_fn.rs
    type Item = T;

    fn poll_next(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let item = (&mutself.f)();
        let item = (self.f)();
        Poll::Ready(item)
    }
 }
diff --git a/src/stream/repeat_with.rs b/src/stream/repeat_with.rs
    type Item = T;

    fn poll_next(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Self::Item>> {
        let item = (&mutself.f)();
        let item = (self.f)();
        Poll::Ready(Some(item))
    }
 }
diff --git a/src/stream/stream/all.rs b/src/stream/stream/all.rs

        match next {
            Some(v) => {
                let result = (&mutself.f)(v);
                let result = (self.f)(v);

                if result {
                    // don't forget to wake this task again to pull the next item from stream
diff --git a/src/stream/stream/any.rs b/src/stream/stream/any.rs

        match next {
            Some(v) => {
                let result = (&mutself.f)(v);
                let result = (self.f)(v);

                if result {
                    Poll::Ready(true)
diff --git a/src/stream/stream/find.rs b/src/stream/stream/find.rs

 impl<S: Unpin, P> Unpin for FindFuture<'_, S, P> {}

 impl<'a,S, P> Future for FindFuture<'a, S, P>
 impl<S, P> Future for FindFuture<'_, S, P>
 where
    S: Stream + Unpin + Sized,
    P: FnMut(&S::Item) -> bool,
        let item = futures_core::ready!(Pin::new(&mut *self.stream).poll_next(cx));

        match item {
            Some(v) if (&mutself.p)(&v) => Poll::Ready(Some(v)),
            Some(v) if (self.p)(&v) => Poll::Ready(Some(v)),
            Some(_) => {
                cx.waker().wake_by_ref();
                Poll::Pending
diff --git a/src/stream/stream/find_map.rs b/src/stream/stream/find_map.rs

 impl<S: Unpin, F> Unpin for FindMapFuture<'_, S, F> {}

 impl<'a,S, B, F> Future for FindMapFuture<'a, S, F>
 impl<S, B, F> Future for FindMapFuture<'_, S, F>
 where
    S: Stream + Unpin + Sized,
    F: FnMut(S::Item) -> Option<B>,
        let item = futures_core::ready!(Pin::new(&mut *self.stream).poll_next(cx));

        match item {
            Some(v) => match (&mutself.f)(v) {
            Some(v) => match (self.f)(v) {
                Some(v) => Poll::Ready(Some(v)),
                None => {
                    cx.waker().wake_by_ref();
diff --git a/src/stream/stream/nth.rs b/src/stream/stream/nth.rs
    }
 }

 impl<'a,S> Future for NthFuture<'a, S>
 impl<S> Future for NthFuture<'_, S>
 where
    S: Stream + Unpin + Sized,
 {
diff --git a/src/stream/stream/position.rs b/src/stream/stream/position.rs
    index: usize,
 }

 impl<'a,S, P> Unpin for PositionFuture<'a, S, P> {}
 impl<S, P> Unpin for PositionFuture<'_, S, P> {}

 impl<'a, S, P> PositionFuture<'a, S, P> {
    pub(super) fn new(stream: &'a mut S, predicate: P) -> Self {
    }
 }

 impl<'a,S, P> Future for PositionFuture<'a, S, P>
 impl<S, P> Future for PositionFuture<'_, S, P>
 where
    S: Stream + Unpin,
    P: FnMut(S::Item) -> bool,

        match next {
            Some(v) => {
                if (&mutself.predicate)(v) {
                if (self.predicate)(v) {
                    Poll::Ready(Some(self.index))
                } else {
                    cx.waker().wake_by_ref();
diff --git a/src/stream/stream/try_fold.rs b/src/stream/stream/try_fold.rs
    acc: Option<T>,
 }

 impl<'a,S, F, T> Unpin for TryFoldFuture<'a, S, F, T> {}
 impl<S, F, T> Unpin for TryFoldFuture<'_, S, F, T> {}

 impl<'a, S, F, T> TryFoldFuture<'a, S, F, T> {
    pub(super) fn new(stream: &'a mut S, init: T, f: F) -> Self {
    }
 }

 impl<'a,S, F, T, E> Future for TryFoldFuture<'a, S, F, T>
 impl<S, F, T, E> Future for TryFoldFuture<'_, S, F, T>
 where
    S: Stream + Unpin,
    F: FnMut(T, S::Item) -> Result<T, E>,
            match next {
                Some(v) => {
                    let old = self.acc.take().unwrap();
                    let new = (&mutself.f)(old, v);
                    let new = (self.f)(old, v);

                    match new {
                        Ok(o) => self.acc = Some(o),
diff --git a/src/stream/stream/try_for_each.rs b/src/stream/stream/try_for_each.rs
    f: F,
 }

 impl<'a,S, F> Unpin for TryForEachFuture<'a, S, F> {}
 impl<S, F> Unpin for TryForEachFuture<'_, S, F> {}

 impl<'a, S, F> TryForEachFuture<'a, S, F> {
    pub(crate) fn new(stream: &'a mut S, f: F) -> Self {
        Self { stream, f }
    }
 }

 impl<'a,S, F, E> Future for TryForEachFuture<'a, S, F>
 impl<S, F, E> Future for TryForEachFuture<'_, S, F>
 where
    S: Stream + Unpin,
    F: FnMut(S::Item) -> Result<(), E>,
            match item {
                None => return Poll::Ready(Ok(())),
                Some(v) => {
                    let res = (&mutself.f)(v);
                    let res = (self.f)(v);
                    if let Err(e) = res {
                        return Poll::Ready(Err(e));
                    }
diff --git a/src/task/builder.rs b/src/task/builder.rs

        thread_local! {
            /// Tracks the number of nested block_on calls.
            static NUM_NESTED_BLOCKING: Cell<usize> = Cell::new(0);
            static NUM_NESTED_BLOCKING: Cell<usize> =const {Cell::new(0) };
        }

        // Run the future as a task.
diff --git a/src/task/task_id.rs b/src/task/task_id.rs
        static COUNTER: AtomicUsize = AtomicUsize::new(1);

        let id = COUNTER.fetch_add(1, Ordering::Relaxed);
        if id > usize::max_value() / 2 {
        if id > usize::MAX / 2 {
            std::process::abort();
        }
        TaskId(id)
diff --git a/src/task/task_local.rs b/src/task/task_local.rs
            static COUNTER: AtomicU32 = AtomicU32::new(1);

            let counter = COUNTER.fetch_add(1, Ordering::Relaxed);
            if counter > u32::max_value() / 2 {
            if counter > u32::MAX / 2 {
                std::process::abort();
            }

diff --git a/src/task/task_locals_wrapper.rs b/src/task/task_locals_wrapper.rs

 thread_local! {
    /// A pointer to the currently running task.
    static CURRENT: Cell<*const TaskLocalsWrapper> = Cell::new(ptr::null_mut());
    static CURRENT: Cell<*const TaskLocalsWrapper> =const {Cell::new(ptr::null_mut()) };
 }

 /// A wrapper to store task local data.
diff --git a/src/utils.rs b/src/utils.rs
    Timer::after(dur)
 }

 #[cfg(any(all(target_arch = "wasm32", feature = "default"),))]
 #[cfg(all(target_arch = "wasm32", feature = "default"))]
 mod timer {
    use std::pin::Pin;
    use std::task::Poll;
Original file line number	Diff line number	Diff line change
Expand Up		@@ -696,7 +696,7 @@ impl LockGuard<State> {
		// file. This call should not block because it doesn't touch the actual file on disk.
		if pos == SeekFrom::Current(0) {
		// Poll the internal file cursor.
		let internal = (&*self.file).seek(SeekFrom::Current(0))?;
		let internal = (&*self.file).stream_position()?;

		// Factor in the difference caused by caching.
		let actual = match self.mode {
Expand All		@@ -714,7 +714,7 @@ impl LockGuard<State> {
		if let Some(new) = (start as i64).checked_add(diff) {
		if 0 <= new && new <= self.cache.len() as i64 {
		// Poll the internal file cursor.
		let internal = (&*self.file).seek(SeekFrom::Current(0))?;
		let internal = (&*self.file).stream_position()?;

		// Adjust the current position in the read cache.
		self.mode = Mode::Reading(new as usize);
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -44,6 +44,6 @@ where
		type Output = T;

		fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T> {
		(&mutself.f)(cx)
		(self.f)(cx)
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -50,7 +50,7 @@ impl<R: BufRead> Stream for Lines<R> {
		this.buf.pop();
		}
		}
		Poll::Ready(Some(Ok(mem::replace(this.buf, String::new()))))
		Poll::Ready(Some(Ok(mem::take(this.buf))))
		}
		}

Expand All		@@ -62,7 +62,7 @@ pub fn read_line_internal<R: BufRead + ?Sized>(
		read: &mut usize,
		) -> Poll<io::Result<usize>> {
		let ret = futures_core::ready!(read_until_internal(reader, cx, b'\n', bytes, read));
		if str::from_utf8(&bytes).is_err() {
		if str::from_utf8(bytes).is_err() {
		Poll::Ready(ret.and_then(\|_\| {
		Err(io::Error::new(
		io::ErrorKind::InvalidData,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -136,7 +136,7 @@ pub trait BufReadExt: BufRead {
		{
		ReadLineFuture {
		reader: self,
		bytes: unsafe { mem::replace(buf.as_mut_vec(), Vec::new()) },
		bytes: unsafe {std::mem::take(buf.as_mut_vec()) },
		buf,
		read: 0,
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -29,7 +29,7 @@ impl<T: BufRead + Unpin + ?Sized> Future for ReadLineFuture<'_, T> {
		let reader = Pin::new(reader);

		let ret = futures_core::ready!(read_until_internal(reader, cx, b'\n', bytes, read));
		if str::from_utf8(&bytes).is_err() {
		if str::from_utf8(bytes).is_err() {
		Poll::Ready(ret.and_then(\|_\| {
		Err(io::Error::new(
		io::ErrorKind::InvalidData,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -46,6 +46,6 @@ impl<R: BufRead> Stream for Split<R> {
		if this.buf[this.buf.len() - 1] == *this.delim {
		this.buf.pop();
		}
		Poll::Ready(Some(Ok(mem::replace(this.buf, vec![]))))
		Poll::Ready(Some(Ok(mem::take(this.buf))))
		}
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -144,7 +144,7 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
		let this = self.project();
		if !*this.done_first {
		match futures_core::ready!(this.first.poll_fill_buf(cx)) {
		Ok(buf) if buf.is_empty() => {
		Ok([]) => {
		*this.done_first = true;
		}
		Ok(buf) => return Poll::Ready(Ok(buf)),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -168,7 +168,7 @@ pub trait ReadExt: Read {
		let start_len = buf.len();
		ReadToStringFuture {
		reader: self,
		bytes: unsafe { mem::replace(buf.as_mut_vec(), Vec::new()) },
		bytes: unsafe { mem::take(buf.as_mut_vec()) },
		buf,
		start_len,
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -20,7 +20,7 @@ impl<T: Read + Unpin + ?Sized> Future for ReadExactFuture<'_, T> {

		while !buf.is_empty() {
		let n = futures_core::ready!(Pin::new(&mut *reader).poll_read(cx, buf))?;
		let (_, rest) = mem::replace(buf, &mut []).split_at_mut(n);
		let (_, rest) = mem::take(buf).split_at_mut(n);
		*buf = rest;

		if n == 0 {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -29,7 +29,7 @@ impl<T: Read + Unpin + ?Sized> Future for ReadToStringFuture<'_, T> {
		let reader = Pin::new(reader);

		let ret = futures_core::ready!(read_to_end_internal(reader, cx, bytes, *start_len));
		if str::from_utf8(&bytes).is_err() {
		if str::from_utf8(bytes).is_err() {
		Poll::Ready(ret.and_then(\|_\| {
		Err(io::Error::new(
		io::ErrorKind::InvalidData,
Expand Down