13353308356

Committed 16 Feb 2025 08:29AM UTC coverage: 99.961% (-0.02%) from 99.98%

Build # 13353308356

Build Type

push

github

Committed by

afxres

Commit Message

Fix internal exception thrown

Run Details

7 of 8 new or added lines in 2 files covered. (87.5%)

1 existing line in 1 file now uncovered.

5118 of 5120 relevant lines covered (99.96%)

303471.85 hits per line

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

99.37

/code/Binary/Internal/CommonModule.cs

﻿namespace Mikodev.Binary.Internal;

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Runtime.ExceptionServices;

[RequiresDynamicCode(CommonDefine.RequiresDynamicCodeMessage)]
[RequiresUnreferencedCode(CommonDefine.RequiresUnreferencedCodeMessage)]
internal static class CommonModule
{
    internal static T? SelectGenericTypeDefinitionOrDefault<T>(Type type, Func<Type, T> func)
    {
        return type.IsGenericType ? func.Invoke(type.GetGenericTypeDefinition()) : default;
    }

    internal static T CreateDelegate<T>(object? target, MethodInfo method) where T : MulticastDelegate
    {
        return (T)Delegate.CreateDelegate(typeof(T), target, method);
    }

    internal static object CreateInstance(Type type, object?[]? arguments)
    {
        try
        {
            if (Activator.CreateInstance(type, arguments) is { } result)
                return result;
            throw new InvalidOperationException($"Invalid null instance detected, type: {type}");
        }
        catch (TargetInvocationException e)
        {
            if (e.InnerException is { } inner)
                ExceptionDispatchInfo.Throw(inner);
            throw;
        }
    }

