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, 15 deletions

diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp
index 718de86cc..af47eaedb 100644
--- a/source/slang/slang-check-modifier.cpp
+++ b/source/slang/slang-check-modifier.cpp
@@ -1096,6 +1096,7 @@ namespace Slang
         case ASTNodeType::GLSLLayoutModifierGroupBegin:
         case ASTNodeType::GLSLLayoutModifierGroupEnd:
         case ASTNodeType::GLSLBufferModifier:
+        case ASTNodeType::MemoryQualifierSetModifier:
         case ASTNodeType::GLSLWriteOnlyModifier:
         case ASTNodeType::GLSLReadOnlyModifier:
         case ASTNodeType::GLSLVolatileModifier:
@@ -1317,38 +1318,34 @@ namespace Slang
             }
         }
 
-        MemoryQualifierCollectionModifier::Flags::MemoryQualifiersBit memoryQualifierBit = 
-            MemoryQualifierCollectionModifier::Flags::kNone;
+        MemoryQualifierSetModifier::Flags::MemoryQualifiersBit memoryQualifierBit = MemoryQualifierSetModifier::Flags::kNone;
         if(as<GloballyCoherentModifier>(m))
-            memoryQualifierBit = MemoryQualifierCollectionModifier::Flags::kCoherent;
+            memoryQualifierBit = MemoryQualifierSetModifier::Flags::kCoherent;
         else if(as<GLSLReadOnlyModifier>(m))
-            memoryQualifierBit = MemoryQualifierCollectionModifier::Flags::kReadOnly;
+            memoryQualifierBit = MemoryQualifierSetModifier::Flags::kReadOnly;
         else if(as<GLSLWriteOnlyModifier>(m))
-            memoryQualifierBit = MemoryQualifierCollectionModifier::Flags::kWriteOnly;
+            memoryQualifierBit = MemoryQualifierSetModifier::Flags::kWriteOnly;
         else if(as<GLSLVolatileModifier>(m))
-            memoryQualifierBit = MemoryQualifierCollectionModifier::Flags::kVolatile;
+            memoryQualifierBit = MemoryQualifierSetModifier::Flags::kVolatile;
         else if(as<GLSLRestrictModifier>(m))
-            memoryQualifierBit = MemoryQualifierCollectionModifier::Flags::kRestrict;
-        if(memoryQualifierBit != MemoryQualifierCollectionModifier::Flags::kNone)
+            memoryQualifierBit = MemoryQualifierSetModifier::Flags::kRestrict;
+        if(memoryQualifierBit != MemoryQualifierSetModifier::Flags::kNone)
         {
             bool newModifier = false;
-            MemoryQualifierCollectionModifier* memoryQualifiers = syntaxNode->findModifier<MemoryQualifierCollectionModifier>();
+            MemoryQualifierSetModifier* memoryQualifiers = syntaxNode->findModifier<MemoryQualifierSetModifier>();
             if(!memoryQualifiers)
             {
                 newModifier = true;
-                memoryQualifiers = getASTBuilder()->create<MemoryQualifierCollectionModifier>();
+                memoryQualifiers = getASTBuilder()->create<MemoryQualifierSetModifier>();
             }
             memoryQualifiers->addQualifier(m,
                 memoryQualifierBit);
             if (newModifier)
             {
-                // insert in modifiers list the memoryQualifierCollection
-                Modifier* mod = m->next;
                 m->next = memoryQualifiers;
-                memoryQualifiers->next = mod;
-                return m;
+                return memoryQualifiers;
             }
-            return m;
+            return nullptr;
         }
 
         if (auto hlslSemantic = as<HLSLSimpleSemantic>(m))