Language server pointer type support + add `DLLImport` test (#2350)

* Language server pointer type support.

+ Natvis for AST.

* Add completion suggestion for GUID.

* Make executable test able to use slang-rt.

* Fix gcc argument for rpath.

* Fix DLLImport on linux.

* Fix windows.

* Fix.

Co-authored-by: Yong He <yhe@nvidia.com>

12 files changed, 400 insertions, 67 deletions

diff --git a/source/compiler-core/slang-gcc-compiler-util.cpp b/source/compiler-core/slang-gcc-compiler-util.cpp
index aee3b1bcc..2c1380cde 100644
--- a/source/compiler-core/slang-gcc-compiler-util.cpp
+++ b/source/compiler-core/slang-gcc-compiler-util.cpp
@@ -564,6 +564,7 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
         }
         case SLANG_HOST_EXECUTABLE:
         {
+            cmdLine.addArg("-rdynamic");
             break;
         }
         case SLANG_OBJECT_CODE:
@@ -623,6 +624,12 @@ static SlangResult _parseGCCFamilyLine(const UnownedStringSlice& line, LineParse
     }
 
     // Add the library paths
+
+    if (options.libraryPaths.getCount() && options.targetType == SLANG_HOST_EXECUTABLE)
+    {
+        cmdLine.addArg("-Wl,-rpath,$ORIGIN");
+    }
+
     StringSlicePool libPathPool(StringSlicePool::Style::Default);
 
     for (const auto& libPath : options.libraryPaths)
diff --git a/source/core/slang-platform.cpp b/source/core/slang-platform.cpp
index 5185d5d23..921c85612 100644
--- a/source/core/slang-platform.cpp
+++ b/source/core/slang-platform.cpp
@@ -43,7 +43,7 @@ namespace Slang
 
         Path::combineIntoBuilder(parent.getUnownedSlice(), platformFileNameBuilder.getUnownedSlice(), outPath);
     }
-    else
+    else if (filename.getLength() > 0)
     {     
         appendPlatformFileName(filename.getUnownedSlice(), outPath);
     }
