31404809605

Committed 10 Aug 2026 03:39PM UTC coverage: 97.826% (+1.0%) from 96.835%

Build # 31404809605

Build Type

Pull #174

github

Committed by

web-flow

Commit Message

Merge 1d3822327 into 2ee555014

Pull Request Pull Request #174: Expose nullable reference type metadata across all target frameworks

Coverage Stats

298 of 312 branches covered (95.51%)

Branch coverage included in aggregate %.

61 of 61 new or added lines in 3 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

557 of 562 relevant lines covered (99.11%)

3914612.91 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.29

/src/Reflectify/TypeMetaDataExtensions.cs

#if !REFLECTIFY_COMPILE
// <autogenerated />
#pragma warning disable
#endif

#nullable disable

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;

namespace Reflectify;

#if REFLECTIFY_COMPILE
public static class TypeMetaDataExtensions
#else
[global::Microsoft.CodeAnalysis.Embedded]
[global::System.Diagnostics.DebuggerNonUserCode]
internal static class TypeMetaDataExtensions
#endif
{
    /// <summary>
    /// Returns the name of the type without the generic backtick and the type arguments.
    /// </summary>
    public static string GetNonGenericName(this Type type)
    {
        string name = type.Name;
        int index = name.IndexOf('`');
        return index == -1 ? name : name.Substring(0, index);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is derived from an open-generic type, or <see langword="false" /> otherwise.
    /// </summary>
    public static bool IsDerivedFromOpenGeneric(this Type type, Type openGenericType)
    {
        // do not consider a type to be derived from itself
        if (type == openGenericType)
        {
            return false;
        }

        // check subject and its base types against definition
        for (Type baseType = type;
             baseType is not null;
             baseType = baseType.BaseType)
        {
            if (baseType.IsGenericType && baseType.GetGenericTypeDefinition() == openGenericType)
            {
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// Returns the interfaces that the <paramref name="type"/> implements or inherits from that are concrete
    /// versions of the <paramref name="openGenericType"/>.
    /// </summary>
    public static Type[] GetClosedGenericInterfaces(this Type type, Type openGenericType)
    {
        if (type.IsGenericType && type.GetGenericTypeDefinition() == openGenericType)
        {
            return [type];
        }

        Type[] interfaces = type.GetInterfaces();

        return interfaces
            .Where(t => t.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == openGenericType))
            .ToArray();
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is decorated with the specific <typeparamref name="TAttribute"/>,
    /// or <see langword="false" /> otherwise.
    /// </summary>
    public static bool HasAttribute<TAttribute>(this Type type)
        where TAttribute : Attribute
    {
        return type.IsDefined(typeof(TAttribute), inherit: false);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is decorated with the specific <typeparamref name="TAttribute"/> <i>and</i>
    /// that attribute instance matches the predicate, or <see langword="false" /> otherwise.
    /// </summary>
    public static bool HasAttribute<TAttribute>(this Type type, Func<TAttribute, bool> predicate)
        where TAttribute : Attribute
    {
        if (predicate is null)
        {
            throw new ArgumentNullException(nameof(predicate));
        }

        return type.GetCustomAttributes<TAttribute>(inherit: false).Any(predicate);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type or one its parents are decorated with the
    /// specific <typeparamref name="TAttribute"/>.
    /// </summary>
    public static bool HasAttributeInHierarchy<TAttribute>(this Type type)
        where TAttribute : Attribute
    {
        return type.IsDefined(typeof(TAttribute), inherit: true);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type or one its parents are decorated with the
    /// specific <typeparamref name="TAttribute"/> <i>and</i> that attribute instance
    /// matches the predicate. Returns <see langword="false" /> otherwise.
    /// </summary>
    public static bool HasAttributeInHierarchy<TAttribute>(this Type type, Func<TAttribute, bool> predicate)
        where TAttribute : Attribute
    {
        if (predicate is null)
        {
            throw new ArgumentNullException(nameof(predicate));
        }

        return type.GetCustomAttributes<TAttribute>(inherit: true).Any(predicate);
    }

    /// <summary>
    /// Retrieves all custom attributes of the specified type from a class or its inheritance hierarchy.
    /// </summary>
    public static TAttribute[] GetMatchingAttributes<TAttribute>(this Type type)
        where TAttribute : Attribute
    {
        return (TAttribute[])type.GetCustomAttributes<TAttribute>(inherit: true);
    }

    /// <summary>
    /// Retrieves an array of attributes of a specified type that match the provided predicate.
    /// </summary>
    public static TAttribute[] GetMatchingAttributes<TAttribute>(this Type type, Func<TAttribute, bool> predicate)
        where TAttribute : Attribute
    {
        if (predicate is null)
        {
            throw new ArgumentNullException(nameof(predicate));
        }

        return type.GetCustomAttributes<TAttribute>(inherit: true).Where(predicate).ToArray();
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type overrides the Equals method, or <see langword="false" /> otherwise.
    /// </summary>
    public static bool OverridesEquals(this Type type)
    {
        MethodInfo method = type
            .GetMethod("Equals", [typeof(object)]);

        return method is not null
               && method.GetBaseDefinition().DeclaringType != method.DeclaringType;
    }

    /// <summary>
    /// Determines whether the actual type is the same as, or inherits from, the expected type.
    /// </summary>
    /// <remarks>
    /// The expected type can also be an open generic type definition.
    /// </remarks>
    /// <returns><see langword="true" /> if the actual type is the same as, or inherits from, the expected type; otherwise, <see langword="false" />.</returns>
    public static bool IsSameOrInherits<TExpectedType>(this Type actualType)
    {
        return actualType.IsSameOrInherits(typeof(TExpectedType));
    }

    /// <summary>
    /// Determines whether the actual type is the same as, or inherits from, the expected type.
    /// </summary>
    /// <remarks>
    /// The expected type can also be an open generic type definition.
    /// </remarks>
    /// <returns><see langword="true" /> if the actual type is the same as, or inherits from, the expected type; otherwise, <see langword="false" />.</returns>
    public static bool IsSameOrInherits(this Type actualType, Type expectedType)
    {
        return actualType == expectedType ||
               expectedType.IsAssignableFrom(actualType) ||
               (actualType.BaseType is { IsGenericType: true } && actualType.BaseType.GetGenericTypeDefinition() == expectedType);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a delegate type; otherwise, <see langword="false" />.
    /// </summary>
    public static bool IsDelegate(this Type type)
    {
        return typeof(Delegate).IsAssignableFrom(type);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a compiler-generated type, or <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// Typical examples of compiler-generated types are anonymous types, tuples, and records.
    /// </remarks>
    public static bool IsCompilerGenerated(this Type type)
    {
        return type.HasAttribute<CompilerGeneratedAttribute>() ||
               type.IsRecord() ||
               type.IsTuple();
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type has a readable name, or <see langword="false" />
    /// if it is a compiler-generated name.
    /// </summary>
    public static bool HasFriendlyName(this Type type)
    {
        return !type.IsAnonymous() && !type.IsTuple();
    }

    /// <summary>
    /// Return <see langword="true" /> if the type is a tuple type; otherwise, <see langword="false" />
    /// </summary>
    public static bool IsTuple(this Type type)
    {
        if (!type.IsGenericType)
        {
            return false;
        }

#if NETCOREAPP2_0_OR_GREATER || NET471_OR_GREATER || NETSTANDARD2_1_OR_GREATER
        return typeof(ITuple).IsAssignableFrom(type);
#else
        Type openType = type.GetGenericTypeDefinition();

        return openType == typeof(ValueTuple<>)
               || openType == typeof(ValueTuple<,>)
               || openType == typeof(ValueTuple<,,>)
               || openType == typeof(ValueTuple<,,,>)
               || openType == typeof(ValueTuple<,,,,>)
               || openType == typeof(ValueTuple<,,,,,>)
               || openType == typeof(ValueTuple<,,,,,,>)
               || (openType == typeof(ValueTuple<,,,,,,,>) && IsTuple(type.GetGenericArguments()[7]))
               || openType == typeof(Tuple<>)
               || openType == typeof(Tuple<,>)
               || openType == typeof(Tuple<,,>)
               || openType == typeof(Tuple<,,,>)
               || openType == typeof(Tuple<,,,,>)
               || openType == typeof(Tuple<,,,,,>)
               || openType == typeof(Tuple<,,,,,,>)
               || (openType == typeof(Tuple<,,,,,,,>) && IsTuple(type.GetGenericArguments()[7]));
#endif
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is an anonymous type, or <see langword="false" /> otherwise.
    /// </summary>
    public static bool IsAnonymous(this Type type)
    {
        if (type.FullName!.IndexOf("AnonymousType", StringComparison.Ordinal) < 0)
        {
            return false;
        }

        return type.HasAttribute<CompilerGeneratedAttribute>();
    }

    /// <summary>
    /// Return <see langword="true" /> if the type is a struct or class record type; otherwise, <see langword="false" />.
    /// </summary>
    public static bool IsRecord(this Type type)
    {
        return type.IsRecordClass() || type.IsRecordStruct();
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a class record type; otherwise, <see langword="false" />.
    /// </summary>
    public static bool IsRecordClass(this Type type)
    {
        return type.GetMethod("<Clone>$", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) is { } &&
               type.GetProperty("EqualityContract", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)?
                   .GetMethod?.HasAttribute<CompilerGeneratedAttribute>() == true;
    }

    /// <summary>
    /// Return <see langword="true" /> if the type is a record struct; otherwise, <see langword="false" />
    /// </summary>
    public static bool IsRecordStruct(this Type type)
    {
        // As noted here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-10.0/record-structs#open-questions
        // recognizing record structs from metadata is an open point. The following check is based on common sense
        // and heuristic testing, apparently giving good results but not supported by official documentation.
        return type.BaseType == typeof(ValueType) &&
               type.GetMethod("PrintMembers", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly, null,
                   [typeof(StringBuilder)], null) is { } &&
               type.GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly, null,
                       [type, type], null)?
                   .HasAttribute<CompilerGeneratedAttribute>() == true;
    }

    /// <summary>
    /// Determines whether the specified type is a KeyValuePair.
    /// </summary>
    /// <param name="type">The type to check.</param>
    /// <returns><see langword="true" /> if the type is a KeyValuePair; otherwise, <see langword="false" />.</returns>
    public static bool IsKeyValuePair(this Type type)
    {
        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(KeyValuePair<,>);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a struct (i.e., a value type that is not an enum);
    /// otherwise, <see langword="false" />.
    /// </summary>
    public static bool IsStruct(this Type type)
    {
        return type.IsValueType && !type.IsEnum;
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a ref struct; otherwise, <see langword="false" />.
    /// </summary>
    /// <remarks>
    /// Returns <see langword="false" /> on .NET versions that do not support ref structs.
    /// </remarks>
    public static bool IsRefStruct(this Type type)
    {
#if NETCOREAPP2_1_OR_GREATER || NETSTANDARD2_1_OR_GREATER
        return type.IsDefined(typeof(IsByRefLikeAttribute), false);
#else
        return false;
#endif
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a constructed <see cref="Nullable{T}"/> type,
    /// or <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// This uses the same check as <c>NullableOrActualType</c> (<c>type.IsGenericType &amp;&amp; type.GetGenericTypeDefinition() == typeof(Nullable&lt;&gt;)</c>),
    /// so <c>type.IsNullable()</c> is <see langword="true" /> exactly when <c>type.NullableOrActualType()</c> returns a
    /// different type than <paramref name="type"/> itself.
    /// </remarks>
    public static bool IsNullable(this Type type)
    {
        return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type implements <see cref="IEnumerable"/> (including <see cref="IEnumerable{T}"/>),
    /// or <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// <see cref="string"/> is explicitly excluded, even though it implements <see cref="IEnumerable{T}"/> of <see cref="char"/>.
    /// Treating strings as enumerables is rarely what a caller wants, so this method always returns <see langword="false" />
    /// for <see cref="string"/>.
    /// </remarks>
    /// <remarks>
    /// This method only recognizes the standard <see cref="IEnumerable"/>/<see cref="IEnumerable{T}"/> interfaces.
    /// It does not support the C# 9 pattern-based (duck-typed) <c>foreach</c>, i.e. a type that merely exposes a
    /// public <c>GetEnumerator()</c> method without implementing <see cref="IEnumerable"/>. Recognizing the
    /// well-known interfaces covers the vast majority of real-world use cases.
    /// </remarks>
    public static bool IsEnumerable(this Type type)
    {
        return type != typeof(string) && typeof(IEnumerable).IsAssignableFrom(type);
    }

    /// <summary>
    /// Returns the element type of an enumerable <paramref name="type"/>, or <see langword="null" /> if the type
    /// is not enumerable.
    /// </summary>
    /// <remarks>
    /// For arrays, this returns the array's element type. For types that implement <see cref="IEnumerable{T}"/>
    /// exactly once (directly or through an inherited interface), this returns that single <c>T</c>. When a type
    /// implements <see cref="IEnumerable{T}"/> for multiple different element types (e.g. a type that implements
    /// both <c>IEnumerable&lt;int&gt;</c> and <c>IEnumerable&lt;string&gt;</c>), or when the type only implements the
    /// non-generic <see cref="IEnumerable"/>, the element type cannot be uniquely determined. In that case, this
    /// method falls back to returning <see cref="object"/> as a safe default.
    /// </remarks>
    public static Type GetElementTypeOfEnumerable(this Type type)
    {
        if (!type.IsEnumerable())
        {
            return null;
        }

        if (type.IsArray)
        {
            return type.GetElementType();
        }

        Type[] elementTypes = type.GetClosedGenericInterfacesIncludingSelf(typeof(IEnumerable<>))
            .Select(i => i.GetGenericArguments()[0])
            .Distinct()
            .ToArray();

        return elementTypes.Length == 1 ? elementTypes[0] : typeof(object);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type implements <see cref="IDictionary"/> or a closed
    /// <see cref="IDictionary{TKey,TValue}"/> or <see cref="IReadOnlyDictionary{TKey,TValue}"/>, or <see langword="false" /> otherwise.
    /// </summary>
    public static bool IsDictionary(this Type type)
    {
        return typeof(IDictionary).IsAssignableFrom(type)
               || type.GetClosedGenericInterfacesIncludingSelf(typeof(IDictionary<,>)).Length > 0
               || type.GetClosedGenericInterfacesIncludingSelf(typeof(IReadOnlyDictionary<,>)).Length > 0;
    }

    /// <summary>
    /// Attempts to get the key and value types of a dictionary <paramref name="type"/>.
    /// </summary>
    /// <returns>
    /// <see langword="true" /> and the key and value types if <paramref name="type"/> implements a closed
    /// <see cref="IDictionary{TKey,TValue}"/> or <see cref="IReadOnlyDictionary{TKey,TValue}"/>; otherwise,
    /// <see langword="false" /> with both out parameters set to <see langword="null" />.
    /// </returns>
    /// <remarks>
    /// Types that only implement the non-generic <see cref="IDictionary"/> (and hence do return
    /// <see langword="true" /> from <see cref="IsDictionary"/>) do not carry key/value type information and will
    /// therefore make this method return <see langword="false" />.
    /// </remarks>
    public static bool TryGetDictionaryTypes(this Type type, out Type keyType, out Type valueType)
    {
        Type match = type.GetClosedGenericInterfacesIncludingSelf(typeof(IDictionary<,>)).FirstOrDefault()
                      ?? type.GetClosedGenericInterfacesIncludingSelf(typeof(IReadOnlyDictionary<,>)).FirstOrDefault();

        if (match is not null)
        {
            Type[] genericArguments = match.GetGenericArguments();
            keyType = genericArguments[0];
            valueType = genericArguments[1];
            return true;
        }

        keyType = null;
        valueType = null;
        return false;
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type can be awaited using the C# <c>await</c> keyword, or
    /// <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// This is a reflection-based duck-typing check that mirrors what the C# compiler itself requires of an
    /// awaitable type: a public, parameterless, instance <c>GetAwaiter()</c> method whose return type (the
    /// "awaiter") has a public <c>IsCompleted</c> property, a public parameterless <c>GetResult()</c> method, and
    /// implements <see cref="INotifyCompletion"/>. The awaiter type itself does not need to come from a specific
    /// namespace or assembly; any type that satisfies this shape is recognized.
    /// </remarks>
    public static bool IsAwaitable(this Type type)
    {
        MethodInfo getAwaiter = type.GetMethod("GetAwaiter", BindingFlags.Public | BindingFlags.Instance, null,
            Type.EmptyTypes, null);

        if (getAwaiter is null)
        {
            return false;
        }

        Type awaiterType = getAwaiter.ReturnType;

        bool hasIsCompleted = awaiterType.GetProperty("IsCompleted", BindingFlags.Public | BindingFlags.Instance)
            ?.GetMethod?.IsPublic == true;

        bool hasGetResult = awaiterType.GetMethod("GetResult", BindingFlags.Public | BindingFlags.Instance, null,
            Type.EmptyTypes, null) is not null;

        bool implementsNotifyCompletion = typeof(INotifyCompletion).IsAssignableFrom(awaiterType);

        return hasIsCompleted && hasGetResult && implementsNotifyCompletion;
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is <see cref="Task"/>, a constructed <see cref="Task{TResult}"/>,
    /// <c>ValueTask</c>, or a constructed <c>ValueTask&lt;TResult&gt;</c>, or <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// Unlike <see cref="IsAwaitable"/>, this is a narrower check for these specific, concrete BCL types rather than
    /// a general awaitable duck-type check. <c>ValueTask</c> and <c>ValueTask&lt;TResult&gt;</c> are not part
    /// of the reference assemblies of every target framework this library supports (on net47 and netstandard2.0 they
    /// are only available through the <c>System.Threading.Tasks.Extensions</c> package), so they are recognized by
    /// their full name rather than through a direct <c>typeof</c> reference, keeping this method available - and
    /// correct - on every supported target framework regardless of which packages the consumer has installed.
    /// </remarks>
    public static bool IsTaskLike(this Type type)
    {
        if (type == typeof(Task) || (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>)))
        {
            return true;
        }

        if (type.FullName == "System.Threading.Tasks.ValueTask")
        {
            return true;
        }

        if (type.IsGenericType && type.GetGenericTypeDefinition().FullName == "System.Threading.Tasks.ValueTask`1")
        {
            return true;
        }

        return false;
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is one of the numeric primitive types (<see cref="byte"/>,
    /// <see cref="sbyte"/>, <see cref="short"/>, <see cref="ushort"/>, <see cref="int"/>, <see cref="uint"/>,
    /// <see cref="long"/>, <see cref="ulong"/>, <see cref="float"/>, <see cref="double"/>, or <see cref="decimal"/>),
    /// or <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// <see cref="decimal"/> is included explicitly because, unlike the other numeric types, it is not considered
    /// a CLR primitive (<c>typeof(decimal).IsPrimitive</c> is <see langword="false" />).
    /// </remarks>
    /// <remarks>
    /// <see cref="Nullable{T}"/> forms of these types (e.g. <c>int?</c>) are considered <b>not</b> numeric by this
    /// method; the check applies to the type itself only. Callers that want nullable-aware numeric checks should
    /// first unwrap the type, for instance using <c>NullableOrActualType</c>.
    /// </remarks>
    public static bool IsNumeric(this Type type)
    {
        return type == typeof(byte)
               || type == typeof(sbyte)
               || type == typeof(short)
               || type == typeof(ushort)
               || type == typeof(int)
               || type == typeof(uint)
               || type == typeof(long)
               || type == typeof(ulong)
               || type == typeof(float)
               || type == typeof(double)
               || type == typeof(decimal);
    }

    /// <summary>
    /// Returns <see langword="true" /> if the type is a CLR primitive type or <see cref="string"/>, or
    /// <see langword="false" /> otherwise.
    /// </summary>
    /// <remarks>
    /// This follows the underlying <see cref="Type.IsPrimitive"/> CLR semantics as-is, which has a couple of
    /// notable quirks: <see cref="decimal"/> is <b>not</b> considered primitive (see <see cref="IsNumeric"/> if you
    /// need to include it), while <see cref="IntPtr"/> and <see cref="UIntPtr"/> <b>are</b> considered primitive on
    /// some but not all frameworks/runtimes. This method intentionally does not attempt to normalize that
    /// framework-dependent behavior and simply defers to <see cref="Type.IsPrimitive"/>.
    /// </remarks>
    public static bool IsPrimitiveOrString(this Type type)
    {
        return type.IsPrimitive || type == typeof(string);
    }

    /// <summary>
    /// Returns the closed generic interfaces implemented by <paramref name="type"/> that close over
    /// <paramref name="openGenericType"/>, adapting <see cref="GetClosedGenericInterfaces"/> to also cover the case
    /// where <paramref name="type"/> itself, or one of the interfaces it directly implements, is already a closed
    /// version of <paramref name="openGenericType"/> (a case <see cref="GetClosedGenericInterfaces"/> does not
    /// cover on its own, since it only looks for the open generic type among the interfaces of the interfaces
    /// implemented by <paramref name="type"/>).
    /// </summary>
    private static Type[] GetClosedGenericInterfacesIncludingSelf(this Type type, Type openGenericType)
    {
        IEnumerable<Type> self = type.IsGenericType && type.GetGenericTypeDefinition() == openGenericType
            ? [type]
            : Type.EmptyTypes;

        IEnumerable<Type> directInterfaces = type.GetInterfaces()
            .Where(i => i.IsGenericType && i.GetGenericTypeDefinition() == openGenericType);

        return self
            .Concat(directInterfaces)
            .Concat(type.GetClosedGenericInterfaces(openGenericType))
            .Distinct()
            .ToArray();
    }
}

dennisdoomen / reflectify / 31404809605

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous