refactor: Rename rem_cid to remote_cid and friends (#351)

matheus23 · web-flow · commit 7706e5a4e197 · 2026-01-20T16:37:57.000Z
* refactor: Rename `rem_cid` to `remote_cid` and friends

* `cargo make format`
diff --git a/quinn-proto/src/connection/mod.rs b/quinn-proto/src/connection/mod.rs
diff --git a/quinn-proto/src/connection/qlog.rs b/quinn-proto/src/connection/qlog.rs
@@ -144,8 +144,8 @@ impl QlogSink {
     pub(crate) fn emit_connection_started(
         &self,
         now: Instant,
-        loc_cid: ConnectionId,
-        rem_cid: ConnectionId,
+        local_cid: ConnectionId,
+        remote_cid: ConnectionId,
         remote: SocketAddr,
         local_ip: Option<IpAddr>,
         transport_params: &TransportParameters,
@@ -157,11 +157,11 @@ impl QlogSink {
             };
             stream.emit_event(
                 EventData::ConnectionStarted(ConnectionStarted {
-                    local: tuple_endpoint_info(local_ip, None, Some(loc_cid)),
+                    local: tuple_endpoint_info(local_ip, None, Some(local_cid)),
                     remote: tuple_endpoint_info(
                         Some(remote.ip()),
                         Some(remote.port()),
-                        Some(rem_cid),
+                        Some(remote_cid),
                     ),
                 }),
                 now,
diff --git a/quinn-proto/src/connection/state.rs b/quinn-proto/src/connection/state.rs
@@ -330,7 +330,7 @@ pub struct Handshake {
     /// Whether the remote CID has been set by the peer yet.
     ///
     /// Always set for servers.
-    pub(super) rem_cid_set: bool,
+    pub(super) remote_cid_set: bool,
     /// Stateless retry token received in the first Initial by a server.
     ///
     /// Must be present in every Initial. Always empty for clients.
diff --git a/quinn-proto/src/endpoint.rs b/quinn-proto/src/endpoint.rs
@@ -118,7 +118,7 @@ impl Endpoint {
             }
             RetireConnectionId(now, path_id, seq, allow_more_cids) => {
                 if let Some(cid) = self.connections[ch]
-                    .loc_cids
+                    .local_cids
                     .get_mut(&path_id)
                     .and_then(|pcid| pcid.cids.remove(&seq))
                 {
@@ -348,12 +348,12 @@ impl Endpoint {
         trace!(initial_dcid = %remote_id);
 
         let ch = ConnectionHandle(self.connections.vacant_key());
-        let loc_cid = self.new_cid(ch, PathId::ZERO);
+        let local_cid = self.new_cid(ch, PathId::ZERO);
         let params = TransportParameters::new(
             &config.transport,
             &self.config,
             self.local_cid_generator.as_ref(),
-            loc_cid,
+            local_cid,
             None,
             &mut self.rng,
         );
@@ -365,7 +365,7 @@ impl Endpoint {
             ch,
             config.version,
             remote_id,
-            loc_cid,
+            local_cid,
             remote_id,
             FourTuple {
                 remote,
@@ -394,7 +394,7 @@ impl Endpoint {
         let mut ids = vec![];
         for _ in 0..num {
             let id = self.new_cid(ch, path_id);
-            let cid_meta = self.connections[ch].loc_cids.entry(path_id).or_default();
+            let cid_meta = self.connections[ch].local_cids.entry(path_id).or_default();
             let sequence = cid_meta.issued;
             cid_meta.issued += 1;
             cid_meta.cids.insert(sequence, id);
@@ -606,16 +606,16 @@ impl Endpoint {
         };
 
         let ch = ConnectionHandle(self.connections.vacant_key());
-        let loc_cid = self.new_cid(ch, PathId::ZERO);
+        let local_cid = self.new_cid(ch, PathId::ZERO);
         let mut params = TransportParameters::new(
             &server_config.transport,
             &self.config,
             self.local_cid_generator.as_ref(),
-            loc_cid,
+            local_cid,
             Some(&server_config),
             &mut self.rng,
         );
-        params.stateless_reset_token = Some(ResetToken::new(&*self.config.reset_key, loc_cid));
+        params.stateless_reset_token = Some(ResetToken::new(&*self.config.reset_key, local_cid));
         params.original_dst_cid = Some(incoming.token.orig_dst_cid);
         params.retry_src_cid = incoming.token.retry_src_cid;
         let mut pref_addr_cid = None;
@@ -636,7 +636,7 @@ impl Endpoint {
             ch,
             version,
             dst_cid,
-            loc_cid,
+            local_cid,
             src_cid,
             incoming.network_path,
             incoming.received_at,
@@ -751,7 +751,7 @@ impl Endpoint {
         // with established connections. In the unlikely event that a collision occurs
         // between two connections in the initial phase, both will fail fast and may be
         // retried by the application layer.
-        let loc_cid = self.local_cid_generator.generate_cid();
+        let local_cid = self.local_cid_generator.generate_cid();
 
         let payload = TokenPayload::Retry {
             address: incoming.network_path.remote,
@@ -761,7 +761,7 @@ impl Endpoint {
         let token = Token::new(payload, &mut self.rng).encode(&*server_config.token_key);
 
         let header = Header::Retry {
-            src_cid: loc_cid,
+            src_cid: local_cid,
             dst_cid: incoming.packet.header.src_cid,
             version: incoming.packet.header.version,
         };
@@ -805,8 +805,8 @@ impl Endpoint {
         ch: ConnectionHandle,
         version: u32,
         init_cid: ConnectionId,
-        loc_cid: ConnectionId,
-        rem_cid: ConnectionId,
+        local_cid: ConnectionId,
+        remote_cid: ConnectionId,
         network_path: FourTuple,
         now: Instant,
         tls: Box<dyn crypto::Session>,
@@ -825,8 +825,8 @@ impl Endpoint {
 
         qlog.emit_connection_started(
             now,
-            loc_cid,
-            rem_cid,
+            local_cid,
+            remote_cid,
             network_path.remote,
             network_path.local_ip,
             params,
@@ -836,8 +836,8 @@ impl Endpoint {
             self.config.clone(),
             transport_config,
             init_cid,
-            loc_cid,
-            rem_cid,
+            local_cid,
+            remote_cid,
             network_path,
             tls,
             self.local_cid_generator.as_ref(),
@@ -850,7 +850,7 @@ impl Endpoint {
         );
 
         let mut path_cids = PathLocalCids::default();
-        path_cids.cids.insert(path_cids.issued, loc_cid);
+        path_cids.cids.insert(path_cids.issued, local_cid);
         path_cids.issued += 1;
 
         if let Some(cid) = pref_addr_cid {
@@ -861,14 +861,14 @@ impl Endpoint {
 
         let id = self.connections.insert(ConnectionMeta {
             init_cid,
-            loc_cids: FxHashMap::from_iter([(PathId::ZERO, path_cids)]),
+            local_cids: FxHashMap::from_iter([(PathId::ZERO, path_cids)]),
             network_path,
             side,
             reset_token: Default::default(),
         });
         debug_assert_eq!(id, ch.0, "connection handle allocation out of sync");
 
-        self.index.insert_conn(network_path, loc_cid, ch, side);
+        self.index.insert_conn(network_path, local_cid, ch, side);
 
         conn
     }
@@ -1093,7 +1093,11 @@ impl ConnectionIndex {
         if conn.side.is_server() {
             self.remove_initial(conn.init_cid);
         }
-        for cid in conn.loc_cids.values().flat_map(|pcids| pcids.cids.values()) {
+        for cid in conn
+            .local_cids
+            .values()
+            .flat_map(|pcids| pcids.cids.values())
+        {
             self.connection_ids.remove(cid);
         }
         self.incoming_connection_remotes.remove(&conn.network_path);
@@ -1144,7 +1148,7 @@ impl ConnectionIndex {
 pub(crate) struct ConnectionMeta {
     init_cid: ConnectionId,
     /// Locally issues CIDs for each path
-    loc_cids: FxHashMap<PathId, PathLocalCids>,
+    local_cids: FxHashMap<PathId, PathLocalCids>,
     /// Remote/local addresses the connection began with
     ///
     /// Only needed to support connections with zero-length CIDs, which cannot migrate, so we don't
diff --git a/quinn-proto/src/lib.rs b/quinn-proto/src/lib.rs
@@ -351,7 +351,7 @@ pub struct Transmit {
 //
 
 /// The maximum number of CIDs we bother to issue per path
-const LOC_CID_COUNT: u64 = 12;
+const LOCAL_CID_COUNT: u64 = 12;
 const RESET_TOKEN_SIZE: usize = 16;
 const MAX_CID_SIZE: usize = 20;
 const MIN_INITIAL_SIZE: u16 = 1200;
diff --git a/quinn-proto/src/tests/mod.rs b/quinn-proto/src/tests/mod.rs
@@ -1702,9 +1702,9 @@ fn cid_rotation() {
     let mut stop = pair.time;
     let end = pair.time + 5 * CID_TIMEOUT;
 
-    use crate::{LOC_CID_COUNT, cid_queue::CidQueue};
+    use crate::{LOCAL_CID_COUNT, cid_queue::CidQueue};
     let mut active_cid_num = CidQueue::LEN as u64 + 1;
-    active_cid_num = active_cid_num.min(LOC_CID_COUNT);
+    active_cid_num = active_cid_num.min(LOCAL_CID_COUNT);
     let mut left_bound = 0;
     let mut right_bound = active_cid_num - 1;
 
@@ -1747,11 +1747,11 @@ fn cid_retirement() {
     // Any unexpected behavior may trigger TransportError::CONNECTION_ID_LIMIT_ERROR
     assert!(!pair.client_conn_mut(client_ch).is_closed());
     assert!(!pair.server_conn_mut(server_ch).is_closed());
-    assert_matches!(pair.client_conn_mut(client_ch).active_rem_cid_seq(), 1);
+    assert_matches!(pair.client_conn_mut(client_ch).active_remote_cid_seq(), 1);
 
-    use crate::{LOC_CID_COUNT, cid_queue::CidQueue};
+    use crate::{LOCAL_CID_COUNT, cid_queue::CidQueue};
     let mut active_cid_num = CidQueue::LEN as u64;
-    active_cid_num = active_cid_num.min(LOC_CID_COUNT);
+    active_cid_num = active_cid_num.min(LOCAL_CID_COUNT);
 
     let now = pair.time;
     let next_retire_prior_to = active_cid_num + 1;
@@ -1764,7 +1764,7 @@ fn cid_retirement() {
     assert!(!pair.server_conn_mut(server_ch).is_closed());
 
     assert_eq!(
-        pair.client_conn_mut(client_ch).active_rem_cid_seq(),
+        pair.client_conn_mut(client_ch).active_remote_cid_seq(),
         next_retire_prior_to,
     );
 }
diff --git a/quinn-proto/src/tests/multipath.rs b/quinn-proto/src/tests/multipath.rs
@@ -12,7 +12,7 @@ use crate::tests::RoutingTable;
 use crate::tests::util::{CLIENT_PORTS, SERVER_PORTS};
 use crate::{
     ClientConfig, ClosePathError, ConnectionHandle, ConnectionId, ConnectionIdGenerator, Endpoint,
-    EndpointConfig, FourTuple, LOC_CID_COUNT, PathId, PathStatus, RandomConnectionIdGenerator,
+    EndpointConfig, FourTuple, LOCAL_CID_COUNT, PathId, PathStatus, RandomConnectionIdGenerator,
     ServerConfig, TransportConfig, cid_queue::CidQueue,
 };
 use crate::{Event, PathError, PathEvent};
@@ -238,7 +238,7 @@ fn multipath_cid_rotation() {
     let end = pair.time + 5 * CID_TIMEOUT;
 
     let mut active_cid_num = CidQueue::LEN as u64 + 1;
-    active_cid_num = active_cid_num.min(LOC_CID_COUNT);
+    active_cid_num = active_cid_num.min(LOCAL_CID_COUNT);
     let mut left_bound = 0;
     let mut right_bound = active_cid_num - 1;
 
diff --git a/quinn-proto/src/transport_parameters.rs b/quinn-proto/src/transport_parameters.rs
@@ -17,7 +17,7 @@ use rand::{Rng as _, RngCore, seq::SliceRandom as _};
 use thiserror::Error;
 
 use crate::{
-    LOC_CID_COUNT, MAX_CID_SIZE, MAX_STREAM_COUNT, RESET_TOKEN_SIZE, ResetToken, Side,
+    LOCAL_CID_COUNT, MAX_CID_SIZE, MAX_STREAM_COUNT, RESET_TOKEN_SIZE, ResetToken, Side,
     TIMER_GRANULARITY, TransportError, VarInt, address_discovery,
     cid_generator::ConnectionIdGenerator,
     cid_queue::CidQueue,
@@ -227,9 +227,9 @@ impl TransportParameters {
     /// Maximum number of CIDs to issue to this peer
     ///
     /// Consider both a) the active_connection_id_limit from the other end; and
-    /// b) LOC_CID_COUNT used locally
+    /// b) LOCAL_CID_COUNT used locally
     pub(crate) fn issue_cids_limit(&self) -> u64 {
-        self.active_connection_id_limit.0.min(LOC_CID_COUNT)
+        self.active_connection_id_limit.0.min(LOCAL_CID_COUNT)
     }
 }
 