    internal static bool TryGetInterfaceArguments(Type type, Type definition, [MaybeNullWhen(false)] out Type[] arguments)
    {
        Debug.Assert(definition.IsInterface);
        Debug.Assert(definition.IsGenericTypeDefinition);
        var interfaces = type.IsInterface ? (IEnumerable<Type>)[type, .. type.GetInterfaces()] : type.GetInterfaces();
        var types = interfaces.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == definition).ToList();
        var count = types.Count;
        if (count > 1)
            throw new ArgumentException($"Multiple interface implementations detected, type: {type}, interface type: {definition}");
        arguments = count is 0 ? null : types.Single().GetGenericArguments();
        return arguments is not null;
    }

    internal static MethodInfo GetPublicInstanceMethod(Type type, string methodName)
    {
        var result = type.GetMethod(methodName, CommonDefine.PublicInstanceBindingFlags);
        if (result is null)
            throw new MissingMethodException($"Method not found, method name: {methodName}, type: {type}");
        return result;
    }

    internal static FieldInfo GetPublicInstanceField(Type type, string fieldName)
    {
        var result = type.GetField(fieldName, CommonDefine.PublicInstanceBindingFlags);
        if (result is null)
            throw new MissingFieldException($"Field not found, field name: {fieldName}, type: {type}");
        return result;
    }

    internal static PropertyInfo GetPublicInstanceProperty(Type type, string propertyName)
    {
        var result = type.GetProperty(propertyName, CommonDefine.PublicInstanceBindingFlags);
        if (result is null)
            throw new MissingMemberException($"Property not found, property name: {propertyName}, type: {type}");
        return result;
    }

    internal static ConstructorInfo GetPublicInstanceConstructor(Type type, Type[] types)
    {
        var result = type.GetConstructor(types);
        if (result is null)
            throw new MissingMethodException($"Constructor not found, type: {type}");
        return result;
    }

    internal static ImmutableArray<Attribute> GetAttributes(MemberInfo member, Func<Attribute, bool> filter)
    {
        Debug.Assert(member is Type or FieldInfo or PropertyInfo);
        var attributes = member.GetCustomAttributes(false).OfType<Attribute>().Where(filter).ToImmutableArray();
        return attributes;
    }

    internal static bool IsIndexer(PropertyInfo property)
    {
        return property.GetIndexParameters().Length is not 0;
    }

    internal static int CompareInheritance(Type? x, Type? y)
    {
        ArgumentNullException.ThrowIfNull(x);
        ArgumentNullException.ThrowIfNull(y);
        if (x.IsValueType || y.IsValueType)
            throw new ArgumentException("Require reference type.");
        if (x == y)
            throw new ArgumentException("Identical types detected.");
        if (x.IsAssignableTo(y))
            return -1;
        if (y.IsAssignableTo(x))
            return 1;
        return 0;
    }

    internal static ImmutableArray<MemberInfo> GetAllPropertiesForInterfaceType(Type type, BindingFlags flags)
    {
        if (type.IsInterface is false)
            throw new ArgumentException("Require interface type.");

        var source = ImmutableArray.CreateRange(type.GetInterfaces()).Add(type);
        var result = ImmutableArray.CreateBuilder<MemberInfo>();
        var dictionary = new SortedDictionary<string, List<PropertyInfo>>();

        void Insert(PropertyInfo member)
        {
            var same = new List<PropertyInfo>();
            var less = new List<PropertyInfo>();
            if (dictionary.TryGetValue(member.Name, out var values))
            {
                foreach (var i in values)
                {
                    var signal = CompareInheritance(i.DeclaringType, member.DeclaringType);
                    if (signal is 0)
                        same.Add(i);
                    else if (signal is -1)
                        less.Add(i);
                }
            }

            if (less.Count is 0)
                less.Add(member);
            less.AddRange(same);
            dictionary[member.Name] = less;
        }

        foreach (var target in source)
        {
            var members = target.GetProperties(flags);
            foreach (var member in members)
            {
                // ignore overriding or shadowing
                if (IsIndexer(member))
                    result.Add(member);
                else
                    Insert(member);
            }
        }

        foreach (var i in dictionary)
        {
            var values = i.Value;
            if (values.Count is 1)
                result.Add(values.First());
            else
                ThrowHelper.ThrowAmbiguousMembers(i.Key, type);
        }

        return result.DrainToImmutable();
    }

    internal static ImmutableArray<MemberInfo> GetAllFieldsAndPropertiesForNonInterfaceType(Type type, BindingFlags flags)
    {
        if (type.IsInterface)
            throw new ArgumentException("Require not interface type.");

        var result = ImmutableArray.CreateBuilder<MemberInfo>();
        var dictionary = new SortedDictionary<string, MemberInfo>();
        for (var target = type; target is not null; target = target.BaseType)
        {
            var members = target.GetMembers(flags);
            foreach (var member in members)
            {
                if (target != member.DeclaringType)
                    continue;
                if (member is not FieldInfo and not PropertyInfo)
                    continue;
                // ignore overriding or shadowing
                if (member is PropertyInfo property && IsIndexer(property))
                    result.Add(member);
                else if (dictionary.TryGetValue(member.Name, out var exists) is false)
                    dictionary.Add(member.Name, member);
                else if (target == exists.DeclaringType)
                    ThrowHelper.ThrowAmbiguousMembers(member.Name, type);
            }
        }
        result.AddRange(dictionary.Values);
        return result.DrainToImmutable();
    }

    internal static ImmutableArray<MemberInfo> GetAllFieldsAndProperties(Type type, BindingFlags flags)
    {
        if (type.IsInterface)
            return GetAllPropertiesForInterfaceType(type, flags);
        return GetAllFieldsAndPropertiesForNonInterfaceType(type, flags);
    }

    internal static IConverter? GetConverter(IGeneratorContext context, Type type, Type typeDefinition, Type converterDefinition)
    {
        Debug.Assert(converterDefinition.IsGenericTypeDefinition);
        Debug.Assert(converterDefinition.GetGenericArguments().Length == typeDefinition.GetGenericArguments().Length);
        if (type.IsGenericType is false || type.GetGenericTypeDefinition() != typeDefinition)
            return null;
        var arguments = type.GetGenericArguments();
        var converterArguments = arguments.Select(context.GetConverter).Cast<object>().ToArray();
        var converterType = converterDefinition.MakeGenericType(arguments);
        var converter = CreateInstance(converterType, converterArguments);
        return (IConverter)converter;
    }
}

