DateTime and TimeSpan are not handled as primitive types

- Remove these throughout the code base.
- Add DateTime::NewObject and rework code accordingly.
- Update data type lookup for DateTime and TimeSpan so they end up as value type types.

src/CLR/CorLib/corlib_native.h

@@ -496,6 +496,7 @@ struct Library_corlib_native_System_DateTime
 
     //--//
 
+    static CLR_INT64 *NewObject(CLR_RT_StackFrame &stack);
     static CLR_INT64 *GetValuePtr(CLR_RT_StackFrame &stack);
     static CLR_INT64 *GetValuePtr(CLR_RT_HeapBlock &ref);
 

src/CLR/CorLib/corlib_native_System_Convert.cpp

@@ -523,30 +523,19 @@ HRESULT Library_corlib_native_System_Convert::NativeToDateTime___STATIC__SystemD
 {
     NANOCLR_HEADER();
 
-    CLR_RT_TypeDescriptor dtType;
-    CLR_INT64 *pRes;
+    uint64_t ticks;
+    CLR_INT64 *value;
 
     char *str = (char *)stack.Arg0().RecoverString();
     char *conversionResult = NULL;
     // char *str = (char *)"1999-10-31 10:00:00Z";
-    uint64_t ticks;
 
     // grab parameter with flag to throw on failure
     bool throwOnFailure = (bool)stack.Arg1().NumericByRefConst().u1;
 
-    CLR_RT_HeapBlock &ref = stack.PushValue();
-
     // check string parameter for null
     FAULT_ON_NULL_ARG(str);
 
-    // initialize <DateTime> type descriptor
-    NANOCLR_CHECK_HRESULT(dtType.InitializeFromType(g_CLR_RT_WellKnownTypes.m_DateTime));
-
-    // create an instance of <DateTime>
-    NANOCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObject(ref, dtType.m_handlerCls));
-
-    pRes = Library_corlib_native_System_DateTime::GetValuePtr(ref);
-
     // try 'u' Universal time with sortable format (yyyy-MM-dd' 'HH:mm:ss)
     conversionResult = Nano_strptime(str, "%Y-%m-%d %H:%M:%SZ", &ticks);
     if (conversionResult == NULL)
@@ -570,12 +559,12 @@ HRESULT Library_corlib_native_System_Convert::NativeToDateTime___STATIC__SystemD
     if (conversionResult == NULL)
     {
         // failed to parse string
-
         NANOCLR_SET_AND_LEAVE(CLR_E_FORMAT_EXCEPTION);
     }
     else
     {
-        *pRes = ticks;
+        value = Library_corlib_native_System_DateTime::NewObject(stack);
+        *value = ticks;
     }
 
     NANOCLR_CLEANUP();

src/CLR/CorLib/corlib_native_System_DateTime.cpp

@@ -151,54 +151,49 @@ HRESULT Library_corlib_native_System_DateTime::get_UtcNow___STATIC__SystemDateTi
 {
     NATIVE_PROFILE_CLR_CORE();
     NANOCLR_HEADER();
-
-    CLR_RT_TypeDescriptor dtType;
-    CLR_INT64*            val;
-
-    CLR_RT_HeapBlock& ref = stack.PushValue();
 
-    // initialize <DateTime> type descriptor
-    NANOCLR_CHECK_HRESULT( dtType.InitializeFromType(g_CLR_RT_WellKnownTypes.m_DateTime));
-
-    // create an instance of <DateTime>
-    NANOCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObject(ref, dtType.m_handlerCls));
+    CLR_INT64 *val = NewObject(stack);
 
-    val = GetValuePtr(ref);
-
     // load with full date&time
     // including UTC flag
-    *val = HAL_Time_CurrentDateTime(false) | s_UTCMask;
+    *val = (CLR_INT64)(HAL_Time_CurrentDateTime(false) | s_UTCMask);
 
