[Reflection API] Getting name of the module in which a type was declared?

[papasitopapi]

Hi,

Like the title says, for a given type in my program I would like to know the module in which it was declared.

My current approach is to

1. Iterate over all loaded modules in the session after compiling my shaders.
2. Iterate over the declarations in the module reflection.
3. For declarations of types I'm interested in, map their TypeReflection* to the module name

std::unordered_map<slang::TypeReflection *, std::string> typeToModuleNameMap;

void mapTypes()
{
    for (SlangInt i = 0; i < slangSession->getLoadedModuleCount(); ++i)
    {
        slang::IModule *module = slangSession->getLoadedModule(i);
        auto moduleName = std::string(module->getName());
        for (slang::DeclReflection *childDecl : module->getModuleReflection()->getChildren())
        {
            auto kind = childDecl->getKind();
            if (kind == slang::DeclReflection::Kind::Struct)
            {
                slang::TypeReflection *typeReflection = childDecl->getType();
                typeToModuleNameMap[typeReflection] = moduleName;
            }
        }
    }
}

And, when iterating a ProgramLayout, I check the TypeReflection* encountered against the map to retrieve its module:

void printType(slang::TypeReflection *type)
{
    auto typeName = std::string(type->getName());
    auto moduleName = typeToModuleNameMap.contains(type) ? typeToModuleNameMap[type] : "Not found";
    print(std::format("Name: {}, Module: {}", typeName, moduleName));
}

My questions are:

• Does the API have a more direct way to get the source module of a type?
• Otherwise, is my approach stable? For a TypeReflection* retrieved from a ProgramLayout, will the address pointed always be the same as the one from the TypeReflection* in the corresponding DeclReflection? Could that change in the future?