1	namespace Mikodev.Binary.Internal;
2
3	using System;
4	using System.Collections.Generic;
5	using System.Collections.Immutable;
6	using System.Diagnostics;
7	using System.Diagnostics.CodeAnalysis;
8	using System.Linq;
9	using System.Reflection;
10	using System.Runtime.ExceptionServices;
11
12	[RequiresDynamicCode(CommonDefine.RequiresDynamicCodeMessage)]
13	[RequiresUnreferencedCode(CommonDefine.RequiresUnreferencedCodeMessage)]
14	internal static class CommonModule
15	{
16	internal static T? SelectGenericTypeDefinitionOrDefault<T>(Type type, Func<Type, T> func)
17	{	5,914✔
18	return type.IsGenericType ? func.Invoke(type.GetGenericTypeDefinition()) : default;	5,914✔
19	}	5,914✔
20
21	internal static T CreateDelegate<T>(object? target, MethodInfo method) where T : MulticastDelegate
22	{	2,228✔
23	return (T)Delegate.CreateDelegate(typeof(T), target, method);	2,228✔
24	}	2,228✔
25
26	internal static object CreateInstance(Type type, object?[]? arguments)
27	{	1,342✔
28	try
29	{	1,342✔
30	if (Activator.CreateInstance(type, arguments) is { } result)	1,342✔
31	return result;	1,310✔
32	throw new InvalidOperationException($"Invalid null instance detected, type: {type}");	4✔
33	}
34	catch (TargetInvocationException e)	14✔
35	{	14✔
36	if (e.InnerException is { } inner)	14✔
37	ExceptionDispatchInfo.Throw(inner);	14✔
NEW 38	throw;	×
39	}
40	}	1,310✔
41
42	internal static bool TryGetInterfaceArguments(Type type, Type definition, [MaybeNullWhen(false)] out Type[] arguments)
43	{	1,998✔
44	Debug.Assert(definition.IsInterface);	1,998✔
45	Debug.Assert(definition.IsGenericTypeDefinition);	1,998✔
46	var interfaces = type.IsInterface ? (IEnumerable<Type>)[type, .. type.GetInterfaces()] : type.GetInterfaces();	1,998✔
47	var types = interfaces.Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == definition).ToList();	11,474✔
48	var count = types.Count;	1,998✔
49	if (count > 1)	1,998✔
50	throw new ArgumentException($"Multiple interface implementations detected, type: {type}, interface type: {definition}");	2✔
51	arguments = count is 0 ? null : types.Single().GetGenericArguments();	1,996✔
52	return arguments is not null;	1,996✔
53	}	1,996✔
54
55	internal static MethodInfo GetPublicInstanceMethod(Type type, string methodName)
56	{	1,166✔
57	var result = type.GetMethod(methodName, CommonDefine.PublicInstanceBindingFlags);	1,166✔
58	if (result is null)	1,166✔
59	throw new MissingMethodException($"Method not found, method name: {methodName}, type: {type}");	4✔
60	return result;	1,162✔
61	}	1,162✔
62
63	internal static FieldInfo GetPublicInstanceField(Type type, string fieldName)
64	{	432✔
65	var result = type.GetField(fieldName, CommonDefine.PublicInstanceBindingFlags);	432✔
66	if (result is null)	432✔
67	throw new MissingFieldException($"Field not found, field name: {fieldName}, type: {type}");	4✔
68	return result;	428✔
69	}	428✔
70
71	internal static PropertyInfo GetPublicInstanceProperty(Type type, string propertyName)
72	{	516✔
73	var result = type.GetProperty(propertyName, CommonDefine.PublicInstanceBindingFlags);	516✔
74	if (result is null)	516✔
75	throw new MissingMemberException($"Property not found, property name: {propertyName}, type: {type}");	4✔
76	return result;	512✔
77	}	512✔
78
79	internal static ConstructorInfo GetPublicInstanceConstructor(Type type, Type[] types)
80	{	180✔
81	var result = type.GetConstructor(types);	180✔
82	if (result is null)	180✔
83	throw new MissingMethodException($"Constructor not found, type: {type}");	4✔
84	return result;	176✔
85	}	176✔
86
87	internal static ImmutableArray<Attribute> GetAttributes(MemberInfo member, Func<Attribute, bool> filter)
88	{	5,410✔
89	Debug.Assert(member is Type or FieldInfo or PropertyInfo);	5,410✔
90	var attributes = member.GetCustomAttributes(false).OfType<Attribute>().Where(filter).ToImmutableArray();	5,410✔
91	return attributes;	5,410✔
92	}	5,410✔
93
94	internal static bool IsIndexer(PropertyInfo property)
95	{	3,054✔
96	return property.GetIndexParameters().Length is not 0;	3,054✔
97	}	3,054✔
98
99	internal static int CompareInheritance(Type? x, Type? y)
100	{	188✔
101	ArgumentNullException.ThrowIfNull(x);	188✔
102	ArgumentNullException.ThrowIfNull(y);	188✔
103	if (x.IsValueType \|\| y.IsValueType)	188✔
104	throw new ArgumentException("Require reference type.");	6✔
105	if (x == y)	182✔
106	throw new ArgumentException("Identical types detected.");	6✔
107	if (x.IsAssignableTo(y))	176✔
108	return -1;	10✔
109	if (y.IsAssignableTo(x))	166✔
110	return 1;	30✔
111	return 0;	136✔
112	}	176✔
113
114	internal static ImmutableArray<MemberInfo> GetAllPropertiesForInterfaceType(Type type, BindingFlags flags)
115	{	50✔
116	if (type.IsInterface is false)	50✔
117	throw new ArgumentException("Require interface type.");	4✔
118
119	var source = ImmutableArray.CreateRange(type.GetInterfaces()).Add(type);	46✔
120	var result = ImmutableArray.CreateBuilder<MemberInfo>();	46✔
121	var dictionary = new SortedDictionary<string, List<PropertyInfo>>();	46✔
122
123	void Insert(PropertyInfo member)
124	{	138✔
125	var same = new List<PropertyInfo>();	138✔
126	var less = new List<PropertyInfo>();	138✔
127	if (dictionary.TryGetValue(member.Name, out var values))	138✔
128	{	64✔
129	foreach (var i in values)	524✔
130	{	166✔
131	var signal = CompareInheritance(i.DeclaringType, member.DeclaringType);	166✔
132	if (signal is 0)	166✔
133	same.Add(i);	130✔
134	else if (signal is -1)	36✔
135	less.Add(i);	8✔
136	}	166✔
137	}	64✔
138
139	if (less.Count is 0)	138✔
140	less.Add(member);	130✔
141	less.AddRange(same);	138✔
142	dictionary[member.Name] = less;	138✔
143	}	138✔
144
145	foreach (var target in source)	414✔
146	{	138✔
147	var members = target.GetProperties(flags);	138✔
148	foreach (var member in members)	726✔
149	{	156✔
150	// ignore overriding or shadowing
151	if (IsIndexer(member))	156✔
152	result.Add(member);	18✔
153	else
154	Insert(member);	138✔
155	}	156✔
156	}	138✔
157
158	foreach (var i in dictionary)	264✔
159	{	70✔
160	var values = i.Value;	70✔
161	if (values.Count is 1)	70✔
162	result.Add(values.First());	56✔
163	else
164	ThrowHelper.ThrowAmbiguousMembers(i.Key, type);	14✔
165	}	56✔
166
167	return result.DrainToImmutable();	32✔
168	}	32✔
169
170	internal static ImmutableArray<MemberInfo> GetAllFieldsAndPropertiesForNonInterfaceType(Type type, BindingFlags flags)
171	{	686✔
172	if (type.IsInterface)	686✔
173	throw new ArgumentException("Require not interface type.");	6✔
174
175	var result = ImmutableArray.CreateBuilder<MemberInfo>();	680✔
176	var dictionary = new SortedDictionary<string, MemberInfo>();	680✔
177	for (var target = type; target is not null; target = target.BaseType)	4,576✔
178	{	1,612✔
179	var members = target.GetMembers(flags);	1,612✔
180	foreach (var member in members)	32,024✔
181	{	13,596✔
182	if (target != member.DeclaringType)	13,596✔
183	continue;	3,210✔
184	if (member is not FieldInfo and not PropertyInfo)	10,386✔
185	continue;	8,746✔
186	// ignore overriding or shadowing
187	if (member is PropertyInfo property && IsIndexer(property))	1,640✔
188	result.Add(member);	96✔
189	else if (dictionary.TryGetValue(member.Name, out var exists) is false)	1,544✔
190	dictionary.Add(member.Name, member);	1,452✔
191	else if (target == exists.DeclaringType)	92✔
192	ThrowHelper.ThrowAmbiguousMembers(member.Name, type);	4✔
193	}	1,636✔
194	}	1,608✔
195	result.AddRange(dictionary.Values);	676✔
196	return result.DrainToImmutable();	676✔
197	}	676✔
198
199	internal static ImmutableArray<MemberInfo> GetAllFieldsAndProperties(Type type, BindingFlags flags)
200	{	726✔
201	if (type.IsInterface)	726✔
202	return GetAllPropertiesForInterfaceType(type, flags);	46✔
203	return GetAllFieldsAndPropertiesForNonInterfaceType(type, flags);	680✔
204	}	708✔
205
206	internal static IConverter? GetConverter(IGeneratorContext context, Type type, Type typeDefinition, Type converterDefinition)
207	{	12,226✔
208	Debug.Assert(converterDefinition.IsGenericTypeDefinition);	12,226✔
209	Debug.Assert(converterDefinition.GetGenericArguments().Length == typeDefinition.GetGenericArguments().Length);	12,226✔
210	if (type.IsGenericType is false \|\| type.GetGenericTypeDefinition() != typeDefinition)	12,226✔
211	return null;	12,016✔
212	var arguments = type.GetGenericArguments();	210✔
213	var converterArguments = arguments.Select(context.GetConverter).Cast<object>().ToArray();	210✔
214	var converterType = converterDefinition.MakeGenericType(arguments);	210✔
215	var converter = CreateInstance(converterType, converterArguments);	210✔
216	return (IConverter)converter;	208✔
217	}	12,224✔
218	}

afxres / binary / 13353308356

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