-    NANOCLR_NOCLEANUP();
+    NANOCLR_NOCLEANUP_NOLABEL();
 }
 
 HRESULT Library_corlib_native_System_DateTime::get_Today___STATIC__SystemDateTime(CLR_RT_StackFrame &stack)
 {
     NATIVE_PROFILE_CLR_CORE();
     NANOCLR_HEADER();
 
+    CLR_INT64 *val = NewObject(stack);
+
+    // load with date part only
+    // including UTC flag
+    *val = (CLR_INT64)(HAL_Time_CurrentDateTime(true) | s_UTCMask);
+
+    NANOCLR_NOCLEANUP_NOLABEL();
+}
+
+//--//
+
+CLR_INT64 *Library_corlib_native_System_DateTime::NewObject(CLR_RT_StackFrame &stack)
+{
+    NATIVE_PROFILE_CLR_CORE();
+
     CLR_RT_TypeDescriptor dtType;
-    CLR_INT64*            val;
 
-    CLR_RT_HeapBlock& ref = stack.PushValue();
+    CLR_RT_HeapBlock &ref = stack.PushValue();
 
     // initialize <DateTime> type descriptor
-    NANOCLR_CHECK_HRESULT(dtType.InitializeFromType(g_CLR_RT_WellKnownTypes.m_DateTime));
+    dtType.InitializeFromType(g_CLR_RT_WellKnownTypes.m_DateTime);
 
     // create an instance of <DateTime>
-    NANOCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObject( ref, dtType.m_handlerCls));
+    g_CLR_RT_ExecutionEngine.NewObject(ref, dtType.m_handlerCls);
 
-    val = GetValuePtr( ref );
-
-    // load with date part only
-    // including UTC flag
-    *val = HAL_Time_CurrentDateTime(true) | s_UTCMask;
-
-    NANOCLR_NOCLEANUP();
+    return GetValuePtr(ref);
 }
 
-//--//
-
 CLR_INT64 *Library_corlib_native_System_DateTime::GetValuePtr(CLR_RT_StackFrame &stack)
 {
     NATIVE_PROFILE_CLR_CORE();
@@ -221,17 +216,16 @@ CLR_INT64 *Library_corlib_native_System_DateTime::GetValuePtr(CLR_RT_HeapBlock &
 
     // after dereferencing the object if it's pointing to another Object
     // need to do it again because this DateTime instance is most likely boxed
-    if (dt == DATATYPE_OBJECT)
+    if (dt == DATATYPE_OBJECT || dt == DATATYPE_BYREF)
     {
         obj = obj->Dereference();
+
         if (!obj)
+        {
             return NULL;
-        dt = obj->DataType();
-    }
+        }
 
-    if (dt == DATATYPE_DATETIME)
-    {
-        return (CLR_INT64 *)&obj->NumericByRef().s8;
+        dt = obj->DataType();
     }
 
     if (dt == DATATYPE_I8)

src/CLR/CorLib/corlib_native_System_Reflection_FieldInfo.cpp

@@ -74,17 +74,7 @@ HRESULT Library_corlib_native_System_Reflection_FieldInfo::SetValue___VOID__OBJE
 #endif
     }
 
-    switch(obj->DataType())
-    {
-        case DATATYPE_DATETIME: // Special case.
-        case DATATYPE_TIMESPAN: // Special case.
-            obj->NumericByRef().s8 = val.NumericByRefConst().s8;
-            break;
-
-        default:
-            obj->Assign( val );
-            break;
-    }
+    obj->Assign(val);
 
     NANOCLR_NOCLEANUP();
 }

src/CLR/CorLib/corlib_native_System_TimeSpan.cpp

@@ -180,12 +180,18 @@ HRESULT Library_corlib_native_System_TimeSpan::Equals___STATIC__BOOLEAN__SystemT
 CLR_INT64 *Library_corlib_native_System_TimeSpan::NewObject(CLR_RT_StackFrame &stack)
 {
     NATIVE_PROFILE_CLR_CORE();
+
+    CLR_RT_TypeDescriptor dtType;
+
     CLR_RT_HeapBlock &ref = stack.PushValue();
 
-    ref.SetDataId(CLR_RT_HEAPBLOCK_RAW_ID(DATATYPE_TIMESPAN, 0, 1));
-    ref.ClearData();
+    // initialize <TimeSpan> type descriptor
+    dtType.InitializeFromType(g_CLR_RT_WellKnownTypes.m_TimeSpan);
 
-    return (CLR_INT64 *)&ref.NumericByRef().s8;
+    // create an instance of <TimeSpan>
+    g_CLR_RT_ExecutionEngine.NewObject(ref, dtType.m_handlerCls);
+
+    return GetValuePtr(ref);
 }
 
 CLR_INT64 *Library_corlib_native_System_TimeSpan::GetValuePtr(CLR_RT_StackFrame &stack)
