From a067ea56d51ef94d790c82ae25b8e980328c62ad Mon Sep 17 00:00:00 2001
From: Dzmitry Malyshau <kvark@fastmail.com>
Date: Thu, 13 Apr 2023 21:14:56 -0700
Subject: [PATCH] Strip DATA out of binding arrays

---
 src/lib.rs             |  3 ++-
 src/valid/interface.rs | 52 +++++++++++++++++++-----------------------
 src/valid/type.rs      |  6 ++---
 tests/wgsl-errors.rs   |  8 +++++++
 4 files changed, 36 insertions(+), 33 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index b727b098f7..e744b7d40d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -200,7 +200,8 @@ tree.
     clippy::match_like_matches_macro,
     clippy::collapsible_if,
     clippy::derive_partial_eq_without_eq,
-    clippy::needless_borrowed_reference
+    clippy::needless_borrowed_reference,
+    clippy::single_match
 )]
 #![warn(
     trivial_casts,
diff --git a/src/valid/interface.rs b/src/valid/interface.rs
index d9ee9f5402..91e8a03901 100644
--- a/src/valid/interface.rs
+++ b/src/valid/interface.rs
@@ -400,7 +400,11 @@ impl super::Validator {
         use super::TypeFlags;
 
         log::debug!("var {:?}", var);
-        let type_info = &self.types[var.ty.index()];
+        let inner_ty = match types[var.ty].inner {
+            crate::TypeInner::BindingArray { base, .. } => base,
+            _ => var.ty,
+        };
+        let type_info = &self.types[inner_ty.index()];
 
         let (required_type_flags, is_resource) = match var.space {
             crate::AddressSpace::Function => {
@@ -437,22 +441,8 @@ impl super::Validator {
                 )
             }
             crate::AddressSpace::Handle => {
-                match types[var.ty].inner {
-                    crate::TypeInner::Image { .. }
-                    | crate::TypeInner::Sampler { .. }
-                    | crate::TypeInner::BindingArray { .. }
-                    | crate::TypeInner::AccelerationStructure
-                    | crate::TypeInner::RayQuery => {}
-                    _ => {
-                        return Err(GlobalVariableError::InvalidType(var.space));
-                    }
-                };
-                let inner_ty = match &types[var.ty].inner {
-                    &crate::TypeInner::BindingArray { base, .. } => &types[base].inner,
-                    ty => ty,
-                };
-                if let crate::TypeInner::Image {
-                    class:
+                match types[inner_ty].inner {
+                    crate::TypeInner::Image { class, .. } => match class {
                         crate::ImageClass::Storage {
                             format:
                                 crate::StorageFormat::R16Unorm
@@ -462,17 +452,23 @@ impl super::Validator {
                                 | crate::StorageFormat::Rgba16Unorm
                                 | crate::StorageFormat::Rgba16Snorm,
                             ..
-                        },
-                    ..
-                } = *inner_ty
-                {
-                    if !self
-                        .capabilities
-                        .contains(Capabilities::STORAGE_TEXTURE_16BIT_NORM_FORMATS)
-                    {
-                        return Err(GlobalVariableError::UnsupportedCapability(
-                            Capabilities::STORAGE_TEXTURE_16BIT_NORM_FORMATS,
-                        ));
+                        } => {
+                            if !self
+                                .capabilities
+                                .contains(Capabilities::STORAGE_TEXTURE_16BIT_NORM_FORMATS)
+                            {
+                                return Err(GlobalVariableError::UnsupportedCapability(
+                                    Capabilities::STORAGE_TEXTURE_16BIT_NORM_FORMATS,
+                                ));
+                            }
+                        }
+                        _ => {}
+                    },
+                    crate::TypeInner::Sampler { .. }
+                    | crate::TypeInner::AccelerationStructure
+                    | crate::TypeInner::RayQuery => {}
+                    _ => {
+                        return Err(GlobalVariableError::InvalidType(var.space));
                     }
                 }
 
diff --git a/src/valid/type.rs b/src/valid/type.rs
index 7a2e5c4e6e..ab83e6188b 100644
--- a/src/valid/type.rs
+++ b/src/valid/type.rs
@@ -635,12 +635,10 @@ impl super::Validator {
                     return Err(TypeError::UnresolvedBase(base));
                 }
                 let type_info_mask = match size {
-                    crate::ArraySize::Constant(_) => {
-                        TypeFlags::DATA | TypeFlags::SIZED | TypeFlags::HOST_SHAREABLE
-                    }
+                    crate::ArraySize::Constant(_) => TypeFlags::SIZED | TypeFlags::HOST_SHAREABLE,
                     crate::ArraySize::Dynamic => {
                         // Final type is non-sized
-                        TypeFlags::DATA | TypeFlags::HOST_SHAREABLE
+                        TypeFlags::HOST_SHAREABLE
                     }
                 };
                 let base_info = &self.types[base.index()];
diff --git a/tests/wgsl-errors.rs b/tests/wgsl-errors.rs
index d44dd97f37..57d6e9618e 100644
--- a/tests/wgsl-errors.rs
+++ b/tests/wgsl-errors.rs
@@ -1820,3 +1820,11 @@ fn function_returns_void() {
 "###,
     )
 }
+
+#[test]
+fn binding_array_local() {
+    check_validation! {
+        "fn f() { var x: binding_array<i32, 4>; }":
+        Err(_)
+    }
+}