refactor(naga): rename MathFunction::FindLsb to FirstTrailingBit

Author: ErichDonGubler

naga/src/back/glsl/mod.rs

@@ -3574,7 +3574,7 @@ impl<'a, W: Write> Writer<'a, W> {
 
                         return Ok(());
                     }
-                    Mf::FindLsb => "findLSB",
+                    Mf::FirstTrailingBit => "findLSB",
                     Mf::FirstLeadingBit => "findMSB",
                     // data packing
                     Mf::Pack4x8snorm => "packSnorm4x8",
@@ -3597,7 +3597,7 @@ impl<'a, W: Write> Writer<'a, W> {
                 // so they need to be cast to uint if the argument is also an uint.
                 let ret_might_need_int_to_uint = matches!(
                     fun,
-                    Mf::FindLsb | Mf::FirstLeadingBit | Mf::CountOneBits | Mf::Abs
+                    Mf::FirstTrailingBit | Mf::FirstLeadingBit | Mf::CountOneBits | Mf::Abs
                 );
 
                 // Some GLSL functions only accept signed integers (like abs),

naga/src/back/hlsl/writer.rs

@@ -2907,7 +2907,7 @@ impl<'a, W: fmt::Write> super::Writer<'a, W> {
                     Mf::CountLeadingZeros => Function::CountLeadingZeros,
                     Mf::CountOneBits => Function::MissingIntOverload("countbits"),
                     Mf::ReverseBits => Function::MissingIntOverload("reversebits"),
-                    Mf::FindLsb => Function::MissingIntReturnType("firstbitlow"),
+                    Mf::FirstTrailingBit => Function::MissingIntReturnType("firstbitlow"),
                     Mf::FirstLeadingBit => Function::MissingIntReturnType("firstbithigh"),
                     Mf::ExtractBits => Function::Regular(EXTRACT_BITS_FUNCTION),
                     Mf::InsertBits => Function::Regular(INSERT_BITS_FUNCTION),

naga/src/back/msl/writer.rs

@@ -1820,7 +1820,7 @@ impl<W: Write> Writer<W> {
                     Mf::ReverseBits => "reverse_bits",
                     Mf::ExtractBits => "",
                     Mf::InsertBits => "",
-                    Mf::FindLsb => "",
+                    Mf::FirstTrailingBit => "",
                     Mf::FirstLeadingBit => "",
                     // data packing
                     Mf::Pack4x8snorm => "pack_float_to_snorm4x8",
@@ -1859,7 +1859,7 @@ impl<W: Write> Writer<W> {
                     write!(self.out, " - ")?;
                     self.put_expression(arg1.unwrap(), context, false)?;
                     write!(self.out, ")")?;
-                } else if fun == Mf::FindLsb {
+                } else if fun == Mf::FirstTrailingBit {
                     let scalar = context.resolve_type(arg).scalar().unwrap();
                     let constant = scalar.width * 8 + 1;
 

naga/src/back/spv/block.rs

@@ -1183,7 +1183,7 @@ impl<'w> BlockContext<'w> {
                             count_id,
                         ))
                     }
-                    Mf::FindLsb => MathOp::Ext(spirv::GLOp::FindILsb),
+                    Mf::FirstTrailingBit => MathOp::Ext(spirv::GLOp::FindILsb),
                     Mf::FirstLeadingBit => {
                         if arg_ty.scalar_width() == Some(4) {
                             let thing = match arg_scalar_kind {

naga/src/back/wgsl/writer.rs

@@ -1708,7 +1708,7 @@ impl<W: Write> Writer<W> {
                     Mf::ReverseBits => Function::Regular("reverseBits"),
                     Mf::ExtractBits => Function::Regular("extractBits"),
                     Mf::InsertBits => Function::Regular("insertBits"),
-                    Mf::FindLsb => Function::Regular("firstTrailingBit"),
+                    Mf::FirstTrailingBit => Function::Regular("firstTrailingBit"),
                     Mf::FirstLeadingBit => Function::Regular("firstLeadingBit"),
                     // data packing
                     Mf::Pack4x8snorm => Function::Regular("pack4x8snorm"),

naga/src/front/glsl/builtins.rs

@@ -646,7 +646,7 @@ fn inject_standard_builtins(
                 "bitfieldReverse" => MathFunction::ReverseBits,
                 "bitfieldExtract" => MathFunction::ExtractBits,
                 "bitfieldInsert" => MathFunction::InsertBits,
-                "findLSB" => MathFunction::FindLsb,
+                "findLSB" => MathFunction::FirstTrailingBit,
                 "findMSB" => MathFunction::FirstLeadingBit,
                 _ => unreachable!(),
             };
@@ -695,7 +695,9 @@ fn inject_standard_builtins(
                 // we need to cast the return type of findLsb / findMsb
                 let mc = if scalar.kind == Sk::Uint {
                     match mc {
-                        MacroCall::MathFunction(MathFunction::FindLsb) => MacroCall::FindLsbUint,
+                        MacroCall::MathFunction(MathFunction::FirstTrailingBit) => {
+                            MacroCall::FindLsbUint
+                        }
                         MacroCall::MathFunction(MathFunction::FirstLeadingBit) => {
                             MacroCall::FindMsbUint
                         }
@@ -1789,7 +1791,7 @@ impl MacroCall {
             )?,
             mc @ (MacroCall::FindLsbUint | MacroCall::FindMsbUint) => {
                 let fun = match mc {
-                    MacroCall::FindLsbUint => MathFunction::FindLsb,
+                    MacroCall::FindLsbUint => MathFunction::FirstTrailingBit,
                     MacroCall::FindMsbUint => MathFunction::FirstLeadingBit,
                     _ => unreachable!(),
                 };

naga/src/front/spv/mod.rs

@@ -2985,7 +2985,7 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
                         Glo::UnpackHalf2x16 => Mf::Unpack2x16float,
                         Glo::UnpackUnorm2x16 => Mf::Unpack2x16unorm,
                         Glo::UnpackSnorm2x16 => Mf::Unpack2x16snorm,
-                        Glo::FindILsb => Mf::FindLsb,
+                        Glo::FindILsb => Mf::FirstTrailingBit,
                         Glo::FindUMsb | Glo::FindSMsb => Mf::FirstLeadingBit,
                         // TODO: https://github.com/gfx-rs/naga/issues/2526
                         Glo::Modf | Glo::Frexp => return Err(Error::UnsupportedExtInst(inst_id)),

naga/src/front/wgsl/parse/conv.rs

@@ -235,7 +235,7 @@ pub fn map_standard_fun(word: &str) -> Option<crate::MathFunction> {
         "reverseBits" => Mf::ReverseBits,
         "extractBits" => Mf::ExtractBits,
         "insertBits" => Mf::InsertBits,
-        "firstTrailingBit" => Mf::FindLsb,
+        "firstTrailingBit" => Mf::FirstTrailingBit,
         "firstLeadingBit" => Mf::FirstLeadingBit,
         // data packing
         "pack4x8snorm" => Mf::Pack4x8snorm,

naga/src/lib.rs

@@ -1211,7 +1211,7 @@ pub enum MathFunction {
     ReverseBits,
     ExtractBits,
     InsertBits,
-    FindLsb,
+    FirstTrailingBit,
     FirstLeadingBit,
     // data packing
     Pack4x8snorm,

naga/src/proc/mod.rs

@@ -509,7 +509,7 @@ impl super::MathFunction {
             Self::ReverseBits => 1,
             Self::ExtractBits => 3,
             Self::InsertBits => 4,
-            Self::FindLsb => 1,
+            Self::FirstTrailingBit => 1,
             Self::FirstLeadingBit => 1,
             // data packing
             Self::Pack4x8snorm => 1,

naga/src/proc/typifier.rs

@@ -788,7 +788,7 @@ impl<'a> ResolveContext<'a> {
                     Mf::ReverseBits |
                     Mf::ExtractBits |
                     Mf::InsertBits |
-                    Mf::FindLsb |
+                    Mf::FirstTrailingBit |
                     Mf::FirstLeadingBit => match *res_arg.inner_with(types)  {
                         Ti::Scalar(scalar @ crate::Scalar {
                             kind: crate::ScalarKind::Sint | crate::ScalarKind::Uint,

naga/src/valid/expression.rs

@@ -1358,7 +1358,7 @@ impl super::Validator {
                     | Mf::CountOneBits
                     | Mf::ReverseBits
                     | Mf::FirstLeadingBit
-                    | Mf::FindLsb => {
+                    | Mf::FirstTrailingBit => {
                         if arg1_ty.is_some() || arg2_ty.is_some() || arg3_ty.is_some() {
                             return Err(ExpressionError::WrongArgumentCount(fun));
                         }