fix(core): Fix validation of shader I/O numeric types

- Inter-stage types must match exactly
- Fragment outputs only require that scalar kind matches. Scalar width
  may differ in either direction.

Author: andyleiserson

CHANGELOG.md

@@ -93,6 +93,8 @@ Bottom level categories:
 
 - Validate that the arguments are within the indirect buffer when encoding an indirect draw to a render bundle. Moves some indirect draw errors from `RenderPassErrorInner` to `RenderCommandError`. By @andyleiserson in [#9871](https://github.com/gfx-rs/wgpu/pull/9871).
 - When creating render pipelines, validate that a corresponding shader output is present for each color attachment with non-zero write mask, and that shader output includes alpha when the blend operation uses source alpha. By @andyleiserson in [#9939](https://github.com/gfx-rs/wgpu/pull/9939).
+- Numeric types must now match exactly on inter-stage interfaces. Previously, the receiving type was only required to be a subtype of the originating type. By @andyleiserson in TBD.
+- Relaxed requirement that the pipeline scalar type for a color output be at least as wide as the shader output type. Now, only the scalar kind must match. By @andyleiserson in TBD.
 
 #### Naga
 

cts_runner/test.lst

@@ -277,6 +277,7 @@ webgpu:api,validation,render_pipeline,fragment_state:targets_write_mask:*
 webgpu:api,validation,render_pipeline,inter_stage:location,*
 webgpu:api,validation,render_pipeline,inter_stage:max_shader_variable_location:*
 fails-if(dx12) webgpu:api,validation,render_pipeline,inter_stage:max_variables_count,*
+webgpu:api,validation,render_pipeline,inter_stage:type:*
 webgpu:api,validation,render_pipeline,misc:basic:*
 fails-if(vulkan) webgpu:api,validation,render_pipeline,misc:external_texture:*
 webgpu:api,validation,render_pipeline,misc:no_attachment:*

tests/tests/wgpu-validation/api/render_pipeline.rs

@@ -1,6 +1,6 @@
 //! Tests of [`wgpu::RenderPipeline`] and related.
 
-use wgpu_test::fail;
+use wgpu_test::{fail, valid};
 
 #[test]
 fn reject_fragment_shader_output_over_max_color_attachments() {
@@ -68,3 +68,69 @@ fn frag() -> @location({}) vec4f {{
         )),
     );
 }
+
+/// A fragment shader may output an `f16` value to a color target whose sample
+/// type is `float`, even when the format's components are 32-bit. The WebGPU
+/// spec only requires the output's scalar *kind* (floating-point) to match the
+/// format's sample type, not its bit width.
+#[test]
+fn accept_f16_fragment_output_to_f32_target() {
+    let (device, _queue) = wgpu::Device::noop(&wgpu::DeviceDescriptor {
+        required_features: wgpu::Features::SHADER_F16,
+        ..Default::default()
+    });
+
+    // NOTE: Vertex shader is a boring quad. The fragment shader is the interesting part.
+    let source = "\
+enable f16;
+
+@vertex
+fn vert(@builtin(vertex_index) vertex_index : u32) -> @builtin(position) vec4f {
+    var pos = array<vec2f, 3>(
+        vec2(0.0, 0.5),
+        vec2(-0.5, -0.5),
+        vec2(0.5, -0.5)
+    );
+    return vec4f(pos[vertex_index], 0.0, 1.0);
+}
+
+@fragment
+fn frag() -> @location(0) vec4h {
+    return vec4h(1.0h, 0.0h, 0.0h, 1.0h);
+}
+";
+
+    let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {
+        label: None,
+        source: wgpu::ShaderSource::Wgsl(source.into()),
+    });
+    let module = &module;
+
+    valid(&device, || {
+        device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
+            layout: None,
+            label: None,
+            vertex: wgpu::VertexState {
+                module,
+                entry_point: None,
+                compilation_options: Default::default(),
+                buffers: &[],
+            },
+            fragment: Some(wgpu::FragmentState {
+                module,
+                entry_point: None,
+                compilation_options: Default::default(),
+                targets: &[Some(wgpu::ColorTargetState {
+                    format: wgpu::TextureFormat::Rgba8Unorm,
+                    blend: None,
+                    write_mask: Default::default(),
+                })],
+            }),
+            primitive: Default::default(),
+            depth_stencil: None,
+            multisample: Default::default(),
+            multiview_mask: None,
+            cache: None,
+        })
+    });
+}

wgpu-core/src/validation.rs

@@ -1029,14 +1029,11 @@ impl NumericType {
         }
     }
 
-    fn is_subtype_of(self, other: NumericType) -> bool {
-        if self.scalar.width > other.scalar.width {
+    fn compatible_with_shader_output(self, shader: NumericType) -> bool {
+        if self.scalar.kind != shader.scalar.kind {
             return false;
         }
-        if self.scalar.kind != other.scalar.kind {
-            return false;
-        }
-        match (self.dim, other.dim) {
+        match (self.dim, shader.dim) {
             (NumericDimension::Scalar, NumericDimension::Scalar) => true,
             (NumericDimension::Scalar, NumericDimension::Vector(_)) => true,
             (NumericDimension::Vector(s0), NumericDimension::Vector(s1)) => s0 <= s1,
@@ -1054,7 +1051,7 @@ pub fn check_color_attachment_compatibility(
     output_ty: NumericType,
 ) -> Result<(), ColorStateError> {
     let pipeline_ty = NumericType::from_texture_format(state.format);
-    if !pipeline_ty.is_subtype_of(output_ty) {
+    if !pipeline_ty.compatible_with_shader_output(output_ty) {
         return Err(ColorStateError::IncompatibleFormat {
             pipeline: pipeline_ty,
             shader: output_ty,
@@ -1647,7 +1644,7 @@ impl Interface {
                                         ));
                                     }
                                     (
-                                        iv.ty.is_subtype_of(provided.ty),
+                                        iv.ty == provided.ty,
                                         iv.per_primitive == provided.per_primitive,
                                     )
                                 }