WIP: CI: add spellcheck (#3421)

* CI: add spellcheck

* revert me

* CI: explicit command for spellchecker

* spellcheck: edit misspells

* CI: run spellcheck on diff

* spellcheck: edits

* spellcheck: edit misspells

* spellcheck: add rules

* spellcheck: mv configs

* spellcheck: more edits

* spellcheck: chore

* spellcheck: one more thing

* spellcheck: and another one

* spellcheck: seems like it doesn't get to an end

* spellcheck: new words after rebase

* spellcheck: new words appearing out of nowhere

* chore

* review edits

* more review edits

* more edits

* wonky behavior

* wonky behavior 2

* wonky behavior 3

* change git behavior

* spellcheck: another bunch of new edits

* spellcheck: new words are koming out of nowhere

* CI: finding the master

* CI: fetching master implicitly

* CI: undebug

* new errors

* a bunch of new edits

* and some more

* Update node/core/approval-voting/src/approval_db/v1/mod.rs

Co-authored-by: Andronik Ordian <write@reusable.software>

* Update xcm/xcm-executor/src/assets.rs

Co-authored-by: Andronik Ordian <write@reusable.software>

* Apply suggestions from code review

Co-authored-by: Andronik Ordian <write@reusable.software>

* Suggestions from the code review

* CI: scan only changed files

Co-authored-by: Andronik Ordian <write@reusable.software>

polkadot/node/core/pvf/src/error.rs

@@ -40,13 +40,13 @@ pub enum InvalidCandidate {
 	///
 	/// (b) The candidate triggered a code path that has lead to the process death. For example,
 	///     the PVF found a way to consume unbounded amount of resources and then it either exceeded
-	///     an rlimit (if set) or, again, invited OOM killer. Another possibility is a bug in
+	///     an `rlimit` (if set) or, again, invited OOM killer. Another possibility is a bug in
 	///     wasmtime allowed the PVF to gain control over the execution worker.
 	///
 	/// We attribute such an event to an invalid candidate in either case.
 	///
 	/// The rationale for this is that a glitch may lead to unfair rejecting candidate by a single
-	/// validator. If the glitch is somewhat more persistant the validator will reject all candidate
+	/// validator. If the glitch is somewhat more persistent the validator will reject all candidate
 	/// thrown at it and hopefully the operator notices it by decreased reward performance of the
 	/// validator. On the other hand, if the worker died because of (b) we would have better chances
 	/// to stop the attack.

polkadot/node/core/pvf/src/execute/worker.rs

@@ -185,7 +185,7 @@ impl Response {
 	}
 }
 
-/// The entrypoint that the spawned execute worker should start with. The socket_path specifies
+/// The entrypoint that the spawned execute worker should start with. The `socket_path` specifies
 /// the path to the socket used to communicate with the host.
 pub fn worker_entrypoint(socket_path: &str) {
 	worker_event_loop("execute", socket_path, |mut stream| async move {

polkadot/node/core/pvf/src/executor_intf.rs

@@ -54,7 +54,7 @@ const CONFIG: Config = Config {
 	},
 };
 
-/// Runs the prevaldation on the given code. Returns a [`RuntimeBlob`] if it succeeds.
+/// Runs the prevalidation on the given code. Returns a [`RuntimeBlob`] if it succeeds.
 pub fn prevalidate(code: &[u8]) -> Result<RuntimeBlob, sc_executor_common::error::WasmError> {
 	let blob = RuntimeBlob::new(code)?;
 	// It's assumed this function will take care of any prevalidation logic

polkadot/node/core/pvf/src/host.rs

@@ -49,7 +49,7 @@ pub struct ValidationHost {
 }
 
 impl ValidationHost {
-	/// Execute PVF with the given code, params and priority. The result of execution will be sent
+	/// Execute PVF with the given code, parameters and priority. The result of execution will be sent
 	/// to the provided result sender.
 	///
 	/// This is async to accommodate the fact a possibility of back-pressure. In the vast majority of
@@ -106,7 +106,7 @@ pub struct Config {
 	pub cache_path: PathBuf,
 	/// The path to the program that can be used to spawn the prepare workers.
 	pub prepare_worker_program_path: PathBuf,
-	/// The time alloted for a prepare worker to spawn and report to the host.
+	/// The time allotted for a prepare worker to spawn and report to the host.
 	pub prepare_worker_spawn_timeout: Duration,
 	/// The maximum number of workers that can be spawned in the prepare pool for tasks with the
 	/// priority below critical.
@@ -115,7 +115,7 @@ pub struct Config {
 	pub prepare_workers_hard_max_num: usize,
 	/// The path to the program that can be used to spawn the execute workers.
 	pub execute_worker_program_path: PathBuf,
-	/// The time alloted for an execute worker to spawn and report to the host.
+	/// The time allotted for an execute worker to spawn and report to the host.
 	pub execute_worker_spawn_timeout: Duration,
 	/// The maximum number of execute workers that can run at the same time.
 	pub execute_workers_max_num: usize,
@@ -147,7 +147,7 @@ impl Config {
 /// must be polled in order for validation host to function.
 ///
 /// The future should not return normally but if it does then that indicates an unrecoverable error.
-/// In that case all pending requests will be cancelled, dropping the result senders and new ones
+/// In that case all pending requests will be canceled, dropping the result senders and new ones
 /// will be rejected.
 pub fn start(config: Config) -> (ValidationHost, impl Future<Output = ()>) {
 	let (to_host_tx, to_host_rx) = mpsc::channel(10);
@@ -220,7 +220,7 @@ struct PendingExecutionRequest {
 }
 
 /// A mapping from an artifact ID which is in preparation state to the list of pending execution
-/// requests that should be executed once the artifact's prepration is finished.
+/// requests that should be executed once the artifact's preparation is finished.
 #[derive(Default)]
 struct AwaitingPrepare(HashMap<ArtifactId, Vec<PendingExecutionRequest>>);
 
@@ -628,7 +628,7 @@ mod tests {
 		}
 	}
 
-	/// Creates a new pvf which artifact id can be uniquely identified by the given number.
+	/// Creates a new PVF which artifact id can be uniquely identified by the given number.
 	fn artifact_id(descriminator: u32) -> ArtifactId {
 		Pvf::from_discriminator(descriminator).as_artifact_id()
 	}

polkadot/node/core/pvf/src/lib.rs

@@ -23,14 +23,14 @@
 //!
 //! Then using the handle the client can send two types of requests:
 //!
-//! (a) PVF execution. This accepts the PVF [params][`polkadot_parachain::primitives::ValidationParams`]
+//! (a) PVF execution. This accepts the PVF [`params`][`polkadot_parachain::primitives::ValidationParams`]
 //!     and the PVF [code][`Pvf`], prepares (verifies and compiles) the code, and then executes PVF
-//!     with the params.
+//!     with the `params`.
 //!
 //! (b) Heads up. This request allows to signal that the given PVF may be needed soon and that it
 //!     should be prepared for execution.
 //!
-//! The preparation results are cached for some time after they either used or was signalled in heads up.
+//! The preparation results are cached for some time after they either used or was signaled in heads up.
 //! All requests that depends on preparation of the same PVF are bundled together and will be executed
 //! as soon as the artifact is prepared.
 //!
@@ -70,7 +70,7 @@
 //!
 //! The execute workers will be fed by the requests from the execution queue, which is basically a
 //! combination of a path to the compiled artifact and the
-//! [params][`polkadot_parachain::primitives::ValidationParams`].
+//! [`params`][`polkadot_parachain::primitives::ValidationParams`].
 //!
 //! Each fixed interval of time a pruning task will run. This task will remove all artifacts that
 //! weren't used or received a heads up signal for a while.

polkadot/node/core/pvf/src/prepare/pool.rs

@@ -80,7 +80,7 @@ pub enum FromPool {
 	Spawned(Worker),
 
 	/// The given worker either succeeded or failed the given job. Under any circumstances the
-	/// artifact file has been written. The bool says whether the worker ripped.
+	/// artifact file has been written. The `bool` says whether the worker ripped.
 	Concluded(Worker, bool),
 
 	/// The given worker ceased to exist.

polkadot/node/core/pvf/src/prepare/queue.rs

@@ -530,7 +530,7 @@ mod tests {
 	use std::task::Poll;
 	use super::*;
 
-	/// Creates a new pvf which artifact id can be uniquely identified by the given number.
+	/// Creates a new PVF which artifact id can be uniquely identified by the given number.
 	fn pvf(descriminator: u32) -> Pvf {
 		Pvf::from_discriminator(descriminator)
 	}

polkadot/node/core/pvf/src/prepare/worker.rs

@@ -273,7 +273,7 @@ fn renice(pid: u32, niceness: i32) {
 	}
 }
 
-/// The entrypoint that the spawned prepare worker should start with. The socket_path specifies
+/// The entrypoint that the spawned prepare worker should start with. The `socket_path` specifies
 /// the path to the socket used to communicate with the host.
 pub fn worker_entrypoint(socket_path: &str) {
 	worker_event_loop("prepare", socket_path, |mut stream| async move {

polkadot/node/core/pvf/src/pvf.rs

@@ -42,7 +42,7 @@ impl Pvf {
 		Self { code, code_hash }
 	}
 
-	/// Creates a new pvf which artifact id can be uniquely identified by the given number.
+	/// Creates a new PVF which artifact id can be uniquely identified by the given number.
 	#[cfg(test)]
 	pub(crate) fn from_discriminator(num: u32) -> Self {
 		let descriminator_buf = num.to_le_bytes().to_vec();

polkadot/node/core/pvf/src/worker_common.rs

@@ -177,7 +177,7 @@ pub enum SpawnErr {
 	Accept,
 	/// An error happened during spawning the process.
 	ProcessSpawn,
-	/// The deadline alloted for the worker spawning and connecting to the socket has elapsed.
+	/// The deadline allotted for the worker spawning and connecting to the socket has elapsed.
 	AcceptTimeout,
 }
 
@@ -187,7 +187,7 @@ pub enum SpawnErr {
 /// has been terminated. Since the worker is running in another process it is obviously not necessarily
 ///  to poll this future to make the worker run, it's only for termination detection.
 ///
-/// This future relies on the fact that a child process's stdout fd is closed upon it's termination.
+/// This future relies on the fact that a child process's stdout `fd` is closed upon it's termination.
 #[pin_project]
 pub struct WorkerHandle {
 	child: async_process::Child,