Merge pull request #802 from godot-rust/qol/small-cleanup

Typos + code reordering

Author: Bromeon

.github/workflows/release-version.yml

@@ -179,7 +179,7 @@ jobs:
 #        # Note: first block was for an alternative approach, where a separate `releases` branch tracks deployments.
 #        # Such a branch would however be disjoint and require quite a bit of extra space in the repo.
 #        run: |
-#          # Backup current repo, so we can checkout.
+#          # Backup current repo, so we can check out.
 #          mkdir -p /tmp/repo
 #          rsync -av --exclude .git --exclude target ./ /tmp/repo/
 #          git fetch origin releases && git switch releases || git switch --orphan releases

godot-bindings/src/godot_version.rs

@@ -90,7 +90,7 @@ fn test_godot_versions() {
         ("4.0.rc1.official.8843d9ad3", 4, 0, 0, "rc1", s("8843d9ad3")),
         ("4.0.stable.arch_linux", 4, 0, 0, "stable", None),
         ("4.1.1.stable.arch_linux\n", 4, 1, 1, "stable", None),
-        // Output from 4.0.stable on MacOS in debug mode:
+        // Output from 4.0.stable on macOS in debug mode:
         // https://github.com/godotengine/godot/issues/74906
         ("arguments
 0: /Users/runner/work/_temp/godot_bin/godot.macos.editor.dev.x86_64

godot-cell/src/blocking_cell.rs

@@ -15,7 +15,7 @@ use crate::blocking_guards::{MutGuardBlocking, RefGuardBlocking};
 use crate::cell::GdCellInner;
 use crate::guards::InaccessibleGuard;
 
-/// Blocking version of [`panicking::GdCell`](crate::panicking::GdCell) for multi-threaded usage.
+/// Blocking version of [`panicking::GdCell`](crate::panicking::GdCell) for multithreaded usage.
 ///
 /// This version of GdCell blocks the current thread if it does not yet hold references to the cell.
 ///

godot-cell/src/cell.rs

@@ -121,7 +121,7 @@ impl<T> GdCellInner<T> {
         let value = state.get_ptr();
 
         // SAFETY: `increment_mut` succeeded, therefore any existing mutable references are inaccessible.
-        // Additionally no new references can be created, unless the returned guard is made inaccessible.
+        // Additionally, no new references can be created, unless the returned guard is made inaccessible.
         //
         // This is the case because the only way for a new `GdMut` or `GdRef` to be made after this is for
         // either this guard to be dropped or `make_inaccessible` to be called and succeed.
@@ -170,10 +170,9 @@ impl<T> GdCellInner<T> {
     }
 }
 
-// SAFETY: `T` is sync so we can return references to it on different threads, it is also send so we can return
-// mutable references to it on different threads.
-// Additionally all internal state is synchronized via a mutex, so we wont have race conditions when trying
-// to use it from multiple threads.
+// SAFETY: `T` is Sync, so we can return references to it on different threads.
+// It is also Send, so we can return mutable references to it on different threads.
+// Additionally, all internal state is synchronized via a mutex, so we won't have race conditions when trying to use it from multiple threads.
 unsafe impl<T: Send + Sync> Sync for GdCellInner<T> {}
 
 /// Mutable state of the `GdCell`, bundled together to make it easier to avoid deadlocks when locking the
@@ -227,7 +226,7 @@ impl<T> CellState<T> {
         NonNull::new(self.ptr).unwrap()
     }
 
-    /// Push a pointer to this state..
+    /// Push a pointer to this state.
     pub(crate) fn push_ptr(&mut self, new_ptr: NonNull<T>) -> usize {
         self.ptr = new_ptr.as_ptr();
         self.stack_depth += 1;

godot-cell/src/guards.rs

@@ -196,7 +196,7 @@ impl<'a, T> Drop for MutGuard<'a, T> {
 /// creation. When the guard is dropped, `state`'s pointer is reset to the original pointer.
 ///
 /// This ensures that any new references are derived from the new reference we pass in, and when this guard
-/// is dropped the state is reset to what it was before, as if this guard never existed.
+/// is dropped, it resets the state to what it was before, as if this guard never existed.
 #[derive(Debug)]
 pub struct InaccessibleGuard<'a, T> {
     state: &'a Mutex<CellState<T>>,

godot-cell/src/lib.rs

@@ -25,10 +25,10 @@
 //! reference (or other pointer) to some value is considered accessible when it is possible to either read
 //! from or write to the value it points to without using `unsafe`. Importantly, if we know that a reference
 //! `a` is inaccessible, and then we create a new reference `b` derived from `a` to the same value, then we
-//! know for sure that `b` wont alias `a`. This is because aliasing in rust is based on accesses, and if we
+//! know for sure that `b` won't alias `a`. This is because aliasing in rust is based on accesses, and if we
 //! never access `a` then we cannot ever violate aliasing for `a` and `b`. And since `b` is derived from `a`
 //! (that is, `b` was created from `a` somehow such as by casting `a` to a raw pointer then to a reference
-//! `b`), then `a` wont get invalidated by accesses to `b`.
+//! `b`), then `a` won't get invalidated by accesses to `b`.
 
 mod blocking_cell;
 mod blocking_guards;

godot-cell/tests/mock/blocking.rs

@@ -32,7 +32,7 @@ impl MyClass {
 
 /// Call each method from different threads, allowing them to run in parallel.
 ///
-/// This should not cause borrow failures and should not lead to dead locks.
+/// This should not cause borrow failures and should not lead to deadlocks.
 #[test]
 fn calls_parallel() {
     use std::thread;
@@ -61,7 +61,7 @@ fn calls_parallel() {
 
 /// Call each method from different threads, allowing them to run in parallel.
 ///
-/// This should not cause borrow failures and should not lead to dead locks.
+/// This should not cause borrow failures and should not lead to deadlocks.
 ///
 /// Runs each method several times in a row. This should reduce the non-determinism that comes from
 /// scheduling of threads.
@@ -95,7 +95,7 @@ fn calls_parallel_many_serial() {
 
 /// Call each method from different threads, allowing them to run in parallel.
 ///
-/// This should not cause borrow failures and should not lead to dead locks.
+/// This should not cause borrow failures and should not lead to deadlocks.
 ///
 /// Runs all the tests several times. This is different from [`calls_parallel_many_serial`] as that calls the
 /// methods like AAA...BBB...CCC..., whereas this interleaves the methods like ABC...ABC...ABC...

godot-cell/tests/mock/panicking.rs

@@ -83,7 +83,7 @@ fn calls_different_thread() {
 /// Call each method from different threads, allowing them to run in parallel.
 ///
 /// This may cause borrow failures, we do a best-effort attempt at estimating the value then. We can detect
-/// if the first call failed, so then we know the integer was incremented by 0. Otherwise we at least know
+/// if the first call failed, so then we know the integer was incremented by 0. Otherwise, we at least know
 /// the range of values that it can be incremented by.
 #[test]
 fn calls_parallel() {
@@ -114,7 +114,7 @@ fn calls_parallel() {
 /// Call each method from different threads, allowing them to run in parallel.
 ///
 /// This may cause borrow failures, we do a best-effort attempt at estimating the value then. We can detect
-/// if the first call failed, so then we know the integer was incremented by 0. Otherwise we at least know
+/// if the first call failed, so then we know the integer was incremented by 0. Otherwise, we at least know
 /// the range of values that it can be incremented by.
 ///
 /// Runs each method several times in a row. This should reduce the non-determinism that comes from
@@ -150,7 +150,7 @@ fn calls_parallel_many_serial() {
 /// Call each method from different threads, allowing them to run in parallel.
 ///
 /// This may cause borrow failures, we do a best-effort attempt at estimating the value then. We can detect
-/// if the first call failed, so then we know the integer was incremented by 0. Otherwise we at least know
+/// if the first call failed, so then we know the integer was incremented by 0. Otherwise, we at least know
 /// the range of values that it can be incremented by.
 ///
 /// Runs all the tests several times. This is different from [`calls_parallel_many_serial`] as that calls the

godot-codegen/src/conv/name_conversions.rs

@@ -280,7 +280,7 @@ fn try_strip_prefixes<'e>(enumerator: &'e str, prefixes: &[&str]) -> &'e str {
     enumerator
 }
 
-/// Check if input is a valid identifier; ie. no special characters except '_' and not starting with a digit.
+/// Check if input is a valid identifier; i.e. no special characters except '_' and not starting with a digit.
 fn is_valid_ident(s: &str) -> bool {
     !starts_with_invalid_char(s) && s.chars().all(|c| c == '_' || c.is_ascii_alphanumeric())
 }

godot-codegen/src/conv/type_conversions.rs

@@ -82,7 +82,7 @@ fn to_hardcoded_rust_enum(ty: &str) -> Option<&str> {
     Some(result)
 }
 
-/// Maps an input type to a Godot type with the same C representation. This is subtly different than [`to_rust_type`],
+/// Maps an input type to a Godot type with the same C representation. This is subtly different from [`to_rust_type`],
 /// which maps to an appropriate corresponding Rust type. This function should be used in situations where the C ABI for
 /// a type must match the Godot equivalent exactly, such as when dealing with pointers.
 pub(crate) fn to_rust_type_abi(ty: &str, ctx: &mut Context) -> (RustTy, bool) {
@@ -105,7 +105,7 @@ pub(crate) fn to_rust_type_abi(ty: &str, ctx: &mut Context) -> (RustTy, bool) {
     (ty, is_obj)
 }
 
-/// Maps an _input_ type from the Godot JSON to the corresponding Rust type (wrapping some sort of a token stream).
+/// Maps an _input_ type from the Godot JSON to the corresponding Rust type (wrapping some sort of token stream).
 ///
 /// Uses an internal cache (via `ctx`), as several types are ubiquitous.
 // TODO take TyName as input
@@ -401,7 +401,7 @@ fn to_rust_expr_inner(expr: &str, ty: &RustTy, is_inner: bool) -> TokenStream {
 }
 
 fn suffixed_lit(num: impl fmt::Display, suffix: &Ident) -> TokenStream {
-    // i32, u16 etc happens to be also the literal suffix
+    // i32, u16 etc. happen to be also the literal suffixes
     let combined = format!("{num}{suffix}");
     combined
         .parse::<Literal>()