Add support for multithreading

HapetBackend/Llvm/TypeInfo/TypeInfoGenerator.cs

@@ -103,8 +103,11 @@ private void GenerateInitializerForTypeInfo(HapetType type)
             int rawSize = (type is PointerType pp && pp.CreatedByCompiler ? pp.TargetType : type).GetSize();
             LLVMValueRef rawSizeValue = LLVMValueRef.CreateConstInt(_context.Int32Type, (ulong)rawSize);
 
+            // is value type
+            LLVMValueRef isValueType = LLVMValueRef.CreateConstInt(_context.Int1Type, (ulong)(type is StructType ? 1 : 0));
+
             _builder.BuildStore(LLVMValueRef.CreateConstNamedStruct(typeInfoType,
-                [interfaceOffsets, dtorDelegate, rawSizeValue]), globConst);
+                [interfaceOffsets, dtorDelegate, rawSizeValue, isValueType]), globConst);
         }
 
         private LLVMTypeRef _typeInfoType;

HapetFrontend/Helpers/GenericsHelper.cs

@@ -302,7 +302,9 @@
                 return HasAnyGenericTypes(nullE);
             else if (expr is AstIdExpr || expr is AstEmptyExpr || expr is AstNullableExpr)
                 return false; // just return false because OutType is checked above
-            Debug.Assert(false, "Unexcepted expr type to check");
+
+            // do not error, just skip this shite. probably errored somewhere above
+            // Debug.Assert(false, "Unexcepted expr type to check");
             return false;
         }
 

std/System/Array.hpt

@@ -136,6 +136,11 @@ public static class Array
         array = newArray;
     }
 
+    public static void Clear<T>(T[] array)
+    {
+        Marshal.Memset(array.Buffer, 0, array.Length * sizeof(T));
+    }
+
     public static void Clear<T>(T[] array, int index, int length)
     {
         Marshal.Memset(array.Buffer + index, 0, length * sizeof(T));

std/System/ArrayTypeMismatchException.hpt

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+
+/// <summary>
+/// The exception that is thrown when an attempt is made to store an element of the wrong type within an array.
+/// </summary>
+public class ArrayTypeMismatchException : SystemException
+{
+    // Creates a new ArrayMismatchException with its message string set to
+    // the empty string, its HRESULT set to COR_E_ARRAYTYPEMISMATCH,
+    // and its ExceptionInfo reference set to null.
+    public ArrayTypeMismatchException() : base(SR.Arg_ArrayTypeMismatchException) { }
+
+    // Creates a new ArrayMismatchException with its message string set to
+    // message, its HRESULT set to COR_E_ARRAYTYPEMISMATCH,
+    // and its ExceptionInfo reference set to null.
+    //
+    public ArrayTypeMismatchException(string message) : base(message ?? SR.Arg_ArrayTypeMismatchException) { }
+}

std/System/BitConverter.hpt

@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // Some modifications were made for hapet-lang compatibility.
 
+using System.Runtime.CompilerServices;
+
 /// <summary>
 /// Converts base data types to an array of bytes, and an array of bytes to base data types.
 /// </summary>
@@ -15,4 +17,25 @@ public static class BitConverter
 #else
     public static readonly bool IsLittleEndian = true;
 #endif
+
+    /// <summary>
+    /// Converts the specified double-precision floating point number to a 64-bit signed integer.
+    /// </summary>
+    /// <param name="value">The number to convert.</param>
+    /// <returns>A 64-bit signed integer whose bits are identical to <paramref name="value"/>.</returns>
+    public static inline long DoubleToInt64Bits(double value) => Unsafe.BitCast<double, long>(value);
+
+    /// <summary>
+    /// Converts the specified double-precision floating point number to a 64-bit unsigned integer.
+    /// </summary>
+    /// <param name="value">The number to convert.</param>
+    /// <returns>A 64-bit unsigned integer whose bits are identical to <paramref name="value"/>.</returns>
+    public static inline ulong DoubleToUInt64Bits(double value) => Unsafe.BitCast<double, ulong>(value);
+
+    /// <summary>
+    /// Converts the specified 64-bit unsigned integer to a double-precision floating point number.
+    /// </summary>
+    /// <param name="value">The number to convert.</param>
+    /// <returns>A double-precision floating point number whose bits are identical to <paramref name="value"/>.</returns>
+    public static inline double UInt64BitsToDouble(ulong value) => Unsafe.BitCast<ulong, double>(value);
 }