Fold MAX_STREAMS fields on Retransmits into an array for concision

No behavioral change.

quinn-proto/src/connection/mod.rs

@@ -2597,10 +2597,7 @@ impl Connection {
         let pending = &mut self.spaces[SpaceId::Data].pending;
         for dir in Dir::iter() {
             if self.streams.take_max_streams_dirty(dir) {
-                match dir {
-                    Dir::Uni => pending.max_uni_stream_id = true,
-                    Dir::Bi => pending.max_bi_stream_id = true,
-                }
+                pending.max_stream_id[dir as usize] = true;
             }
         }
 

quinn-proto/src/connection/spaces.rs

@@ -11,7 +11,7 @@ use rustc_hash::FxHashSet;
 use super::assembler::Assembler;
 use crate::{
     connection::StreamsState, crypto::Keys, frame, packet::SpaceId, range_set::ArrayRangeSet,
-    shared::IssuedCid, StreamId, VarInt,
+    shared::IssuedCid, Dir, StreamId, VarInt,
 };
 
 pub(crate) struct PacketSpace {
@@ -225,8 +225,7 @@ pub(crate) struct SentPacket {
 #[derive(Debug, Default, Clone)]
 pub struct Retransmits {
     pub(crate) max_data: bool,
-    pub(crate) max_uni_stream_id: bool,
-    pub(crate) max_bi_stream_id: bool,
+    pub(crate) max_stream_id: [bool; 2],
     pub(crate) reset_stream: Vec<(StreamId, VarInt)>,
     pub(crate) stop_sending: Vec<frame::StopSending>,
     pub(crate) max_stream_data: FxHashSet<StreamId>,
@@ -239,8 +238,7 @@ pub struct Retransmits {
 impl Retransmits {
     pub fn is_empty(&self, streams: &StreamsState) -> bool {
         !self.max_data
-            && !self.max_uni_stream_id
-            && !self.max_bi_stream_id
+            && !self.max_stream_id.into_iter().any(|x| x)
             && self.reset_stream.is_empty()
             && self.stop_sending.is_empty()
             && self
@@ -259,8 +257,9 @@ impl ::std::ops::BitOrAssign for Retransmits {
         // We reduce in-stream head-of-line blocking by queueing retransmits before other data for
         // STREAM and CRYPTO frames.
         self.max_data |= rhs.max_data;
-        self.max_uni_stream_id |= rhs.max_uni_stream_id;
-        self.max_bi_stream_id |= rhs.max_bi_stream_id;
+        for dir in Dir::iter() {
+            self.max_stream_id[dir as usize] |= rhs.max_stream_id[dir as usize];
+        }
         self.reset_stream.extend_from_slice(&rhs.reset_stream);
         self.stop_sending.extend_from_slice(&rhs.stop_sending);
         self.max_stream_data.extend(&rhs.max_stream_data);

quinn-proto/src/connection/streams/recv.rs

@@ -6,7 +6,7 @@ use tracing::debug;
 
 use super::{Retransmits, ShouldTransmit, StreamHalf, StreamId, StreamsState, UnknownStream};
 use crate::connection::assembler::{Assembler, Chunk, IllegalOrderedRead};
-use crate::{frame, Dir, TransportError, VarInt};
+use crate::{frame, TransportError, VarInt};
 
 #[derive(Debug, Default)]
 pub(super) struct Recv {
@@ -301,10 +301,7 @@ impl<'a> Chunks<'a> {
         if matches!(state, ChunksState::Finished | ChunksState::Reset(_))
             && self.streams.side != self.id.initiator()
         {
-            match self.id.dir() {
-                Dir::Uni => self.pending.max_uni_stream_id = true,
-                Dir::Bi => self.pending.max_bi_stream_id = true,
-            }
+            self.pending.max_stream_id[self.id.dir() as usize] = true;
             should_transmit = true;
         }
 

quinn-proto/src/connection/streams/state.rs

@@ -443,32 +443,29 @@ impl StreamsState {
             stats.max_stream_data += 1;
         }
 
-        // MAX_STREAMS_UNI
-        if pending.max_uni_stream_id && buf.len() + 9 < max_size {
-            pending.max_uni_stream_id = false;
-            retransmits.get_or_create().max_uni_stream_id = true;
-            self.max_streams_dirty[Dir::Uni as usize] = false;
-            trace!(
-                value = self.max_remote[Dir::Uni as usize],
-                "MAX_STREAMS (unidirectional)"
-            );
-            buf.write(frame::Type::MAX_STREAMS_UNI);
-            buf.write_var(self.max_remote[Dir::Uni as usize]);
-            stats.max_streams_uni += 1;
-        }
+        // MAX_STREAMS
+        for dir in Dir::iter() {
+            if !pending.max_stream_id[dir as usize] || buf.len() + 9 >= max_size {
+                continue;
+            }
 
-        // MAX_STREAMS_BIDI
-        if pending.max_bi_stream_id && buf.len() + 9 < max_size {
-            pending.max_bi_stream_id = false;
-            retransmits.get_or_create().max_bi_stream_id = true;
-            self.max_streams_dirty[Dir::Bi as usize] = false;
+            pending.max_stream_id[dir as usize] = false;
+            retransmits.get_or_create().max_stream_id[dir as usize] = true;
+            self.max_streams_dirty[dir as usize] = false;
             trace!(
-                value = self.max_remote[Dir::Bi as usize],
-                "MAX_STREAMS (bidirectional)"
+                value = self.max_remote[dir as usize],
+                "MAX_STREAMS ({:?})",
+                dir
             );
-            buf.write(frame::Type::MAX_STREAMS_BIDI);
-            buf.write_var(self.max_remote[Dir::Bi as usize]);
-            stats.max_streams_bidi += 1;
+            buf.write(match dir {
+                Dir::Uni => frame::Type::MAX_STREAMS_UNI,
+                Dir::Bi => frame::Type::MAX_STREAMS_BIDI,
+            });
+            buf.write_var(self.max_remote[dir as usize]);
+            match dir {
+                Dir::Uni => stats.max_streams_uni += 1,
+                Dir::Bi => stats.max_streams_bidi += 1,
+            }
         }
     }
 
@@ -912,7 +909,7 @@ mod tests {
         assert!(chunks.next(0).unwrap().is_none());
         let should_transmit = chunks.finalize();
         assert!(should_transmit.0);
-        assert!(pending.max_uni_stream_id);
+        assert!(pending.max_stream_id[Dir::Uni as usize]);
         assert_eq!(client.local_max_data - initial_max, MESSAGE_SIZE as u64);
     }