Merge pull request #1474 from disarray2077/gca

Add `GetCustomAttributes` and `GetCustomAttributes<T>`

BeefLibs/corlib/src/Reflection/AttributeInfo.bf

@@ -1,3 +1,4 @@
+using System.Collections;
 namespace System.Reflection
 {
 	class AttributeInfo
@@ -112,5 +113,527 @@ namespace System.Reflection
 
 			return .Err;
 		}
+
+		public struct CustomAttributeEnumerator : IEnumerator<Variant>, IDisposable
+		{
+			void* mData;
+			int32 mAttrIdx;
+			uint8 mCount;
+			Variant mTargetAttr;
+
+			public this(void* inAttrData)
+			{
+				mData = inAttrData;
+				mData++;
+				mAttrIdx = 0;
+				mCount = mData != null ? AttributeInfo.Decode!<uint8>(mData) : 0;
+				mTargetAttr = default;
+			}
+
+			public Variant Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				if (mAttrIdx >= mCount || mData == null)
+					return false;
+
+				void* startPtr = mData;
+				var len = AttributeInfo.Decode!<uint16>(mData);
+				void* endPtr = (uint8*)startPtr + len;
+
+				var typeId = AttributeInfo.Decode!<TypeId>(mData);
+
+				var methodIdx = AttributeInfo.Decode!<uint16>(mData);
+
+				Type attrType = Type.[Friend]GetType(typeId);
+				TypeInstance attrTypeInst = attrType as TypeInstance;
+				MethodInfo methodInfo = .(attrTypeInst, attrTypeInst.[Friend]mMethodDataPtr + methodIdx);
+
+				Object[] args = scope Object[methodInfo.[Friend]mData.mMethodData.mParamCount];
+
+				int argIdx = 0;
+				while (mData < endPtr)
+				{
+				    var attrDataType = AttributeInfo.Decode!<TypeCode>(mData);
+					switch (attrDataType)
+					{
+					case .Int8,
+						 .UInt8,
+						 .Char8,
+						 .Boolean:
+						let attrData = AttributeInfo.Decode!<int8>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int16,
+						.UInt16,
+						.Char16:
+						let attrData = AttributeInfo.Decode!<int16>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int32,
+						 .UInt32,
+						 .Char32:
+						let attrData = AttributeInfo.Decode!<int32>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Float:
+						let attrData = AttributeInfo.Decode!<float>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int64,
+						.UInt64,
+						.Double:
+						let attrData = AttributeInfo.Decode!<int64>(mData);
+						args[argIdx] = scope:: box attrData;
+					case (TypeCode)typeof(TypeCode).MaxValue + 8: //BfConstType_TypeOf
+						let argTypeId = AttributeInfo.Decode!<int32>(mData);
+						args[argIdx] = Type.[Friend]GetType((.)argTypeId);
+					case (TypeCode)255:
+						let stringId = AttributeInfo.Decode!<int32>(mData);
+						String str = String.[Friend]sIdStringLiterals[stringId];
+						args[argIdx] = str;
+					default:
+						Runtime.FatalError("Not handled");
+					}
+					argIdx++;
+				}
+
+				mTargetAttr.Dispose();
+				void* data = Variant.Alloc(attrType, out mTargetAttr);
+
+				if (methodInfo.Invoke(data, params args) case .Ok(var val))
+					val.Dispose();
+
+				mAttrIdx++;
+				return true;
+			}
+
+			public void Dispose() mut
+			{
+				mTargetAttr.Dispose();
+			}
+
+			public Result<Variant> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeTypeCustomAttributeEnumerator : IEnumerator<Variant>, IDisposable
+		{
+			int32 mTypeId;
+			int32 mAttrIdx;
+			Variant mTargetAttr;
+
+			public this(int32 typeId)
+			{
+				mTypeId = typeId;
+				mAttrIdx = -1;
+				mTargetAttr = default;
+			}
+
+			public Variant Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				let attrType = Type.[Friend]Comptime_Type_GetCustomAttributeType(mTypeId, ++mAttrIdx);
+				if (attrType != null)
+				{
+					mTargetAttr.Dispose();
+					void* data = Variant.Alloc(attrType, out mTargetAttr);
+
+					if (Type.[Friend]Comptime_Type_GetCustomAttribute(mTypeId, mAttrIdx, data))
+						return true;
+				}
+				return false;
+			}
+
+			public void Dispose() mut
+			{
+				mTargetAttr.Dispose();
+			}
+
+			public Result<Variant> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeFieldCustomAttributeEnumerator : IEnumerator<Variant>, IDisposable
+		{
+			int32 mTypeId;
+			int32 mFieldIdx;
+			int32 mAttrIdx;
+			Variant mTargetAttr;
+
+			public this(int32 typeId, int32 fieldIdx)
+			{
+				mTypeId = typeId;
+				mFieldIdx = fieldIdx;
+				mAttrIdx = -1;
+				mTargetAttr = default;
+			}
+
+			public Variant Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				let attrType = Type.[Friend]Comptime_Field_GetCustomAttributeType(mTypeId, mFieldIdx, ++mAttrIdx);
+				if (attrType != null)
+				{
+					mTargetAttr.Dispose();
+					void* data = Variant.Alloc(attrType, out mTargetAttr);
+
+					if (Type.[Friend]Comptime_Field_GetCustomAttribute(mTypeId, mFieldIdx, mAttrIdx, data))
+						return true;
+				}
+				return false;
+			}
+
+			public void Dispose() mut
+			{
+				mTargetAttr.Dispose();
+			}
+
+			public Result<Variant> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeMethodCustomAttributeEnumerator : IEnumerator<Variant>, IDisposable
+		{
+			int64 mMethodHandle;
+			int32 mAttrIdx;
+			Variant mTargetAttr;
+
+			public this(int64 methodHandle)
+			{
+				mMethodHandle = methodHandle;
+				mAttrIdx = -1;
+				mTargetAttr = default;
+			}
+
+			public Variant Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				let attrType = Type.[Friend]Comptime_Method_GetCustomAttributeType(mMethodHandle, ++mAttrIdx);
+				if (attrType != null)
+				{
+					mTargetAttr.Dispose();
+					void* data = Variant.Alloc(attrType, out mTargetAttr);
+
+					if (Type.[Friend]Comptime_Method_GetCustomAttribute(mMethodHandle, mAttrIdx, data))
+						return true;
+				}
+				return false;
+			}
+
+			public void Dispose() mut
+			{
+				mTargetAttr.Dispose();
+			}
+
+			public Result<Variant> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct CustomAttributeEnumerator<T> : IEnumerator<T>
+		{
+			void* mData;
+			int32 mAttrIdx;
+			uint8 mCount;
+			T mTargetAttr;
+
+			public this(void* inAttrData)
+			{
+				mData = inAttrData;
+				mData++;
+				mAttrIdx = 0;
+				mCount = mData != null ? AttributeInfo.Decode!<uint8>(mData) : 0;
+				mTargetAttr = ?;
+			}
+
+			public T Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				if (mAttrIdx >= mCount || mData == null)
+					return false;
+
+				void* endPtr = null;
+				TypeId typeId = 0;
+
+				while (true)
+				{
+					void* startPtr = mData;
+					var len = AttributeInfo.Decode!<uint16>(mData);
+					endPtr = (uint8*)startPtr + len;
+
+					typeId = AttributeInfo.Decode!<TypeId>(mData);
+					if (typeId != typeof(T).TypeId)
+					{
+						mAttrIdx++;
+						if (mAttrIdx >= mCount)
+							return false;
+					    mData = endPtr;
+					    continue;
+					}
+
+					break;
+				}
+
+				var methodIdx = AttributeInfo.Decode!<uint16>(mData);
+
+				Type attrType = Type.[Friend]GetType(typeId);
+				TypeInstance attrTypeInst = attrType as TypeInstance;
+				MethodInfo methodInfo = .(attrTypeInst, attrTypeInst.[Friend]mMethodDataPtr + methodIdx);
+
+				Object[] args = scope Object[methodInfo.[Friend]mData.mMethodData.mParamCount];
+
+				int argIdx = 0;
+				while (mData < endPtr)
+				{
+				    var attrDataType = AttributeInfo.Decode!<TypeCode>(mData);
+					switch (attrDataType)
+					{
+					case .Int8,
+						 .UInt8,
+						 .Char8,
+						 .Boolean:
+						let attrData = AttributeInfo.Decode!<int8>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int16,
+						.UInt16,
+						.Char16:
+						let attrData = AttributeInfo.Decode!<int16>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int32,
+						 .UInt32,
+						 .Char32:
+						let attrData = AttributeInfo.Decode!<int32>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Float:
+						let attrData = AttributeInfo.Decode!<float>(mData);
+						args[argIdx] = scope:: box attrData;
+					case .Int64,
+						.UInt64,
+						.Double:
+						let attrData = AttributeInfo.Decode!<int64>(mData);
+						args[argIdx] = scope:: box attrData;
+					case (TypeCode)typeof(TypeCode).MaxValue + 8: //BfConstType_TypeOf
+						let argTypeId = AttributeInfo.Decode!<int32>(mData);
+						args[argIdx] = Type.[Friend]GetType((.)argTypeId);
+					case (TypeCode)255:
+						let stringId = AttributeInfo.Decode!<int32>(mData);
+						String str = String.[Friend]sIdStringLiterals[stringId];
+						args[argIdx] = str;
+					default:
+						Runtime.FatalError("Not handled");
+					}
+					argIdx++;
+				}
+
+				if (methodInfo.Invoke(&mTargetAttr, params args) case .Ok(var val))
+					val.Dispose();
+
+				mAttrIdx++;
+				return true;
+			}
+
+			public void Dispose()
+			{
+			}
+
+			public Result<T> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeTypeCustomAttributeEnumerator<T> : IEnumerator<T>
+		{
+			int32 mTypeId;
+			int32 mAttrIdx;
+			T mTargetAttr;
+
+			public this(int32 typeId)
+			{
+				mTypeId = typeId;
+				mAttrIdx = -1;
+				mTargetAttr = ?;
+			}
+
+			public T Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Type_GetCustomAttributeType(mTypeId, ++mAttrIdx);
+					if (attrType == typeof(T))
+					{
+						if (Type.[Friend]Comptime_Type_GetCustomAttribute(mTypeId, mAttrIdx, &mTargetAttr))
+							return true;
+					}
+				} while (attrType != null);
+				return false;
+			}
+
+			public void Dispose()
+			{
+			}
+
+			public Result<T> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeFieldCustomAttributeEnumerator<T> : IEnumerator<T>
+		{
+			int32 mTypeId;
+			int32 mFieldIdx;
+			int32 mAttrIdx;
+			T mTargetAttr;
+
+			public this(int32 typeId, int32 fieldIdx)
+			{
+				mTypeId = typeId;
+				mFieldIdx = fieldIdx;
+				mAttrIdx = -1;
+				mTargetAttr = ?;
+			}
+
+			public T Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Field_GetCustomAttributeType(mTypeId, mFieldIdx, ++mAttrIdx);
+					if (attrType == typeof(T))
+					{
+						if (Type.[Friend]Comptime_Field_GetCustomAttribute(mTypeId, mFieldIdx, mAttrIdx, &mTargetAttr))
+							return true;
+					}
+				} while (attrType != null);
+				return false;
+			}
+
+			public void Dispose()
+			{
+			}
+
+			public Result<T> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
+
+		public struct ComptimeMethodCustomAttributeEnumerator<T> : IEnumerator<T>
+		{
+			int64 mMethodHandle;
+			int32 mAttrIdx;
+			T mTargetAttr;
+
+			public this(int64 methodHandle)
+			{
+				mMethodHandle = methodHandle;
+				mAttrIdx = -1;
+				mTargetAttr = ?;
+			}
+
+			public T Current
+			{
+				get
+				{
+					return mTargetAttr;
+				}
+			}
+
+			public bool MoveNext() mut
+			{
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Method_GetCustomAttributeType(mMethodHandle, ++mAttrIdx);
+					if (attrType == typeof(T))
+					{
+						if (Type.[Friend]Comptime_Method_GetCustomAttribute(mMethodHandle, mAttrIdx, &mTargetAttr))
+							return true;
+					}
+				} while (attrType != null);
+				return false;
+			}
+
+			public void Dispose()
+			{
+			}
+
+			public Result<T> GetNext() mut
+			{
+				if (!MoveNext())
+					return .Err;
+				return Current;
+			}
+		}
 	}
 }

