Require new F16_IN_F32 capability for pack/unpack/quantize f16

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
capability that decides whether these functions are available.

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

Author: andyleiserson

naga/src/front/wgsl/mod.rs

@@ -11,6 +11,8 @@ mod parse;
 #[cfg(test)]
 mod tests;
 
+pub use parse::directive::enable_extension::{EnableExtension, ImplementedEnableExtension};
+
 pub use crate::front::wgsl::error::ParseError;
 pub use crate::front::wgsl::parse::directive::language_extension::{
     ImplementedLanguageExtension, LanguageExtension, UnimplementedLanguageExtension,

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,23 @@ 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 `ImplementedEnableExtension` corresponding to this capability, if there is one.
+    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),
+            Self::SHADER_FLOAT16 => Some(Ext::F16),
+            // SHADER_FLOAT16_IN_FLOAT32 _does not_ require the `f16` extension
+            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 # TODO: replace with finer `F16_IN_F32` capability

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,5 +1,9 @@
+//! Tests of the module validator.
+//!
+//! There are also some validation tests in `wgsl_errors`.
+
 #![allow(
-    // We need to investiagate these.
+    // We need to investigate these.
     clippy::result_large_err
 )]