[Deprecation] Remove sp_weights::OldWeight

prdoc/pr_3491.prdoc

@@ -0,0 +1,12 @@
+# Schema: Polkadot SDK PRDoc Schema (prdoc) v1.0.0
+# See doc at https://raw.githubusercontent.com/paritytech/polkadot-sdk/master/prdoc/schema_user.json
+
+title: Remove Deprecated OldWeight
+
+doc:
+  - audience: Runtime Dev
+    description: |
+      Removed deprecated sp_weights::OldWeight type. Use [`weight_v2::Weight`] instead.
+
+crates:
+    - name: frame-support

substrate/frame/contracts/src/wasm/mod.rs

@@ -1821,17 +1821,6 @@ mod tests {
 		assert!(weight_left.all_gt(actual_left), "gas_left must be greater than final");
 	}
 
-	/// Test that [`frame_support::weights::OldWeight`] en/decodes the same as our
-	/// [`crate::OldWeight`].
-	#[test]
-	fn old_weight_decode() {
-		#![allow(deprecated)]
-		let sp = frame_support::weights::OldWeight(42).encode();
-		let our = crate::OldWeight::decode(&mut &*sp).unwrap();
-
-		assert_eq!(our, 42);
-	}
-
 	const CODE_VALUE_TRANSFERRED: &str = r#"
 (module
 	(import "seal0" "seal_value_transferred" (func $seal_value_transferred (param i32 i32)))

substrate/primitives/weights/src/lib.rs

@@ -18,17 +18,14 @@
 //! # Primitives for transaction weighting.
 
 #![cfg_attr(not(feature = "std"), no_std)]
-// TODO remove once `OldWeight` is gone. I dont know why this is needed, maybe by one of the macros
-// of `OldWeight`.
-#![allow(deprecated)]
 
 extern crate self as sp_weights;
 
 mod weight_meter;
 mod weight_v2;
 
 use bounded_collections::Get;
-use codec::{CompactAs, Decode, Encode, MaxEncodedLen};
+use codec::{Decode, Encode};
 use scale_info::TypeInfo;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -52,28 +49,6 @@ pub mod constants {
 	pub const WEIGHT_PROOF_SIZE_PER_KB: u64 = 1024;
 }
 
-/// The old weight type.
-///
-/// NOTE: This type exists purely for compatibility purposes! Use [`weight_v2::Weight`] in all other
-/// cases.
-#[derive(
-	Decode,
-	Encode,
-	CompactAs,
-	PartialEq,
-	Eq,
-	Clone,
-	Copy,
-	RuntimeDebug,
-	Default,
-	MaxEncodedLen,
-	TypeInfo,
-)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[cfg_attr(feature = "serde", serde(transparent))]
-#[deprecated(note = "Will be removed soon; use `Weight` instead.")]
-pub struct OldWeight(pub u64);
-
 /// The weight of database operations that the runtime can invoke.
 ///
 /// NOTE: This is currently only measured in computational time, and will probably

substrate/primitives/weights/src/weight_meter.rs

@@ -118,13 +118,6 @@ impl WeightMeter {
 		debug_assert!(self.consumed.all_lte(self.limit), "Weight counter overflow");
 	}
 
-	/// Consume the given weight after checking that it can be consumed and return `true`. Otherwise
-	/// do nothing and return `false`.
-	#[deprecated(note = "Use `try_consume` instead. Will be removed after December 2023.")]
-	pub fn check_accrue(&mut self, w: Weight) -> bool {
-		self.try_consume(w).is_ok()
-	}
-
 	/// Consume the given weight after checking that it can be consumed.
 	///
 	/// Returns `Ok` if the weight can be consumed or otherwise an `Err`.
@@ -139,12 +132,6 @@ impl WeightMeter {
 		})
 	}
 