BeefLibs/corlib/src/Reflection/FieldInfo.bf

@@ -230,15 +230,47 @@ namespace System.Reflection
 		public Result<T> GetCustomAttribute<T>() where T : Attribute
 		{
 			if (Compiler.IsComptime)
+			{
+				int32 attrIdx = -1;
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Field_GetCustomAttributeType((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx, ++attrIdx);
+					if (attrType == typeof(T))
 					{
 						T val = ?;
-				if (Type.[Friend]Comptime_Field_GetCustomAttribute((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx, (.)typeof(T).TypeId, &val))
+						if (Type.[Friend]Comptime_Field_GetCustomAttribute((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx, attrIdx, &val))
 							return val;
+					}
+				}
+				while (attrType != null);
 				return .Err;
 			}
 			return mTypeInstance.[Friend]GetCustomAttribute<T>(mFieldData.mCustomAttributesIdx);
 		}
 
+		public AttributeInfo.CustomAttributeEnumerator GetCustomAttributes()
+		{
+			return mTypeInstance.[Friend]GetCustomAttributes(mFieldData.mCustomAttributesIdx);
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeFieldCustomAttributeEnumerator GetCustomAttributes()
+		{
+			return .((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx);
+		}
+
+		public AttributeInfo.CustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			return mTypeInstance.[Friend]GetCustomAttributes<T>(mFieldData.mCustomAttributesIdx);
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeFieldCustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			return .((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx);
+		}
+
 	    void* GetDataPtrAndType(Object value, out Type type)
 	    {
 	        type = value.[Friend]RawGetType();

BeefLibs/corlib/src/Reflection/MethodInfo.bf

@@ -92,18 +92,66 @@ namespace System.Reflection
 			return mTypeInstance.[Friend]GetCustomAttribute<T>(mData.mMethodData.mParamData[paramIdx].mCustomAttributesIdx);
 		}
 
+		public AttributeInfo.CustomAttributeEnumerator GetParamCustomAttributes(int paramIdx)
+		{
+			if (Compiler.IsComptime)
+				Runtime.NotImplemented();
+			Debug.Assert((uint)paramIdx < (uint)mData.mMethodData.mParamCount);
+			return mTypeInstance.[Friend]GetCustomAttributes(mData.mMethodData.mParamData[paramIdx].mCustomAttributesIdx);
+		}
+
+		public AttributeInfo.CustomAttributeEnumerator<T> GetParamCustomAttributes<T>(int paramIdx) where T : Attribute
+		{
+			if (Compiler.IsComptime)
+				Runtime.NotImplemented();
+			Debug.Assert((uint)paramIdx < (uint)mData.mMethodData.mParamCount);
+			return mTypeInstance.[Friend]GetCustomAttributes<T>(mData.mMethodData.mParamData[paramIdx].mCustomAttributesIdx);
+		}
+
 		public Result<T> GetCustomAttribute<T>() where T : Attribute
 		{
 			if (Compiler.IsComptime)
+			{
+				int32 attrIdx = -1;
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Method_GetCustomAttributeType(mData.mComptimeMethodInstance, ++attrIdx);
+					if (attrType == typeof(T))
 					{
 						T val = ?;
-				if (Type.[Friend]Comptime_Method_GetCustomAttribute(mData.mComptimeMethodInstance, (.)typeof(T).TypeId, &val))
+						if (Type.[Friend]Comptime_Method_GetCustomAttribute(mData.mComptimeMethodInstance, attrIdx, &val))
 							return val;
+					}
+				}
+				while (attrType != null);
 				return .Err;
 			}
 			return mTypeInstance.[Friend]GetCustomAttribute<T>(mData.mMethodData.mCustomAttributesIdx);
 		}
 
+		public AttributeInfo.CustomAttributeEnumerator GetCustomAttributes()
+		{
+			return mTypeInstance.[Friend]GetCustomAttributes(mData.mMethodData.mCustomAttributesIdx);
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeMethodCustomAttributeEnumerator GetCustomAttributes()
+		{
+			return .(mData.mComptimeMethodInstance);
+		}
+
+		public AttributeInfo.CustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			return mTypeInstance.[Friend]GetCustomAttributes<T>(mData.mMethodData.mCustomAttributesIdx);
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeMethodCustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			return .(mData.mComptimeMethodInstance);
+		}
+
 		public Result<T> GetReturnCustomAttribute<T>() where T : Attribute
 		{
 			if (Compiler.IsComptime)
@@ -111,6 +159,20 @@ namespace System.Reflection
 			return mTypeInstance.[Friend]GetCustomAttribute<T>(mData.mMethodData.mReturnCustomAttributesIdx);
 		}
 
+		public AttributeInfo.CustomAttributeEnumerator GetReturnCustomAttributes()
+		{
+			if (Compiler.IsComptime)
+				Runtime.NotImplemented();
+			return mTypeInstance.[Friend]GetCustomAttributes(mData.mMethodData.mReturnCustomAttributesIdx);
+		}
+
+		public AttributeInfo.CustomAttributeEnumerator<T> GetReturnCustomAttributes<T>() where T : Attribute
+		{
+			if (Compiler.IsComptime)
+				Runtime.NotImplemented();
+			return mTypeInstance.[Friend]GetCustomAttributes<T>(mData.mMethodData.mReturnCustomAttributesIdx);
+		}
+
 		public enum CallError
 		{
 			case None;

BeefLibs/corlib/src/Type.bf

@@ -528,9 +528,12 @@ namespace System
 		static extern Type Comptime_GetTypeByName(StringView name);
 		static extern String Comptime_Type_ToString(int32 typeId);
 		static extern Type Comptime_GetSpecializedType(Type unspecializedType, Span<Type> typeArgs);
-		static extern bool Comptime_Type_GetCustomAttribute(int32 typeId, int32 attributeId, void* dataPtr);
-		static extern bool Comptime_Field_GetCustomAttribute(int32 typeId, int32 fieldIdx, int32 attributeId, void* dataPtr);
-		static extern bool Comptime_Method_GetCustomAttribute(int64 methodHandle, int32 attributeId, void* dataPtr);
+		static extern bool Comptime_Type_GetCustomAttribute(int32 typeId, int32 attributeIdx, void* dataPtr);
+		static extern bool Comptime_Field_GetCustomAttribute(int32 typeId, int32 fieldIdx, int32 attributeIdx, void* dataPtr);
+		static extern bool Comptime_Method_GetCustomAttribute(int64 methodHandle, int32 attributeIdx, void* dataPtr);
+		static extern Type Comptime_Type_GetCustomAttributeType(int32 typeId, int32 attributeIdx);
+		static extern Type Comptime_Field_GetCustomAttributeType(int32 typeId, int32 fieldIdx, int32 attributeIdx);
+		static extern Type Comptime_Method_GetCustomAttributeType(int64 methodHandle, int32 attributeIdx);
 		static extern int32 Comptime_GetMethodCount(int32 typeId);
 		static extern int64 Comptime_GetMethod(int32 typeId, int32 methodIdx);
 		static extern String Comptime_Method_ToString(int64 methodHandle);
@@ -647,7 +650,16 @@ namespace System
 		{
 			if (Compiler.IsComptime)
 			{
-				return Comptime_Type_GetCustomAttribute((int32)TypeId, (.)typeof(T).TypeId, null);
+				int32 attrIdx = -1;
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Type_GetCustomAttributeType((int32)TypeId, ++attrIdx);
+					if (attrType == typeof(T))
+						return true;
+				}
+				while (attrType != null);
+				return false;
 			}
 
 			if (var typeInstance = this as TypeInstance)
@@ -658,10 +670,20 @@ namespace System
 		public Result<T> GetCustomAttribute<T>() where T : Attribute
 		{
 			if (Compiler.IsComptime)
+			{
+				int32 attrIdx = -1;
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Type_GetCustomAttributeType((int32)TypeId, ++attrIdx);
+					if (attrType == typeof(T))
 					{
 						T val = ?;
-				if (Comptime_Type_GetCustomAttribute((int32)TypeId, (.)typeof(T).TypeId, &val))
+						if (Type.[Friend]Comptime_Type_GetCustomAttribute((int32)TypeId, attrIdx, &val))
 							return val;
+					}
+				}
+				while (attrType != null);
 				return .Err;
 			}
 
@@ -670,6 +692,32 @@ namespace System
 			return .Err;
 		}
 
+		public AttributeInfo.CustomAttributeEnumerator GetCustomAttributes()
+		{
+			if (var typeInstance = this as TypeInstance)
+				return typeInstance.[Friend]GetCustomAttributes(typeInstance.[Friend]mCustomAttributesIdx);
+			Runtime.NotImplemented();
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeTypeCustomAttributeEnumerator GetCustomAttributes()
+		{
+			return .((int32)TypeId);
+		}
+
+		public AttributeInfo.CustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			if (var typeInstance = this as TypeInstance)
+				return typeInstance.[Friend]GetCustomAttributes<T>(typeInstance.[Friend]mCustomAttributesIdx);
+			Runtime.NotImplemented();
+		}
+
+		[Comptime]
+		public AttributeInfo.ComptimeTypeCustomAttributeEnumerator<T> GetCustomAttributes<T>() where T : Attribute
+		{
+			return .((int32)TypeId);
+		}
+
 		public override void ToString(String strBuffer)
 		{
 			GetFullName(strBuffer);
@@ -1074,6 +1122,24 @@ namespace System.Reflection
 				return .Err;
 			}
 		}
+
+		AttributeInfo.CustomAttributeEnumerator GetCustomAttributes(int customAttributeIdx)
+		{
+			if (customAttributeIdx == -1)
+			    return .(null);
+
+			void* data = mCustomAttrDataPtr[customAttributeIdx];
+			return .(data);
+		}
+
+		AttributeInfo.CustomAttributeEnumerator<T> GetCustomAttributes<T>(int customAttributeIdx) where T : Attribute
+		{
+			if (customAttributeIdx == -1)
+			    return .(null);
+
+			void* data = mCustomAttrDataPtr[customAttributeIdx];
+			return .(data);
+		}
     }
 
 	[Ordered, AlwaysInclude(AssumeInstantiated=true)]

IDEHelper/Compiler/BfResolvedTypeUtils.cpp

@@ -2904,6 +2904,13 @@ BfCustomAttribute* BfCustomAttributes::Get(BfType* type)
 	return NULL;
 }
 
