Include suggested documentation, more binding array tests, enforce st…

…ructs

src/back/spv/block.rs

@@ -1405,8 +1405,8 @@ impl<'w> BlockContext<'w> {
     /// Emit any needed bounds-checking expressions to `block`.
     ///
     /// Some cases we need to generate a different return type than what the IR gives us.
-    /// This is because pointers to binding arrays don't exist in the IR, but we need to
-    /// create them to create an access chain in SPIRV.
+    /// This is because pointers to binding arrays of handles (such as images or samplers)
+    /// don't exist in the IR, but we need to create them to create an access chain in SPIRV.
     ///
     /// On success, the return value is an [`ExpressionPointer`] value; see the
     /// documentation for that type.

src/back/spv/mod.rs

@@ -288,6 +288,11 @@ enum LocalType {
         image_type_id: Word,
     },
     Sampler,
+    /// Equivalent to a [`LocalType::Pointer`] whose `base` is a Naga IR [`BindingArray`]. SPIR-V
+    /// permits duplicated `OpTypePointer` ids, so it's fine to have two different [`LocalType`]
+    /// representations for pointer types.
+    ///
+    /// [`BindingArray`]: crate::TypeInner::BindingArray
     PointerToBindingArray {
         base: Handle<crate::Type>,
         size: u64,

src/valid/interface.rs

@@ -401,6 +401,9 @@ impl super::Validator {
 
         log::debug!("var {:?}", var);
         let inner_ty = match types[var.ty].inner {
+            // A binding array is (mostly) supposed to behave the same as a
+            // series of individually bound resources, so we can (mostly)
+            // validate a `binding_array<T>` as if it were just a plain `T`.
             crate::TypeInner::BindingArray { base, .. } => base,
             _ => var.ty,
         };

src/valid/type.rs

@@ -117,6 +117,8 @@ pub enum TypeError {
     InvalidArrayStride { stride: u32, expected: u32 },
     #[error("Field '{0}' can't be dynamically-sized, has type {1:?}")]
     InvalidDynamicArray(String, Handle<crate::Type>),
+    #[error("The base handle {0:?} has to be a struct")]
+    BindingArrayBaseTypeNotStruct(Handle<crate::Type>),
     #[error("Structure member[{index}] at {offset} overlaps the previous member")]
     MemberOverlap { index: u32, offset: u32 },
     #[error(
@@ -612,7 +614,7 @@ impl super::Validator {
             }
             Ti::AccelerationStructure => {
                 self.require_type_capability(Capabilities::RAY_QUERY)?;
-                TypeInfo::new(TypeFlags::empty(), Alignment::ONE)
+                TypeInfo::new(TypeFlags::ARGUMENT, Alignment::ONE)
             }
             Ti::RayQuery => {
                 self.require_type_capability(Capabilities::RAY_QUERY)?;
@@ -631,6 +633,14 @@ impl super::Validator {
                 };
                 let base_info = &self.types[base.index()];
 
+                if base_info.flags.contains(TypeFlags::DATA) {
+                    // Currently Naga only supports binding arrays of structs for non-handle types.
+                    match types[base].inner {
+                        crate::TypeInner::Struct { .. } => {}
+                        _ => return Err(TypeError::BindingArrayBaseTypeNotStruct(base)),
+                    };
+                }
+
                 TypeInfo::new(base_info.flags & type_info_mask, Alignment::ONE)
             }
         })

tests/wgsl-errors.rs

@@ -1860,7 +1860,26 @@ fn function_returns_void() {
 #[test]
 fn binding_array_local() {
     check_validation! {
-        "fn f() { var x: binding_array<i32, 4>; }":
+        "fn f() { var x: binding_array<sampler, 4>; }":
         Err(_)
     }
 }
+
+#[test]
+fn binding_array_private() {
+    check_validation! {
+        "var<private> x: binding_array<sampler, 4>;":
+        Err(_)
+    }
+}
+
+#[test]
+fn binding_array_non_struct() {
+    check_validation! {
+        "var<storage> x: binding_array<i32, 4>;":
+        Err(naga::valid::ValidationError::Type {
+            source: naga::valid::TypeError::BindingArrayBaseTypeNotStruct(_),
+            ..
+        })
+    }
+}