Add F16_IN_F32 downlevel flag for pack/unpack/quantize f16 (#8130)

Although the operation of these functions is defined in terms of f16
semantics, the input/output types are not f16, and they are generally
available even when native `f16` support is not. But in at least one
case, they are only available with `f16` support, so add a new downlevel
flag that is cleared when these functions are not available.

Add some infrastructure to simplify testing of missing
capabilities/extensions, and add tests for a few more kinds of f16
usage.

Co-authored-by: Erich Gubler <[email protected]>

Author: andyleiserson

CHANGELOG.md

@@ -110,6 +110,7 @@ By @cwfitzgerald in [#8162](https://github.com/gfx-rs/wgpu/pull/8162).
   By @kpreid in [#8011](https://github.com/gfx-rs/wgpu/pull/8011).
 - Make a compacted hal acceleration structure inherit a label from the base BLAS. By @Vecvec in [#8103](https://github.com/gfx-rs/wgpu/pull/8103).
 - The limits requested for a device must now satisfy `min_subgroup_size <= max_subgroup_size`. By @andyleiserson in [#8085](https://github.com/gfx-rs/wgpu/pull/8085).
+- Require new `F16_IN_F32` downlevel flag for `quantizeToF16`, `pack2x16float`, and `unpack2x16float` in WGSL input. By @aleiserson in [#8130](https://github.com/gfx-rs/wgpu/pull/8130).
 
 #### naga
 

naga/src/valid/expression.rs

@@ -1060,6 +1060,20 @@ impl super::Validator {
                 arg2,
                 arg3,
             } => {
+                if matches!(
+                    fun,
+                    crate::MathFunction::QuantizeToF16
+                        | crate::MathFunction::Pack2x16float
+                        | crate::MathFunction::Unpack2x16float
+                ) && !self
+                    .capabilities
+                    .contains(crate::valid::Capabilities::SHADER_FLOAT16_IN_FLOAT32)
+                {
+                    return Err(ExpressionError::MissingCapabilities(
+                        crate::valid::Capabilities::SHADER_FLOAT16_IN_FLOAT32,
+                    ));
+                }
+
                 let actuals: &[_] = match (arg1, arg2, arg3) {
                     (None, None, None) => &[arg],
                     (Some(arg1), None, None) => &[arg, arg1],

naga/src/valid/mod.rs

@@ -170,6 +170,27 @@ bitflags::bitflags! {
         const SHADER_FLOAT16 = 1 << 26;
         /// Support for [`ImageClass::External`]
         const TEXTURE_EXTERNAL = 1 << 27;
+        /// Support for `quantizeToF16`, `pack2x16float`, and `unpack2x16float`, which store
+        /// `f16`-precision values in `f32`s.
+        const SHADER_FLOAT16_IN_FLOAT32 = 1 << 28;
+    }
+}
+
+impl Capabilities {
+    /// Returns the extension corresponding to this capability, if there is one.
+    ///
+    /// This is used by integration tests.
+    #[cfg(feature = "wgsl-in")]
+    #[doc(hidden)]
+    pub const fn extension(&self) -> Option<crate::front::wgsl::ImplementedEnableExtension> {
+        use crate::front::wgsl::ImplementedEnableExtension as Ext;
+        match *self {
+            Self::DUAL_SOURCE_BLENDING => Some(Ext::DualSourceBlending),
+            // NOTE: `SHADER_FLOAT16_IN_FLOAT32` _does not_ require the `f16` extension
+            Self::SHADER_FLOAT16 => Some(Ext::F16),
+            Self::CLIP_DISTANCE => Some(Ext::ClipDistances),
+            _ => None,
+        }
     }
 }
 

naga/tests/in/glsl/bits_glsl.frag renamed to naga/tests/in/glsl/bits.frag

@@ -0,0 +1 @@
+god_mode = true # requires F16_IN_F32

naga/tests/in/glsl/bits.toml

@@ -1,3 +1,4 @@
+god_mode = true   # requires F16_IN_F32
 targets = "METAL"
 
 [msl]

naga/tests/in/wgsl/bits-optimized-msl.toml

@@ -1,3 +1,5 @@
+god_mode = true # requires F16_IN_F32
+
 [msl]
 fake_missing_bindings = false
 lang_version = [1, 2]

naga/tests/in/wgsl/bits.toml

@@ -0,0 +1 @@
+god_mode = true # requires F16_IN_F32

naga/tests/in/wgsl/math-functions.toml

@@ -1,3 +1,7 @@
+//! Tests of the module validator.
+//!
+//! There are also some validation tests in [`wgsl_errors`](super::wgsl_errors).
+
 #![allow(
     // We need to investigate these.
     clippy::result_large_err