even more wrapping

Author: Noratrieb

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -285,7 +285,7 @@ impl AllocDecodingState {
         let counter = DECODER_SESSION_ID.fetch_add(1, Ordering::SeqCst);
 
         // Make sure this is never zero.
-        let session_id = DecodingSessionId::new((counter & 0x7FFFFFFF) + 1).unwrap();
+        let session_id = DecodingSessionId::new((counter & 0x7FFFFFFF).wrapping_add(1)).unwrap();
 
         AllocDecodingSession { state: self, session_id }
     }

compiler/rustc_query_system/src/dep_graph/serialized.rs

@@ -101,14 +101,14 @@ impl SerializedDepGraph {
         // edge list, or the end of the array if this is the last edge.
         let end = self
             .edge_list_indices
-            .get(source + 1)
+            .get(SerializedDepNodeIndex::from_usize(source.index().wrapping_add(1)))
             .map(|h| h.start())
-            .unwrap_or_else(|| self.edge_list_data.len() - DEP_NODE_PAD);
+            .unwrap_or_else(|| self.edge_list_data.len().wrapping_sub(DEP_NODE_PAD));
 
         // The number of edges for this node is implicitly stored in the combination of the byte
         // width and the length.
         let bytes_per_index = header.bytes_per_index();
-        let len = (end - header.start()) / bytes_per_index;
+        let len = (end.wrapping_sub(header.start())) / bytes_per_index;
 
         // LLVM doesn't hoist EdgeHeader::mask so we do it ourselves.
         let mask = header.mask();

compiler/rustc_serialize/src/leb128.rs

@@ -24,15 +24,15 @@ macro_rules! impl_write_unsigned_leb128 {
                         *out.get_unchecked_mut(i) = value as u8;
                     }
 
-                    i += 1;
+                    i = i.wrapping_add(1);
                     break;
                 } else {
                     unsafe {
                         *out.get_unchecked_mut(i) = ((value & 0x7f) | 0x80) as u8;
                     }
 
                     value >>= 7;
-                    i += 1;
+                    i = i.wrapping_add(1);
                 }
             }
 
@@ -60,7 +60,7 @@ macro_rules! impl_read_unsigned_leb128 {
                 return byte as $int_ty;
             }
             let mut result = (byte & 0x7F) as $int_ty;
-            let mut shift = 7;
+            let mut shift = 7_usize;
             loop {
                 let byte = decoder.read_u8();
                 if (byte & 0x80) == 0 {
@@ -69,7 +69,7 @@ macro_rules! impl_read_unsigned_leb128 {
                 } else {
                     result |= ((byte & 0x7F) as $int_ty) << shift;
                 }
-                shift += 7;
+                shift = shift.wrapping_add(7);
             }
         }
     };

compiler/rustc_serialize/src/opaque.rs

@@ -65,7 +65,7 @@ impl FileEncoder {
         // Tracking position this way instead of having a `self.position` field
         // means that we only need to update `self.buffered` on a write call,
         // as opposed to updating `self.position` and `self.buffered`.
-        self.flushed + self.buffered
+        self.flushed.wrapping_add(self.buffered)
     }
 
     #[cold]
@@ -119,7 +119,7 @@ impl FileEncoder {
         }
         if let Some(dest) = self.buffer_empty().get_mut(..buf.len()) {
             dest.copy_from_slice(buf);
-            self.buffered += buf.len();
+            self.buffered = self.buffered.wrapping_add(buf.len());
         } else {
             self.write_all_cold_path(buf);
         }
@@ -158,7 +158,7 @@ impl FileEncoder {
         if written > N {
             Self::panic_invalid_write::<N>(written);
         }
-        self.buffered += written;
+        self.buffered = self.buffered.wrapping_add(written);
     }
 
     #[cold]