+BfCustomAttribute* BfCustomAttributes::Get(int idx)
+{
+	if (idx >= mAttributes.size())
+		return NULL;
+	return &mAttributes[idx];
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 BfResolvedTypeSet::~BfResolvedTypeSet()

IDEHelper/Compiler/BfResolvedTypeUtils.h

@@ -2550,6 +2550,7 @@ public:
 	bool Contains(BfTypeDef* typeDef);
 	BfCustomAttribute* Get(BfTypeDef* typeDef);
 	BfCustomAttribute* Get(BfType* type);
+	BfCustomAttribute* Get(int idx);
 
 	void ReportMemory(MemReporter* memReporter);
 };

IDEHelper/Compiler/CeMachine.cpp

@@ -3472,16 +3472,12 @@ bool CeContext::GetStringFromStringView(addr_ce addr, StringImpl& str)
 	return true;
 }
 
-bool CeContext::GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeTypeId, addr_ce resultAddr)
+bool CeContext::GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeIdx, addr_ce resultAddr)
 {
 	if (customAttributes == NULL)
 		return false;
 
-	BfType* attributeType = GetBfType(attributeTypeId);
-	if (attributeType == NULL)
-		return false;
-
-	auto customAttr = customAttributes->Get(attributeType);
+	auto customAttr = customAttributes->Get(attributeIdx);
 	if (customAttr == NULL)
 		return false;
 	
@@ -3504,6 +3500,18 @@ bool CeContext::GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolde
 	return true;
 }
 