@@ -107,6 +107,13 @@ SLANG_COMPILE_TIME_ASSERT(E_OUTOFMEMORY == SLANG_E_OUT_OF_MEMORY);
 /* static */SlangResult SharedLibrary::loadWithPlatformPath(char const* platformFileName, SharedLibrary::Handle& handleOut)
 {
     handleOut = nullptr;
+    if (!platformFileName || strlen(platformFileName) == 0)
+    {
+        if (!GetModuleHandleExA(0, nullptr, (HMODULE*)&handleOut))
+            return SLANG_FAIL;
+        return SLANG_OK;
+    }
+
     // https://docs.microsoft.com/en-us/windows/desktop/api/libloaderapi/nf-libloaderapi-loadlibrarya
     const HMODULE h = LoadLibraryA(platformFileName);
     if (!h)
@@ -170,10 +177,11 @@ SLANG_COMPILE_TIME_ASSERT(E_OUTOFMEMORY == SLANG_E_OUT_OF_MEMORY);
 /* static */SlangResult SharedLibrary::loadWithPlatformPath(char const* platformFileName, Handle& handleOut)
 {
     handleOut = nullptr;
-
-	void* h = dlopen(platformFileName, RTLD_NOW | RTLD_GLOBAL);
-	if(!h)
-	{
+    if (strlen(platformFileName) == 0)
+        platformFileName = nullptr;
+    void *h = dlopen(platformFileName, RTLD_NOW | RTLD_GLOBAL);
+    if (!h)
+    {
 #if 0
         // We can't output the error message here, because it will cause output when testing what code gen is available
 		if(auto msg = dlerror())
@@ -195,7 +203,6 @@ SLANG_COMPILE_TIME_ASSERT(E_OUTOFMEMORY == SLANG_E_OUT_OF_MEMORY);
 
 /* static */void* SharedLibrary::findSymbolAddressByName(Handle handle, char const* name)
 {
-    SLANG_ASSERT(handle);
 	return dlsym((void*)handle, name);
 }
 
diff --git a/source/core/slang-shared-library.cpp b/source/core/slang-shared-library.cpp
index f31c7d689..6ce10ad9e 100644
--- a/source/core/slang-shared-library.cpp
+++ b/source/core/slang-shared-library.cpp
@@ -33,7 +33,7 @@ SlangResult DefaultSharedLibraryLoader::loadSharedLibrary(const char* path, ISla
 {
     *outSharedLibrary = nullptr;
     // Try loading
-    SharedLibrary::Handle handle;
+    SharedLibrary::Handle handle = nullptr;
     SLANG_RETURN_ON_FAIL(SharedLibrary::load(path, handle));
     *outSharedLibrary = ComPtr<ISlangSharedLibrary>(new DefaultSharedLibrary(handle)).detach();
     return SLANG_OK;
diff --git a/source/slang-rt/slang-rt.cpp b/source/slang-rt/slang-rt.cpp
index 163a1b99c..94699dfa0 100644
--- a/source/slang-rt/slang-rt.cpp
+++ b/source/slang-rt/slang-rt.cpp
@@ -25,7 +25,7 @@ extern "C"
         ComPtr<ISlangSharedLibrary> lib;
         if (!slangRT_loadedLibraries.TryGetValue(modulePath, lib))
         {
-            if (DefaultSharedLibraryLoader::getSingleton()->loadSharedLibrary(
+            if (DefaultSharedLibraryLoader::getSingleton()->loadPlatformSharedLibrary(
                     modulePath.getBuffer(), lib.writeRef()) != SLANG_OK)
             {
                 _slang_rt_abort("Failed to load DLL \"" + modulePath + "\"");
@@ -38,6 +38,10 @@ extern "C"
     SLANG_RT_API void* SLANG_MCALL
         _slang_rt_load_dll_func(void* moduleHandle, Slang::String funcName)
     {
+        if (moduleHandle == nullptr)
+        {
+            moduleHandle = _slang_rt_load_dll("");
+        }
         auto lib = static_cast<ISlangSharedLibrary*>(moduleHandle);
         auto funcPtr = lib->findFuncByName(funcName.getBuffer());
         if (!funcPtr)
diff --git a/source/slang/slang-ast-iterator.h b/source/slang/slang-ast-iterator.h
index 417f93d0d..d439420a9 100644
--- a/source/slang/slang-ast-iterator.h
+++ b/source/slang/slang-ast-iterator.h
@@ -230,6 +230,11 @@ struct ASTIterator
             iterator->maybeDispatchCallback(expr);
             dispatchIfNotNull(expr->base.exp);
         }
+        void visitPointerTypeExpr(PointerTypeExpr* expr)
+        {
+            iterator->maybeDispatchCallback(expr);
+            dispatchIfNotNull(expr->base.exp);
+        }
     };
 
     struct ASTIteratorStmtVisitor : public StmtVisitor<ASTIteratorStmtVisitor>
diff --git a/source/slang/slang-ir-dll-import.cpp b/source/slang/slang-ir-dll-import.cpp
index 43ed9a102..01e1241ff 100644
--- a/source/slang/slang-ir-dll-import.cpp
+++ b/source/slang/slang-ir-dll-import.cpp
@@ -127,7 +127,7 @@ struct DllImportContext
 
         if (dllImportDecoration->getLibraryName() == "")
         {
-            modulePtr = builder.getIntValue(builder.getIntType(), 0);
+            modulePtr = builder.getPtrValue(nullptr);
         }
         else
         {
diff --git a/source/slang/slang-language-server-ast-lookup.cpp b/source/slang/slang-language-server-ast-lookup.cpp
index 6792a18e7..3de335c33 100644
--- a/source/slang/slang-language-server-ast-lookup.cpp
+++ b/source/slang/slang-language-server-ast-lookup.cpp
@@ -371,6 +371,18 @@ public:
             return true;
         return dispatchIfNotNull(expr->right.exp);
     }
+    bool visitPointerTypeExpr(PointerTypeExpr* expr)
+    {
+        if (_isLocInRange(context, expr->loc, 0))
+        {
+            ASTLookupResult result;
+            result.path = context->nodePath;
+            result.path.add(expr);
+            context->results.add(result);
+            return true;
+        }
+        return dispatchIfNotNull(expr->base.exp);
+    }
     bool visitModifiedTypeExpr(ModifiedTypeExpr* expr) { return dispatchIfNotNull(expr->base.exp); }
     bool visitTryExpr(TryExpr* expr) { return dispatchIfNotNull(expr->base); }
 
diff --git a/source/slang/slang-language-server-completion.cpp b/source/slang/slang-language-server-completion.cpp
index 93b10b816..21586089a 100644
--- a/source/slang/slang-language-server-completion.cpp
+++ b/source/slang/slang-language-server-completion.cpp
@@ -644,6 +644,37 @@ List<LanguageServerProtocol::CompletionItem> CompletionContext::createSwizzleCan
     return result;
 }
 
+LanguageServerProtocol::CompletionItem CompletionContext::generateGUIDCompletionItem()
+{
+    StringBuilder sb;
+    sb << "COM(\"";
+    auto docHash = doc->getURI().getHashCode() ^ doc->getText().getHashCode();
+    int sectionLengths[] = { 8,4,4,4,12 };
+    srand((unsigned int)std::chrono::high_resolution_clock::now().time_since_epoch().count());
+    auto hashStr = String(docHash, 16);
+    sectionLengths[0] -= (int)hashStr.getLength();
+    sb << hashStr;
+    for (int j = 0; j < SLANG_COUNT_OF(sectionLengths); j++)
+    {
+        auto len = sectionLengths[j];
+        if (j != 0)
+            sb << "-";
+        for (int i = 0; i < len; i++)
+        {
+            auto digit = rand() % 16;
+            if (digit < 10)
+                sb << digit;
+            else
+                sb.appendChar((char)('A' + digit - 10));
+        }
+    }
+    sb << "\")";
+    LanguageServerProtocol::CompletionItem resultItem;
+    resultItem.kind = LanguageServerProtocol::kCompletionItemKindKeyword;
+    resultItem.label = sb.ProduceString();
+    return resultItem;
+}
+
 List<LanguageServerProtocol::CompletionItem> CompletionContext::collectAttributes()
 {
     List<LanguageServerProtocol::CompletionItem> result;
@@ -672,6 +703,10 @@ List<LanguageServerProtocol::CompletionItem> CompletionContext::collectAttribute
             }
         }
     }
+
+    // Add a suggestion for `[COM]` attribute with generated GUID.
+    auto guidItem = generateGUIDCompletionItem();
+    result.add(guidItem);
     return result;
 }
 
diff --git a/source/slang/slang-language-server-completion.h b/source/slang/slang-language-server-completion.h
index 45082e0d3..5a09ba371 100644
--- a/source/slang/slang-language-server-completion.h
+++ b/source/slang/slang-language-server-completion.h
@@ -40,6 +40,7 @@ struct CompletionContext
     List<LanguageServerProtocol::CompletionItem> createSwizzleCandidates(
         Type* baseType, IntegerLiteralValue elementCount[2]);
     List<LanguageServerProtocol::CompletionItem> collectAttributes();
+    LanguageServerProtocol::CompletionItem generateGUIDCompletionItem();
     List<LanguageServerProtocol::TextEditCompletionItem> gatherFileAndModuleCompletionItems(
         const String& prefixPath,
         bool translateModuleName,
diff --git a/source/slang/slang-lookup.cpp b/source/slang/slang-lookup.cpp
index 85924ab30..48f7ea099 100644
--- a/source/slang/slang-lookup.cpp
+++ b/source/slang/slang-lookup.cpp
@@ -267,6 +267,26 @@ static void _lookUpDirectAndTransparentMembers(
     }
 }
 
+LookupRequest initLookupRequest(
+    SemanticsVisitor* semantics,
+    Name* name,
+    LookupMask mask,
+    LookupOptions options,
+    Scope* scope)
+{
+    LookupRequest request;
+    request.semantics = semantics;
+    request.mask = mask;
+    request.options = options;
+    request.scope = scope;
+
+    if (semantics && semantics->getSession() &&
+        name == semantics->getSession()->getCompletionRequestTokenName())
+        request.options = (LookupOptions)((int)request.options | (int)LookupOptions::Completion);
+
+    return request;
+}
+
     /// Perform "direct" lookup in a container declaration
 LookupResult lookUpDirectAndTransparentMembers(
     ASTBuilder*             astBuilder,
@@ -275,9 +295,7 @@ LookupResult lookUpDirectAndTransparentMembers(
     DeclRef<ContainerDecl>  containerDeclRef,
     LookupMask              mask)
 {
-    LookupRequest request;
-    request.semantics = semantics;
-    request.mask = mask;
+    LookupRequest request = initLookupRequest(semantics, name, mask, LookupOptions::None, nullptr);
     LookupResult result;
     _lookUpDirectAndTransparentMembers(
         astBuilder,
@@ -984,13 +1002,7 @@ LookupResult lookUp(
     Scope*              scope,
     LookupMask          mask)
 {
-    LookupRequest request;
-    request.semantics = semantics;
-    request.scope = scope;
-    request.mask = mask;
-    if (semantics && semantics->getSession() &&
-        name == semantics->getSession()->getCompletionRequestTokenName())
-        request.options = (LookupOptions)((int)request.options | (int)LookupOptions::Completion);
+    LookupRequest request = initLookupRequest(semantics, name, mask, LookupOptions::None, scope);
     LookupResult result;
     _lookUpInScopes(astBuilder, name, request, result);
     return result;
@@ -1004,14 +1016,7 @@ LookupResult lookUpMember(
     LookupMask          mask,
     LookupOptions       options)
 {
-    LookupRequest request;
-    request.semantics = semantics;
-    request.mask = mask;
-    request.options = options;
-    if (semantics && semantics->getSession() &&
-        name == semantics->getSession()->getCompletionRequestTokenName())
-        request.options = (LookupOptions)((int)request.options | (int)LookupOptions::Completion);
-
+    LookupRequest request = initLookupRequest(semantics, name, mask, options, nullptr);
     LookupResult result;
     _lookUpMembersInType(astBuilder, name, type, request, result, nullptr);
     return result;
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
index cdf418d3d..17794a4b5 100644
--- a/source/slang/slang-parser.cpp
+++ b/source/slang/slang-parser.cpp
@@ -4336,26 +4336,9 @@ namespace Slang
             // isn't a keyword should we fall back to the approach
             // here.
             //
+            bool prevHasSeenCompletionToken = hasSeenCompletionToken;
             Expr* type = ParseType();
 
-            if (type && hasSeenCompletionToken)
-            {
-                // If we encountered a completion token, just return the parsed expr
-                // as an ExprStmt.
-                for (auto tokenPos = startPos.tokenReaderCursor;
-                    tokenPos && tokenPos < tokenReader.getCursor().tokenReaderCursor;
-                    ++tokenPos)
-                {
-                    if (tokenPos && tokenPos->type == TokenType::CompletionRequest)
-                    {
-                        auto exprStmt = astBuilder->create<ExpressionStmt>();
-                        exprStmt->loc = type->loc;
-                        exprStmt->expression = type;
-                        return exprStmt;
-                    }
-                }
-            }
-
             // We don't actually care about the type, though, so
             // don't retain it
             //
@@ -4385,15 +4368,17 @@ namespace Slang
             // general kinds of declarators (notably pointer declarators),
             // so we'll need to be careful about this.
             //
-            // If the lookahead token is `*`, then we have to decide
-            // whether to parse a pointer declarator or a multiply
-            // expression. In this context it makes sense to disambiguate
+            // If the line being parsed token is `Something* ...`, then the `*`
+            // is already consumed by `ParseType` above and the current logic
+            // will continue to parse as var declaration instead of a mul expr.
+            // In this context it makes sense to disambiguate
             // in favor of a pointer over a multiply, since a multiply
             // expression can't appear at the start of a statement
             // with any side effects.
             //
             //
-            if (LookAheadToken(TokenType::Identifier) || LookAheadToken(TokenType::OpMul))
+            if (!hasSeenCompletionToken && (LookAheadToken(TokenType::Identifier) ||
+                                            LookAheadToken(TokenType::CompletionRequest)))
             {
                 // Reset the cursor and try to parse a declaration now.
                 // Note: the declaration will consume any modifiers
@@ -4404,6 +4389,7 @@ namespace Slang
             }
 
             // Fallback: reset and parse an expression
+            hasSeenCompletionToken = prevHasSeenCompletionToken;
             tokenReader.setCursor(startPos);
             statement = ParseExpressionStatement();
         }
diff --git a/source/slang/slang.natvis b/source/slang/slang.natvis
index 3e742ffb5..d56fa885d 100644
--- a/source/slang/slang.natvis
+++ b/source/slang/slang.natvis
@@ -15,12 +15,15 @@
     <DisplayString Condition="decl != 0">{(*(*(Slang::DeclRefBase*)this).decl).nameAndLoc}</DisplayString>
     <Expand>
       <ExpandedItem>decl ? ($T1*)(decl) : ($T1*)0</ExpandedItem>
-      <Item Name="[Substitutions]:">"========================="</Item>
-      <LinkedListItems>
-        <HeadPointer>substitutions.substitutions.pointer</HeadPointer>
-        <NextPointer>outer.pointer</NextPointer>
-        <ValueNode>this</ValueNode>
-      </LinkedListItems>
+      <Synthetic Name="[Substitutions]">
+        <Expand>
+            <LinkedListItems>
+                <HeadPointer>substitutions.substitutions</HeadPointer>
+                <NextPointer>outer</NextPointer>
+                <ValueNode>this</ValueNode>
+            </LinkedListItems>
+        </Expand>
+      </Synthetic>
     </Expand>
   </Type>
     <Type Name="Slang::DeclRefBase">
@@ -29,18 +32,15 @@
         <DisplayString Condition="decl != 0">{(*(*(Slang::DeclRefBase*)this).decl).nameAndLoc}</DisplayString>
         <Expand>
             <ExpandedItem>decl</ExpandedItem>
-            <Item Name="[Substitutions]:">"========================="</Item>
-            <LinkedListItems>
-                <HeadPointer>substitutions.genericSubstitutions.pointer</HeadPointer>
-                <NextPointer>outer.pointer</NextPointer>
-                <ValueNode>this</ValueNode>
-            </LinkedListItems>
-            <LinkedListItems>
-                <HeadPointer>substitutions.globalGenParamSubstitutions.pointer</HeadPointer>
-                <NextPointer>outer.pointer</NextPointer>
-                <ValueNode>this</ValueNode>
-            </LinkedListItems>
-            <Item Name ="thisSubst">substitutions.thisTypeSubstitution</Item>
+            <Synthetic Name="[Substitutions]">
+                <Expand>
+                    <LinkedListItems>
+                        <HeadPointer>substitutions.substitutions</HeadPointer>
+                        <NextPointer>outer</NextPointer>
+                        <ValueNode>this</ValueNode>
+                    </LinkedListItems>
+                </Expand>
+            </Synthetic>
         </Expand>
     </Type>
     <Type Name="Slang::GenericSubstitution">
@@ -188,4 +188,275 @@
       <ExpandedItem>usedValue</ExpandedItem>
     </Expand>
   </Type>
+
+    <Type Name="Slang::Expr" Inheritable="false">
+        <DisplayString>{astNodeType}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclRefExpr">(Slang::DeclRefExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VarExpr">(Slang::VarExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::MemberExpr">(Slang::MemberExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StaticMemberExpr">(Slang::StaticMemberExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OverloadedExpr">(Slang::OverloadedExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OverloadedExpr2">(Slang::OverloadedExpr2*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LiteralExpr">(Slang::LiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::IntegerLiteralExpr">(Slang::IntegerLiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FloatingPointLiteralExpr">(Slang::FloatingPointLiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BoolLiteralExpr">(Slang::BoolLiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NullPtrLiteralExpr">(Slang::NullPtrLiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StringLiteralExpr">(Slang::StringLiteralExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InitializerListExpr">(Slang::InitializerListExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExprWithArgsBase">(Slang::ExprWithArgsBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AggTypeCtorExpr">(Slang::AggTypeCtorExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AppExprBase">(Slang::AppExprBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InvokeExpr">(Slang::InvokeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NewExpr">(Slang::NewExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OperatorExpr">(Slang::OperatorExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InfixExpr">(Slang::InfixExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PrefixExpr">(Slang::PrefixExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PostfixExpr">(Slang::PostfixExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SelectExpr">(Slang::SelectExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeCastExpr">(Slang::TypeCastExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExplicitCastExpr">(Slang::ExplicitCastExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ImplicitCastExpr">(Slang::ImplicitCastExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericAppExpr">(Slang::GenericAppExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TryExpr">(Slang::TryExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::IndexExpr">(Slang::IndexExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::MatrixSwizzleExpr">(Slang::MatrixSwizzleExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SwizzleExpr">(Slang::SwizzleExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DerefExpr">(Slang::DerefExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::CastToSuperTypeExpr">(Slang::CastToSuperTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifierCastExpr">(Slang::ModifierCastExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SharedTypeExpr">(Slang::SharedTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AssignExpr">(Slang::AssignExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParenExpr">(Slang::ParenExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisExpr">(Slang::ThisExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LetExpr">(Slang::LetExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtractExistentialValueExpr">(Slang::ExtractExistentialValueExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OpenRefExpr">(Slang::OpenRefExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::JVPDifferentiateExpr">(Slang::JVPDifferentiateExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TaggedUnionTypeExpr">(Slang::TaggedUnionTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisTypeExpr">(Slang::ThisTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AndTypeExpr">(Slang::AndTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifiedTypeExpr">(Slang::ModifiedTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PointerTypeExpr">(Slang::PointerTypeExpr*)&amp;astNodeType</ExpandedItem>
+            <Item Name="[Expr]">(Slang::Expr*)this,nd</Item>
+        </Expand>
+    </Type>
+    <Type Name="Slang::Stmt" Inheritable="false">
+        <DisplayString>{astNodeType}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ScopeStmt">(Slang::ScopeStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BlockStmt">(Slang::BlockStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BreakableStmt">(Slang::BreakableStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SwitchStmt">(Slang::SwitchStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LoopStmt">(Slang::LoopStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ForStmt">(Slang::ForStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UnscopedForStmt">(Slang::UnscopedForStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::WhileStmt">(Slang::WhileStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DoWhileStmt">(Slang::DoWhileStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GpuForeachStmt">(Slang::GpuForeachStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::CompileTimeForStmt">(Slang::CompileTimeForStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SeqStmt">(Slang::SeqStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UnparsedStmt">(Slang::UnparsedStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EmptyStmt">(Slang::EmptyStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DiscardStmt">(Slang::DiscardStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclStmt">(Slang::DeclStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::IfStmt">(Slang::IfStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ChildStmt">(Slang::ChildStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::CaseStmtBase">(Slang::CaseStmtBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::CaseStmt">(Slang::CaseStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DefaultStmt">(Slang::DefaultStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::JumpStmt">(Slang::JumpStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BreakStmt">(Slang::BreakStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ContinueStmt">(Slang::ContinueStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ReturnStmt">(Slang::ReturnStmt*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExpressionStmt">(Slang::ExpressionStmt*)&amp;astNodeType</ExpandedItem>
+            <Item Name="[Stmt]">(Slang::Stmt*)this,nd</Item>
+        </Expand>
+    </Type>
+    <Type Name="Slang::Name">
+        <DisplayString>{text}</DisplayString>
+    </Type>
+    <Type Name="Slang::Decl" Inheritable="false">
+        <DisplayString Condition="nameAndLoc.name!=0">{nameAndLoc.name->text}: {astNodeType}</DisplayString>
+        <DisplayString Condition="nameAndLoc.name==0">{astNodeType}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ContainerDecl">(Slang::ContainerDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtensionDecl">(Slang::ExtensionDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StructDecl">(Slang::StructDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ClassDecl">(Slang::ClassDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EnumDecl">(Slang::EnumDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InterfaceDecl">(Slang::InterfaceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AssocTypeDecl">(Slang::AssocTypeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GlobalGenericParamDecl">(Slang::GlobalGenericParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ScopeDecl">(Slang::ScopeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ConstructorDecl">(Slang::ConstructorDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GetterDecl">(Slang::GetterDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SetterDecl">(Slang::SetterDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::RefAccessorDecl">(Slang::RefAccessorDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FuncDecl">(Slang::FuncDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SubscriptDecl">(Slang::SubscriptDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PropertyDecl">(Slang::PropertyDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamespaceDecl">(Slang::NamespaceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModuleDecl">(Slang::ModuleDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericDecl">(Slang::GenericDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AttributeDecl">(Slang::AttributeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VarDeclBase">(Slang::VarDeclBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VarDecl">(Slang::VarDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LetDecl">(Slang::LetDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GlobalGenericValueParamDecl">(Slang::GlobalGenericValueParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParamDecl">(Slang::ParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModernParamDecl">(Slang::ModernParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericValueParamDecl">(Slang::GenericValueParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EnumCaseDecl">(Slang::EnumCaseDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeConstraintDecl">(Slang::TypeConstraintDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InheritanceDecl">(Slang::InheritanceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericTypeConstraintDecl">(Slang::GenericTypeConstraintDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SimpleTypeDecl">(Slang::SimpleTypeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeDefDecl">(Slang::TypeDefDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeAliasDecl">(Slang::TypeAliasDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericTypeParamDecl">(Slang::GenericTypeParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UsingDecl">(Slang::UsingDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ImportDecl">(Slang::ImportDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EmptyDecl">(Slang::EmptyDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SyntaxDecl">(Slang::SyntaxDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclGroup">(Slang::DeclGroup*)&amp;astNodeType</ExpandedItem>
+            <Item Name="Decl">(Slang::DeclBase*)this,nd</Item>
+        </Expand>
+    </Type>
+
+    <Type Name="Slang::DeclBase" Inheritable="false">
+        <DisplayString>{astNodeType}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ContainerDecl">(Slang::ContainerDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtensionDecl">(Slang::ExtensionDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StructDecl">(Slang::StructDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ClassDecl">(Slang::ClassDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EnumDecl">(Slang::EnumDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InterfaceDecl">(Slang::InterfaceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AssocTypeDecl">(Slang::AssocTypeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GlobalGenericParamDecl">(Slang::GlobalGenericParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ScopeDecl">(Slang::ScopeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ConstructorDecl">(Slang::ConstructorDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GetterDecl">(Slang::GetterDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SetterDecl">(Slang::SetterDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::RefAccessorDecl">(Slang::RefAccessorDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FuncDecl">(Slang::FuncDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SubscriptDecl">(Slang::SubscriptDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PropertyDecl">(Slang::PropertyDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamespaceDecl">(Slang::NamespaceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModuleDecl">(Slang::ModuleDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericDecl">(Slang::GenericDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AttributeDecl">(Slang::AttributeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VarDeclBase">(Slang::VarDeclBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VarDecl">(Slang::VarDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::LetDecl">(Slang::LetDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GlobalGenericValueParamDecl">(Slang::GlobalGenericValueParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParamDecl">(Slang::ParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModernParamDecl">(Slang::ModernParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericValueParamDecl">(Slang::GenericValueParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EnumCaseDecl">(Slang::EnumCaseDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeConstraintDecl">(Slang::TypeConstraintDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InheritanceDecl">(Slang::InheritanceDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericTypeConstraintDecl">(Slang::GenericTypeConstraintDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SimpleTypeDecl">(Slang::SimpleTypeDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeDefDecl">(Slang::TypeDefDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeAliasDecl">(Slang::TypeAliasDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericTypeParamDecl">(Slang::GenericTypeParamDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UsingDecl">(Slang::UsingDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ImportDecl">(Slang::ImportDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EmptyDecl">(Slang::EmptyDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SyntaxDecl">(Slang::SyntaxDecl*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclGroup">(Slang::DeclGroup*)&amp;astNodeType</ExpandedItem>
+            <Item Name="Decl">(Slang::DeclBase*)this,nd</Item>
+        </Expand>
+    </Type>
+
+    <Type Name="Slang::Type" Inheritable="false">
+        <DisplayString>{astNodeType}</DisplayString>
+        <Expand>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OverloadGroupType">(Slang::OverloadGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InitializerListType">(Slang::InitializerListType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ErrorType">(Slang::ErrorType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BottomType">(Slang::BottomType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DeclRefType">(Slang::DeclRefType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ArithmeticExpressionType">(Slang::ArithmeticExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BasicExpressionType">(Slang::BasicExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VectorExpressionType">(Slang::VectorExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::MatrixExpressionType">(Slang::MatrixExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BuiltinType">(Slang::BuiltinType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FeedbackType">(Slang::FeedbackType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ResourceType">(Slang::ResourceType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TextureTypeBase">(Slang::TextureTypeBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TextureType">(Slang::TextureType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TextureSamplerType">(Slang::TextureSamplerType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GLSLImageType">(Slang::GLSLImageType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::SamplerStateType">(Slang::SamplerStateType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::BuiltinGenericType">(Slang::BuiltinGenericType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PointerLikeType">(Slang::PointerLikeType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParameterGroupType">(Slang::ParameterGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UniformParameterGroupType">(Slang::UniformParameterGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ConstantBufferType">(Slang::ConstantBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TextureBufferType">(Slang::TextureBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GLSLShaderStorageBufferType">(Slang::GLSLShaderStorageBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParameterBlockType">(Slang::ParameterBlockType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::VaryingParameterGroupType">(Slang::VaryingParameterGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GLSLInputParameterGroupType">(Slang::GLSLInputParameterGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GLSLOutputParameterGroupType">(Slang::GLSLOutputParameterGroupType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLStructuredBufferTypeBase">(Slang::HLSLStructuredBufferTypeBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLStructuredBufferType">(Slang::HLSLStructuredBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLRWStructuredBufferType">(Slang::HLSLRWStructuredBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLRasterizerOrderedStructuredBufferType">(Slang::HLSLRasterizerOrderedStructuredBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLAppendStructuredBufferType">(Slang::HLSLAppendStructuredBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLConsumeStructuredBufferType">(Slang::HLSLConsumeStructuredBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLStreamOutputType">(Slang::HLSLStreamOutputType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLPointStreamType">(Slang::HLSLPointStreamType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLLineStreamType">(Slang::HLSLLineStreamType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLTriangleStreamType">(Slang::HLSLTriangleStreamType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::UntypedBufferResourceType">(Slang::UntypedBufferResourceType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLByteAddressBufferType">(Slang::HLSLByteAddressBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLRWByteAddressBufferType">(Slang::HLSLRWByteAddressBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLRasterizerOrderedByteAddressBufferType">(Slang::HLSLRasterizerOrderedByteAddressBufferType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::RaytracingAccelerationStructureType">(Slang::RaytracingAccelerationStructureType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLPatchType">(Slang::HLSLPatchType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLInputPatchType">(Slang::HLSLInputPatchType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::HLSLOutputPatchType">(Slang::HLSLOutputPatchType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GLSLInputAttachmentType">(Slang::GLSLInputAttachmentType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StringTypeBase">(Slang::StringTypeBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::StringType">(Slang::StringType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NativeStringType">(Slang::NativeStringType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::DynamicType">(Slang::DynamicType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::EnumTypeType">(Slang::EnumTypeType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PtrTypeBase">(Slang::PtrTypeBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::PtrType">(Slang::PtrType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ParamDirectionType">(Slang::ParamDirectionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OutTypeBase">(Slang::OutTypeBase*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::OutType">(Slang::OutType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::InOutType">(Slang::InOutType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::RefType">(Slang::RefType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NullPtrType">(Slang::NullPtrType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ArrayExpressionType">(Slang::ArrayExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TypeType">(Slang::TypeType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamedExpressionType">(Slang::NamedExpressionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::FuncType">(Slang::FuncType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::GenericDeclRefType">(Slang::GenericDeclRefType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::NamespaceType">(Slang::NamespaceType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExtractExistentialType">(Slang::ExtractExistentialType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::TaggedUnionType">(Slang::TaggedUnionType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ExistentialSpecializedType">(Slang::ExistentialSpecializedType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ThisType">(Slang::ThisType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::AndType">(Slang::AndType*)&amp;astNodeType</ExpandedItem>
+            <ExpandedItem Condition="astNodeType == Slang::ASTNodeType::ModifiedType">(Slang::ModifiedType*)&amp;astNodeType</ExpandedItem>
+            <Item Name="[Type]">(Slang::Type*)this,nd</Item>
+        </Expand>
+    </Type>
+
+    <Type Name="Slang::AggTypeDecl">
+        <DisplayString>{nameAndLoc.name}: {astNodeType}</DisplayString>
+        <Expand>
+            <Item Name="[Name]">nameAndLoc.name</Item>
+            <Item Name="[Parent]">parentDecl</Item>
+            <Item Name="[Members]">members</Item>
+        </Expand>
+    </Type>
 </AutoVisualizer>
\ No newline at end of file