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

@@ -231,14 +231,46 @@ namespace System.Reflection
 		{
 			if (Compiler.IsComptime)
 			{
-				T val = ?;
-				if (Type.[Friend]Comptime_Field_GetCustomAttribute((int32)mTypeInstance.TypeId, mFieldData.mCustomAttributesIdx, (.)typeof(T).TypeId, &val))
-					return val;
+				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, 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)
 			{
-				T val = ?;
-				if (Type.[Friend]Comptime_Method_GetCustomAttribute(mData.mComptimeMethodInstance, (.)typeof(T).TypeId, &val))
-					return val;
+				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, 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)
@@ -659,9 +671,19 @@ namespace System
 		{
 			if (Compiler.IsComptime)
 			{
-				T val = ?;
-				if (Comptime_Type_GetCustomAttribute((int32)TypeId, (.)typeof(T).TypeId, &val))
-					return val;
+				int32 attrIdx = -1;
+				Type attrType = null;
+				repeat
+				{
+					attrType = Type.[Friend]Comptime_Type_GetCustomAttributeType((int32)TypeId, ++attrIdx);
+					if (attrType == typeof(T))
+					{
+						T 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)]