Use MAX associated const (#9196)

* Use MAX associated const

Author: gilescope

bin/node/runtime/src/impls.rs

@@ -307,7 +307,7 @@ mod multiplier_tests {
 	fn weight_to_fee_should_not_overflow_on_large_weights() {
 		let kb = 1024 as Weight;
 		let mb = kb * kb;
-		let max_fm = Multiplier::saturating_from_integer(i128::max_value());
+		let max_fm = Multiplier::saturating_from_integer(i128::MAX);
 
 		// check that for all values it can compute, correctly.
 		vec![

client/consensus/aura/src/lib.rs

@@ -97,7 +97,7 @@ fn slot_author<P: Pair>(slot: Slot, authorities: &[AuthorityId<P>]) -> Option<&A
 
 	let idx = *slot % (authorities.len() as u64);
 	assert!(
-		idx <= usize::max_value() as u64,
+		idx <= usize::MAX as u64,
 		"It is impossible to have a vector with length beyond the address space; qed",
 	);
 

client/finality-grandpa/src/communication/gossip.rs

@@ -1468,7 +1468,7 @@ impl<Block: BlockT> GossipValidator<Block> {
 						"" => "",
 					);
 
-					let len = std::cmp::min(i32::max_value() as usize, data.len()) as i32;
+					let len = std::cmp::min(i32::MAX as usize, data.len()) as i32;
 					Action::Discard(Misbehavior::UndecodablePacket(len).cost())
 				}
 			}

client/informant/src/display.rs

@@ -179,7 +179,7 @@ fn speed<B: BlockT>(
 		// algebraic approach and we stay within the realm of integers.
 		let one_thousand = NumberFor::<B>::from(1_000u32);
 		let elapsed = NumberFor::<B>::from(
-			<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::max_value())
+			<u32 as TryFrom<_>>::try_from(elapsed_ms).unwrap_or(u32::MAX)
 		);
 
 		let speed = diff.saturating_mul(one_thousand).checked_div(&elapsed)

client/network/src/protocol/notifications/upgrade/notifications.rs

@@ -159,7 +159,7 @@ where TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
 			}
 
 			let mut codec = UviBytes::default();
-			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::max_value()));
+			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::MAX));
 
 			let substream = NotificationsInSubstream {
 				socket: Framed::new(socket, codec),
@@ -390,7 +390,7 @@ where TSubstream: AsyncRead + AsyncWrite + Unpin + Send + 'static,
 			}
 
 			let mut codec = UviBytes::default();
-			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::max_value()));
+			codec.set_max_len(usize::try_from(self.max_notification_size).unwrap_or(usize::MAX));
 
 			Ok(NotificationsOutOpen {
 				handshake,

client/network/src/request_responses.rs

@@ -809,7 +809,7 @@ impl RequestResponseCodec for GenericCodec {
 		// Read the length.
 		let length = unsigned_varint::aio::read_usize(&mut io).await
 			.map_err(|err| io::Error::new(io::ErrorKind::InvalidInput, err))?;
-		if length > usize::try_from(self.max_request_size).unwrap_or(usize::max_value()) {
+		if length > usize::try_from(self.max_request_size).unwrap_or(usize::MAX) {
 			return Err(io::Error::new(
 				io::ErrorKind::InvalidInput,
 				format!("Request size exceeds limit: {} > {}", length, self.max_request_size)
@@ -846,7 +846,7 @@ impl RequestResponseCodec for GenericCodec {
 			Err(err) => return Err(io::Error::new(io::ErrorKind::InvalidInput, err)),
 		};
 
-		if length > usize::try_from(self.max_response_size).unwrap_or(usize::max_value()) {
+		if length > usize::try_from(self.max_response_size).unwrap_or(usize::MAX) {
 			return Err(io::Error::new(
 				io::ErrorKind::InvalidInput,
 				format!("Response size exceeds limit: {} > {}", length, self.max_response_size)

client/network/src/service.rs

@@ -300,20 +300,20 @@ impl<B: BlockT + 'static, H: ExHashT> NetworkWorker<B, H> {
 				let yamux_maximum_buffer_size = {
 					let requests_max = params.network_config
 						.request_response_protocols.iter()
-						.map(|cfg| usize::try_from(cfg.max_request_size).unwrap_or(usize::max_value()));
+						.map(|cfg| usize::try_from(cfg.max_request_size).unwrap_or(usize::MAX));
 					let responses_max = params.network_config
 						.request_response_protocols.iter()
-						.map(|cfg| usize::try_from(cfg.max_response_size).unwrap_or(usize::max_value()));
+						.map(|cfg| usize::try_from(cfg.max_response_size).unwrap_or(usize::MAX));
 					let notifs_max = params.network_config
 						.extra_sets.iter()
-						.map(|cfg| usize::try_from(cfg.max_notification_size).unwrap_or(usize::max_value()));
+						.map(|cfg| usize::try_from(cfg.max_notification_size).unwrap_or(usize::MAX));
 
 					// A "default" max is added to cover all the other protocols: ping, identify,
 					// kademlia, block announces, and transactions.
 					let default_max = cmp::max(
 						1024 * 1024,
 						usize::try_from(protocol::BLOCK_ANNOUNCES_TRANSACTIONS_SUBSTREAM_SIZE)
-							.unwrap_or(usize::max_value())
+							.unwrap_or(usize::MAX)
 					);
 
 					iter::once(default_max)

client/network/src/service/out_events.rs

@@ -254,7 +254,7 @@ impl Metrics {
 						.inc_by(num);
 					self.notifications_sizes
 						.with_label_values(&[protocol, "sent", name])
-						.inc_by(num.saturating_mul(u64::try_from(message.len()).unwrap_or(u64::max_value())));
+						.inc_by(num.saturating_mul(u64::try_from(message.len()).unwrap_or(u64::MAX)));
 				}
 			},
 		}
@@ -294,7 +294,7 @@ impl Metrics {
 						.inc();
 					self.notifications_sizes
 						.with_label_values(&[&protocol, "received", name])
-						.inc_by(u64::try_from(message.len()).unwrap_or(u64::max_value()));
+						.inc_by(u64::try_from(message.len()).unwrap_or(u64::MAX));
 				}
 			},
 		}

client/network/src/service/tests.rs

@@ -345,7 +345,7 @@ fn lots_of_incoming_peers_works() {
 				fallback_names: Vec::new(),
 				max_notification_size: 1024 * 1024,
 				set_config: config::SetConfig {
-					in_peers: u32::max_value(),
+					in_peers: u32::MAX,
 					.. Default::default()
 				},
 			}

client/peerset/src/peersstate.rs

@@ -97,8 +97,8 @@ struct Node {
 	/// are indices into this `Vec`.
 	sets: Vec<MembershipState>,
 
-	/// Reputation value of the node, between `i32::min_value` (we hate that node) and
-	/// `i32::max_value` (we love that node).
+	/// Reputation value of the node, between `i32::MIN` (we hate that node) and
+	/// `i32::MAX` (we love that node).
 	reputation: i32,
 }