Fix handling generic type in several IL

src/CLR/Core/CLR_RT_HeapBlock.cpp

@@ -774,6 +774,137 @@ HRESULT CLR_RT_HeapBlock::Reassign(const CLR_RT_HeapBlock &value)
     NANOCLR_NOCLEANUP();
 }
 
+HRESULT CLR_RT_HeapBlock::Reassign(CLR_RT_HeapBlock &rhs, const CLR_RT_TypeDef_Instance &expectedType)
+{
+    NATIVE_PROFILE_CLR_CORE();
+    NANOCLR_HEADER();
+
+    // Build a TypeDescriptor for the *expected* type (the IL TypeSpec/TypeDef)
+    CLR_RT_TypeDescriptor descExpected;
+    NANOCLR_CHECK_HRESULT(descExpected.InitializeFromTypeDef(expectedType));
+
+    // Build a TypeDescriptor for the *actual* runtime object in rhs
+    CLR_RT_TypeDescriptor descActual;
+    NANOCLR_CHECK_HRESULT(descActual.InitializeFromObject(rhs));
+
+    // Compare them (including generics, arrays, value-types, etc.)
+    if (!TypeDescriptorsMatch(descExpected, descActual))
+    {
+        NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
+    }
+
+    // They match: now do the actual copy
+    // - reference types & arrays: copy the object reference
+    // - value-types & primitives: copy the raw data
+    switch (descActual.GetDataType())
+    {
+        case DATATYPE_CLASS:
+        case DATATYPE_SZARRAY:
+        {
+            // object reference or single-dim array
+            this->Assign(rhs);
+            break;
+        }
+
+        default:
+        {
+            // value-type, primitive, struct, etc.
+            // this->CopyFrom(rhs);
+            break;
+        }
+    }
+
+    NANOCLR_NOCLEANUP();
+}
+
+bool CLR_RT_HeapBlock::TypeDescriptorsMatch(
+    const CLR_RT_TypeDescriptor &expectedType,
+    const CLR_RT_TypeDescriptor &actualType)
+{
+    // Figure out logical DataTypes, promoting ACTUAL CLASS ---> GENERICINST
+    NanoCLRDataType expectedDataType = expectedType.GetDataType();
+    NanoCLRDataType actualDataType = actualType.GetDataType();
+
+    // If the *actual* object is a closed-generic (even though boxed as CLASS),
+    // it will have m_handlerGenericType set.  Promote it to GENERICINST.
+    if (actualDataType == DATATYPE_CLASS && actualType.m_handlerGenericType.data != CLR_EmptyToken)
+    {
+        actualDataType = DATATYPE_GENERICINST;
+    }
+
+    // If either side is GENERICINST, we do generic-inst matching
+    if (expectedDataType == DATATYPE_GENERICINST || actualDataType == DATATYPE_GENERICINST)
+    {
+        auto &eSpec = expectedType.m_handlerGenericType;
+        auto &aSpec = actualType.m_handlerGenericType;
+
+        return eSpec.Assembly() == aSpec.Assembly() && eSpec.typeDefIndex == aSpec.typeDefIndex;
+    }
+
+    if (actualDataType <= DATATYPE_LAST_PRIMITIVE_TO_PRESERVE)
+    {
+        // If they declared a true valuetype, match directly:
+        if (expectedDataType == DATATYPE_VALUETYPE)
+        {
+            const auto &dtl = c_CLR_RT_DataTypeLookup[actualDataType];
+            if (dtl.m_cls && dtl.m_cls->data == expectedType.m_handlerCls.data)
+            {
+                return true;
+            }
+        }
+        // if they declared a boxed struct (CLASS whose TypeDef is a struct),
+        // need to match that too:
+        else if (expectedDataType == DATATYPE_CLASS && expectedType.m_handlerGenericType.data == 0)
+        {
+            // Look up the TypeDef record flags to see if it's a VALUE-TYPE.
+            CLR_RT_TypeDef_Index clsIdx = expectedType.m_handlerCls;
+
+            // fetch the owning assembly
+            CLR_RT_Assembly *ownerAsm = g_CLR_RT_TypeSystem.m_assemblies[clsIdx.Assembly() - 1];
+            const CLR_RECORD_TYPEDEF *rec = ownerAsm->GetTypeDef(clsIdx.Type());
+
+            if (rec &&
+                ((rec->flags & CLR_RECORD_TYPEDEF::TD_Semantics_Mask) == CLR_RECORD_TYPEDEF::TD_Semantics_ValueType))
+            {
+                const auto &dtl = c_CLR_RT_DataTypeLookup[actualDataType];
+                if (dtl.m_cls && dtl.m_cls->data == clsIdx.data)
+                {
+                    return true;
+                }
+            }
+        }
+    }
+
+    // For everything else, DataTypes must line up exactly
+    if (expectedDataType != actualDataType)
+    {
+        return false;
+    }
+
+    // Dispatch on the remaining kinds
+    switch (expectedDataType)
+    {
+        case DATATYPE_CLASS:
+        case DATATYPE_VALUETYPE:
+        {
+            // compare TypeDef indices
+            auto &eCls = expectedType.m_handlerCls;
+            auto &aCls = actualType.m_handlerCls;
+            return eCls.data == aCls.data;
+        }
+
+        case DATATYPE_SZARRAY:
+        {
+            // compare outer dims (always 1) then element types
+            return TypeDescriptorsMatch(expectedType, actualType);
+        }
+
+        // primitives and other leaf types match on the DataType alone
+        default:
+            return true;
+    }
+}
+
 void CLR_RT_HeapBlock::AssignAndPinReferencedObject(const CLR_RT_HeapBlock &value)
 {
     // This is very special case that we have local variable with pinned attribute in metadata.
@@ -787,7 +918,7 @@ void CLR_RT_HeapBlock::AssignAndPinReferencedObject(const CLR_RT_HeapBlock &valu
         m_data.objectReference.ptr->Unpin();
     }
 
-    // Move the data.
+    // Move the data
     m_data = value.m_data;
 
     // Leave the same logic as in AssignAndPreserveType

src/CLR/Core/Execution.cpp

@@ -1983,7 +1983,7 @@ HRESULT CLR_RT_ExecutionEngine::InitializeLocals(
                     parser.Advance(element);
 
                     // walk forward to the Nth generic-parameter
-                    for (int i = 0; i < genericParamPosition; i++)
+                    for (int i = 0; i <= genericParamPosition; i++)
                     {
                         parser.Advance(element);
                     }
@@ -3217,6 +3217,85 @@ bool CLR_RT_ExecutionEngine::IsInstanceOf(
     return IsInstanceOf(desc, descTarget, isInstInstruction);
 }
 
+/// <summary>
+/// Checks whether the heap-object 'obj' satisfies exactly the type encoded by
+/// the compressed token 'token' in the IL stream, under the current generic
+/// instantiation in 'caller'.  Supports DATATYPE_VAR slots and full GENERICINST.
+/// </summary>
+bool CLR_RT_ExecutionEngine::IsInstanceOfToken(
+    CLR_UINT32 token,
+    CLR_RT_HeapBlock &obj,
+    const CLR_RT_MethodDef_Instance &caller)
+{
+    // Resolve the *expected* signature into a TypeDescriptor
+    CLR_RT_TypeDescriptor expectedDesc;
+    HRESULT hr = expectedDesc.InitializeFromSignatureToken(caller.assembly, token, &caller);
+
+    if (FAILED(hr))
+    {
+        return false;
+    }
+
+    // Extract the *actual* runtime type of the object
+    CLR_RT_TypeDescriptor actualDesc;
+    hr = actualDesc.InitializeFromObject(obj);
+
+    if (FAILED(hr))
+    {
+        return false;
+    }
+
+    // Delegate to the CLR built-in type-compatibility test
+    return TypeDescriptorsMatch(expectedDesc, actualDesc);
+}
+
+bool CLR_RT_ExecutionEngine::TypeDescriptorsMatch(const CLR_RT_TypeDescriptor &exp, const CLR_RT_TypeDescriptor &act)
+{
+    // Quick check on the raw element kind
+    if (exp.GetDataType() != act.GetDataType())
+    {
+        return false;
+    }
+
+    switch (exp.GetDataType())
+    {
+        // Closed‐generic instantiation: compare the TypeSpec head
+        case DATATYPE_GENERICINST:
+        case DATATYPE_VAR:
+        {
+            auto &eSpec = exp.m_handlerGenericType;
+            auto &aSpec = act.m_handlerGenericType;
+            return eSpec.Assembly() == aSpec.Assembly() && eSpec.typeDefIndex == aSpec.typeDefIndex;
+        }
+
+        // Plain object or value‐type: compare the TypeDef_Index
+        case DATATYPE_CLASS:
+        case DATATYPE_VALUETYPE:
+        case DATATYPE_SZARRAY:
+        {
+            auto &eCls = exp.m_handlerCls;
+            auto &aCls = act.m_handlerCls;
+
+            if (eCls.data != aCls.data)
+            {
+                return false;
+            }
+
+            // for array we may need to compare element‐types
+            if (exp.GetDataType() == DATATYPE_SZARRAY)
+            {
+                // recurse into element descriptors
+                return TypeDescriptorsMatch(exp, act);
+            }
+            return true;
+        }
+
+        // All the primitives (I4, I8, R4, etc.) don't carry extra metadata
+        default:
+            return true;
+    }
+}
+
 HRESULT CLR_RT_ExecutionEngine::CastToType(
     CLR_RT_HeapBlock &ref,
     CLR_UINT32 tk,

src/CLR/Core/Interpreter.cpp

@@ -2644,9 +2644,9 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
 
                     switch (dt)
                     {
+                        case DATATYPE_GENERICINST:
                         case DATATYPE_CLASS:
                         case DATATYPE_VALUETYPE:
-                        case DATATYPE_GENERICINST:
                             obj[fieldInst.CrossReference().offset].AssignAndPreserveType(evalPos[2]);
                             break;
                         case DATATYPE_DATETIME: // Special case.
@@ -2969,7 +2969,7 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                     NANOCLR_CHECK_HRESULT(CLR_RT_TypeDescriptor::ExtractTypeIndexFromObject(evalPos[0], cls));
 
                     // Check this is an object of the requested type.
-                    if (type.data != cls.data)
+                    if (!g_CLR_RT_ExecutionEngine.IsInstanceOfToken(arg, evalPos[0], stack->m_call))
                     {
                         NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
                     }
@@ -3125,18 +3125,37 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                 OPDEF(CEE_STELEM, "stelem", PopRef + PopI + Pop1, Push0, InlineType, IObjModel, 1, 0xFF, 0xA4, NEXT)
                 // Stack: ... ... <obj> <index> <value> -> ...
                 {
-                    // Treat STELEM like ldelema + stobj
-                    ip += 2; // Skip type argument, not used...
+                    FETCH_ARG_COMPRESSED_TYPETOKEN(arg, ip);
 
-                    evalPos -= 3; // "pop" args from evaluation stack
+                    evalPos -= 3;
                     CHECKSTACK(stack, evalPos);
 
+                    // Build a by-ref to the array slot at [index]
                     NANOCLR_CHECK_HRESULT(
                         evalPos[1].InitializeArrayReference(evalPos[1], evalPos[2].NumericByRef().s4));
                     evalPos[1].FixArrayReferenceForValueTypes();
 
-                    // Reassign will make sure these are objects of the same type.
-                    NANOCLR_CHECK_HRESULT(evalPos[1].Reassign(evalPos[3]));
+                    // Resolve the IL's element type in the context of any generics
+                    CLR_RT_TypeDef_Instance expectedType;
+                    if (!expectedType.ResolveToken(arg, assm, &stack->m_call))
+                    {
+                        NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
+                    }
+
+                    NanoCLRDataType elemDT = (NanoCLRDataType)expectedType.target->dataType;
+
+                    // Promote the value if it's a reference or boxed struct
+                    evalPos[3].Promote();
+
+                    // Compute the element‐size: 0 for refs (incl. genericinst), sizeInBytes for primitives
+                    size_t size = 0;
+                    if (elemDT <= DATATYPE_LAST_PRIMITIVE_TO_PRESERVE)
+                    {
+                        size = c_CLR_RT_DataTypeLookup[elemDT].m_sizeInBytes;
+                    }
+
+                    // Store the value into the actual array buffer
+                    NANOCLR_CHECK_HRESULT(evalPos[3].StoreToReference(evalPos[1], size));
 
                     break;
                 }