Fix loading token for TypeSpec

- Parsing a typespec when dumping an ldtoken now outputs correct type.
- Parsing a typespec when executing ldtoken IL now sets reflection with instanciated type.
- Add parameter with caller to SetReflection from TypeSpec.
- Fix calls.

Author: josesimoes

src/CLR/Core/CLR_RT_HeapBlock.cpp

@@ -232,17 +232,54 @@ HRESULT CLR_RT_HeapBlock::SetReflection(const CLR_RT_Assembly_Index &assm)
     NANOCLR_NOCLEANUP_NOLABEL();
 }
 
-HRESULT CLR_RT_HeapBlock::SetReflection(const CLR_RT_TypeSpec_Index &sig)
+HRESULT CLR_RT_HeapBlock::SetReflection(const CLR_RT_TypeSpec_Instance &tsInst, const CLR_RT_TypeSpec_Index *caller)
 {
     NATIVE_PROFILE_CLR_CORE();
     NANOCLR_HEADER();
 
-    CLR_RT_TypeDescriptor desc{};
+    m_id.raw = CLR_RT_HEAPBLOCK_RAW_ID(DATATYPE_REFLECTION, 0, 1);
+    m_data.reflection.kind = REFLECTION_TYPE;
 
-    NANOCLR_CHECK_HRESULT(desc.InitializeFromTypeSpec(sig));
+    // start parsing the signature
+    CLR_RT_SignatureParser parser;
+    parser.Initialize_TypeSpec(tsInst.assembly, tsInst.target);
 
-    m_id.raw = CLR_RT_HEAPBLOCK_RAW_ID(DATATYPE_REFLECTION, 0, 1);
-    m_data.reflection = desc.m_reflex;
+    // read first element
+    CLR_RT_SignatureParser::Element elem;
+    if (FAILED(parser.Advance(elem)))
+    {
+        NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
+    }
+
+    if (elem.DataType == DATATYPE_VAR || elem.DataType == DATATYPE_MVAR)
+    {
+        int gpIndex = elem.GenericParamPosition;
+
+        // if the caller's genericType is non‐null, ask the CLR to map !n→actual argument:
+        if (caller != nullptr && NANOCLR_INDEX_IS_VALID(*caller))
+        {
+            CLR_RT_TypeDef_Index tdArg{};
+            NanoCLRDataType dtArg;
+
+            bool ok = g_CLR_RT_TypeSystem.m_assemblies[caller->Assembly() - 1]
+                          ->FindGenericParamAtTypeSpec(caller->TypeSpec(), gpIndex, tdArg, dtArg);
+            if (ok)
+            {
+                m_data.reflection.data.type = tdArg;
+                m_data.reflection.levels = elem.Levels;
+            }
+        }
+        else
+        {
+            // TODO
+            _ASSERTE(false);
+        }
+    }
+    else
+    {
+        m_data.reflection.data.type = elem.Class;
+        m_data.reflection.levels = elem.Levels;
+    }
 
     NANOCLR_NOCLEANUP();
 }

src/CLR/Core/CLR_RT_HeapBlock_Array.cpp

@@ -104,7 +104,7 @@ HRESULT CLR_RT_HeapBlock_Array::CreateInstance(
     }
     else if (def.ResolveToken(tk, assm))
     {
-        NANOCLR_CHECK_HRESULT(ref.SetReflection(def));
+        NANOCLR_CHECK_HRESULT(ref.SetReflection(def, caller->genericType));
     }
     else
     {

src/CLR/Core/Interpreter.cpp

@@ -3210,13 +3210,13 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                     {
                         case TBL_TypeSpec:
                         {
-                            CLR_RT_TypeSpec_Instance sig{};
-                            if (sig.ResolveToken(arg, assm) == false)
+                            CLR_RT_TypeSpec_Instance tsInst{};
+                            if (tsInst.ResolveToken(arg, assm) == false)
                             {
                                 NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
                             }
 
-                            evalPos[0].SetReflection(sig);
+                            evalPos[0].SetReflection(tsInst, stack->m_call.genericType);
                         }
                         break;
 

src/CLR/Diagnostics/Info.cpp

@@ -531,7 +531,7 @@ void CLR_RT_Assembly::DumpToken(CLR_UINT32 token, const CLR_RT_TypeSpec_Index *g
             }
 
             CLR_RT_TypeSpec_Index tsIdx;
-            tsIdx.Set(ownerAsm, index);
+            tsIdx.Set(assemblyIndex, index);
 
             // bind to get the signature blob
             CLR_RT_TypeSpec_Instance tsInst{};
@@ -568,17 +568,19 @@ void CLR_RT_Assembly::DumpToken(CLR_UINT32 token, const CLR_RT_TypeSpec_Index *g
                 {
                     CLR_RT_TypeDef_Index tdArg{};
                     NanoCLRDataType dtArg;
-
-                    bool ok =
-                        tsInst.assembly->FindGenericParamAtTypeSpec(genericType->TypeSpec(), gpIndex, tdArg, dtArg);
+                    bool ok = g_CLR_RT_TypeSystem.m_assemblies[genericType->Assembly() - 1]
+                                  ->FindGenericParamAtTypeSpec(genericType->TypeSpec(), gpIndex, tdArg, dtArg);
                     if (ok)
                     {
-                        // Print that bound argument (e.g. "I4" or full class name)
-                        char bufArg[256];
+                        char bufArg[256]{};
                         char *pArg = bufArg;
                         size_t cbArg = sizeof(bufArg);
-                        g_CLR_RT_TypeSystem.BuildTypeName(tdArg, pArg, cbArg);
+
+                        g_CLR_RT_TypeSystem
+                            .BuildTypeName(tdArg, pArg, cbArg, CLR_RT_TypeSystem::TYPENAME_FLAGS_FULL, elem.Levels);
+
                         CLR_Debug::Printf("%s", bufArg);
+
                         break;
                     }
                 }

src/CLR/Include/nanoCLR_Runtime__HeapBlock.h

@@ -1347,7 +1347,7 @@ struct CLR_RT_HeapBlock
 
     HRESULT SetReflection(const CLR_RT_ReflectionDef_Index &reflex);
     HRESULT SetReflection(const CLR_RT_Assembly_Index &assm);
-    HRESULT SetReflection(const CLR_RT_TypeSpec_Index &sig);
+    HRESULT SetReflection(const CLR_RT_TypeSpec_Instance &tsInst, const CLR_RT_TypeSpec_Index *caller);
     HRESULT SetReflection(const CLR_RT_TypeDef_Index &cls);
     HRESULT SetReflection(const CLR_RT_FieldDef_Index &fd);
     HRESULT SetReflection(const CLR_RT_MethodDef_Index &md);