+BfType* CeContext::GetCustomAttributeType(BfCustomAttributes* customAttributes, int attributeIdx)
+{
+	if (customAttributes == NULL)
+		return NULL;
+
+	auto customAttr = customAttributes->Get(attributeIdx);
+	if (customAttr == NULL)
+		return NULL;
+	
+	return customAttr->mType;
+}
+
 //#define CE_GETC(T) *((T*)(addr += sizeof(T)) - 1)
 #define CE_GETC(T) *(T*)(mMemory.mVals + addr)
 
@@ -5130,7 +5138,7 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 			else if (checkFunction->mFunctionKind == CeFunctionKind_Type_GetCustomAttribute)
 			{
 				int32 typeId = *(int32*)((uint8*)stackPtr + 1);
-				int32 attributeTypeId = *(int32*)((uint8*)stackPtr + 1 + 4);
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + 1 + 4);
 				addr_ce resultPtr = *(addr_ce*)((uint8*)stackPtr + 1 + 4 + 4);
 
 				BfType* type = GetBfType(typeId);
@@ -5139,7 +5147,7 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 				{
 					auto typeInst = type->ToTypeInstance();
 					if (typeInst != NULL)
-						success = GetCustomAttribute(mCurModule, typeInst->mConstHolder, typeInst->mCustomAttributes, attributeTypeId, resultPtr);
+						success = GetCustomAttribute(mCurModule, typeInst->mConstHolder, typeInst->mCustomAttributes, attributeIdx, resultPtr);
 					_FixVariables();
 				}
 
