Synthesizing GenericTypeInstSig and generating guid

Author: DefaultRyan

natvis/cppwinrt_visualizer.cpp

@@ -150,33 +150,81 @@ TypeDef FindSimpleType(DkmProcess* process, std::string_view const& typeNamespac
     return type;
 }
 
-TypeSig FindType(DkmProcess* process, std::string_view const& typeName)
+std::vector<std::string> ParseTypeName(std::string_view name)
 {
-    auto paramIndex = typeName.find('<');
-    if (paramIndex == std::string_view::npos)
+    DWORD count;
+    HSTRING* parts;
+    auto wide_name = winrt::to_hstring(name);
+    winrt::check_hresult(::RoParseTypeName(static_cast<HSTRING>(get_abi(wide_name)), &count, &parts));
+
+    winrt::com_array<winrt::hstring> wide_parts{ parts, count, winrt::take_ownership_from_abi };
+    std::vector<std::string> result;
+    for (auto&& part : wide_parts)
     {
-        return TypeSig{ FindSimpleType(process, typeName).coded_index<TypeDefOrRef>() };
+        result.push_back(winrt::to_string(part));
     }
-    else
+    return result;
+}
+
+template <std::input_iterator iter, std::sentinel_for<iter> sent>
+TypeSig ResolveGenericTypePart(DkmProcess* process, iter& it, sent const& end)
+{
+    constexpr std::pair<std::string_view, ElementType> elementNames[] = {
+        {"Boolean", ElementType::Boolean},
+        {"Int8", ElementType::I1},
+        {"Int16", ElementType::I2},
+        {"Int32", ElementType::I4},
+        {"Int64", ElementType::I8},
+        {"UInt8", ElementType::U1},
+        {"UInt16", ElementType::U2},
+        {"UInt32", ElementType::U4},
+        {"UInt64", ElementType::U8},
+        {"Single", ElementType::R4},
+        {"Double", ElementType::R8},
+        {"String", ElementType::String},
+        {"Object", ElementType::Object}
+    };
+    std::string_view partName = *it;
+    auto basic_type_pos = std::find_if(std::begin(elementNames), std::end(elementNames), [&partName](auto&& elem) { return elem.first == partName; });
+    if (basic_type_pos != std::end(elementNames))
+    {
+        return TypeSig{ basic_type_pos->second };
+    }
+    
+    TypeDef type = FindSimpleType(process, partName);
+    auto tickPos = partName.rfind('`');
+    if (tickPos == std::string_view::basic_string_view::npos)
     {
-        XLANG_ASSERT(typeName.back() == '>');
-        return TypeSig{ FindSimpleType(process, typeName.substr(0, paramIndex)).coded_index<TypeDefOrRef>() };
-        // TODO: Assemble the GenericTypeInstSig
+        return TypeSig{ type.coded_index<TypeDefOrRef>() };
     }
+
+    int paramCount = 0;
+    std::from_chars(partName.data() + tickPos + 1, partName.data() + partName.size(), paramCount);
+    std::vector<TypeSig> genericArgs;
+    for (int i = 0; i < paramCount; ++i)
+    {
+        genericArgs.push_back(ResolveGenericTypePart(process, ++it, end));
+    }
+    return TypeSig{ GenericTypeInstSig{ type.coded_index<TypeDefOrRef>(), std::move(genericArgs) } };
 }
 
-TypeSig FindType(DkmProcess* process, std::string_view const& typeNamespace, std::string_view const& typeName)
+TypeSig ResolveGenericType(DkmProcess* process, std::string_view genericName)
+{
+    auto parts = ParseTypeName(genericName);
+    auto begin = parts.begin();
+    return ResolveGenericTypePart(process, begin, parts.end());
+}
+
+TypeSig FindType(DkmProcess* process, std::string_view const& typeName)
 {
     auto paramIndex = typeName.find('<');
     if (paramIndex == std::string_view::npos)
     {
-        return TypeSig{ FindSimpleType(process, typeNamespace, typeName).coded_index<TypeDefOrRef>() };
+        return TypeSig{ FindSimpleType(process, typeName).coded_index<TypeDefOrRef>() };
     }
     else
     {
-        XLANG_ASSERT(typeName.back() == '>');
-        return TypeSig{ FindSimpleType(process, typeNamespace, typeName.substr(0, paramIndex)).coded_index<TypeDefOrRef>() };
-        // TODO: Assemble the GenericTypeInstSig
+        return ResolveGenericType(process, typeName);
     }
 }
 

natvis/pch.h

@@ -43,6 +43,7 @@
 #include <variant>
 #include <cmd_reader.h>
 #include <winmd_reader.h>
+#include <rometadataresolution.h>
 
 #ifndef IF_FAIL_RET
 #define IF_FAIL_RET(expr) { HRESULT _hr = (expr); if(FAILED(_hr)) { return(_hr); } }
