Improve reflection for readonly, dynamic, extension attributes

Refactored attribute handling to use new constants and generic methods for DynamicAttribute and ExtensionAttribute. Enhanced parameter and property metadata logic, including IsDynamic and IsGeneric support, and clarified readonly/ref/in/out semantics. Removed redundant readonly property logic and updated init-only detection. Improved attribute lookup performance and code clarity with switch expressions and better documentation.

Author: BionicCode

src/BionicCode.Utilities.Net.Common/ReflectionConstants.cs

@@ -1,8 +1,4 @@
 namespace BionicCode.Utilities.Net;
-
-using System.ComponentModel;
-using System.Runtime.InteropServices;
-
 /// <summary>
 /// Provides a set of constant string values that are commonly used in reflection scenarios, particularly when working with properties, indexers, events, delegates, and operator methods in .NET. These constants can be used to ensure consistency and avoid hardcoding string literals throughout the codebase when performing reflection operations or generating code dynamically.
 /// </summary>
@@ -89,4 +85,6 @@ public static class ReflectionConstants
     public const string RequiresLocationAttributeFullName = "System.Runtime.CompilerServices.RequiresLocationAttribute";
     public const string InAttributeFullName = "System.Runtime.InteropServices.InAttribute";
     public const string IsExternalInitFullName = "System.Runtime.CompilerServices.IsExternalInit";
+    public const string DynamicAttributeFullName = "System.Runtime.CompilerServices.DynamicAttribute";
+    public const string ExtensionAttributeFullName = "System.Runtime.CompilerServices.ExtensionAttribute";
 }

src/BionicCode.Utilities.Reflection/IParameterDataView.cs

@@ -10,6 +10,8 @@ public interface IParameterDataView : ISymbolInfoDataView
     RuntimeTypeHandle DeclaringTypeHandle { get; }
     object? DefaultValue { get; }
     bool IsByRef { get; }
+    bool IsDynamic { get; } 
+    bool IsGeneric { get; }
     bool IsGenericMethodParameter { get; }
     bool IsGenericTypeParameter { get; }
     bool IsIn { get; }

src/BionicCode.Utilities.Reflection/MethodData.cs

@@ -76,7 +76,6 @@ internal sealed partial class MethodData : ParameterizedMemberData, IMethodDataI
     private RuntimeTypeHandle? _implementingTypeHandle;
     private bool? _isExplicitInterfaceImplementation;
     private IMethodDataView? _methodDataView;
-    private bool? _isReadonly;
 
     internal MethodData(SymbolReflectionInfoCacheKeyInternal symbolReflectionInfoCacheKey)
         : base(symbolReflectionInfoCacheKey)
@@ -1164,12 +1163,9 @@ internal bool IsAwaitableGenericTask
         }
     }
 
-    internal bool IsReadonly => _isReadonly
-        ??= DeclaringTypeData.IsStruct && HasCompilerAttribute<IsReadOnlyAttribute>(ReflectionConstants.IsReadOnlyAttributeFullName);
-
     internal bool IsOverride => _isOverride ??= MethodData.IsMethodOverride(this);
 
-    internal bool IsReturnValueReadOnly => _isReturnValueReadOnly ??= ReturnParameterData.IsRefReadOnly;
+    internal bool IsReturnValueRefReadOnly => _isReturnValueReadOnly ??= ReturnParameterData.IsRefReadOnly;
 
     internal bool IsReturnValueByRef => _isReturnValueByRef ??= ReturnTypeData.IsByRef;
 
@@ -1239,7 +1235,7 @@ private static bool IsMethodExtensionMethod(MethodData methodData)
             return false;
         }
 