@@ -5149,7 +5157,7 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 			{
 				int32 typeId = *(int32*)((uint8*)stackPtr + 1);
 				int32 fieldIdx = *(int32*)((uint8*)stackPtr + 1 + 4);
-				int32 attributeTypeId = *(int32*)((uint8*)stackPtr + 1 + 4 + 4);
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + 1 + 4 + 4);
 				addr_ce resultPtr = *(addr_ce*)((uint8*)stackPtr + 1 + 4 + 4 + 4);
 
 				BfType* type = GetBfType(typeId);
@@ -5164,7 +5172,7 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 						if ((fieldIdx >= 0) && (fieldIdx < typeInst->mFieldInstances.mSize))
 						{
 							auto& fieldInstance = typeInst->mFieldInstances[fieldIdx];
-							success = GetCustomAttribute(mCurModule, typeInst->mConstHolder, fieldInstance.mCustomAttributes, attributeTypeId, resultPtr);
+							success = GetCustomAttribute(mCurModule, typeInst->mConstHolder, fieldInstance.mCustomAttributes, attributeIdx, resultPtr);
 							_FixVariables();
 						}
 						else if (fieldIdx != -1)
@@ -5180,7 +5188,7 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 			else if (checkFunction->mFunctionKind == CeFunctionKind_Method_GetCustomAttribute)
 			{
 				int64 methodHandle = *(int64*)((uint8*)stackPtr + 1);				
-				int32 attributeTypeId = *(int32*)((uint8*)stackPtr + 1 + 8);
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + 1 + 8);
 				addr_ce resultPtr = *(addr_ce*)((uint8*)stackPtr + 1 + 8 + 4);				
 
 				auto methodInstance = mCeMachine->GetMethodInstance(methodHandle);