@@ -209,11 +215,6 @@ CLR_INT64 *Library_corlib_native_System_TimeSpan::GetValuePtr(CLR_RT_HeapBlock &
         dt = obj->DataType();
     }
 
-    if (dt == DATATYPE_TIMESPAN)
-    {
-        return (CLR_INT64 *)&obj->NumericByRef().s8;
-    }
-
     if (dt == DATATYPE_I8)
     {
         return (CLR_INT64 *)&obj->NumericByRef().s8;

src/CLR/Core/CLR_RT_HeapBlock.cpp

@@ -180,8 +180,6 @@ HRESULT CLR_RT_HeapBlock::EnsureObjectReference(CLR_RT_HeapBlock *&obj)
             {
                 case DATATYPE_CLASS:
                 case DATATYPE_VALUETYPE:
-                case DATATYPE_DATETIME: // Special case.
-                case DATATYPE_TIMESPAN: // Special case.
                     NANOCLR_SET_AND_LEAVE(S_OK);
 
                 default:
@@ -191,11 +189,6 @@ HRESULT CLR_RT_HeapBlock::EnsureObjectReference(CLR_RT_HeapBlock *&obj)
         }
         break;
 
-        case DATATYPE_DATETIME: // Special case.
-        case DATATYPE_TIMESPAN: // Special case.
-            obj = this;
-            NANOCLR_SET_AND_LEAVE(S_OK);
-
         default:
             // the remaining data types aren't to be handled
             break;
@@ -358,24 +351,11 @@ void CLR_RT_HeapBlock::FixArrayReferenceForValueTypes()
     NATIVE_PROFILE_CLR_CORE();
     CLR_RT_HeapBlock_Array *array = m_data.arrayReference.array;
 
-    //
     // ValueTypes are implemented as pointers to objects,
     // so getting an array reference to a ValueType has to be treated like assigning a pointer!
-    //
-    // DateTime and TimeSpan are optimized as primitive types,
-    // so getting an array reference to them is like getting a reference to them.
-    //
-    switch (array->m_typeOfElement)
+    if (array->m_typeOfElement == DATATYPE_VALUETYPE)
     {
-        case DATATYPE_VALUETYPE:
-            this->SetReference(*(CLR_RT_HeapBlock *)array->GetElement(m_data.arrayReference.index));
-            break;
-
-        case DATATYPE_DATETIME:
-        case DATATYPE_TIMESPAN:
-            m_id.raw = CLR_RT_HEAPBLOCK_RAW_ID(DATATYPE_BYREF, 0, 1);
-            m_data.objectReference.ptr = (CLR_RT_HeapBlock *)array->GetElement(m_data.arrayReference.index);
-            break;
+        this->SetReference(*(CLR_RT_HeapBlock *)array->GetElement(m_data.arrayReference.index));
     }
 }
 
@@ -831,18 +811,6 @@ HRESULT CLR_RT_HeapBlock::PerformBoxing(const CLR_RT_TypeDef_Instance &cls)
                 g_CLR_RT_ExecutionEngine.ExtractHeapBlocksForClassOrValueTypes(DATATYPE_VALUETYPE, HB_Boxed, cls, 2);
             FAULT_ON_NULL(ptr);
 
-            switch (dataType)
-            {
-                case DATATYPE_DATETIME: // Special case.
-                case DATATYPE_TIMESPAN: // Special case.
-                    dataType = DATATYPE_I8;
-                    break;
-
-                default:
-                    // the remaining data types aren't to be handled
-                    break;
-            }
-
             ptr[1].SetDataId(CLR_RT_HEAPBLOCK_RAW_ID(dataType, 0, 1));
             ptr[1].AssignData(*this);
 
@@ -1208,11 +1176,9 @@ CLR_UINT32 CLR_RT_HeapBlock::GetAtomicDataUsedBytes() const
             return 4;
             break;
 
-        case DATATYPE_I8:       // Fall through, hashDataSize = 8
-        case DATATYPE_U8:       // Fall through, hashDataSize = 8
-        case DATATYPE_R8:       // Fall through, hashDataSize = 8
-        case DATATYPE_DATETIME: // Fall through, hashDataSize = 8
-        case DATATYPE_TIMESPAN:
+        case DATATYPE_I8: // Fall through, hashDataSize = 8
+        case DATATYPE_U8: // Fall through, hashDataSize = 8
+        case DATATYPE_R8: // Fall through, hashDataSize = 8
             return 8;
             break;
 
