SYNC POINT: resolve merge conflicts

ErichDonGubler · ErichDonGubler · commit bbed2c01a468 · 2026-03-19T14:37:29.000-06:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -42,6 +42,18 @@ Bottom level categories:
 
 ## Unreleased
 
+### Added/New Features
+
+#### Metal
+
+- Unconditionally enable `Features::CLIP_DISTANCES`. By @ErichDonGubler in [#????](https://github.com/gfx-rs/wgpu/pull/????).
+
+### Changes
+
+#### General
+
+- `Features::CLIP_DISTANCE` and `naga::Capabilities::CLIP_DISTANCE` have been renamed to `CLIP_DISTANCES` (N.B. the `S`), to match the WebGPU spec. By @ErichDonGubler in [#????](https://github.com/gfx-rs/wgpu/pull/????).
+
 ### Bug Fixes
 
 #### General
diff --git a/naga/src/back/glsl/conv.rs b/naga/src/back/glsl/conv.rs
@@ -76,7 +76,7 @@ pub(in crate::back::glsl) const fn glsl_built_in(
         // vertex
         Bi::BaseInstance => "uint(gl_BaseInstance)",
         Bi::BaseVertex => "uint(gl_BaseVertex)",
-        Bi::ClipDistance => "gl_ClipDistance",
+        Bi::ClipDistances => "gl_ClipDistance",
         Bi::CullDistance => "gl_CullDistance",
         Bi::InstanceIndex => {
             if options.draw_parameters {
diff --git a/naga/src/back/glsl/features.rs b/naga/src/back/glsl/features.rs
@@ -618,7 +618,7 @@ impl<W> Writer<'_, W> {
         } else if let Some(binding) = binding {
             match *binding {
                 Binding::BuiltIn(built_in) => match built_in {
-                    crate::BuiltIn::ClipDistance => self.features.request(Features::CLIP_DISTANCE),
+                    crate::BuiltIn::ClipDistances => self.features.request(Features::CLIP_DISTANCE),
                     crate::BuiltIn::CullDistance => self.features.request(Features::CULL_DISTANCE),
                     crate::BuiltIn::SampleIndex => {
                         self.features.request(Features::SAMPLE_VARIABLES)
diff --git a/naga/src/back/glsl/mod.rs b/naga/src/back/glsl/mod.rs
@@ -626,7 +626,7 @@ pub fn supported_capabilities() -> valid::Capabilities {
     Caps::IMMEDIATES
         | Caps::FLOAT64
         | Caps::PRIMITIVE_INDEX
-        | Caps::CLIP_DISTANCE
+        | Caps::CLIP_DISTANCES
         | Caps::MULTIVIEW
         | Caps::EARLY_DEPTH_TEST
         | Caps::MULTISAMPLED_SHADING
diff --git a/naga/src/back/glsl/writer.rs b/naga/src/back/glsl/writer.rs
@@ -1084,7 +1084,7 @@ impl<'a, W: Write> Writer<'a, W> {
                             }
                         }
                     }
-                    crate::BuiltIn::ClipDistance => {
+                    crate::BuiltIn::ClipDistances => {
                         // Re-declare `gl_ClipDistance` with number of clip planes.
                         let TypeInner::Array { size, .. } = self.module.types[ty].inner else {
                             unreachable!();
diff --git a/naga/src/back/hlsl/conv.rs b/naga/src/back/hlsl/conv.rs
@@ -153,7 +153,7 @@ impl crate::BuiltIn {
         Ok(match self {
             Self::Position { .. } => "SV_Position",
             // vertex
-            Self::ClipDistance => "SV_ClipDistance",
+            Self::ClipDistances => "SV_ClipDistance",
             Self::CullDistance => "SV_CullDistance",
             Self::InstanceIndex => "SV_InstanceID",
             Self::VertexIndex => "SV_VertexID",
diff --git a/naga/src/back/hlsl/mod.rs b/naga/src/back/hlsl/mod.rs
@@ -771,7 +771,7 @@ pub fn supported_capabilities() -> crate::valid::Capabilities {
         | Caps::STORAGE_TEXTURE_BINDING_ARRAY
         // No STORAGE_BUFFER_BINDING_ARRAY
         | Caps::ACCELERATION_STRUCTURE_BINDING_ARRAY
-        // No CLIP_DISTANCE
+        // No CLIP_DISTANCES
         // No CULL_DISTANCE
         | Caps::STORAGE_TEXTURE_16BIT_NORM_FORMATS
         | Caps::MULTIVIEW
diff --git a/naga/src/back/msl/mod.rs b/naga/src/back/msl/mod.rs
@@ -686,7 +686,7 @@ impl ResolvedBinding {
                     // vertex
                     Bi::BaseInstance => "base_instance",
                     Bi::BaseVertex => "base_vertex",
-                    Bi::ClipDistance => "clip_distance",
+                    Bi::ClipDistances => "clip_distance",
                     Bi::InstanceIndex => "instance_id",
                     Bi::PointSize => "point_size",
                     Bi::VertexIndex => "vertex_id",
@@ -841,7 +841,7 @@ pub fn supported_capabilities() -> crate::valid::Capabilities {
         // No BUFFER_BINDING_ARRAY
         | Caps::STORAGE_TEXTURE_BINDING_ARRAY
         | Caps::STORAGE_BUFFER_BINDING_ARRAY
-        | Caps::CLIP_DISTANCE // CLIP_DISTANCE isn't supported by metal backend? But is supported by MSL writer
+        | Caps::CLIP_DISTANCES
         // No CULL_DISTANCE
         | Caps::STORAGE_TEXTURE_16BIT_NORM_FORMATS
         | Caps::MULTIVIEW
diff --git a/naga/src/back/msl/writer.rs b/naga/src/back/msl/writer.rs
@@ -7190,10 +7190,19 @@ template <typename A>
                         };
                         let resolved = options.resolve_local_binding(binding, out_mode)?;
                         write!(self.out, "{}{} {}", back::INDENT, ty_name, name)?;
+                        let binding_attr_comes_before_array = matches!(
+                            resolved,
+                            super::ResolvedBinding::BuiltIn(crate::BuiltIn::ClipDistances)
+                        );
+                        if binding_attr_comes_before_array {
+                            resolved.try_fmt(&mut self.out)?;
+                        }
                         if let Some(array_len) = array_len {
                             write!(self.out, " [{array_len}]")?;
                         }
-                        resolved.try_fmt(&mut self.out)?;
+                        if !binding_attr_comes_before_array {
+                            resolved.try_fmt(&mut self.out)?;
+                        }
                         writeln!(self.out, ";")?;
                     }
 
diff --git a/naga/src/back/spv/mod.rs b/naga/src/back/spv/mod.rs
@@ -1158,7 +1158,7 @@ pub fn supported_capabilities() -> crate::valid::Capabilities {
         | Caps::STORAGE_TEXTURE_BINDING_ARRAY
         | Caps::STORAGE_BUFFER_BINDING_ARRAY
         | Caps::ACCELERATION_STRUCTURE_BINDING_ARRAY
-        | Caps::CLIP_DISTANCE
+        | Caps::CLIP_DISTANCES
         // No cull distance
         | Caps::STORAGE_TEXTURE_16BIT_NORM_FORMATS
         | Caps::MULTIVIEW
diff --git a/naga/src/back/spv/writer.rs b/naga/src/back/spv/writer.rs
@@ -3071,9 +3071,9 @@ impl Writer {
                     // vertex
                     Bi::BaseInstance => BuiltIn::BaseInstance,
                     Bi::BaseVertex => BuiltIn::BaseVertex,
-                    Bi::ClipDistance => {
+                    Bi::ClipDistances => {
                         self.require_any(
-                            "`clip_distance` built-in",
+                            "`clip_distances` built-in",
                             &[spirv::Capability::ClipDistance],
                         )?;
                         BuiltIn::ClipDistance
diff --git a/naga/src/back/wgsl/writer.rs b/naga/src/back/wgsl/writer.rs
@@ -309,7 +309,7 @@ impl<W: Write> Writer<W> {
             } => {
                 needed.dual_source_blending = true;
             }
-            crate::Binding::BuiltIn(crate::BuiltIn::ClipDistance) => {
+            crate::Binding::BuiltIn(crate::BuiltIn::ClipDistances) => {
                 needed.clip_distances = true;
             }
             crate::Binding::BuiltIn(crate::BuiltIn::PrimitiveIndex) => {
diff --git a/naga/src/common/wgsl/to_wgsl.rs b/naga/src/common/wgsl/to_wgsl.rs
@@ -165,7 +165,7 @@ impl TryToWgsl for crate::BuiltIn {
             Bi::ViewIndex => "view_index",
             Bi::InstanceIndex => "instance_index",
             Bi::VertexIndex => "vertex_index",
-            Bi::ClipDistance => "clip_distances",
+            Bi::ClipDistances => "clip_distances",
             Bi::FragDepth => "frag_depth",
             Bi::FrontFacing => "front_facing",
             Bi::PrimitiveIndex => "primitive_index",
diff --git a/naga/src/front/glsl/variables.rs b/naga/src/front/glsl/variables.rs
@@ -189,7 +189,7 @@ impl Frontend {
                         stride: 4,
                     },
                     builtin: match name {
-                        "gl_ClipDistance" => BuiltIn::ClipDistance,
+                        "gl_ClipDistance" => BuiltIn::ClipDistances,
                         "gl_CullDistance" => BuiltIn::CullDistance,
                         _ => unreachable!(),
                     },
diff --git a/naga/src/front/spv/convert.rs b/naga/src/front/spv/convert.rs
@@ -136,7 +136,7 @@ pub(super) fn map_builtin(word: spirv::Word, invariant: bool) -> Result<crate::B
         // vertex
         Some(Bi::BaseInstance) => crate::BuiltIn::BaseInstance,
         Some(Bi::BaseVertex) => crate::BuiltIn::BaseVertex,
-        Some(Bi::ClipDistance) => crate::BuiltIn::ClipDistance,
+        Some(Bi::ClipDistance) => crate::BuiltIn::ClipDistances,
         Some(Bi::CullDistance) => crate::BuiltIn::CullDistance,
         Some(Bi::InstanceIndex) => crate::BuiltIn::InstanceIndex,
         Some(Bi::PointSize) => crate::BuiltIn::PointSize,
diff --git a/naga/src/front/wgsl/parse/conv.rs b/naga/src/front/wgsl/parse/conv.rs
@@ -99,7 +99,7 @@ pub fn map_built_in(
         "vertex_index" => crate::BuiltIn::VertexIndex,
         "instance_index" => crate::BuiltIn::InstanceIndex,
         "view_index" => crate::BuiltIn::ViewIndex,
-        "clip_distances" => crate::BuiltIn::ClipDistance,
+        "clip_distances" => crate::BuiltIn::ClipDistances,
         // fragment
         "front_facing" => crate::BuiltIn::FrontFacing,
         "frag_depth" => crate::BuiltIn::FragDepth,
@@ -148,7 +148,7 @@ pub fn map_built_in(
         _ => return Err(Box::new(Error::UnknownBuiltin(span))),
     };
     match built_in {
-        crate::BuiltIn::ClipDistance => {
+        crate::BuiltIn::ClipDistances => {
             enable_extensions.require(ImplementedEnableExtension::ClipDistances, span)?
         }
         crate::BuiltIn::PrimitiveIndex => {
diff --git a/naga/src/front/wgsl/parse/directive/enable_extension.rs b/naga/src/front/wgsl/parse/directive/enable_extension.rs
@@ -246,7 +246,7 @@ impl ImplementedEnableExtension {
         match self {
             Self::F16 => C::SHADER_FLOAT16,
             Self::DualSourceBlending => C::DUAL_SOURCE_BLENDING,
-            Self::ClipDistances => C::CLIP_DISTANCE,
+            Self::ClipDistances => C::CLIP_DISTANCES,
             Self::WgpuMeshShader => C::MESH_SHADER,
             Self::WgpuRayQuery => C::RAY_QUERY,
             Self::WgpuRayQueryVertexReturn => C::RAY_HIT_VERTEX_POSITION,
diff --git a/naga/src/ir/mod.rs b/naga/src/ir/mod.rs
@@ -416,7 +416,7 @@ pub enum BuiltIn {
     /// Read in vertex shaders
     BaseVertex,
     /// Written in vertex & mesh shaders
-    ClipDistance,
+    ClipDistances,
     /// Written in vertex & mesh shaders
     CullDistance,
     /// Read in vertex, any- and closest-hit shaders
diff --git a/naga/src/valid/interface.rs b/naga/src/valid/interface.rs
@@ -258,7 +258,7 @@ impl VaryingContext<'_> {
                 self.built_ins.insert(canonical);
 
                 let required = match built_in {
-                    Bi::ClipDistance => Capabilities::CLIP_DISTANCE,
+                    Bi::ClipDistances => Capabilities::CLIP_DISTANCES,
                     Bi::CullDistance => Capabilities::CULL_DISTANCE,
                     // Primitive index is allowed w/o any other extensions in any- and closest-hit shaders
                     Bi::PrimitiveIndex if !matches!(ep.stage, St::AnyHit | St::ClosestHit) => {
@@ -304,7 +304,7 @@ impl VaryingContext<'_> {
                             && !self.output,
                         *ty_inner == Ti::Scalar(crate::Scalar::U32),
                     ),
-                    Bi::ClipDistance | Bi::CullDistance => (
+                    Bi::ClipDistances | Bi::CullDistance => (
                         (self.stage == St::Vertex || self.stage == St::Mesh) && self.output,
                         match *ty_inner {
                             Ti::Array { base, size, .. } => {
diff --git a/naga/src/valid/mod.rs b/naga/src/valid/mod.rs
@@ -102,10 +102,10 @@ bitflags::bitflags! {
         const STORAGE_TEXTURE_BINDING_ARRAY = 1 << 5;
         /// Support for binding arrays of storage buffers.
         const STORAGE_BUFFER_BINDING_ARRAY = 1 << 6;
-        /// Support for [`BuiltIn::ClipDistance`].
+        /// Support for [`BuiltIn::ClipDistances`].
         ///
-        /// [`BuiltIn::ClipDistance`]: crate::BuiltIn::ClipDistance
-        const CLIP_DISTANCE = 1 << 7;
+        /// [`BuiltIn::ClipDistances`]: crate::BuiltIn::ClipDistances
+        const CLIP_DISTANCES = 1 << 7;
         /// Support for [`BuiltIn::CullDistance`].
         ///
         /// [`BuiltIn::CullDistance`]: crate::BuiltIn::CullDistance
@@ -229,7 +229,7 @@ impl Capabilities {
             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),
+            Self::CLIP_DISTANCES => Some(Ext::ClipDistances),
             Self::MESH_SHADER => Some(Ext::WgpuMeshShader),
             Self::RAY_QUERY => Some(Ext::WgpuRayQuery),
             Self::RAY_HIT_VERTEX_POSITION => Some(Ext::WgpuRayQueryVertexReturn),
diff --git a/naga/tests/in/wgsl/clip-distances.toml b/naga/tests/in/wgsl/clip-distances.toml
@@ -1,5 +1,5 @@
-capabilities = "CLIP_DISTANCE"
-targets = "SPIRV | GLSL | WGSL"
+capabilities = "CLIP_DISTANCES"
+targets = "SPIRV | GLSL | WGSL | METAL"
 
 [glsl]
 version.Desktop = 330
diff --git a/naga/tests/naga/wgsl_errors.rs b/naga/tests/naga/wgsl_errors.rs
@@ -4310,7 +4310,7 @@ fn subgroup_invalid_broadcast() {
 fn invalid_clip_distances() {
     // Missing capability or enable directive
     check_extension_validation! {
-        Capabilities::CLIP_DISTANCE,
+        Capabilities::CLIP_DISTANCES,
         r#"
             @vertex
             fn vs_main() -> @builtin(clip_distances) array<f32, 8> {
@@ -4330,7 +4330,7 @@ fn invalid_clip_distances() {
         Err(naga::valid::ValidationError::EntryPoint {
             stage: naga::ShaderStage::Vertex,
             source: naga::valid::EntryPointError::Result(
-                naga::valid::VaryingError::UnsupportedCapability(Capabilities::CLIP_DISTANCE)
+                naga::valid::VaryingError::UnsupportedCapability(Capabilities::CLIP_DISTANCES)
             ),
             ..
         })
@@ -4354,11 +4354,11 @@ fn invalid_clip_distances() {
         Err(naga::valid::ValidationError::EntryPoint {
             stage: naga::ShaderStage::Vertex,
             source: naga::valid::EntryPointError::Result(
-                naga::valid::VaryingError::InvalidBuiltInType(naga::ir::BuiltIn::ClipDistance, _)
+                naga::valid::VaryingError::InvalidBuiltInType(naga::ir::BuiltIn::ClipDistances, _)
             ),
             ..
         }),
-        naga::valid::Capabilities::CLIP_DISTANCE
+        naga::valid::Capabilities::CLIP_DISTANCES
     }
 }
 
diff --git a/naga/tests/out/msl/wgsl-clip-distances.metal b/naga/tests/out/msl/wgsl-clip-distances.metal
@@ -0,0 +1,27 @@
+// language: metal1.0
+#include <metal_stdlib>
+#include <simd/simd.h>
+
+using metal::uint;
+
+struct type_2 {
+    float inner[1];
+};
+struct VertexOutput {
+    metal::float4 position;
+    type_2 clip_distances;
+    char _pad2[12];
+};
+
+struct main_Output {
+    metal::float4 position [[position]];
+    float clip_distances [[clip_distance]] [1];
+};
+vertex main_Output main_(
+) {
+    VertexOutput out = {};
+    out.clip_distances.inner[0] = 0.5;
+    VertexOutput _e4 = out;
+    const auto _tmp = _e4;
+    return main_Output { _tmp.position, {_tmp.clip_distances.inner[0]} };
+}
diff --git a/wgpu-core/src/validation.rs b/wgpu-core/src/validation.rs
@@ -162,7 +162,7 @@ enum BuiltIn {
     ViewIndex,
     BaseInstance,
     BaseVertex,
-    ClipDistance { array_size: u32 },
+    ClipDistances { array_size: u32 },
     CullDistance,
     InstanceIndex,
     PointSize,
@@ -216,7 +216,7 @@ impl BuiltIn {
             Self::ViewIndex => naga::BuiltIn::ViewIndex,
             Self::BaseInstance => naga::BuiltIn::BaseInstance,
             Self::BaseVertex => naga::BuiltIn::BaseVertex,
-            Self::ClipDistance { .. } => naga::BuiltIn::ClipDistance,
+            Self::ClipDistances { .. } => naga::BuiltIn::ClipDistances,
             Self::CullDistance => naga::BuiltIn::CullDistance,
             Self::InstanceIndex => naga::BuiltIn::InstanceIndex,
             Self::PointSize => naga::BuiltIn::PointSize,
@@ -1081,7 +1081,7 @@ impl Interface {
             naga::TypeInner::Array { base, size, stride }
                 if matches!(
                     binding,
-                    Some(naga::Binding::BuiltIn(naga::BuiltIn::ClipDistance)),
+                    Some(naga::Binding::BuiltIn(naga::BuiltIn::ClipDistances)),
                 ) =>
             {
                 // NOTE: We should already have validated these in `naga`.
@@ -1102,7 +1102,7 @@ impl Interface {
                 };
                 let array_size = array_size.get();
 
-                list.push(Varying::BuiltIn(BuiltIn::ClipDistance { array_size }));
+                list.push(Varying::BuiltIn(BuiltIn::ClipDistances { array_size }));
                 return;
             }
             ref other => {
@@ -1137,7 +1137,7 @@ impl Interface {
                 naga::BuiltIn::ViewIndex => BuiltIn::ViewIndex,
                 naga::BuiltIn::BaseInstance => BuiltIn::BaseInstance,
                 naga::BuiltIn::BaseVertex => BuiltIn::BaseVertex,
-                naga::BuiltIn::ClipDistance => unreachable!(),
+                naga::BuiltIn::ClipDistances => unreachable!(),
                 naga::BuiltIn::CullDistance => BuiltIn::CullDistance,
                 naga::BuiltIn::InstanceIndex => BuiltIn::InstanceIndex,
                 naga::BuiltIn::PointSize => BuiltIn::PointSize,
@@ -1626,15 +1626,15 @@ impl Interface {
                 };
 
                 let clip_distance_deductions = entry_point.outputs.iter().filter_map(|output| {
-                    if let &Varying::BuiltIn(BuiltIn::ClipDistance { array_size }) = output {
-                        Some(MaxVertexShaderOutputDeduction::ClipDistance { array_size })
+                    if let &Varying::BuiltIn(BuiltIn::ClipDistances { array_size }) = output {
+                        Some(MaxVertexShaderOutputDeduction::ClipDistances { array_size })
                     } else {
                         None
                     }
                 });
                 debug_assert!(
                     clip_distance_deductions.clone().count() <= 1,
-                    "multiple `clip_distance` outputs found"
+                    "multiple `clip_distances` outputs found"
                 );
 
                 let deductions = point_list_deduction
diff --git a/wgpu-core/src/validation/shader_io_deductions.rs b/wgpu-core/src/validation/shader_io_deductions.rs
diff --git a/wgpu-hal/src/metal/adapter.rs b/wgpu-hal/src/metal/adapter.rs
diff --git a/wgpu-naga-bridge/src/lib.rs b/wgpu-naga-bridge/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -1084,7 +1084,7 @@ impl<'a, W: Write> Writer<'a, W> {`
`1084`	`1084`	`}`
`1085`	`1085`	`}`
`1086`	`1086`	`}`
`1087`		`- crate::BuiltIn::ClipDistance => {`
	`1087`	`+ crate::BuiltIn::ClipDistances => {`
`1088`	`1088`	// Re-declare `gl_ClipDistance` with number of clip planes.
`1089`	`1089`	`let TypeInner::Array { size, .. } = self.module.types[ty].inner else {`
`1090`	`1090`	`unreachable!();`