Resolver: Validate resource binding decorations

Validate that:
* That resource variables have resource bindings
* Only resource variables have resource bindings
* That a [[binding]] decoration is paired with a [[group]]
* That binding points are not reused in the same entry point

Fixed: tint:235
Fixed: tint:645
Bug: tint:645
Change-Id: I2542934b4c6a2b4bbde48242932c04c796033a90
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/50500
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: David Neto <dneto@google.com>

src/ast/module_clone_test.cc

@@ -41,16 +41,16 @@ type t1 = array<vec4<f32>>;
 
 var<private> g0 : u32 = 20u;
 var<private> g1 : f32 = 123.0;
-var g2 : texture_2d<f32>;
-var g3 : [[access(read)]] texture_storage_2d<r32uint>;
-var g4 : [[access(write)]] texture_storage_2d<rg32float>;
-var g5 : [[access(read)]] texture_storage_2d<r32uint>;
-var g6 : [[access(write)]] texture_storage_2d<rg32float>;
+[[group(0), binding(0)]] var g2 : texture_2d<f32>;
+[[group(1), binding(0)]] var g3 : [[access(read)]] texture_storage_2d<r32uint>;
+[[group(2), binding(0)]] var g4 : [[access(write)]] texture_storage_2d<rg32float>;
+[[group(3), binding(0)]] var g5 : [[access(read)]] texture_storage_2d<r32uint>;
+[[group(4), binding(0)]] var g6 : [[access(write)]] texture_storage_2d<rg32float>;
 
 var<private> g7 : vec3<f32>;
-[[group(10), binding(20)]] var<storage> g8 : [[access(write)]] S;
-[[group(10), binding(20)]] var<storage> g9 : [[access(read)]] S;
-[[group(10), binding(20)]] var<storage> g10 : [[access(read_write)]] S;
+[[group(0), binding(1)]] var<storage> g8 : [[access(write)]] S;
+[[group(1), binding(1)]] var<storage> g9 : [[access(read)]] S;
+[[group(2), binding(1)]] var<storage> g10 : [[access(read_write)]] S;
 
 fn f0(p0 : bool) -> f32 {
   if (p0) {

src/ast/storage_class.cc

@@ -17,53 +17,35 @@
 namespace tint {
 namespace ast {
 
-std::ostream& operator<<(std::ostream& out, StorageClass sc) {
+const char* str(StorageClass sc) {
   switch (sc) {
-    case StorageClass::kInvalid: {
-      out << "invalid";
-      break;
-    }
-    case StorageClass::kNone: {
-      out << "none";
-      break;
-    }
-    case StorageClass::kInput: {
-      out << "in";
-      break;
-    }
-    case StorageClass::kOutput: {
-      out << "out";
-      break;
-    }
-    case StorageClass::kUniform: {
-      out << "uniform";
-      break;
-    }
-    case StorageClass::kWorkgroup: {
-      out << "workgroup";
-      break;
-    }
-    case StorageClass::kUniformConstant: {
-      out << "uniform_constant";
-      break;
-    }
-    case StorageClass::kStorage: {
-      out << "storage";
-      break;
-    }
-    case StorageClass::kImage: {
-      out << "image";
-      break;
-    }
-    case StorageClass::kPrivate: {
-      out << "private";
-      break;
-    }
-    case StorageClass::kFunction: {
-      out << "function";
-      break;
-    }
+    case StorageClass::kInvalid:
+      return "invalid";
+    case StorageClass::kNone:
+      return "none";
+    case StorageClass::kInput:
+      return "in";
+    case StorageClass::kOutput:
+      return "out";
+    case StorageClass::kUniform:
+      return "uniform";
+    case StorageClass::kWorkgroup:
+      return "workgroup";
+    case StorageClass::kUniformConstant:
+      return "uniform_constant";
+    case StorageClass::kStorage:
+      return "storage";
+    case StorageClass::kImage:
+      return "image";
+    case StorageClass::kPrivate:
+      return "private";
+    case StorageClass::kFunction:
+      return "function";
   }
+  return "<unknown>";
+}
+std::ostream& operator<<(std::ostream& out, StorageClass sc) {
+  out << str(sc);
   return out;
 }
 

src/ast/storage_class.h

@@ -42,6 +42,10 @@ inline bool IsHostShareable(StorageClass sc) {
   return sc == ast::StorageClass::kUniform || sc == ast::StorageClass::kStorage;
 }
 
+/// @param sc the StorageClass
+/// @return the name of the given storage class
+const char* str(StorageClass sc);
+
 /// @param out the std::ostream to write to
 /// @param sc the StorageClass
 /// @return the std::ostream so calls can be chained