fix some warnings

substrate/frame/support/src/lib.rs

@@ -47,7 +47,7 @@ pub mod __private {
 	pub use sp_core::{OpaqueMetadata, Void};
 	pub use sp_core_hashing_proc_macro;
 	pub use sp_inherents;
-	pub use sp_io::{self, storage::root as storage_root};
+	pub use sp_io::{self, storage::root as storage_root, TestExternalities};
 	pub use sp_metadata_ir as metadata_ir;
 	#[cfg(feature = "std")]
 	pub use sp_runtime::{bounded_btree_map, bounded_vec};
@@ -57,7 +57,6 @@ pub mod __private {
 	pub use sp_std;
 	pub use sp_tracing;
 	pub use tt_call::*;
-	pub use sp_io::TestExternalities;
 }
 
 #[macro_use]
@@ -2200,28 +2199,30 @@ pub use frame_support_procedural::pallet;
 /// Contains macro stubs for all of the pallet:: macros
 pub mod pallet_macros {
 	pub use frame_support_procedural::{
-		composite_enum, config, constant, disable_frame_system_supertrait_check, error,
-		event, extra_constants, generate_deposit, generate_store, getter, hooks, import_section,
-		inherent, no_default, no_default_bounds, origin, pallet_section, storage, storage_prefix,
+		composite_enum, config, constant, disable_frame_system_supertrait_check, error, event,
+		extra_constants, generate_deposit, generate_store, getter, hooks, import_section, inherent,
+		no_default, no_default_bounds, origin, pallet_section, storage, storage_prefix,
 		storage_version, type_value, unbounded, validate_unsigned, weight, whitelist_storage,
 	};
 
-	/// Allows a pallet to declare a set of functions as a *dispatchable extrinsic*. In slightly
-	/// simplified terms, this macro declares the set of "transactions" of a pallet.
+	/// Allows a pallet to declare a set of functions as a *dispatchable extrinsic*. In
+	/// slightly simplified terms, this macro declares the set of "transactions" of a pallet.
 	///
 	/// > The exact definition of **extrinsic** can be found in
 	/// > [`sp_runtime::generic::UncheckedExtrinsic`].
 	///
 	/// A **dispatchable** is a common term in FRAME, referring to process of constructing a
-	/// function, and dispatching it with the correct inputs. This is commonly used with extrinsics,
-	/// for example "an extrinsic has been dispatched". See [`sp_runtime::traits::Dispatchable`] and
-	/// [`crate::dispatch::UnfilteredDispatch`].
+	/// function, and dispatching it with the correct inputs. This is commonly used with
+	/// extrinsics, for example "an extrinsic has been dispatched". See
+	/// [`sp_runtime::traits::Dispatchable`] and
+	/// [`crate::traits::UnfilteredDispatchable`].
 	///
 	/// ## Call Enum
 	///
-	/// The macro is called `call` (rather than `#[pallet::extrinsics]`) because of the generation
-	/// of a `enum Call`. This enum contains only the encoding of the function arguments of the
-	/// dispatchable, alongside the information needed to route it to the correct function.
+	/// The macro is called `call` (rather than `#[pallet::extrinsics]`) because of the
+	/// generation of a `enum Call`. This enum contains only the encoding of the function
+	/// arguments of the dispatchable, alongside the information needed to route it to the
+	/// correct function.
 	///
 	/// ```
 	/// #[frame_support::pallet(dev_mode)]
@@ -2270,7 +2271,7 @@ pub mod pallet_macros {
 	/// #    TestExternalities::new_empty().execute_with(|| {
 	///     let origin: RuntimeOrigin = frame_system::RawOrigin::Signed(10).into();
 	///     // calling into a dispatchable from within the runtime is simply a function call.
-	///	    let _ = custom_pallet::Pallet::<Runtime>::some_dispatchable(origin.clone(), 10);
+	/// 	    let _ = custom_pallet::Pallet::<Runtime>::some_dispatchable(origin.clone(), 10);
 	///
 	///     // calling into a dispatchable from the outer world involves constructing the bytes of
 	///     let call = custom_pallet::Call::<Runtime>::some_dispatchable { input: 10 };
@@ -2284,29 +2285,29 @@ pub mod pallet_macros {
 	///     // referring to the second variant of `enum Call`.
 	///     let call = custom_pallet::Call::<Runtime>::other { input: 10 };
 	///     assert_eq!(call.encode(), vec![1u8, 10, 0, 0, 0, 0, 0, 0, 0]);
-	///	#    });
+	/// 	#    });
 	/// }
 	/// ```
 	///
 	/// Further properties of dispatchable functions are as follows:
 	///
-	/// - Unless if annotated by `dev_mode`, it must contain [`weight`] to denote the pre-dispatch
-	///   weight consumed.
+	/// - Unless if annotated by `dev_mode`, it must contain [`weight`] to denote the
+	///   pre-dispatch weight consumed.
 	/// - The dispatchable must declare its index via [`call_index`], which can override the
 	///   position of a function in `enum Call`.
 	/// - The first argument is always an `OriginFor` (or `T::RuntimeOrigin`).
 	/// - The return type is always [`crate::dispatch::DispatchResult`] (or
 	///   [`crate::dispatch::DispatchResultWithPostInfo`]).
 	///
 	/// **WARNING**: modifying dispatchables, changing their order (ie. using [`call_index`]),
-	/// removing some, etc., must be done with care. This will change the encoding of the , and the
-	/// call can be stored on-chain (e.g. in `pallet-scheduler`). Thus, migration might be needed.
-	/// This is why the use of `call_index` is mandatory by default in FRAME.
+	/// removing some, etc., must be done with care. This will change the encoding of the , and
+	/// the call can be stored on-chain (e.g. in `pallet-scheduler`). Thus, migration might be
+	/// needed. This is why the use of `call_index` is mandatory by default in FRAME.
 	///
 	/// ## Default Behavior
 	///
-	/// If no `#[pallet::call]` exists, then a default implementation corresponding to the following
-	/// code is automatically generated:
+	/// If no `#[pallet::call]` exists, then a default implementation corresponding to the
+	/// following code is automatically generated:
 	///
 	/// ```ignore
 	/// #[pallet::call]
@@ -2317,20 +2318,20 @@ pub mod pallet_macros {
 	/// Enforce the index of a variant in the generated `enum Call`. See [`call`] for more
 	/// information.
 	///
-	/// All call indexes start from 0, until it encounters a dispatchable function with a defined
-	/// call index. The dispatchable function that lexically follows the function with a defined
-	/// call index will have that call index, but incremented by 1, e.g. if there are 3 dispatchable
-	/// functions `fn foo`, `fn bar` and `fn qux` in that order, and only `fn bar` has a call index
-	/// of 10, then `fn qux` will have an index of 11, instead of 1.
+	/// All call indexes start from 0, until it encounters a dispatchable function with a
+	/// defined call index. The dispatchable function that lexically follows the function with
+	/// a defined call index will have that call index, but incremented by 1, e.g. if there are
+	/// 3 dispatchable functions `fn foo`, `fn bar` and `fn qux` in that order, and only `fn
+	/// bar` has a call index of 10, then `fn qux` will have an index of 11, instead of 1.
 	pub use frame_support_procedural::call_index;
 
 	/// Declares the arguments of a [`call`] function to be encoded using
-	/// [`parity_scale_codec::Compact`]. This will results in smaller extrinsic encoding.
+	/// [`codec::Compact`]. This will results in smaller extrinsic encoding.
 	///
-	/// A common example of `compact` is for numeric values that are often times far far away from
-	/// their theoretical maximum. For example, in the context of a crypto-currency, the balance of
-	/// an individual account is often times way less then what the numeric type allows. In all such
-	/// cases, using `compact` is sensible.
+	/// A common example of `compact` is for numeric values that are often times far far away
+	/// from their theoretical maximum. For example, in the context of a crypto-currency, the
+	/// balance of an individual account is often times way less then what the numeric type
+	/// allows. In all such cases, using `compact` is sensible.
 	///
 	/// ```
 	/// #[frame_support::pallet(dev_mode)]

substrate/frame/support/src/migrations.rs

@@ -224,8 +224,7 @@ impl PalletVersionToStorageVersionHelper for T {
 	}
 }
 
-/// Migrate from the `PalletVersion` struct to the new
-/// [`StorageVersion`](crate::traits::StorageVersion) struct.
+/// Migrate from the `PalletVersion` struct to the new [`StorageVersion`] struct.
 ///
 /// This will remove all `PalletVersion's` from the state and insert the current storage version.
 pub fn migrate_from_pallet_version_to_storage_version<

substrate/frame/support/src/storage/child.rs

@@ -165,9 +165,9 @@ pub fn kill_storage(child_info: &ChildInfo, limit: Option<u32>) -> KillStorageRe
 /// guarantee that the subsequent call is in a new block; in this case the previous call's result
 /// cursor need not be passed in an a `None` may be passed instead. This exception may be useful
 /// then making this call solely from a block-hook such as `on_initialize`.
-///
-/// Returns [`MultiRemovalResults`](sp_io::MultiRemovalResults) to inform about the result. Once the
-/// resultant `maybe_cursor` field is `None`, then no further items remain to be deleted.
+
+/// Returns [`MultiRemovalResults`] to inform about the result. Once the resultant `maybe_cursor`
+/// field is `None`, then no further items remain to be deleted.
 ///
 /// NOTE: After the initial call for any given child storage, it is important that no keys further
 /// keys are inserted. If so, then they may or may not be deleted by subsequent calls.

substrate/frame/support/src/storage/mod.rs

@@ -1486,7 +1486,7 @@ pub trait StorageTryAppend<Item>: StorageDecodeLength + private::Sealed {
 	fn bound() -> usize;
 }
 
-/// Storage value that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+/// Storage value that is capable of [`StorageTryAppend`].
 pub trait TryAppendValue<T: StorageTryAppend<I>, I: Encode> {
 	/// Try and append the `item` into the storage item.
 	///
@@ -1515,7 +1515,7 @@ where
 	}
 }
 
-/// Storage map that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+/// Storage map that is capable of [`StorageTryAppend`].
 pub trait TryAppendMap<K: Encode, T: StorageTryAppend<I>, I: Encode> {
 	/// Try and append the `item` into the storage map at the given `key`.
 	///
@@ -1549,7 +1549,7 @@ where
 	}
 }
 
-/// Storage double map that is capable of [`StorageTryAppend`](crate::storage::StorageTryAppend).
+/// Storage double map that is capable of [`StorageTryAppend`].
 pub trait TryAppendDoubleMap<K1: Encode, K2: Encode, T: StorageTryAppend<I>, I: Encode> {
 	/// Try and append the `item` into the storage double map at the given `key`.
 	///