pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 14:41:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix spelling mistakes across the whole repository (#3808)

Browse Source 
**Update:** Pushed additional changes based on the review comments.

**This pull request fixes various spelling mistakes in this
repository.**

Most of the changes are contained in the first **3** commits:

- `Fix spelling mistakes in comments and docs`

- `Fix spelling mistakes in test names`

- `Fix spelling mistakes in error messages, panic messages, logs and
tracing`

Other source code spelling mistakes are separated into individual
commits for easier reviewing:

- `Fix the spelling of 'authority'`

- `Fix the spelling of 'REASONABLE_HEADERS_IN_JUSTIFICATION_ANCESTRY'`

- `Fix the spelling of 'prev_enqueud_messages'`

- `Fix the spelling of 'endpoint'`

- `Fix the spelling of 'children'`

- `Fix the spelling of 'PenpalSiblingSovereignAccount'`

- `Fix the spelling of 'PenpalSudoAccount'`

- `Fix the spelling of 'insufficient'`

- `Fix the spelling of 'PalletXcmExtrinsicsBenchmark'`

- `Fix the spelling of 'subtracted'`

- `Fix the spelling of 'CandidatePendingAvailability'`

- `Fix the spelling of 'exclusive'`

- `Fix the spelling of 'until'`

- `Fix the spelling of 'discriminator'`

- `Fix the spelling of 'nonexistent'`

- `Fix the spelling of 'subsystem'`

- `Fix the spelling of 'indices'`

- `Fix the spelling of 'committed'`

- `Fix the spelling of 'topology'`

- `Fix the spelling of 'response'`

- `Fix the spelling of 'beneficiary'`

- `Fix the spelling of 'formatted'`

- `Fix the spelling of 'UNKNOWN_PROOF_REQUEST'`

- `Fix the spelling of 'succeeded'`

- `Fix the spelling of 'reopened'`

- `Fix the spelling of 'proposer'`

- `Fix the spelling of 'InstantiationNonce'`

- `Fix the spelling of 'depositor'`

- `Fix the spelling of 'expiration'`

- `Fix the spelling of 'phantom'`

- `Fix the spelling of 'AggregatedKeyValue'`

- `Fix the spelling of 'randomness'`

- `Fix the spelling of 'defendant'`

- `Fix the spelling of 'AquaticMammal'`

- `Fix the spelling of 'transactions'`

- `Fix the spelling of 'PassingTracingSubscriber'`

- `Fix the spelling of 'TxSignaturePayload'`

- `Fix the spelling of 'versioning'`

- `Fix the spelling of 'descendant'`

- `Fix the spelling of 'overridden'`

- `Fix the spelling of 'network'`

Let me know if this structure is adequate.

**Note:** The usage of the words `Merkle`, `Merkelize`, `Merklization`,
`Merkelization`, `Merkleization`, is somewhat inconsistent but I left it
as it is.

~~**Note:** In some places the term `Receival` is used to refer to
message reception, IMO `Reception` is the correct word here, but I left
it as it is.~~

~~**Note:** In some places the term `Overlayed` is used instead of the
more acceptable version `Overlaid` but I also left it as it is.~~

~~**Note:** In some places the term `Applyable` is used instead of the
correct version `Applicable` but I also left it as it is.~~

**Note:** Some usage of British vs American english e.g. `judgement` vs
`judgment`, `initialise` vs `initialize`, `optimise` vs `optimize` etc.
are both present in different places, but I suppose that's
understandable given the number of contributors.

~~**Note:** There is a spelling mistake in `.github/CODEOWNERS` but it
triggers errors in CI when I make changes to it, so I left it as it
is.~~
This commit is contained in:
Dcompoze
2024-03-26 13:57:57 +00:00
committed by GitHub
parent b839c995c0
commit 002d9260f9
463 changed files with 1119 additions and 1017 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/support/procedural/src/benchmark.rs
+2 -2
View File
@@ -249,7 +249,7 @@ impl BenchmarkCallDef {
}
}
/// Represents a parsed `#[benchmark]` or `#[instance_banchmark]` item.
/// Represents a parsed `#[benchmark]` or `#[instance_benchmark]` item.
#[derive(Clone)]
struct BenchmarkDef {
params: Vec<ParamDef>,
@@ -466,7 +466,7 @@ pub fn benchmarks(
let mod_vis = module.vis;
let mod_name = module.ident;
// consume #[benchmarks] attribute by exclusing it from mod_attrs
// consume #[benchmarks] attribute by excluding it from mod_attrs
let mod_attrs: Vec<&Attribute> = module
.attrs
.iter()
substrate/frame/support/procedural/src/construct_runtime/mod.rs
+3 -3
View File
@@ -24,7 +24,7 @@
//! - Implicitly: `System: frame_system`
//! - Explicitly: `System: frame_system::{Pallet, Call}`
//!
//! The `construct_runtime` transitions from the implicit definition to the explict one.
//! The `construct_runtime` transitions from the implicit definition to the explicit one.
//! From the explicit state, Substrate expands the pallets with additional information
//! that is to be included in the runtime metadata. This expansion makes visible some extra
//! parts of the pallets, mainly the `Error` if defined. The expanded state looks like
@@ -55,7 +55,7 @@
//! +----------+ +------------------+
//! ```
//!
//! When all pallet parts are implcit, then the `construct_runtime!` macro expands to its final
//! When all pallet parts are implicit, then the `construct_runtime!` macro expands to its final
//! state, the `ExplicitExpanded`. Otherwise, all implicit parts are converted to an explicit
//! expanded part allow the `construct_runtime!` to expand any remaining explicit parts to an
//! explicit expanded part.
@@ -202,7 +202,7 @@
//! Similarly to the previous transition, the macro expansion transforms `System:
//! frame_system::{Pallet, Call}` into `System: frame_system expanded::{Error} ::{Pallet, Call}`.
//! The `expanded` section adds extra parts that the Substrate would like to expose for each pallet
//! by default. This is done to expose the approprite types for metadata construction.
//! by default. This is done to expose the appropriate types for metadata construction.
//!
//! This time, instead of calling `tt_default_parts` we are using the `tt_extra_parts` macro.
//! This macro returns the ` :: expanded { Error }` list of additional parts we would like to
substrate/frame/support/procedural/src/construct_runtime/parse.rs
+5 -5
View File
@@ -322,7 +322,7 @@ impl Parse for PalletDeclaration {
/// A struct representing a path to a pallet. `PalletPath` is almost identical to the standard
/// Rust path with a few restrictions:
/// - No leading colons allowed
/// - Path segments can only consist of identifers separated by colons
/// - Path segments can only consist of identifiers separated by colons
#[derive(Debug, Clone)]
pub struct PalletPath {
pub inner: Path,
@@ -595,7 +595,7 @@ pub struct Pallet {
pub is_expanded: bool,
/// The name of the pallet, e.g.`System` in `System: frame_system`.
pub name: Ident,
/// Either automatically infered, or defined (e.g. `MyPallet ... = 3,`).
/// Either automatically inferred, or defined (e.g. `MyPallet ... = 3,`).
pub index: u8,
/// The path of the pallet, e.g. `frame_system` in `System: frame_system`.
pub path: PalletPath,
@@ -634,7 +634,7 @@ impl Pallet {
/// +----------+ +----------+ +------------------+
/// ```
enum PalletsConversion {
/// Pallets implicitely declare parts.
/// Pallets implicitly declare parts.
///
/// `System: frame_system`.
Implicit(Vec<PalletDeclaration>),
@@ -648,7 +648,7 @@ enum PalletsConversion {
/// Pallets explicitly declare parts that are fully expanded.
///
/// This is the end state that contains extra parts included by
/// default by Subtrate.
/// default by Substrate.
///
/// `System: frame_system expanded::{Error} ::{Pallet, Call}`
///
@@ -660,7 +660,7 @@ enum PalletsConversion {
///
/// Check if all pallet have explicit declaration of their parts, if so then assign index to each
/// pallet using same rules as rust for fieldless enum. I.e. implicit are assigned number
/// incrementedly from last explicit or 0.
/// incrementally from last explicit or 0.
fn convert_pallets(pallets: Vec<PalletDeclaration>) -> syn::Result<PalletsConversion> {
if pallets.iter().any(|pallet| pallet.pallet_parts.is_none()) {
return Ok(PalletsConversion::Implicit(pallets))
substrate/frame/support/procedural/src/derive_impl.rs
+1 -1
View File
@@ -279,7 +279,7 @@ fn test_runtime_type_with_doc() {
}
#[test]
fn test_disambugation_path() {
fn test_disambiguation_path() {
let foreign_impl: ItemImpl = parse_quote!(impl SomeTrait for SomeType {});
let default_impl_path: Path = parse_quote!(SomeScope::SomeType);
substrate/frame/support/procedural/src/dynamic_params.rs
+9 -9
View File
@@ -147,8 +147,8 @@ fn ensure_codec_index(attrs: &Vec<syn::Attribute>, span: Span) -> Result<()> {
/// Used to inject arguments into the inner `#[dynamic_pallet_params(..)]` attribute.
///
/// This allows the outer `#[dynamic_params(..)]` attribute to specify some arguments that dont need
/// to be repeated every time.
/// This allows the outer `#[dynamic_params(..)]` attribute to specify some arguments that don't
/// need to be repeated every time.
struct MacroInjectArgs {
runtime_params: syn::Ident,
params_pallet: syn::Type,
@@ -311,7 +311,7 @@ impl ToTokens for DynamicPalletParamAttr {
)*
}
impl #scrate::traits::dynamic_params::AggregratedKeyValue for Parameters {
impl #scrate::traits::dynamic_params::AggregatedKeyValue for Parameters {
type Key = #key_ident;
type Value = #value_ident;
@@ -497,7 +497,7 @@ impl ToTokens for DynamicParamAggregatedEnum {
#vis enum #params_key_ident {
#(
#(#attributes)*
#param_names(<#param_types as #scrate::traits::dynamic_params::AggregratedKeyValue>::Key),
#param_names(<#param_types as #scrate::traits::dynamic_params::AggregatedKeyValue>::Key),
)*
}
@@ -515,11 +515,11 @@ impl ToTokens for DynamicParamAggregatedEnum {
#vis enum #params_value_ident {
#(
#(#attributes)*
#param_names(<#param_types as #scrate::traits::dynamic_params::AggregratedKeyValue>::Value),
#param_names(<#param_types as #scrate::traits::dynamic_params::AggregatedKeyValue>::Value),
)*
}
impl #scrate::traits::dynamic_params::AggregratedKeyValue for #name {
impl #scrate::traits::dynamic_params::AggregatedKeyValue for #name {
type Key = #params_key_ident;
type Value = #params_value_ident;
@@ -536,13 +536,13 @@ impl ToTokens for DynamicParamAggregatedEnum {
}
#(
impl ::core::convert::From<<#param_types as #scrate::traits::dynamic_params::AggregratedKeyValue>::Key> for #params_key_ident {
fn from(key: <#param_types as #scrate::traits::dynamic_params::AggregratedKeyValue>::Key) -> Self {
impl ::core::convert::From<<#param_types as #scrate::traits::dynamic_params::AggregatedKeyValue>::Key> for #params_key_ident {
fn from(key: <#param_types as #scrate::traits::dynamic_params::AggregatedKeyValue>::Key) -> Self {
#params_key_ident::#param_names(key)
}
}
impl ::core::convert::TryFrom<#params_value_ident> for <#param_types as #scrate::traits::dynamic_params::AggregratedKeyValue>::Value {
impl ::core::convert::TryFrom<#params_value_ident> for <#param_types as #scrate::traits::dynamic_params::AggregatedKeyValue>::Value {
type Error = ();
fn try_from(value: #params_value_ident) -> Result<Self, Self::Error> {
substrate/frame/support/procedural/src/lib.rs
+3 -3
View File
@@ -137,7 +137,7 @@ fn counter_prefix(prefix: &str) -> String {
/// - `Call` - If the pallet has callable functions
/// - `Storage` - If the pallet uses storage
/// - `Event` or `Event<T>` (if the event is generic) - If the pallet emits events
/// - `Origin` or `Origin<T>` (if the origin is generic) - If the pallet has instanciable origins
/// - `Origin` or `Origin<T>` (if the origin is generic) - If the pallet has instantiable origins
/// - `Config` or `Config<T>` (if the config is generic) - If the pallet builds the genesis
/// storage with `GenesisConfig`
/// - `Inherent` - If the pallet provides/can check inherents.
@@ -166,7 +166,7 @@ fn counter_prefix(prefix: &str) -> String {
/// and `Event` are encoded, and to define the ModuleToIndex value.
///
/// if `= $n` is not given, then index is resolved in the same way as fieldless enum in Rust
/// (i.e. incrementedly from previous index):
/// (i.e. incrementally from previous index):
/// ```nocompile
/// pallet1 .. = 2,
/// pallet2 .., // Here pallet2 is given index 3
@@ -460,7 +460,7 @@ pub fn storage_alias(attributes: TokenStream, input: TokenStream) -> TokenStream
}
/// This attribute can be used to derive a full implementation of a trait based on a local partial
/// impl and an external impl containing defaults that can be overriden in the local impl.
/// impl and an external impl containing defaults that can be overridden in the local impl.
///
/// For a full end-to-end example, see [below](#use-case-auto-derive-test-pallet-config-traits).
///
substrate/frame/support/procedural/src/pallet/parse/mod.rs
+1 -1
View File
@@ -321,7 +321,7 @@ impl Def {
Ok(())
}
/// Tries to locate a manual tasks impl (an impl impling a trait whose last path segment is
/// Tries to locate a manual tasks impl (an impl implementing a trait whose last path segment is
/// `Task`) in the event that one has not been found already via the attribute macro
pub fn resolve_manual_tasks_impl(
tasks: &mut Option<tasks::TasksDef>,
substrate/frame/support/src/dispatch_context.rs
+2 -2
View File
@@ -18,7 +18,7 @@
//! Provides functions to interact with the dispatch context.
//!
//! A Dispatch context is created by calling [`run_in_context`] and then the given closure will be
//! executed in this dispatch context. Everyting run in this `closure` will have access to the same
//! executed in this dispatch context. Everything run in this `closure` will have access to the same
//! dispatch context. This also applies to nested calls of [`run_in_context`]. The dispatch context
//! can be used to store and retrieve information locally in this context. The dispatch context can
//! be accessed by using [`with_context`]. This function will execute the given closure and give it
@@ -51,7 +51,7 @@
//!
//! run_in_context(|| {
//! with_context::<CustomContext, _>(|v| {
//! // Intitialize the value to the default value.
//! // Initialize the value to the default value.
//! assert_eq!(0, v.or_default().0);
//! v.or_default().0 = 10;
//! });
substrate/frame/support/src/instances.rs
+16 -16
View File
@@ -31,83 +31,83 @@
//! NOTE: [`frame_support::pallet`] will reexport them inside the module, in order to make them
//! accessible to [`frame_support::construct_runtime`].
/// `Instance1` to be used for instantiable palllets defined with the
/// `Instance1` to be used for instantiable pallets defined with the
/// [`#[pallet]`](`frame_support::pallet`) macro. Instances 2-16 are also available but are hidden
/// from docs.
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance1;
/// `Instance2` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance2` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance2;
/// `Instance3` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance3` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance3;
/// `Instance4` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance4` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance4;
/// `Instance5` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance5` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance5;
/// `Instance6` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance6` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance6;
/// `Instance7` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance7` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance7;
/// `Instance8` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance8` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance8;
/// `Instance9` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance9` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance9;
/// `Instance10` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance10` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance10;
/// `Instance11` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance11` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance11;
/// `Instance12` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance12` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance12;
/// `Instance13` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance13` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance13;
/// `Instance14` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance14` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance14;
/// `Instance15` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance15` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance15;
/// `Instance16` to be used for instantiable palllets defined with the `#[pallet]` macro.
/// `Instance16` to be used for instantiable pallets defined with the `#[pallet]` macro.
#[doc(hidden)]
#[derive(Clone, Copy, PartialEq, Eq, crate::RuntimeDebugNoBound)]
pub struct Instance16;
substrate/frame/support/src/lib.rs
+6 -6
View File
@@ -145,7 +145,7 @@ impl TypeId for PalletId {
/// # Examples
///
/// There are different ways to declare the `prefix` to use. The `prefix` type can either be
/// declared explicetly by passing it to the macro as an attribute or by letting the macro
/// declared explicitly by passing it to the macro as an attribute or by letting the macro
/// guess on what the `prefix` type is. The `prefix` is always passed as the first generic
/// argument to the type declaration. When using [`#[pallet::storage]`](pallet_macros::storage)
/// this first generic argument is always `_`. Besides declaring the `prefix`, the rest of the
@@ -1110,7 +1110,7 @@ pub mod pallet_macros {
/// Declares a storage as unbounded in potential size.
///
/// When implementating the storage info (when `#[pallet::generate_storage_info]` is
/// When implementing the storage info (when `#[pallet::generate_storage_info]` is
/// specified on the pallet struct placeholder), the size of the storage will be declared
/// as unbounded. This can be useful for storage which can never go into PoV (Proof of
/// Validity).
@@ -2340,7 +2340,7 @@ pub mod pallet_macros {
/// Allows defining conditions for a task to run.
///
/// This attribute is attached to a function inside an `impl` block annoated with
/// This attribute is attached to a function inside an `impl` block annotated with
/// [`pallet::tasks_experimental`](`tasks_experimental`) to define the conditions for a
/// given work item to be valid.
///
@@ -2351,7 +2351,7 @@ pub mod pallet_macros {
/// Allows defining an index for a task.
///
/// This attribute is attached to a function inside an `impl` block annoated with
/// This attribute is attached to a function inside an `impl` block annotated with
/// [`pallet::tasks_experimental`](`tasks_experimental`) to define the index of a given
/// work item.
///
@@ -2361,7 +2361,7 @@ pub mod pallet_macros {
/// Allows defining an iterator over available work items for a task.
///
/// This attribute is attached to a function inside an `impl` block annoated with
/// This attribute is attached to a function inside an `impl` block annotated with
/// [`pallet::tasks_experimental`](`tasks_experimental`).
///
/// It takes an iterator as input that yields a tuple with same types as the function
@@ -2370,7 +2370,7 @@ pub mod pallet_macros {
/// Allows defining the weight of a task.
///
/// This attribute is attached to a function inside an `impl` block annoated with
/// This attribute is attached to a function inside an `impl` block annotated with
/// [`pallet::tasks_experimental`](`tasks_experimental`) define the weight of a given work
/// item.
///
substrate/frame/support/src/storage/migration.rs
+4 -4
View File
@@ -303,11 +303,11 @@ pub fn take_storage_item<K: Encode + Sized, T: Decode + Sized, H: StorageHasher>
/// Move a storage from a pallet prefix to another pallet prefix.
///
/// Keys used in pallet storages always start with:
/// `concat(twox_128(pallet_name), towx_128(storage_name))`.
/// `concat(twox_128(pallet_name), twox_128(storage_name))`.
///
/// This function will remove all value for which the key start with
/// `concat(twox_128(old_pallet_name), towx_128(storage_name))` and insert them at the key with
/// the start replaced by `concat(twox_128(new_pallet_name), towx_128(storage_name))`.
/// `concat(twox_128(old_pallet_name), twox_128(storage_name))` and insert them at the key with
/// the start replaced by `concat(twox_128(new_pallet_name), twox_128(storage_name))`.
///
/// # Example
///
@@ -339,7 +339,7 @@ pub fn move_storage_from_pallet(
/// Move all storages from a pallet prefix to another pallet prefix.
///
/// Keys used in pallet storages always start with:
/// `concat(twox_128(pallet_name), towx_128(storage_name))`.
/// `concat(twox_128(pallet_name), twox_128(storage_name))`.
///
/// This function will remove all value for which the key start with `twox_128(old_pallet_name)`
/// and insert them at the key with the start replaced by `twox_128(new_pallet_name)`.
substrate/frame/support/src/storage/mod.rs
+11 -10
View File
@@ -159,7 +159,7 @@ pub trait StorageValue<T: FullCodec> {
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
fn decode_len() -> Option<usize>
where
@@ -363,7 +363,7 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
fn decode_len<KeyArg: EncodeLike<K>>(key: KeyArg) -> Option<usize>
where
@@ -381,7 +381,8 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
///
/// # Warning
///
/// - `None` does not mean that `get()` does not return a value. The default value is completly
/// - `None` does not mean that `get()` does not return a value. The default value is
/// completely
/// ignored by this function.
///
/// - The value returned is the non-deduplicated length of the underlying Vector in storage.This
@@ -410,7 +411,7 @@ pub trait StorageMap<K: FullEncode, V: FullCodec> {
pub trait IterableStorageMap<K: FullEncode, V: FullCodec>: StorageMap<K, V> {
/// The type that iterates over all `(key, value)`.
type Iterator: Iterator<Item = (K, V)>;
/// The type that itereates over all `key`s.
/// The type that iterates over all `key`s.
type KeyIterator: Iterator<Item = K>;
/// Enumerate all elements in the map in lexicographical order of the encoded key. If you
@@ -777,7 +778,7 @@ pub trait StorageDoubleMap<K1: FullEncode, K2: FullEncode, V: FullCodec> {
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
fn decode_len<KArg1, KArg2>(key1: KArg1, key2: KArg2) -> Option<usize>
where
@@ -798,7 +799,7 @@ pub trait StorageDoubleMap<K1: FullEncode, K2: FullEncode, V: FullCodec> {
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
fn decode_non_dedup_len<KArg1, KArg2>(key1: KArg1, key2: KArg2) -> Option<usize>
where
@@ -980,7 +981,7 @@ pub trait StorageNMap<K: KeyGenerator, V: FullCodec> {
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
fn decode_len<KArg: EncodeLikeTuple<K::KArg> + TupleToEncodedIter>(key: KArg) -> Option<usize>
where
@@ -1488,8 +1489,8 @@ pub trait StorageDecodeLength: private::Sealed + codec::DecodeLength {
}
}
/// It is expected that the length is at the beginning of the encoded objectand that the length is a
/// `Compact<u32>`.
/// It is expected that the length is at the beginning of the encoded object and that the length is
/// a `Compact<u32>`.
///
/// # Note
/// The length returned by this trait is not deduplicated, i.e. it is the length of the underlying
@@ -1790,7 +1791,7 @@ mod test {
});
}
// This test ensures that the Digest encoding does not change without being noticied.
// This test ensures that the Digest encoding does not change without being noticed.
#[test]
fn digest_storage_append_works_as_expected() {
TestExternalities::default().execute_with(|| {
substrate/frame/support/src/storage/stream_iter.rs
+1 -1
View File
@@ -217,7 +217,7 @@ const STORAGE_INPUT_BUFFER_CAPACITY: usize = 2 * 1024;
/// Implementation of [`codec::Input`] using [`sp_io::storage::read`].
///
/// Keeps an internal buffer with a size of [`STORAGE_INPUT_BUFFER_CAPACITY`]. All read accesses
/// are tried to be served by this buffer. If the buffer doesn't hold enough bytes to fullfill the
/// are tried to be served by this buffer. If the buffer doesn't hold enough bytes to fulfill the
/// current read access, the buffer is re-filled from the state. A read request that is bigger than
/// the internal buffer is directly forwarded to the state to reduce the number of reads from the
/// state.
substrate/frame/support/src/storage/types/counted_map.rs
+5 -5
View File
@@ -310,7 +310,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Option<usize>
where
@@ -775,13 +775,13 @@ mod test {
assert_eq!(A::try_get(1), Err(()));
assert_eq!(A::count(), 3);
// Take exsisting.
// Take existing.
assert_eq!(A::take(4), 10);
assert_eq!(A::try_get(4), Err(()));
assert_eq!(A::count(), 2);
// Take non-exsisting.
// Take non-existing.
assert_eq!(A::take(4), ADefault::get());
assert_eq!(A::try_get(4), Err(()));
@@ -1022,13 +1022,13 @@ mod test {
assert_eq!(B::try_get(1), Err(()));
assert_eq!(B::count(), 3);
// Take exsisting.
// Take existing.
assert_eq!(B::take(4), Some(10));
assert_eq!(B::try_get(4), Err(()));
assert_eq!(B::count(), 2);
// Take non-exsisting.
// Take non-existing.
assert_eq!(B::take(4), None);
assert_eq!(B::try_get(4), Err(()));
substrate/frame/support/src/storage/types/counted_nmap.rs
+1 -1
View File
@@ -378,7 +378,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
key: KArg,
substrate/frame/support/src/storage/types/double_map.rs
+3 -2
View File
@@ -445,7 +445,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len<KArg1, KArg2>(key1: KArg1, key2: KArg2) -> Option<usize>
where
@@ -465,7 +465,8 @@ where
///
/// # Warning
///
/// - `None` does not mean that `get()` does not return a value. The default value is completly
/// - `None` does not mean that `get()` does not return a value. The default value is
/// completely
/// ignored by this function.
///
/// - The value returned is the non-deduplicated length of the underlying Vector in storage.This
substrate/frame/support/src/storage/types/map.rs
+3 -2
View File
@@ -277,7 +277,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len<KeyArg: EncodeLike<Key>>(key: KeyArg) -> Option<usize>
where
@@ -295,7 +295,8 @@ where
///
/// # Warning
///
/// - `None` does not mean that `get()` does not return a value. The default value is completly
/// - `None` does not mean that `get()` does not return a value. The default value is
/// completely
/// ignored by this function.
///
/// - The value returned is the non-deduplicated length of the underlying Vector in storage.This
substrate/frame/support/src/storage/types/mod.rs
+1 -1
View File
@@ -195,7 +195,7 @@ mod test {
// result query returns error
assert_eq!(C::get(), Err(()));
// value query with custom onempty returns 42
// value query with custom on empty returns 42
assert_eq!(D::get(), 42);
});
}
substrate/frame/support/src/storage/types/nmap.rs
+1 -1
View File
@@ -348,7 +348,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len<KArg: EncodeLikeTuple<Key::KArg> + TupleToEncodedIter>(
key: KArg,
substrate/frame/support/src/storage/types/value.rs
+3 -2
View File
@@ -225,7 +225,7 @@ where
///
/// # Warning
///
/// `None` does not mean that `get()` does not return a value. The default value is completly
/// `None` does not mean that `get()` does not return a value. The default value is completely
/// ignored by this function.
pub fn decode_len() -> Option<usize>
where
@@ -243,7 +243,8 @@ where
///
/// # Warning
///
/// - `None` does not mean that `get()` does not return a value. The default value is completly
/// - `None` does not mean that `get()` does not return a value. The default value is
/// completely
/// ignored by this function.
///
/// - The value returned is the non-deduplicated length of the underlying Vector in storage.This
substrate/frame/support/src/traits/dispatch.rs
+1 -1
View File
@@ -540,7 +540,7 @@ pub trait OriginTrait: Sized {
})
}
/// Extract a reference to the sytsem origin, if that's what the caller is.
/// Extract a reference to the system origin, if that's what the caller is.
fn as_system_ref(&self) -> Option<&RawOrigin<Self::AccountId>> {
self.caller().as_system_ref()
}
substrate/frame/support/src/traits/dynamic_params.rs
+20 -20
View File
@@ -25,30 +25,30 @@ use frame_support::Parameter;
/// A dynamic parameter store across an aggregated KV type.
pub trait RuntimeParameterStore {
type AggregratedKeyValue: AggregratedKeyValue;
type AggregatedKeyValue: AggregatedKeyValue;
/// Get the value of a parametrized key.
///
/// Should return `None` if no explicit value was set instead of a default.
fn get<KV, K>(key: K) -> Option<K::Value>
where
KV: AggregratedKeyValue,
K: Key + Into<<KV as AggregratedKeyValue>::Key>,
<KV as AggregratedKeyValue>::Key: IntoKey<
<<Self as RuntimeParameterStore>::AggregratedKeyValue as AggregratedKeyValue>::Key,
KV: AggregatedKeyValue,
K: Key + Into<<KV as AggregatedKeyValue>::Key>,
<KV as AggregatedKeyValue>::Key: IntoKey<
<<Self as RuntimeParameterStore>::AggregatedKeyValue as AggregatedKeyValue>::Key,
>,
<<Self as RuntimeParameterStore>::AggregratedKeyValue as AggregratedKeyValue>::Value:
TryIntoKey<<KV as AggregratedKeyValue>::Value>,
<KV as AggregratedKeyValue>::Value: TryInto<K::WrappedValue>;
<<Self as RuntimeParameterStore>::AggregatedKeyValue as AggregatedKeyValue>::Value:
TryIntoKey<<KV as AggregatedKeyValue>::Value>,
<KV as AggregatedKeyValue>::Value: TryInto<K::WrappedValue>;
}
/// A dynamic parameter store across a concrete KV type.
pub trait ParameterStore<KV: AggregratedKeyValue> {
pub trait ParameterStore<KV: AggregatedKeyValue> {
/// Get the value of a parametrized key.
fn get<K>(key: K) -> Option<K::Value>
where
K: Key + Into<<KV as AggregratedKeyValue>::Key>,
<KV as AggregratedKeyValue>::Value: TryInto<K::WrappedValue>;
K: Key + Into<<KV as AggregatedKeyValue>::Key>,
<KV as AggregatedKeyValue>::Value: TryInto<K::WrappedValue>;
}
/// Key of a dynamic parameter.
@@ -61,7 +61,7 @@ pub trait Key {
}
/// The aggregated key-value type of a dynamic parameter store.
pub trait AggregratedKeyValue: Parameter {
pub trait AggregatedKeyValue: Parameter {
/// The aggregated key type.
type Key: Parameter + MaxEncodedLen;
@@ -72,7 +72,7 @@ pub trait AggregratedKeyValue: Parameter {
fn into_parts(self) -> (Self::Key, Option<Self::Value>);
}
impl AggregratedKeyValue for () {
impl AggregatedKeyValue for () {
type Key = ();
type Value = ();
@@ -90,17 +90,17 @@ pub struct ParameterStoreAdapter<PS, KV>(sp_std::marker::PhantomData<(PS, KV)>);
impl<PS, KV> ParameterStore<KV> for ParameterStoreAdapter<PS, KV>
where
PS: RuntimeParameterStore,
KV: AggregratedKeyValue,
<KV as AggregratedKeyValue>::Key:
IntoKey<<<PS as RuntimeParameterStore>::AggregratedKeyValue as AggregratedKeyValue>::Key>,
<KV as AggregratedKeyValue>::Value: TryFromKey<
<<PS as RuntimeParameterStore>::AggregratedKeyValue as AggregratedKeyValue>::Value,
KV: AggregatedKeyValue,
<KV as AggregatedKeyValue>::Key:
IntoKey<<<PS as RuntimeParameterStore>::AggregatedKeyValue as AggregatedKeyValue>::Key>,
<KV as AggregatedKeyValue>::Value: TryFromKey<
<<PS as RuntimeParameterStore>::AggregatedKeyValue as AggregatedKeyValue>::Value,
>,
{
fn get<K>(key: K) -> Option<K::Value>
where
K: Key + Into<<KV as AggregratedKeyValue>::Key>,
<KV as AggregratedKeyValue>::Value: TryInto<K::WrappedValue>,
K: Key + Into<<KV as AggregatedKeyValue>::Key>,
<KV as AggregatedKeyValue>::Value: TryInto<K::WrappedValue>,
{
PS::get::<KV, K>(key)
}
substrate/frame/support/src/traits/hooks.rs
+1 -1
View File
@@ -167,7 +167,7 @@ pub trait OnGenesis {
///
/// This hook is intended to be used internally in FRAME and not be exposed to FRAME developers.
///
/// It is defined as a seperate trait from [`OnRuntimeUpgrade`] precisely to not pollute the public
/// It is defined as a separate trait from [`OnRuntimeUpgrade`] precisely to not pollute the public
/// API.
pub trait BeforeAllRuntimeMigrations {
/// Something that should happen before runtime migrations are executed.
substrate/frame/support/src/traits/misc.rs
+1 -1
View File
@@ -1424,7 +1424,7 @@ mod test {
assert_eq!(<WrapperOpaque<[u8; 2usize.pow(14)]>>::max_encoded_len(), 2usize.pow(14) + 4);
let data = 4u64;
// Ensure that we check that the `Vec<u8>` is consumed completly on decode.
// Ensure that we check that the `Vec<u8>` is consumed completely on decode.
assert!(WrapperOpaque::<u32>::decode(&mut &data.encode().encode()[..]).is_err());
}
substrate/frame/support/src/traits/tokens/fungible/conformance_tests/regular/unbalanced.rs
+1 -1
View File
@@ -94,7 +94,7 @@ where
);
assert_eq!(T::balance(&account_0), account_0_initial_balance - amount);
// Decreasing the balance below funds avalibale should fail when Precision::Exact
// Decreasing the balance below funds available should fail when Precision::Exact
let balance_before = T::balance(&account_0);
assert_eq!(
T::decrease_balance(
substrate/frame/support/src/traits/tokens/imbalance/split_two_ways.rs
+1 -1
View File
@@ -15,7 +15,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//! Means for splitting an imbalance into two and hanlding them differently.
//! Means for splitting an imbalance into two and handling them differently.
use super::super::imbalance::{Imbalance, OnUnbalanced};
use sp_runtime::traits::Saturating;
substrate/frame/support/src/traits/tokens/misc.rs
+1 -1
View File
@@ -130,7 +130,7 @@ impl<Balance: Zero> WithdrawConsequence<Balance> {
pub enum DepositConsequence {
/// Deposit couldn't happen due to the amount being too low. This is usually because the
/// account doesn't yet exist and the deposit wouldn't bring it to at least the minimum needed
/// for existance.
/// for existence.
BelowMinimum,
/// Deposit cannot happen since the account cannot be created (usually because it's a consumer
/// and there exists no provider reference).
substrate/frame/support/test/tests/derive_impl_ui/attached_to_non_impl.rs
+1 -1
View File
@@ -50,7 +50,7 @@ impl Animal for FourLeggedAnimal {
}
}
pub struct AcquaticMammal {}
pub struct AquaticMammal {}
#[derive_impl(FourLeggedAnimal as Animal)]
struct Something {}
substrate/frame/support/test/tests/derive_impl_ui/bad_default_impl_path.rs
+2 -2
View File
@@ -50,14 +50,14 @@ impl Animal for FourLeggedAnimal {
}
}
pub struct AcquaticMammal {}
pub struct AquaticMammal {}
// Should throw: `error: cannot find macro `__export_tokens_tt_tiger` in this scope`
//
// Note that there is really no better way to clean up this error, tt_call suffers from the
// same downside but this is really the only rough edge when using macro magic.
#[derive_impl(Tiger as Animal)]
impl Animal for AcquaticMammal {
impl Animal for AquaticMammal {
type Locomotion = (Swims, RunsOnFourLegs);
type Environment = (Land, Sea);
}
substrate/frame/support/test/tests/derive_impl_ui/bad_disambiguation_path.rs
+2 -2
View File
@@ -50,10 +50,10 @@ impl Animal for FourLeggedAnimal {
}
}
pub struct AcquaticMammal {}
pub struct AquaticMammal {}
#[derive_impl(FourLeggedAnimal as Insect)]
impl Animal for AcquaticMammal {
impl Animal for AquaticMammal {
type Locomotion = (Swims, RunsOnFourLegs);
type Environment = (Land, Sea);
}
substrate/frame/support/test/tests/derive_impl_ui/missing_disambiguation_path.rs
+2 -2
View File
@@ -50,10 +50,10 @@ impl Animal for FourLeggedAnimal {
}
}
pub struct AcquaticMammal {}
pub struct AquaticMammal {}
#[derive_impl(FourLeggedAnimal as)]
impl Animal for AcquaticMammal {
impl Animal for AquaticMammal {
type Locomotion = (Swims, RunsOnFourLegs);
type Environment = (Land, Sea);
}
substrate/frame/support/test/tests/derive_impl_ui/pass/basic_overriding.rs
+6 -6
View File
@@ -51,19 +51,19 @@ impl Animal for FourLeggedAnimal {
}
}
pub struct AcquaticMammal {}
pub struct AquaticMammal {}
// without omitting the `as X`
#[derive_impl(FourLeggedAnimal as Animal)]
impl Animal for AcquaticMammal {
impl Animal for AquaticMammal {
type Locomotion = (Swims, RunsOnFourLegs);
type Environment = (Land, Sea);
}
assert_type_eq_all!(<AcquaticMammal as Animal>::Locomotion, (Swims, RunsOnFourLegs));
assert_type_eq_all!(<AcquaticMammal as Animal>::Environment, (Land, Sea));
assert_type_eq_all!(<AcquaticMammal as Animal>::Diet, Omnivore);
assert_type_eq_all!(<AcquaticMammal as Animal>::SleepingStrategy, Diurnal);
assert_type_eq_all!(<AquaticMammal as Animal>::Locomotion, (Swims, RunsOnFourLegs));
assert_type_eq_all!(<AquaticMammal as Animal>::Environment, (Land, Sea));
assert_type_eq_all!(<AquaticMammal as Animal>::Diet, Omnivore);
assert_type_eq_all!(<AquaticMammal as Animal>::SleepingStrategy, Diurnal);
pub struct Lion {}
substrate/frame/support/test/tests/pallet_outer_enums_explicit.rs
+1 -1
View File
@@ -82,7 +82,7 @@ fn module_error_outer_enum_expand_explicit() {
// Check that all error types are propagated
match RuntimeError::Example(pallet::Error::InsufficientProposersBalance) {
// Error passed implicitely to the pallet system.
// Error passed implicitly to the pallet system.
RuntimeError::System(system) => match system {
frame_system::Error::InvalidSpecName => (),
frame_system::Error::SpecVersionNeedsToIncrease => (),
substrate/frame/support/test/tests/pallet_outer_enums_implicit.rs
+3 -3
View File
@@ -62,11 +62,11 @@ frame_support::construct_runtime!(
// Exclude part `Storage` in order not to check its metadata in tests.
System: frame_system exclude_parts { Storage },
// Pallet exposes `Error` implicitely.
// Pallet exposes `Error` implicitly.
Example: common::outer_enums::pallet,
Instance1Example: common::outer_enums::pallet::<Instance1>,
// Pallet exposes `Error` implicitely.
// Pallet exposes `Error` implicitly.
Example2: common::outer_enums::pallet2,
Instance1Example2: common::outer_enums::pallet2::<Instance1>,
@@ -82,7 +82,7 @@ fn module_error_outer_enum_expand_implicit() {
// Check that all error types are propagated
match RuntimeError::Example(pallet::Error::InsufficientProposersBalance) {
// Error passed implicitely to the pallet system.
// Error passed implicitly to the pallet system.
RuntimeError::System(system) => match system {
frame_system::Error::InvalidSpecName => (),
frame_system::Error::SpecVersionNeedsToIncrease => (),
substrate/frame/support/test/tests/pallet_ui/pass/inherited_call_weight3.rs
+1 -1
View File
@@ -18,7 +18,7 @@
use frame_support::pallet_prelude::*;
use frame_system::pallet_prelude::*;
// If, for whatever reason, you dont to not use a `WeightInfo` trait - it will still work.
// If, for whatever reason, you don't to not use a `WeightInfo` trait - it will still work.
struct Impl;
impl Impl {