@@ -5189,10 +5197,82 @@ bool CeContext::Execute(CeFunction* startFunction, uint8* startStackPtr, uint8*
 					_Fail("Invalid method instance");
 					return false;
 				}				
-				bool success = GetCustomAttribute(mCurModule, methodInstance->GetOwner()->mConstHolder, methodInstance->GetCustomAttributes(), attributeTypeId, resultPtr);				
+				bool success = GetCustomAttribute(mCurModule, methodInstance->GetOwner()->mConstHolder, methodInstance->GetCustomAttributes(), attributeIdx, resultPtr);				
 				_FixVariables();
 				*(addr_ce*)(stackPtr + 0) = success;
 			}
+			else if (checkFunction->mFunctionKind == CeFunctionKind_Type_GetCustomAttributeType)
+			{
+				int32 typeId = *(int32*)((uint8*)stackPtr + ptrSize);
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + ptrSize + 4);
+
+				BfType* type = GetBfType(typeId);
+				addr_ce reflectType = 0;
+				if (type != NULL)
+				{
+					auto typeInst = type->ToTypeInstance();
+					if (typeInst != NULL)
+					{
+						auto attrType = GetCustomAttributeType(typeInst->mCustomAttributes, attributeIdx);
+						if (attrType != NULL)
+							reflectType = GetReflectType(attrType->mTypeId);
+					}
+					_FixVariables();
+				}
+
+				CeSetAddrVal(stackPtr + 0, reflectType, ptrSize);
+			}
+			else if (checkFunction->mFunctionKind == CeFunctionKind_Field_GetCustomAttributeType)
+			{
+				int32 typeId = *(int32*)((uint8*)stackPtr + ptrSize);
+				int32 fieldIdx = *(int32*)((uint8*)stackPtr + ptrSize + 4);
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + ptrSize + 4 + 4);
+
+				BfType* type = GetBfType(typeId);
+				addr_ce reflectType = 0;
+				if (type != NULL)
+				{
+					auto typeInst = type->ToTypeInstance();
+					if (typeInst != NULL)
+					{
+						if (typeInst->mDefineState < BfTypeDefineState_CETypeInit)
+							mCurModule->PopulateType(typeInst);
+						if ((fieldIdx >= 0) && (fieldIdx < typeInst->mFieldInstances.mSize))
+						{
+							auto& fieldInstance = typeInst->mFieldInstances[fieldIdx];
+							auto attrType = GetCustomAttributeType(fieldInstance.mCustomAttributes, attributeIdx);
+							if (attrType != NULL)
+								reflectType = GetReflectType(attrType->mTypeId);
+							_FixVariables();
+						}
+						else if (fieldIdx != -1)
+						{
+							_Fail("Invalid field");
+							return false;
+						}
+					}
+				}
+
+				CeSetAddrVal(stackPtr + 0, reflectType, ptrSize);
+			}
+			else if (checkFunction->mFunctionKind == CeFunctionKind_Method_GetCustomAttributeType)
+			{
+				int64 methodHandle = *(int64*)((uint8*)stackPtr + ptrSize);				
+				int32 attributeIdx = *(int32*)((uint8*)stackPtr + ptrSize + 8);			
+
+				auto methodInstance = mCeMachine->GetMethodInstance(methodHandle);
+				if (methodInstance == NULL)
+				{
+					_Fail("Invalid method instance");
+					return false;
+				}				
+				auto attrType = GetCustomAttributeType(methodInstance->GetCustomAttributes(), attributeIdx);
+				if (attrType != NULL)
+					CeSetAddrVal(stackPtr + 0, GetReflectType(attrType->mTypeId), ptrSize);
+				else
+					CeSetAddrVal(stackPtr + 0, 0, ptrSize);
+				_FixVariables();
+			}
 			else if (checkFunction->mFunctionKind == CeFunctionKind_GetMethodCount)
 			{
 				int32 typeId = *(int32*)((uint8*)stackPtr + 4);
@@ -8152,6 +8232,18 @@ void CeMachine::CheckFunctionKind(CeFunction* ceFunction)
 				{
 					ceFunction->mFunctionKind = CeFunctionKind_Method_GetCustomAttribute;
 				}
+				else if (methodDef->mName == "Comptime_Type_GetCustomAttributeType")
+				{
+					ceFunction->mFunctionKind = CeFunctionKind_Type_GetCustomAttributeType;
+				}
+				else if (methodDef->mName == "Comptime_Field_GetCustomAttributeType")
+				{
+					ceFunction->mFunctionKind = CeFunctionKind_Field_GetCustomAttributeType;
+				}
+				else if (methodDef->mName == "Comptime_Method_GetCustomAttributeType")
+				{
+					ceFunction->mFunctionKind = CeFunctionKind_Method_GetCustomAttributeType;
+				}
 				else if (methodDef->mName == "Comptime_GetMethod")
 				{
 					ceFunction->mFunctionKind = CeFunctionKind_GetMethod;

IDEHelper/Compiler/CeMachine.h

@@ -328,6 +328,9 @@ enum CeFunctionKind
 	CeFunctionKind_Type_GetCustomAttribute,
 	CeFunctionKind_Field_GetCustomAttribute,
 	CeFunctionKind_Method_GetCustomAttribute,
+	CeFunctionKind_Type_GetCustomAttributeType,
+	CeFunctionKind_Field_GetCustomAttributeType,
+	CeFunctionKind_Method_GetCustomAttributeType,
 	CeFunctionKind_GetMethodCount,
 	CeFunctionKind_GetMethod,
 	CeFunctionKind_Method_ToString,
@@ -908,7 +911,8 @@ public:
 	bool CheckMemory(addr_ce addr, int32 size);
 	bool GetStringFromAddr(addr_ce strInstAddr, StringImpl& str);
 	bool GetStringFromStringView(addr_ce addr, StringImpl& str);
-	bool GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeTypeId, addr_ce resultAddr);
+	bool GetCustomAttribute(BfModule* module, BfIRConstHolder* constHolder, BfCustomAttributes* customAttributes, int attributeIdx, addr_ce resultAddr);
+	BfType* GetCustomAttributeType(BfCustomAttributes* customAttributes, int attributeIdx);
 
 	bool WriteConstant(BfModule* module, addr_ce addr, BfConstant* constant, BfType* type, bool isParams = false);	
 	BfIRValue CreateConstant(BfModule* module, uint8* ptr, BfType* type, BfType** outType = NULL);