-	/// Check if the given weight can be consumed.
-	#[deprecated(note = "Use `can_consume` instead. Will be removed after December 2023.")]
-	pub fn can_accrue(&self, w: Weight) -> bool {
-		self.can_consume(w)
-	}
-
 	/// Check if the given weight can be consumed.
 	pub fn can_consume(&self, w: Weight) -> bool {
 		self.consumed.checked_add(&w).map_or(false, |t| t.all_lte(self.limit))
@@ -165,80 +152,80 @@ mod tests {
 	fn weight_meter_remaining_works() {
 		let mut meter = WeightMeter::with_limit(Weight::from_parts(10, 20));
 
-		assert!(meter.check_accrue(Weight::from_parts(5, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(5, 0)), Ok(()));
 		assert_eq!(meter.consumed, Weight::from_parts(5, 0));
 		assert_eq!(meter.remaining(), Weight::from_parts(5, 20));
 
-		assert!(meter.check_accrue(Weight::from_parts(2, 10)));
+		assert_eq!(meter.try_consume(Weight::from_parts(2, 10)), Ok(()));
 		assert_eq!(meter.consumed, Weight::from_parts(7, 10));
 		assert_eq!(meter.remaining(), Weight::from_parts(3, 10));
 
-		assert!(meter.check_accrue(Weight::from_parts(3, 10)));
+		assert_eq!(meter.try_consume(Weight::from_parts(3, 10)), Ok(()));
 		assert_eq!(meter.consumed, Weight::from_parts(10, 20));
 		assert_eq!(meter.remaining(), Weight::from_parts(0, 0));
 	}
 
 	#[test]
-	fn weight_meter_can_accrue_works() {
+	fn weight_meter_can_consume_works() {
 		let meter = WeightMeter::with_limit(Weight::from_parts(1, 1));
 
-		assert!(meter.can_accrue(Weight::from_parts(0, 0)));
-		assert!(meter.can_accrue(Weight::from_parts(1, 1)));
-		assert!(!meter.can_accrue(Weight::from_parts(0, 2)));
-		assert!(!meter.can_accrue(Weight::from_parts(2, 0)));
-		assert!(!meter.can_accrue(Weight::from_parts(2, 2)));
+		assert!(meter.can_consume(Weight::from_parts(0, 0)));
+		assert!(meter.can_consume(Weight::from_parts(1, 1)));
+		assert!(!meter.can_consume(Weight::from_parts(0, 2)));
+		assert!(!meter.can_consume(Weight::from_parts(2, 0)));
+		assert!(!meter.can_consume(Weight::from_parts(2, 2)));
 	}
 
 	#[test]
-	fn weight_meter_check_accrue_works() {
+	fn weight_meter_try_consume_works() {
 		let mut meter = WeightMeter::with_limit(Weight::from_parts(2, 2));
 
-		assert!(meter.check_accrue(Weight::from_parts(0, 0)));
-		assert!(meter.check_accrue(Weight::from_parts(1, 1)));
-		assert!(!meter.check_accrue(Weight::from_parts(0, 2)));
-		assert!(!meter.check_accrue(Weight::from_parts(2, 0)));
-		assert!(!meter.check_accrue(Weight::from_parts(2, 2)));
-		assert!(meter.check_accrue(Weight::from_parts(0, 1)));
-		assert!(meter.check_accrue(Weight::from_parts(1, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 0)), Ok(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(1, 1)), Ok(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 2)), Err(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(2, 0)), Err(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(2, 2)), Err(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 1)), Ok(()));
+		assert_eq!(meter.try_consume(Weight::from_parts(1, 0)), Ok(()));
 	}
 
 	#[test]
-	fn weight_meter_check_and_can_accrue_works() {
+	fn weight_meter_check_and_can_consume_works() {
 		let mut meter = WeightMeter::new();
 
-		assert!(meter.can_accrue(Weight::from_parts(u64::MAX, 0)));
-		assert!(meter.check_accrue(Weight::from_parts(u64::MAX, 0)));
+		assert!(meter.can_consume(Weight::from_parts(u64::MAX, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(u64::MAX, 0)), Ok(()));
 
-		assert!(meter.can_accrue(Weight::from_parts(0, u64::MAX)));
-		assert!(meter.check_accrue(Weight::from_parts(0, u64::MAX)));
+		assert!(meter.can_consume(Weight::from_parts(0, u64::MAX)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, u64::MAX)), Ok(()));
 
-		assert!(!meter.can_accrue(Weight::from_parts(0, 1)));
-		assert!(!meter.check_accrue(Weight::from_parts(0, 1)));
+		assert!(!meter.can_consume(Weight::from_parts(0, 1)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 1)), Err(()));
 
-		assert!(!meter.can_accrue(Weight::from_parts(1, 0)));
-		assert!(!meter.check_accrue(Weight::from_parts(1, 0)));
+		assert!(!meter.can_consume(Weight::from_parts(1, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(1, 0)), Err(()));
 
-		assert!(meter.can_accrue(Weight::zero()));
-		assert!(meter.check_accrue(Weight::zero()));
+		assert!(meter.can_consume(Weight::zero()));
+		assert_eq!(meter.try_consume(Weight::zero()), Ok(()));
 	}
 
 	#[test]
 	fn consumed_ratio_works() {
 		let mut meter = WeightMeter::with_limit(Weight::from_parts(10, 20));
 
-		assert!(meter.check_accrue(Weight::from_parts(5, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(5, 0)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(50));
-		assert!(meter.check_accrue(Weight::from_parts(0, 12)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 12)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(60));
 
-		assert!(meter.check_accrue(Weight::from_parts(2, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(2, 0)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(70));
-		assert!(meter.check_accrue(Weight::from_parts(0, 4)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 4)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(80));
 
-		assert!(meter.check_accrue(Weight::from_parts(3, 0)));
+		assert_eq!(meter.try_consume(Weight::from_parts(3, 0)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
-		assert!(meter.check_accrue(Weight::from_parts(0, 4)));
+		assert_eq!(meter.try_consume(Weight::from_parts(0, 4)), Ok(()));
 		assert_eq!(meter.consumed_ratio(), Perbill::from_percent(100));
 	}