Refactor memory qualifier decorators to be a bit-flag set, resolves #3841 (#3881)

* Refactor memory qualifier decorators to be a bit-flag set.

replace GloballyCoherent, ReadOnly, WriteOnly, Volatile, and Restrict memory modifiers and decorations with a bit flag set to more efficiently manage memory qualifiers.

added `restrict` modifier to test to ensure the code works when dropping a `restrict` memory qualifier

* Refine tests & add SSBO memory qualifer support

add CHECK's to tests to ensure memory qualifiers emit as intended

added tests and changed code to ensure memory qualifiers work on SSBO objects (SPIR-V & GLSL)

* add memory qualifiers & fixes.

Add to StructuredBuffer & ByteAddressBuffer `ReadOnly`/NonWritable qualifier.
* Memory qualifiers must be decorated on a variable inst. Due to this the qualifier is added after `lowerStructuredBufferType`

Fixed an error where ReadOnly->NonReadable & WriteOnly->NonWritable
* Adjusted tests accordingly

Added back the removed `globallycoherent` memory qualifier emit'ing code in hlsl-emit (was incorrectly removed).

undo hlsl.meta changes

cleanup

1 files changed, 12 insertions, 11 deletions

diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index ff5dd4af5..e88db59f8 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -314,7 +314,8 @@ namespace Slang
 
         // Check the modifiers on the declaration
         const auto d = varExpr->declRef.getDecl();
-        if(d->hasModifier<GLSLReadOnlyModifier>())
+        auto collection = d->findModifier<MemoryQualifierSetModifier>();
+        if(collection && collection->getMemoryQualifierBit() & MemoryQualifierSetModifier::Flags::kReadOnly)
             return false;
 
         return true;
@@ -2201,27 +2202,27 @@ namespace Slang
         if (!argDeclRef)
             return;
         auto argDecl =  argDeclRef.getDecl();
-        auto argMemMods = argDecl->findModifier<MemoryQualifierCollectionModifier>();
+        auto argMemMods = argDecl->findModifier<MemoryQualifierSetModifier>();
         if(!argMemMods)
             return;
         uint32_t argQualifiers = argMemMods->getMemoryQualifierBit();    
 
         uint32_t paramQualifiers = 0;
-        auto paramMemMods = paramIn->findModifier<MemoryQualifierCollectionModifier>();
+        auto paramMemMods = paramIn->findModifier<MemoryQualifierSetModifier>();
         if(paramMemMods)
             paramQualifiers = paramMemMods->getMemoryQualifierBit();
 
-        if(argQualifiers & MemoryQualifierCollectionModifier::Flags::kCoherent
-            && !(paramQualifiers & MemoryQualifierCollectionModifier::Flags::kCoherent))
+        if(argQualifiers & MemoryQualifierSetModifier::Flags::kCoherent
+            && !(paramQualifiers & MemoryQualifierSetModifier::Flags::kCoherent))
                 getSink()->diagnose(arg, Diagnostics::argumentHasMoreMemoryQualifiersThanParam, "coherent");
-        if(argQualifiers & MemoryQualifierCollectionModifier::Flags::kReadOnly
-            && !(paramQualifiers & MemoryQualifierCollectionModifier::Flags::kReadOnly))
+        if(argQualifiers & MemoryQualifierSetModifier::Flags::kReadOnly
+            && !(paramQualifiers & MemoryQualifierSetModifier::Flags::kReadOnly))
                 getSink()->diagnose(arg, Diagnostics::argumentHasMoreMemoryQualifiersThanParam, "readonly");
-        if(argQualifiers & MemoryQualifierCollectionModifier::Flags::kWriteOnly
-            && !(paramQualifiers & MemoryQualifierCollectionModifier::Flags::kWriteOnly))
+        if(argQualifiers & MemoryQualifierSetModifier::Flags::kWriteOnly
+            && !(paramQualifiers & MemoryQualifierSetModifier::Flags::kWriteOnly))
                 getSink()->diagnose(arg, Diagnostics::argumentHasMoreMemoryQualifiersThanParam, "writeonly");
-        if(argQualifiers & MemoryQualifierCollectionModifier::Flags::kVolatile
-            && !(paramQualifiers & MemoryQualifierCollectionModifier::Flags::kVolatile))
+        if(argQualifiers & MemoryQualifierSetModifier::Flags::kVolatile
+            && !(paramQualifiers & MemoryQualifierSetModifier::Flags::kVolatile))
                 getSink()->diagnose(arg, Diagnostics::argumentHasMoreMemoryQualifiersThanParam, "volatile");
         // dropping a `restrict` qualifier from arguments is allowed in GLSL with memory qualifiers
     }