Moving corlib files out of "System" directory into root

BeefLibs/corlib/src/Reflection/FieldInfo.bf

@@ -0,0 +1,390 @@
+using System.Collections.Generic;
+
+namespace System.Reflection
+{
+	[CRepr, AlwaysInclude]
+	public struct FieldInfo
+	{
+		public enum Error
+		{
+			InvalidTargetType,
+			InvalidValueType
+		}
+
+	    internal TypeInstance mTypeInstance;
+	    internal TypeInstance.FieldData* mFieldData;
+
+	    public this(TypeInstance typeInstance, TypeInstance.FieldData* fieldData)
+	    {
+	        mTypeInstance = typeInstance;
+	        mFieldData = fieldData;
+	    }
+
+	    public int32 MemberOffset
+	    {
+	        get
+	        {
+	            return mFieldData.mDataOffset;
+	        }
+	    }
+
+	    public Type FieldType
+	    {
+	        get
+	        {
+	            return Type.GetType(mFieldData.mFieldTypeId);
+	        }
+	    }
+
+		public StringView Name
+		{
+			get
+			{
+				return mFieldData.mName;
+			}
+		}
+
+	    public Result<void, Error> SetValue(Object obj, Object value)
+	    {    
+	        int32 dataOffsetAdjust = 0;
+	        if (mTypeInstance.IsStruct)
+	        {
+	            Type boxedType = obj.RawGetType();
+	            bool typeMatched = false;
+	            if (boxedType.IsBoxed)
+	            {
+	                if (mTypeInstance == boxedType.UnderlyingType)
+	                {
+	                    dataOffsetAdjust = boxedType.mMemberDataOffset;
+	                    typeMatched = true;
+	                }
+	            }
+	            if (!typeMatched)
+	                return .Err(.InvalidTargetType); // "Invalid target type");
+	        }
+
+	        Type fieldType = Type.GetType(mFieldData.mFieldTypeId);
+	        //Type objType = obj.GetType();
+	        
+	        void* dataAddr = ((uint8*)(void*)obj) + mFieldData.mDataOffset + dataOffsetAdjust;
+
+	        switch (fieldType.mTypeCode)
+	        {
+            case .Boolean:
+				if (!value is bool)
+				return .Err(.InvalidValueType);
+				*(bool*)(uint8*)dataAddr = (.)value;
+				break;        
+	        case .Int32:
+	            if (!value is int32)
+	                return .Err(.InvalidValueType);
+	            *(int32*)(uint8*)dataAddr = (.)value;
+	            break;
+	        default:
+	            return .Err(.InvalidValueType);
+	        }
+	                  
+	        return .Ok;
+	    }
+			
+		public Result<void> SetValue(Object obj, Variant value)
+		{    
+		    int32 dataOffsetAdjust = 0;
+		    if (mTypeInstance.IsStruct)
+		    {
+		        Type boxedType = obj.RawGetType();
+		        bool typeMatched = false;
+		        if (boxedType.IsBoxed)
+		        {
+		            if (mTypeInstance == boxedType.UnderlyingType)
+		            {
+		                dataOffsetAdjust = boxedType.mMemberDataOffset;
+		                typeMatched = true;
+		            }
+		        }
+		        if (!typeMatched)
+		            return .Err;//("Invalid target type");
+		    }
+
+		    Type fieldType = Type.GetType(mFieldData.mFieldTypeId);
+		    //Type objType = obj.GetType();
+		    
+		    void* dataAddr = ((uint8*)(void*)obj) + mFieldData.mDataOffset + dataOffsetAdjust;
+
+			if (value.VariantType != fieldType)
+				return .Err;//("Invalid type");
+
+			value.CopyValueData(dataAddr);
+
+			//TypeCode typeCode = fieldType.mTypeCode;
+
+			/*if (typeCode == TypeCode.Enum)
+				typeCode = fieldType.GetUnderlyingType().mTypeCode;
+
+		    switch (typeCode)
+		    {                             
+		    case TypeCode.Int32:
+		        *(int32*)dataAddr = value.Get<int32>();
+		        break;
+			case TypeCode.Boolean:
+				*(bool*)dataAddr = value.Get<bool>();
+				break;
+			case TypeCode.Object:
+				*(Object*)dataAddr = value.Get<Object>();
+				break;
+		    default:
+		        return .Err;//("Invalid type");
+		    }*/
+		              
+		    return .Ok;
+		}
+	    
+	    static mixin Decode<T2>(void* data)
+	    {
+	        *((*(T2**)&data)++)
+	    }
+
+		public Result<T> GetCustomAttribute<T>() where T : Attribute
+		{
+			if (mFieldData.mCustomAttributesIdx == -1)
+			    return .Err;
+
+			void* data = mTypeInstance.mCustomAttrDataPtr[mFieldData.mCustomAttributesIdx];
+
+			T attrInst = ?;
+			switch (AttributeInfo.GetCustomAttribute(data, typeof(T), &attrInst))
+			{
+			case .Ok: return .Ok(attrInst);
+			default:
+				return .Err;
+			}
+		}
+
+	    void* GetDataPtrAndType(Object value, out Type type)
+	    {
+	        type = value.RawGetType();
+	        /*if (type.IsStruct)
+	            return &value;*/
+
+			if (type.IsStruct)
+			{
+				NOP!();
+			}	
+
+	        if (type.IsBoxed)
+	            return ((uint8*)(void*)value) + type.mMemberDataOffset;
+	        return ((uint8*)(void*)value);
+	    }
+
+	    public Result<void> GetValue<TMember>(Object target, out TMember value)
+	    {
+	        value = default(TMember);
+
+	        Type tTarget;
+	        void* targetDataAddr = GetDataPtrAndType(target, out tTarget);
+			//Type tTarget = target.RawGetType();
+			//void* targetDataAddr = (void*)&target;
+	        
+	        Type tMember = typeof(TMember);
+
+	        targetDataAddr = (uint8*)targetDataAddr + mFieldData.mDataOffset;
+	        
+	        Type fieldType = Type.GetType(mFieldData.mFieldTypeId);
+
+			if (tMember.mTypeCode == TypeCode.Object)
+			{
+				if (!tTarget.IsSubtypeOf(mTypeInstance))
+					Runtime.FatalError();
+				value = *(TMember*)targetDataAddr;
+			}
+	        else if (tMember.mTypeCode == TypeCode.Int32)
+	        {
+	            if (fieldType.mTypeCode == TypeCode.Int32)
+	            {
+	                if (tMember.mTypeCode != TypeCode.Int32)
+	                    Runtime.FatalError("Expected int");
+	                *(int32*)&value = *(int32*)targetDataAddr;
+	            }
+	            else
+	            {
+	                return .Err;//("Invalid type");
+	            }
+	        }
+	        else
+	        {
+	            return .Err;//("Invalid type");
+	        }
+	        
+	        return .Ok;
+	    }
+
+		public Result<Variant> GetValue(Object target)
+		{
+			Variant value = Variant();
+
+			Type tTarget;
+			void* targetDataAddr = GetDataPtrAndType(target, out tTarget);
+			//Type tTarget = target.RawGetType();
+			//void* targetDataAddr = (void*)&target;
+
+			if (!tTarget.IsSubtypeOf(mTypeInstance))
+			    Runtime.FatalError("Invalid type");   
+
+			targetDataAddr = (uint8*)targetDataAddr + mFieldData.mDataOffset;
+
+			Type fieldType = Type.GetType(mFieldData.mFieldTypeId);
+
+			/*if (fieldType.IsNullable)
+			{
+				var specializedType = (SpecializedGenericType)fieldType;
+				var genericArg = specializedType.GetGenericArg(0);
+
+				bool hasValue = *(bool*)((uint8*)targetDataAddr + genericArg.mSize);
+				if (!hasValue)
+					return .Err;
+				fieldType = genericArg;
+			}*/
+
+			//value.mStructType = (int)(void*)fieldType;
+
+			TypeCode typeCode = fieldType.mTypeCode;
+			if (typeCode == TypeCode.Enum)
+				typeCode = fieldType.UnderlyingType.mTypeCode;
+
+		    /*if (typeCode == TypeCode.Int32)
+		    {
+		        *(int32*)&value.mData = *(int32*)targetDataAddr;
+		    }
+			else if (typeCode == TypeCode.Boolean)
+			{
+			    *(bool*)&value.mData = *(bool*)targetDataAddr;
+			}
+			else */if (typeCode == TypeCode.Object)
+		    {
+				value.mStructType = 0;
+		        value.mData = *(int*)targetDataAddr;
+		    }
+			else
+			{
+				value = Variant.Create(fieldType, targetDataAddr);
+			}
+
+		    /*else if (fieldType.mSize <= sizeof(int))
+			{
+				value.mStructType = (int)(void*)fieldType;
+				Internal.MemCpy(&value.mData, targetDataAddr, fieldType.mSize);
+			}
+			else
+			{
+				value.mStructType = (int)(void*)fieldType;
+				void* data = new uint8[fieldType.mSize]*;
+				Internal.MemCpy(data, targetDataAddr, fieldType.mSize);
+				value.mData = (int)data;
+			}*/
+		    /*{
+		        return .Err;
+		    }*/
+
+			return value;
+		}
+
+		public Result<Variant> GetValue()
+		{
+			Variant value = Variant();
+
+			//TODO: Assert static
+
+			if (mFieldData.mFlags.HasFlag(FieldFlags.Const))
+			{
+				return Variant.Create(FieldType, &mFieldData.mConstValue);
+			}
+
+			ThrowUnimplemented();
+
+			//Type tTarget;
+#unwarn
+			void* targetDataAddr = (void*)(int)mFieldData.mConstValue;
+
+			Type fieldType = Type.GetType(mFieldData.mFieldTypeId);
+			value.mStructType = (int)(void*)fieldType;
+
+			TypeCode typeCode = fieldType.mTypeCode;
+			if (typeCode == TypeCode.Enum)
+				typeCode = fieldType.UnderlyingType.mTypeCode;
+			
+		    if (typeCode == TypeCode.Int32)
+		    {
+		        *(int32*)&value.mData = *(int32*)targetDataAddr;
+		    }
+			else if (typeCode == TypeCode.Object)
+		    {
+				value.mStructType = 0;
+		        value.mData = (int)targetDataAddr;
+		    }
+		    else
+		    {
+		        return .Err;
+		    }
+
+			return value;
+		}
+
+	    internal struct Enumerator : IEnumerator<FieldInfo>
+	    {
+			BindingFlags mBindingFlags;
+	        TypeInstance mTypeInstance;
+	        int32 mIdx;
+
+	        internal this(TypeInstance typeInst, BindingFlags bindingFlags)
+	        {
+	            mTypeInstance = typeInst;
+				mBindingFlags = bindingFlags;
+	            mIdx = -1;
+	        }
+
+	        public void Reset() mut
+	        {
+	            mIdx = -1;
+	        }
+
+	        public void Dispose()
+	        {
+	        }
+
+	        public bool MoveNext() mut
+	        {
+				if (mTypeInstance == null)
+					return false;
+
+				for (;;)
+				{
+					mIdx++;
+					if (mIdx == mTypeInstance.mFieldDataCount)
+						return false;
+					var fieldData = &mTypeInstance.mFieldDataPtr[mIdx];
+					bool matches = (mBindingFlags.HasFlag(BindingFlags.Static) && (fieldData.mFlags.HasFlag(FieldFlags.Static)));
+					matches |= (mBindingFlags.HasFlag(BindingFlags.Instance) && (!fieldData.mFlags.HasFlag(FieldFlags.Static)));
+					if (matches)
+						break;
+				}
+	            return true;
+	        }
+
+	        public FieldInfo Current
+	        {
+	            get
+	            {
+					var fieldData = &mTypeInstance.mFieldDataPtr[mIdx];
+	                return FieldInfo(mTypeInstance, fieldData);
+	            }
+	        }
+
+			public Result<FieldInfo> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+	    }
+	}
+}