-        bool hasExtensionMethodMarker = methodData.HasCompilerAttribute(ReflectionHelperExtensions.ExtensionAttributeType, ReflectionHelperExtensions.ExtensionAttributeType.FullName);
+        bool hasExtensionMethodMarker = methodData.HasCompilerAttribute<ExtensionAttribute>(ReflectionConstants.ExtensionAttributeFullName);
         if (!hasExtensionMethodMarker)
         {
             return false;

src/BionicCode.Utilities.Reflection/ParameterData.cs

@@ -46,6 +46,7 @@ internal sealed class ParameterData : SymbolInfoData
     private bool? _isMethodReturnParameter;
     private TypeList? _requiredModifiers;
     private TypeList? _optionalModifiers;
+    private bool? _isDynamic;
 
     internal ParameterData(SymbolReflectionInfoCacheKeyInternal symbolInfoDataCacheKey)
         : base(symbolInfoDataCacheKey.ParameterDescriptor.ParameterName, SymbolKind.Parameter, symbolInfoDataCacheKey)
@@ -62,6 +63,16 @@ internal ParameterData(SymbolReflectionInfoCacheKeyInternal symbolInfoDataCacheK
 
     internal RuntimeTypeHandle ParameterTypeHandle => _propertyTypeHandle ??= ParameterInfo.ParameterType.TypeHandle;
 
+    internal bool IsDynamic => _isDynamic ??= HasCompilerAttribute<DynamicAttribute>(ReflectionConstants.DynamicAttributeFullName);
+
+    /// <summary>
+    /// Gets a value indicating whether the current type represents a generic type or method parameter.
+    /// </summary>
+    /// <remarks>This property returns <see langword="true"/> if the type is either a generic type parameter
+    /// or a generic method parameter. Use this property to determine whether the type is a placeholder for a generic
+    /// argument in type or method definitions.</remarks>
+    internal bool IsGeneric => IsGenericTypeParameter || IsGenericMethodParameter;
+
     /// <summary>
     /// Gets a value indicating whether the current type is passed by reference using the <see langword="ref"/> keyword.
     /// </summary>
@@ -182,7 +193,7 @@ internal ParameterData(SymbolReflectionInfoCacheKeyInternal symbolInfoDataCacheK
     internal override IList<CustomAttributeData> AttributeData => _attributeData ??= [.. ParameterInfo.GetCustomAttributesData()];
 
     /// <summary>
-    /// Gets a value indicating whether the parameter is passed by reference.
+    /// Gets a value indicating whether the parameter is passed by reference (<see langword="in"/>, <see langword="out"/>, <see langword="ref"/> or <see langword="ref"/><see langword="readonly"/>).
     /// </summary>
     internal bool IsByRef => _isByRef ??= ParameterTypeData.Type.IsByRef;
 
@@ -284,7 +295,9 @@ internal bool HasRequiredCustomModifier(string modifierName)
     /// <returns></returns>
     private static bool IsRefInternal(ParameterData parameterData)
     {
-        if (!parameterData.IsByRef || parameterData.IsOut)
+        if (parameterData.IsMethodReturnParameter 
+            || !parameterData.IsByRef 
+            || parameterData.IsOut)
         {
             return false;
         }
@@ -308,8 +321,9 @@ private static bool IsRefReadOnlyInternal(ParameterData parameterData)
 
         if (parameterData.IsMethodReturnParameter)
         {
-            return parameterData.HasOptionalCustomModifier(ReflectionConstants.InAttributeFullName)
-                || parameterData.HasCompilerAttribute<IsReadOnlyAttribute>(ReflectionConstants.IsReadOnlyAttributeFullName);
+            return parameterData.HasRequiredCustomModifier(ReflectionConstants.InAttributeFullName)
+                || parameterData.HasCompilerAttribute<IsReadOnlyAttribute>(ReflectionConstants.IsReadOnlyAttributeFullName)
+                || parameterData.HasRequiredCustomModifier(ReflectionConstants.IsReadOnlyAttributeFullName);
         }
         else
         {
@@ -319,11 +333,15 @@ private static bool IsRefReadOnlyInternal(ParameterData parameterData)
         }
     }
 
-    private static bool IsOutParameter(ParameterData parameterData) => parameterData.IsByRef && parameterData.ParameterInfo.IsOut;
+    private static bool IsOutParameter(ParameterData parameterData) => !parameterData.IsMethodReturnParameter 
+        && parameterData.IsByRef 
+        && parameterData.ParameterInfo.IsOut;
 
     private static bool IsInParameter(ParameterData parameterData)
     {
-        if (!parameterData.ParameterTypeData.IsByRef || parameterData.IsOut)
+        if (parameterData.IsMethodReturnParameter
+            || !parameterData.ParameterTypeData.IsByRef 
+            || parameterData.IsOut)
         {
             return false;
         }

src/BionicCode.Utilities.Reflection/PropertyData.cs

@@ -3,10 +3,8 @@ namespace BionicCode.Utilities.Net.Reflection;
 
 using System;
 using System.Collections.Concurrent;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using Microsoft.CodeAnalysis;
 
 internal sealed class PropertyData : MemberData, IPropertyDataInvoker
 {
@@ -49,8 +47,6 @@ internal sealed class PropertyData : MemberData, IPropertyDataInvoker
     private readonly ConcurrentDictionary<RuntimeTypeHandle, Delegate> _invokerTable;
     private string? _assemblyName;
     private SymbolComponentInfo? _symbolComponentInfo;
-    private bool? _isReadOnlySetMethodOnStruct;
-    private bool? _isReadOnlyGetMethodOnStruct;
     private readonly WellKnownPropertyDescriptor _descriptor;
     private RuntimeTypeHandle? _declaringTypeHandle;
     private RuntimeTypeHandle? _implementingTypeHandle;
@@ -923,21 +919,6 @@ internal AccessModifier GetAccessorAccessModifier
     /// <value><see langword="true"/> if the property does not have a setter and is therefore read-only; otherwise, <see langword="false"/>.</value>
     internal bool IsReadOnly => !CanWrite;
 
-    /// <summary>
-    /// Gets whether the property’s set accessor is a <see langword="readonly"/> instance member (struct-only), meaning it doesn’t modify the struct’s instance state.
-    /// </summary>
-    internal bool IsReadOnlySetMethodOnStruct => _isReadOnlySetMethodOnStruct ??= CanWrite && (PropertySetMethodData.IsReadonly || IsReadOnlyPropertyOnStruct);
-
-    /// <summary>
-    /// Gets whether the property’s get accessor is a <see langword="readonly"/> instance member (struct-only), meaning it doesn’t modify the struct’s instance state.
-    /// </summary>
-    internal bool IsReadOnlyGetMethodOnStruct => _isReadOnlyGetMethodOnStruct ??= CanRead && (PropertyGetMethodData.IsReadonly || IsReadOnlyPropertyOnStruct);
-
-    /// <summary>
-    /// Gets whether the property itself is a <see langword="readonly"/> instance member on a struct type, meaning it doesn’t modify the struct’s instance state. This is determined by checking if the property has the <see cref="IsReadOnlyAttribute"/> applied, which is used by the C# compiler to indicate that a struct member is readonly. If the property does not have this attribute, this property returns <see langword="false"/>. Note that for reference types, this property will always return <see langword="false"/>, as the concept of a readonly instance member only applies to value types (structs).
-    /// </summary>
-    internal bool IsReadOnlyPropertyOnStruct => HasCompilerAttribute<IsReadOnlyAttribute>(ReflectionConstants.IsReadOnlyAttributeFullName);
-
     /// <summary>
     /// Returns whether the property is an init-only property.
     /// </summary>
@@ -1099,8 +1080,8 @@ private static SymbolAttributes GetAttributesInternal(PropertyData propertyData)
         return propertyAttributes;
     }
 
-    private static bool IsPropertyInit(PropertyData propertyData) => propertyData.CanWrite 
-        && propertyData.PropertySetMethodData.ReturnParameterData.HasCompilerAttribute(typeof(IsExternalInit), ReflectionConstants.IsExternalInitFullName);
+    private static bool IsPropertyInit(PropertyData propertyData) => propertyData.CanWrite
+        && propertyData.PropertySetMethodData.ReturnParameterData.HasRequiredCustomModifier(ReflectionConstants.IsExternalInitFullName);
 
     private static (AccessModifier PropertyModifier, AccessModifier GetMethodModifier, AccessModifier SetMethodModifier) GetPropertyAccessModifier(MethodData? getMethodData, MethodData? setMethodData)
     {

src/BionicCode.Utilities.Reflection/ReflectionHelperExtensions.cs

@@ -6,12 +6,10 @@ namespace BionicCode.Utilities.Net.Reflection;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
-using System.Text;
 using Microsoft.CSharp;
 
 /// <summary>
@@ -40,7 +38,6 @@ public static partial class ReflectionHelperExtensions
     internal const BindingFlags AllMembersFullHierarchyFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;
 
     internal static CSharpCodeProvider CodeProvider { get; } = new CSharpCodeProvider();
-    internal static Type ExtensionAttributeType { get; } = typeof(ExtensionAttribute);
     internal static Type IsReadOnlyAttributeType { get; } = typeof(IsReadOnlyAttribute);
 
     internal static PooledStringBuilder AppendCustomAttributes(this PooledStringBuilder nameBuilder, IEnumerable<CustomAttributeData> attributes, bool isAppendNewLineEnabled)
@@ -110,23 +107,16 @@ internal static string ToArgumentDisplayValue(this object value)
     {
         ArgumentNullExceptionAdvanced.ThrowIfNull(value);
 
-        switch (value)
-        {
-            case string stringValue:
-                return $"\"{stringValue}\"";
-            case char charValue:
-                return $"'{charValue}'";
-            case double doubleValue:
-                return string.Format(CultureInfo.InvariantCulture, "{0}", doubleValue);
-            case Enum enumValue:
-                return $"{value.GetType().ToDisplayName()}.{enumValue.ToString()}";
-            case Type type:
-                return $"typeof({type.ToDisplayName()})";
-            case IEnumerable enumerableValue:
-                return $"new[] {{ {string.Join(", ", enumerableValue.OfType<object>().Select(val => val.ToArgumentDisplayValue()))} }}";
-            default:
-                return value.ToString();
-        }
+        return value switch
+        {
+            string stringValue => $"\"{stringValue}\"",
+            char charValue => $"'{charValue}'",
+            double doubleValue => string.Format(CultureInfo.InvariantCulture, "{0}", doubleValue),
+            Enum enumValue => $"{value.GetType().ToDisplayName()}.{enumValue.ToString()}",
+            Type type => $"typeof({type.ToDisplayName()})",
+            IEnumerable enumerableValue => $"new[] {{ {string.Join(", ", enumerableValue.OfType<object>().Select(val => val.ToArgumentDisplayValue()))} }}",
+            _ => value.ToString(),
+        };
     }
 
     internal static PooledStringBuilder AppendDisplayNameInternal(this PooledStringBuilder nameBuilder, TypeData typeData, bool isFullyQualifiedName, bool isGenericTypeParameterIncluded)

src/BionicCode.Utilities.Reflection/SymbolInfoData.cs

@@ -166,7 +166,6 @@ internal bool HasCompilerAttribute(Type? attributeType, string? attributeName =
     internal bool HasCompilerAttribute(string attributeName, bool inherit = false)
     {
         ArgumentNullExceptionAdvanced.ThrowIfNullOrWhiteSpace(attributeName);
-        return AttributeData
-            .Any(attribute => attribute.AttributeType.FullName?.Equals(attributeName, StringComparison.Ordinal) ?? false);
+        return AttributeDataLookup.Contains(attributeName);
     }
 }

src/BionicCode.Utilities.Reflection/SymbolSignatureGenerator.cs

@@ -146,7 +146,7 @@ internal static SymbolComponentInfo ToSignatureComponentsInternal(MethodData met
             symbolComponents.AddModifier("ref");
         }
 
-        if (methodData.IsReturnValueReadOnly)
+        if (methodData.IsReturnValueRefReadOnly)
         {
             symbolComponents.AddModifier("readonly");
         }
@@ -2027,7 +2027,7 @@ internal static string ToSignatureNameInternal(MethodData methodData, bool isFul
               .Append(' ');
         }
 
-        if (methodData.IsReturnValueReadOnly)
+        if (methodData.IsReturnValueRefReadOnly)
         {
             _ = signatureNameBuilder
               .Append("readonly")

src/BionicCode.Utilities.Reflection/TypeData.cs

@@ -1067,8 +1067,7 @@ private static bool CanDeclareExtensionMethods(TypeData typeData)
             return false;
         }
 
-        Attribute? typeExtensionAttribute = typeInfo.GetCustomAttribute(ReflectionHelperExtensions.ExtensionAttributeType, false);
-        return typeExtensionAttribute != null;
+        return typeData.HasCompilerAttribute<ExtensionAttribute>(ReflectionConstants.ExtensionAttributeFullName);
     }
 
     /// <summary>
@@ -1174,7 +1173,7 @@ private static bool IsTypeDelegate(Type type)
             && s_delegateType.IsAssignableFrom(type);
     }
 
-    private static bool IsReadOnlyStructInternal(TypeData typeData) => typeData.IsStruct && typeData.Type.GetCustomAttribute(ReflectionHelperExtensions.IsReadOnlyAttributeType) != null;
+    private static bool IsReadOnlyStructInternal(TypeData typeData) => typeData.IsStruct && typeData.HasCompilerAttribute<IsReadOnlyAttribute>(ReflectionConstants.IsReadOnlyAttributeFullName);
 
     /// <summary>
     /// Checks if the provided <see cref="MethodInfo"/> belongs to an asynchronous/awaitable method.