Require new Capabilities::BINDING_ARRAY for binding_array type.

src/valid/mod.rs

@@ -114,6 +114,8 @@ bitflags::bitflags! {
         const RAY_QUERY = 0x1000;
         /// Support for generating two sources for blending from fragement shaders
         const DUAL_SOURCE_BLENDING = 0x2000;
+        /// Support for binding arrays.
+        const BINDING_ARRAY = 0x4000;
     }
 }
 

src/valid/type.rs

@@ -569,6 +569,7 @@ impl super::Validator {
                 TypeInfo::new(TypeFlags::DATA | TypeFlags::SIZED, Alignment::ONE)
             }
             Ti::BindingArray { base, size } => {
+                self.require_type_capability(Capabilities::BINDING_ARRAY)?;
                 if base >= handle {
                     return Err(TypeError::InvalidArrayBaseType(base));
                 }

tests/in/binding-buffer-arrays.param.ron

@@ -1,5 +1,5 @@
 (
-	god_mode: false,
+	god_mode: true,
 	spv: (
 		version: (1, 1),
 		binding_map: {

tests/in/spv/binding-arrays.dynamic.param.ron

@@ -0,0 +1,3 @@
+(
+	god_mode: true,
+)

tests/in/spv/binding-arrays.static.param.ron

@@ -0,0 +1,3 @@
+(
+	god_mode: true,
+)

tests/wgsl-errors.rs

@@ -853,10 +853,10 @@ fn matrix_with_bad_type() {
 /// Unless you are generating code programmatically, the
 /// `check_validation_error` macro will probably be more convenient to
 /// use.
-macro_rules! check_one_validation {
-    ( $source:expr, $pattern:pat $( if $guard:expr )? ) => {
+macro_rules! check_one_validation_with_capabilities {
+    ( $capabilities:expr, $source:expr, $pattern:pat $( if $guard:expr )? ) => {
         let source = $source;
-        let error = validation_error($source);
+        let error = validation_error($source, $capabilities);
         if ! matches!(&error, $pattern $( if $guard )? ) {
             eprintln!("validation error does not match pattern:\n\
                        source code: {}\n\
@@ -875,6 +875,15 @@ macro_rules! check_one_validation {
     }
 }
 
+macro_rules! check_one_validation {
+    ( $source:expr, $pattern:pat $( if $guard:expr )? ) => {
+        check_one_validation_with_capabilities!(
+            naga::valid::Capabilities::default(),
+            $source, $pattern $( if $guard )?
+        );
+    }
+}
+
 macro_rules! check_validation {
     // We want to support an optional guard expression after the pattern, so
     // that we can check values we can't match against, like strings.
@@ -893,20 +902,20 @@ macro_rules! check_validation {
     }
 }
 
-fn validation_error(source: &str) -> Result<naga::valid::ModuleInfo, naga::valid::ValidationError> {
+fn validation_error(
+    source: &str,
+    capabilities: naga::valid::Capabilities,
+) -> Result<naga::valid::ModuleInfo, naga::valid::ValidationError> {
     let module = match naga::front::wgsl::parse_str(source) {
         Ok(module) => module,
         Err(err) => {
             eprintln!("WGSL parse failed:");
             panic!("{}", err.emit_to_string(source));
         }
     };
-    naga::valid::Validator::new(
-        naga::valid::ValidationFlags::all(),
-        naga::valid::Capabilities::default(),
-    )
-    .validate(&module)
-    .map_err(|e| e.into_inner()) // TODO: Add tests for spans, too?
+    naga::valid::Validator::new(naga::valid::ValidationFlags::all(), capabilities)
+        .validate(&module)
+        .map_err(|e| e.into_inner()) // TODO: Add tests for spans, too?
 }
 
 #[test]
@@ -1939,8 +1948,10 @@ fn binding_array_private() {
 
 #[test]
 fn binding_array_non_struct() {
-    check_validation! {
-        "var<storage> x: binding_array<i32, 4>;":
+    use naga::valid::Capabilities;
+    check_one_validation_with_capabilities! {
+        Capabilities::default() | Capabilities::BINDING_ARRAY,
+        "var<storage> x: binding_array<i32, 4>;",
         Err(naga::valid::ValidationError::Type {
             source: naga::valid::TypeError::BindingArrayBaseTypeNotStruct(_),
             ..