@@ -94,7 +95,6 @@ inline bool starts_with(std::string_view const& value, std::string_view const& m
 winmd::reader::TypeDef FindSimpleType(Microsoft::VisualStudio::Debugger::DkmProcess* process, std::string_view const& typeName);
 winmd::reader::TypeDef FindSimpleType(Microsoft::VisualStudio::Debugger::DkmProcess* process, std::string_view const& typeNamespace, std::string_view const& typeName);
 winmd::reader::TypeSig FindType(Microsoft::VisualStudio::Debugger::DkmProcess* process, std::string_view const& typeName);
-winmd::reader::TypeSig FindType(Microsoft::VisualStudio::Debugger::DkmProcess* process, std::string_view const& typeNamespace, std::string_view const& typeName);
 
 inline winmd::reader::TypeDef ResolveType(Microsoft::VisualStudio::Debugger::DkmProcess* process, winmd::reader::coded_index<winmd::reader::TypeDefOrRef> index) noexcept
 {

natvis/type_resolver.cpp

@@ -98,6 +98,18 @@ struct signature_generator
         }
     }
 
+    static std::string get_signature(GenericTypeInstSig const& type)
+    {
+        std::string sig = "pinterface(" + get_guid_signature(type.GenericType());
+        for (auto&& arg : type.GenericArgs())
+        {
+            sig += ";";
+            sig += get_signature(arg);
+        }
+        sig += ")";
+        return sig;
+    }
+
 private:
     static std::string get_class_signature(TypeDef const& type)
     {
@@ -152,20 +164,8 @@ struct signature_generator
         case TypeDefOrRef::TypeRef:
             return get_guid_signature(find_required(type.TypeRef()));
         default: //case TypeDefOrRef::TypeSpec:
-            return get_guid_signature(type.TypeSpec().Signature().GenericTypeInst().GenericType());
-        }
-    }
-
-    static std::string get_signature(GenericTypeInstSig const& type)
-    {
-        std::string sig = "pinterface(" + get_guid_signature(type.GenericType());
-        for (auto&& arg : type.GenericArgs())
-        {
-            sig += ";";
-            sig += get_signature(arg);
+            return get_signature(type.TypeSpec().Signature().GenericTypeInst());
         }
-        sig += ")";
-        return sig;
     }
 
     static std::string get_signature(TypeSig::value_type const& type)
@@ -266,7 +266,7 @@ static auto calculate_sha1(std::vector<uint8_t> const& input)
     return get_result(intermediate_hash);
 }
 
-static guid generate_guid(coded_index<TypeDefOrRef> const& type)
+static guid generate_guid(GenericTypeInstSig const& type)
 {
     constexpr guid namespace_guid = { 0xd57af411, 0x737b, 0xc042,{ 0xab, 0xae, 0x87, 0x8b, 0x1e, 0x16, 0xad, 0xee } };
     constexpr auto namespace_bytes = winrt::impl::to_array(namespace_guid);
@@ -284,30 +284,32 @@ std::pair<TypeDef, std::wstring> ResolveTypeInterface(DkmProcess* process, winmd
     if (auto ptrIndex = std::get_if<coded_index<TypeDefOrRef>>(&typeSig.Type()))
     {
         index = *ptrIndex;
+        // TODO: Cache on the whole TypeSig, not just the generic index
+        if (auto found = _cache.find(index); found != _cache.end())
+        {
+            return found->second;
+        }
+
+        TypeDef type = ResolveType(process, index);
+        if (!type)
+        {
+            return {};
+        }
+
+        auto guid = index.type() == TypeDefOrRef::TypeSpec ?
+            format_guid(generate_guid(index.TypeSpec().Signature().GenericTypeInst())) : format_guid(get_guid(type));
+
+        auto type_guid = std::pair{ type, guid };
+        _cache[index] = type_guid;
+        return type_guid;
     }
     else if (auto* ptrGeneric = std::get_if<GenericTypeInstSig>(&typeSig.Type()))
     {
         index = ptrGeneric->GenericType();
+        auto guid = format_guid(generate_guid(*ptrGeneric));
+        return { index.TypeDef(), guid };
     }
-
-    // TODO: Cache on the whole TypeSig, not just the generic index
-    if (auto found = _cache.find(index); found != _cache.end())
-    {
-        return found->second;
-    }
-
-    TypeDef type = ResolveType(process, index);
-    if (!type)
-    {
-        return {};
-    }
-
-    auto guid = index.type() == TypeDefOrRef::TypeSpec ?
-        format_guid(generate_guid(index)) : format_guid(get_guid(type));
-
-    auto type_guid = std::pair{ type, guid };
-    _cache[index] = type_guid;
-    return type_guid;
+    return {};
 };
 
 void ClearTypeResolver()