Comment fixes.

Mostly by wrapping long comments 100 chars, because lines longer than
that are hard to read when you have a 100-char window.

Author: nnethercote

crates/spirv-std/macros/src/lib.rs

@@ -527,9 +527,9 @@ fn debug_printf_inner(input: DebugPrintfInput) -> TokenStream {
         .into_iter()
         .collect::<proc_macro2::TokenStream>();
     let op_loads = op_loads.into_iter().collect::<proc_macro2::TokenStream>();
-    // Escapes the '{' and '}' characters in the format string.
-    // Since the `asm!` macro expects '{' '}' to surround its arguments, we have to use '{{' and '}}' instead.
-    // The `asm!` macro will then later turn them back into '{' and '}'.
+    // Escapes the '{' and '}' characters in the format string. Since the `asm!` macro expects '{'
+    // '}' to surround its arguments, we have to use '{{' and '}}' instead. The `asm!` macro will
+    // then later turn them back into '{' and '}'.
     let format_string = format_string.replace('{', "{{").replace('}', "}}");
 
     let op_string = format!("%string = OpString {format_string:?}");
@@ -567,8 +567,8 @@ impl SampleImplRewriter {
         let mut new_impl = f.clone();
         let mut ty_str = String::from("SampleParams<");
 
-        // based on the mask, form a `SampleParams` type string and add the generic parameters to the `impl<>` generics
-        // example type string: `"SampleParams<SomeTy<B>, NoneTy, NoneTy>"`
+        // based on the mask, form a `SampleParams` type string and add the generic parameters to
+        // the `impl<>` generics example type string: `"SampleParams<SomeTy<B>, NoneTy, NoneTy>"`
         for i in 0..SAMPLE_PARAM_COUNT {
             if mask & (1 << i) != 0 {
                 new_impl.generics.params.push(syn::GenericParam::Type(
@@ -600,7 +600,8 @@ impl SampleImplRewriter {
         new_impl
     }
 
-    // generates an operands string for use in the assembly, e.g. "Bias %bias Lod %lod", based on the mask
+    // Generates an operands string for use in the assembly, e.g. "Bias %bias Lod %lod", based on
+    // the mask.
     #[allow(clippy::needless_range_loop)]
     fn get_operands(&self) -> String {
         let mut op = String::new();
@@ -619,7 +620,7 @@ impl SampleImplRewriter {
         op
     }
 
-    // generates list of assembly loads for the data, e.g. "%bias = OpLoad _ {bias}", etc.
+    // Generates list of assembly loads for the data, e.g. "%bias = OpLoad _ {bias}", etc.
     #[allow(clippy::needless_range_loop)]
     fn add_loads(&self, t: &mut Vec<TokenTree>) {
         for i in 0..SAMPLE_PARAM_COUNT {
@@ -651,7 +652,8 @@ impl SampleImplRewriter {
         }
     }
 
-    // generates list of register specifications, e.g. `bias = in(reg) &params.bias.0, ...` as separate tokens
+    // Generates list of register specifications, e.g. `bias = in(reg) &params.bias.0, ...` as
+    // separate tokens.
     #[allow(clippy::needless_range_loop)]
     fn add_regs(&self, t: &mut Vec<TokenTree>) {
         for i in 0..SAMPLE_PARAM_COUNT {
@@ -674,7 +676,8 @@ impl SampleImplRewriter {
 
 impl VisitMut for SampleImplRewriter {
     fn visit_impl_item_fn_mut(&mut self, item: &mut ImplItemFn) {
-        // rewrite the last parameter of this method to be of type `SampleParams<...>` we generated earlier
+        // rewrite the last parameter of this method to be of type `SampleParams<...>` we generated
+        // earlier
         if let Some(syn::FnArg::Typed(p)) = item.sig.inputs.last_mut() {
             *p.ty.as_mut() = self.1.clone();
         }

crates/spirv-std/src/arch.rs

@@ -136,7 +136,7 @@ pub unsafe fn vector_insert_dynamic<T: Scalar, V: Vector<T, N>, const N: usize>(
     }
 }
 
-/// Fragment-shader discard. Equivalvent to `discard()` from GLSL
+/// Fragment-shader discard. Equivalent to `discard()` from GLSL
 ///
 /// Ceases all further processing in any invocation that executes it: Only
 /// instructions these invocations executed before [kill] have observable side
@@ -213,27 +213,39 @@ unsafe fn call_glsl_op_with_ints<T: Integer, const OP: u32>(a: T, b: T) -> T {
 }
 
 /// Compute the minimum of two unsigned integers via a GLSL extended instruction.
+/// <https://registry.khronos.org/SPIR-V/specs/1.0/GLSL.std.450.html>
 #[spirv_std_macros::gpu_only]
 pub fn unsigned_min<T: UnsignedInteger>(a: T, b: T) -> T {
-    unsafe { call_glsl_op_with_ints::<_, 38>(a, b) }
+    unsafe {
+        call_glsl_op_with_ints::<_, /* UMin */ 38>(a, b)
+    }
 }
 
 /// Compute the maximum of two unsigned integers via a GLSL extended instruction.
+/// <https://registry.khronos.org/SPIR-V/specs/1.0/GLSL.std.450.html>
 #[spirv_std_macros::gpu_only]
 pub fn unsigned_max<T: UnsignedInteger>(a: T, b: T) -> T {
-    unsafe { call_glsl_op_with_ints::<_, 41>(a, b) }
+    unsafe {
+        call_glsl_op_with_ints::<_, /* UMax */ 41>(a, b)
+    }
 }
 
 /// Compute the minimum of two signed integers via a GLSL extended instruction.
+/// <https://registry.khronos.org/SPIR-V/specs/1.0/GLSL.std.450.html>
 #[spirv_std_macros::gpu_only]
 pub fn signed_min<T: SignedInteger>(a: T, b: T) -> T {
-    unsafe { call_glsl_op_with_ints::<_, 39>(a, b) }
+    unsafe {
+        call_glsl_op_with_ints::<_, /* SMin */ 39>(a, b)
+    }
 }
 
 /// Compute the maximum of two signed integers via a GLSL extended instruction.
+/// <https://registry.khronos.org/SPIR-V/specs/1.0/GLSL.std.450.html>
 #[spirv_std_macros::gpu_only]
 pub fn signed_max<T: SignedInteger>(a: T, b: T) -> T {
-    unsafe { call_glsl_op_with_ints::<_, 42>(a, b) }
+    unsafe {
+        call_glsl_op_with_ints::<_, /* SMax */ 42>(a, b)
+    }
 }
 
 /// Index into an array without bounds checking.
@@ -244,12 +256,16 @@ pub trait IndexUnchecked<T> {
     /// Returns a reference to the element at `index`. The equivalent of `get_unchecked`.
     ///
     /// # Safety
-    /// Behavior is undefined if the `index` value is greater than or equal to the length of the array.
+    /// Behavior is undefined if the `index` value is greater than or equal to the length of the
+    /// array.
     unsafe fn index_unchecked(&self, index: usize) -> &T;
-    /// Returns a mutable reference to the element at `index`. The equivalent of `get_unchecked_mut`.
+
+    /// Returns a mutable reference to the element at `index`. The equivalent of
+    /// `get_unchecked_mut`.
     ///
     /// # Safety
-    /// Behavior is undefined if the `index` value is greater than or equal to the length of the array.
+    /// Behavior is undefined if the `index` value is greater than or equal to the length of the
+    /// array.
     unsafe fn index_unchecked_mut(&mut self, index: usize) -> &mut T;
 }
 

crates/spirv-std/src/arch/barrier.rs

@@ -14,7 +14,7 @@ use core::arch::asm;
 /// client API.
 ///
 /// If [`crate::memory::Semantics`] is not [`crate::memory::Semantics::NONE`],
-/// this instruction also serves as an [`memory_barrier`] function call, and
+/// this instruction also serves as a [`memory_barrier`] function call, and
 /// also performs and adheres to the description and semantics of an
 /// [`memory_barrier`] function with the same `MEMORY` and `SEMANTICS` operands.
 /// This allows atomically specifying both a control barrier and a memory
@@ -103,11 +103,13 @@ pub fn workgroup_memory_barrier() {
     >();
 }
 
-/// Blocks execution of all threads in a group until all group shared accesses have been completed and all threads in the group have reached this call.
+/// Blocks execution of all threads in a group until all group shared accesses have been completed
+/// and all threads in the group have reached this call.
 ///
 /// This is an exact implementation of `GroupMemoryBarrierWithGroupSync()`.
 ///
-/// From <https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/groupmemorybarrierwithgroupsync>
+/// From
+/// <https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/groupmemorybarrierwithgroupsync>
 #[spirv_std_macros::gpu_only]
 #[inline]
 pub fn workgroup_memory_barrier_with_group_sync() {

crates/spirv-std/src/arch/demote_to_helper_invocation_ext.rs

@@ -1,7 +1,7 @@
 #[cfg(target_arch = "spirv")]
 use core::arch::asm;
 
-/// Demote fragment shader invocation to a helper invocation. Equivalvent to
+/// Demote fragment shader invocation to a helper invocation. Equivalent to
 /// `discard()` in HLSL. Any stores to memory after this instruction are
 /// suppressed and the fragment does not write outputs to the framebuffer.
 ///

crates/spirv-std/src/arch/derivative.rs

@@ -21,14 +21,16 @@ macro_rules! deriv_fn {
 /// Types that can be derived by partial derivatives
 ///
 /// # Safety
-/// Result Type must be a scalar or vector of floating-point type using the IEEE 754 encoding. The component width must be 32 bits.
+/// Result Type must be a scalar or vector of floating-point type using the IEEE 754 encoding. The
+/// component width must be 32 bits.
 pub unsafe trait Derivative: Sealed + Default {
-    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses local differencing
-    /// based on the value of `Self`. Same result as either [`Self::dfdx_fine`] or [`Self::dfdx_coarse`] on `Self`. Selection of which
-    /// one is based on external factors.
+    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses
+    /// local differencing based on the value of `Self`. Same result as either [`Self::dfdx_fine`]
+    /// or [`Self::dfdx_coarse`] on `Self`. Selection of which one is based on external factors.
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -37,11 +39,13 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdx, self)
     }
 
-    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses local differencing
-    /// based on the value of `Self` for the current fragment and its immediate neighbor(s).
+    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses
+    /// local differencing based on the value of `Self` for the current fragment and its immediate
+    /// neighbor(s).
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -50,13 +54,15 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdxFine, self)
     }
 
-    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses local differencing
-    /// based on the value of `Self` for the current fragment’s neighbors, and possibly, but not necessarily, includes
-    /// the value of `Self` for the current fragment. That is, over a given area, the implementation can compute x
-    /// derivatives in fewer unique locations than would be allowed for [`Self::dfdx_fine`].
+    /// Result is the partial derivative of `Self` with respect to the window x coordinate. Uses
+    /// local differencing based on the value of `Self` for the current fragment’s neighbors, and
+    /// possibly, but not necessarily, includes the value of `Self` for the current fragment. That
+    /// is, over a given area, the implementation can compute x derivatives in fewer unique
+    /// locations than would be allowed for [`Self::dfdx_fine`].
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -65,12 +71,13 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdxCoarse, self)
     }
 
-    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses local differencing
-    /// based on the value of `Self`. Same result as either [`Self::dfdy_fine`] or [`Self::dfdy_coarse`] on `Self`. Selection of which
-    /// one is based on external factors.
+    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses
+    /// local differencing based on the value of `Self`. Same result as either [`Self::dfdy_fine`]
+    /// or [`Self::dfdy_coarse`] on `Self`. Selection of which one is based on external factors.
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -79,11 +86,13 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdy, self)
     }
 
-    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses local differencing
-    /// based on the value of `Self` for the current fragment and its immediate neighbor(s).
+    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses
+    /// local differencing based on the value of `Self` for the current fragment and its immediate
+    /// neighbor(s).
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -92,13 +101,15 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdyFine, self)
     }
 
-    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses local differencing
-    /// based on the value of `Self` for the current fragment’s neighbors, and possibly, but not necessarily, includes
-    /// the value of `Self` for the current fragment. That is, over a given area, the implementation can compute y
-    /// derivatives in fewer unique locations than would be allowed for [`Self::dfdy_fine`].
+    /// Result is the partial derivative of `Self` with respect to the window y coordinate. Uses
+    /// local differencing based on the value of `Self` for the current fragment’s neighbors, and
+    /// possibly, but not necessarily, includes the value of `Self` for the current fragment. That
+    /// is, over a given area, the implementation can compute y derivatives in fewer unique
+    /// locations than would be allowed for [`Self::dfdy_fine`].
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -107,10 +118,12 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpDPdyCoarse, self)
     }
 
-    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx`] and [`Self::dfdy`] on P.
+    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx`] and
+    /// [`Self::dfdy`] on P.
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -119,10 +132,12 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpFwidth, self)
     }
 
-    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx_fine`] and [`Self::dfdy_fine`] on P.
+    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx_fine`] and
+    /// [`Self::dfdy_fine`] on P.
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]
@@ -131,10 +146,12 @@ pub unsafe trait Derivative: Sealed + Default {
         deriv_fn!(OpFwidthFine, self)
     }
 
-    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx_coarse`] and [`Self::dfdy_coarse`] on P.
+    /// Result is the same as computing the sum of the absolute values of [`Self::dfdx_coarse`] and
+    /// [`Self::dfdy_coarse`] on P.
     ///
-    /// An invocation will not execute a dynamic instance of this instruction (X') until all invocations in its
-    /// derivative group have executed all dynamic instances that are program-ordered before X'.
+    /// An invocation will not execute a dynamic instance of this instruction (X') until all
+    /// invocations in its derivative group have executed all dynamic instances that are
+    /// program-ordered before X'.
     ///
     /// This instruction is only valid in the Fragment Execution Model.
     #[crate::macros::gpu_only]