@@ -1720,8 +1686,6 @@ CLR_INT32 CLR_RT_HeapBlock::Compare_Values(const CLR_RT_HeapBlock &left, const C
 
             case DATATYPE_I8:
             case DATATYPE_U8:
-            case DATATYPE_DATETIME:
-            case DATATYPE_TIMESPAN:
                 return CompareValues_Numeric(left, right, fSigned, c_CLR_RT_DataTypeLookup[leftDataType].m_sizeInBytes);
 
             default:

src/CLR/Core/Interpreter.cpp

@@ -2513,10 +2513,7 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                         case DATATYPE_VALUETYPE:
                             evalPos[0].Assign(obj[fieldInst.CrossReference().m_offset]);
                             goto Execute_LoadAndPromote;
-                        case DATATYPE_DATETIME:
-                        case DATATYPE_TIMESPAN:
-                            evalPos[0].SetInteger((CLR_INT64)obj->NumericByRefConst().s8);
-                            break;
+
 #if defined(NANOCLR_APPDOMAINS)
                         case DATATYPE_TRANSPARENT_PROXY:
                         {
@@ -2564,10 +2561,6 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                     {
                         evalPos[0].SetReference(obj[fieldInst.CrossReference().m_offset]);
                     }
-                    else if (dt == DATATYPE_DATETIME || dt == DATATYPE_TIMESPAN) // Special case.
-                    {
-                        NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); // NOT SUPPORTED.
-                    }
                     else
                     {
                         NANOCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE);
@@ -2600,10 +2593,6 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                         case DATATYPE_VALUETYPE:
                             obj[fieldInst.CrossReference().m_offset].AssignAndPreserveType(evalPos[2]);
                             break;
-                        case DATATYPE_DATETIME: // Special case.
-                        case DATATYPE_TIMESPAN: // Special case.
-                            obj->NumericByRef().s8 = evalPos[2].NumericByRefConst().s8;
-                            break;
 
 #if defined(NANOCLR_APPDOMAINS)
                         case DATATYPE_TRANSPARENT_PROXY:
@@ -3484,17 +3473,12 @@ HRESULT CLR_RT_Thread::Execute_IL(CLR_RT_StackFrame &stackArg)
                     break;
                 case DATATYPE_R4:
                     break;
-
                 case DATATYPE_I8:
                     break;
                 case DATATYPE_U8:
                     break;
                 case DATATYPE_R8:
                     break;
-                case DATATYPE_DATETIME:
-                    break;
-                case DATATYPE_TIMESPAN:
-                    break;
                 case DATATYPE_STRING:
                     break;
 

src/CLR/Core/NativeEventDispatcher/NativeEventDispatcher.cpp

@@ -6,6 +6,7 @@
 #include "stdafx.h"
 #include <nanoCLR_Hardware.h>
 #include <nf_rt_events_native.h>
+#include <corlib_native.h>
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -223,11 +224,13 @@ HRESULT CLR_RT_HeapBlock_NativeEventDispatcher::StartDispatch(
 
     NANOCLR_HEADER();
 
+    CLR_INT64 *value;
+
     CLR_RT_StackFrame *stackTop;
     CLR_RT_HeapBlock *args;
     CLR_RT_HeapBlock_Delegate *dlg;
     CLR_RT_HeapBlock *event;
-    const CLR_UINT64 c_UTCMask = 0x8000000000000000ULL;
+    const CLR_UINT64 c_UTCMask = ULONGLONGCONSTANT(0x8000000000000000);
 
     InterruptPortInterrupt &interrupt = appInterrupt->m_interruptPortInterrupt;
 
@@ -252,8 +255,11 @@ HRESULT CLR_RT_HeapBlock_NativeEventDispatcher::StartDispatch(
     //
     args[0].SetInteger(interrupt.data1);
     args[1].SetInteger(interrupt.data2);
-    args[2].SetInteger((CLR_UINT64)interrupt.time | c_UTCMask);
-    args[2].ChangeDataType(DATATYPE_DATETIME);
+
+    value = Library_corlib_native_System_DateTime::GetValuePtr(args[2]);
+    FAULT_ON_NULL(value);
+
+    *value = (CLR_UINT64)interrupt.time | c_UTCMask;
 
     th->m_terminationCallback = CLR_RT_HeapBlock_NativeEventDispatcher::ThreadTerminationCallback;
     th->m_terminationParameter = appInterrupt;