15014383252

Committed 14 May 2025 07:03AM UTC coverage: 34.711% (-0.1%) from 34.826%

Build # 15014383252

Build Type

Pull #452

github

Committed by

web-flow

Commit Message

Merge ad62ba652 into e93c0fecc

Pull Request Pull Request #452: Expand type system to support more types

Run Details

1813 of 6508 branches covered (27.86%)

Branch coverage included in aggregate %.

22 of 92 new or added lines in 11 files covered. (23.91%)

4 existing lines in 3 files now uncovered.

4158 of 10694 relevant lines covered (38.88%)

160537.6 hits per line

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

45.83

/Cpp2IL.Core/Utils/GenericInstantiation.cs

using System.Collections.Generic;
using System.Linq;
using Cpp2IL.Core.Model.Contexts;
using LibCpp2IL.BinaryStructures;

namespace Cpp2IL.Core.Utils;

internal static class GenericInstantiation
{
    public static TypeAnalysisContext Instantiate(TypeAnalysisContext type, IReadOnlyList<TypeAnalysisContext> genericTypeParameters, IReadOnlyList<TypeAnalysisContext> genericMethodParameters)
    {
        switch (type)
        {
            case GenericParameterTypeAnalysisContext genericParameterTypeAnalysisContext:
            {
                var index = genericParameterTypeAnalysisContext.Index;
                return genericParameterTypeAnalysisContext.Type switch
                {
                    Il2CppTypeEnum.IL2CPP_TYPE_VAR => genericTypeParameters[index],
                    _ => genericMethodParameters[index],
                };
            }
            case SzArrayTypeAnalysisContext szArrayTypeAnalysisContext:
            {
                var elementType = Instantiate(szArrayTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == szArrayTypeAnalysisContext.ElementType
                    ? szArrayTypeAnalysisContext
                    : new SzArrayTypeAnalysisContext(elementType, szArrayTypeAnalysisContext.DeclaringAssembly);
            }
            case ArrayTypeAnalysisContext arrayTypeAnalysisContext:
            {
                var elementType = Instantiate(arrayTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == arrayTypeAnalysisContext.ElementType
                    ? arrayTypeAnalysisContext
                    : new ArrayTypeAnalysisContext(elementType, arrayTypeAnalysisContext.Rank, arrayTypeAnalysisContext.DeclaringAssembly);
            }
            case ByRefTypeAnalysisContext byReferenceTypeAnalysisContext:
            {
                var elementType = Instantiate(byReferenceTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == byReferenceTypeAnalysisContext.ElementType
                    ? byReferenceTypeAnalysisContext
                    : new ByRefTypeAnalysisContext(elementType, byReferenceTypeAnalysisContext.DeclaringAssembly);
            }
            case PointerTypeAnalysisContext pointerTypeAnalysisContext:
            {
                var elementType = Instantiate(pointerTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == pointerTypeAnalysisContext.ElementType
                    ? pointerTypeAnalysisContext
                    : new PointerTypeAnalysisContext(elementType, pointerTypeAnalysisContext.DeclaringAssembly);
            }
            case PinnedTypeAnalysisContext pinnedTypeAnalysisContext:
            {
                var elementType = Instantiate(pinnedTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == pinnedTypeAnalysisContext.ElementType
                    ? pinnedTypeAnalysisContext
                    : new PinnedTypeAnalysisContext(elementType, pinnedTypeAnalysisContext.DeclaringAssembly);
            }
            case BoxedTypeAnalysisContext boxedTypeAnalysisContext:
            {
                var elementType = Instantiate(boxedTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                return elementType == boxedTypeAnalysisContext.ElementType
                    ? boxedTypeAnalysisContext
                    : new BoxedTypeAnalysisContext(elementType, boxedTypeAnalysisContext.DeclaringAssembly);
            }
            case CustomModifierTypeAnalysisContext customModifierTypeAnalysisContext:
            {
                var elementType = Instantiate(customModifierTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);
                var modifierType = Instantiate(customModifierTypeAnalysisContext.ModifierType, genericTypeParameters, genericMethodParameters);
                return (elementType == customModifierTypeAnalysisContext.ElementType && modifierType == customModifierTypeAnalysisContext.ModifierType)
                    ? customModifierTypeAnalysisContext
                    : new CustomModifierTypeAnalysisContext(elementType, modifierType, customModifierTypeAnalysisContext.Required, customModifierTypeAnalysisContext.DeclaringAssembly);
            }
            case GenericInstanceTypeAnalysisContext genericInstanceTypeAnalysisContext:
            {
                var genericType = Instantiate(genericInstanceTypeAnalysisContext.GenericType, genericTypeParameters, genericMethodParameters);

                var createNew = genericType != genericInstanceTypeAnalysisContext.GenericType;

                var genericArguments = new TypeAnalysisContext[genericInstanceTypeAnalysisContext.GenericArguments.Count];
                for (var i = 0; i < genericInstanceTypeAnalysisContext.GenericArguments.Count; i++)
                {
                    var genericArgument = genericInstanceTypeAnalysisContext.GenericArguments[i];
                    var instantiatedGenericArgument = Instantiate(genericArgument, genericTypeParameters, genericMethodParameters);
                    genericArguments[i] = instantiatedGenericArgument;
                    createNew |= instantiatedGenericArgument != genericArgument;
                }

                return createNew
                    ? new GenericInstanceTypeAnalysisContext(genericType, genericArguments, genericInstanceTypeAnalysisContext.DeclaringAssembly)
                    : genericInstanceTypeAnalysisContext;
            }
            default:
                return type;
        }
    }

    public static bool HasAnyGenericParameters(this TypeAnalysisContext type) => type switch
    {
        GenericParameterTypeAnalysisContext => true,
        SzArrayTypeAnalysisContext szArrayTypeAnalysisContext => HasAnyGenericParameters(szArrayTypeAnalysisContext.ElementType),
        ArrayTypeAnalysisContext arrayTypeAnalysisContext => HasAnyGenericParameters(arrayTypeAnalysisContext.ElementType),
        ByRefTypeAnalysisContext byReferenceTypeAnalysisContext => HasAnyGenericParameters(byReferenceTypeAnalysisContext.ElementType),
        PointerTypeAnalysisContext pointerTypeAnalysisContext => HasAnyGenericParameters(pointerTypeAnalysisContext.ElementType),
        PinnedTypeAnalysisContext pinnedTypeAnalysisContext => HasAnyGenericParameters(pinnedTypeAnalysisContext.ElementType),
        BoxedTypeAnalysisContext boxedTypeAnalysisContext => HasAnyGenericParameters(boxedTypeAnalysisContext.ElementType),
        CustomModifierTypeAnalysisContext customModifierTypeAnalysisContext => HasAnyGenericParameters(customModifierTypeAnalysisContext.ElementType) || HasAnyGenericParameters(customModifierTypeAnalysisContext.ModifierType),
        GenericInstanceTypeAnalysisContext genericInstanceTypeAnalysisContext => genericInstanceTypeAnalysisContext.GenericArguments.Any(HasAnyGenericParameters),
        _ => false,
    };
}

1	using System.Collections.Generic;
2	using System.Linq;
3	using Cpp2IL.Core.Model.Contexts;
4	using LibCpp2IL.BinaryStructures;
5
6	namespace Cpp2IL.Core.Utils;
7
8	internal static class GenericInstantiation
9	{
10	public static TypeAnalysisContext Instantiate(TypeAnalysisContext type, IReadOnlyList<TypeAnalysisContext> genericTypeParameters, IReadOnlyList<TypeAnalysisContext> genericMethodParameters)
11	{
12	switch (type)
13	{
14	case GenericParameterTypeAnalysisContext genericParameterTypeAnalysisContext:
15	{
16	var index = genericParameterTypeAnalysisContext.Index;	157,339!
17	return genericParameterTypeAnalysisContext.Type switch	157,339✔
18	{	157,339✔
19	Il2CppTypeEnum.IL2CPP_TYPE_VAR => genericTypeParameters[index],	115,767✔
20	_ => genericMethodParameters[index],	41,572✔
21	};	157,339✔
22	}
23	case SzArrayTypeAnalysisContext szArrayTypeAnalysisContext:
24	{
25	var elementType = Instantiate(szArrayTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	20,458✔
26	return elementType == szArrayTypeAnalysisContext.ElementType	20,458✔
27	? szArrayTypeAnalysisContext	20,458✔
28	: new SzArrayTypeAnalysisContext(elementType, szArrayTypeAnalysisContext.DeclaringAssembly);	20,458✔
29	}
30	case ArrayTypeAnalysisContext arrayTypeAnalysisContext:
31	{
32	var elementType = Instantiate(arrayTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	×
33	return elementType == arrayTypeAnalysisContext.ElementType	×
34	? arrayTypeAnalysisContext	×
35	: new ArrayTypeAnalysisContext(elementType, arrayTypeAnalysisContext.Rank, arrayTypeAnalysisContext.DeclaringAssembly);	×
36	}
37	case ByRefTypeAnalysisContext byReferenceTypeAnalysisContext:
38	{
39	var elementType = Instantiate(byReferenceTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	8,826✔
40	return elementType == byReferenceTypeAnalysisContext.ElementType	8,826✔
41	? byReferenceTypeAnalysisContext	8,826✔
42	: new ByRefTypeAnalysisContext(elementType, byReferenceTypeAnalysisContext.DeclaringAssembly);	8,826✔
43	}
44	case PointerTypeAnalysisContext pointerTypeAnalysisContext:
45	{
46	var elementType = Instantiate(pointerTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	350✔
47	return elementType == pointerTypeAnalysisContext.ElementType	350!
48	? pointerTypeAnalysisContext	350✔
49	: new PointerTypeAnalysisContext(elementType, pointerTypeAnalysisContext.DeclaringAssembly);	350✔
50	}
51	case PinnedTypeAnalysisContext pinnedTypeAnalysisContext:
52	{
NEW 53	var elementType = Instantiate(pinnedTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	×
NEW 54	return elementType == pinnedTypeAnalysisContext.ElementType	×
NEW 55	? pinnedTypeAnalysisContext	×
NEW 56	: new PinnedTypeAnalysisContext(elementType, pinnedTypeAnalysisContext.DeclaringAssembly);	×
57	}
58	case BoxedTypeAnalysisContext boxedTypeAnalysisContext:
59	{
NEW 60	var elementType = Instantiate(boxedTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	×
NEW 61	return elementType == boxedTypeAnalysisContext.ElementType	×
NEW 62	? boxedTypeAnalysisContext	×
NEW 63	: new BoxedTypeAnalysisContext(elementType, boxedTypeAnalysisContext.DeclaringAssembly);	×
64	}
65	case CustomModifierTypeAnalysisContext customModifierTypeAnalysisContext:
66	{
NEW 67	var elementType = Instantiate(customModifierTypeAnalysisContext.ElementType, genericTypeParameters, genericMethodParameters);	×
NEW 68	var modifierType = Instantiate(customModifierTypeAnalysisContext.ModifierType, genericTypeParameters, genericMethodParameters);	×
NEW 69	return (elementType == customModifierTypeAnalysisContext.ElementType && modifierType == customModifierTypeAnalysisContext.ModifierType)	×
NEW 70	? customModifierTypeAnalysisContext	×
NEW 71	: new CustomModifierTypeAnalysisContext(elementType, modifierType, customModifierTypeAnalysisContext.Required, customModifierTypeAnalysisContext.DeclaringAssembly);	×
72	}
73	case GenericInstanceTypeAnalysisContext genericInstanceTypeAnalysisContext:
74	{
75	var genericType = Instantiate(genericInstanceTypeAnalysisContext.GenericType, genericTypeParameters, genericMethodParameters);	35,320✔
76
77	var createNew = genericType != genericInstanceTypeAnalysisContext.GenericType;	35,320✔
78
79	var genericArguments = new TypeAnalysisContext[genericInstanceTypeAnalysisContext.GenericArguments.Count];	35,320✔
80	for (var i = 0; i < genericInstanceTypeAnalysisContext.GenericArguments.Count; i++)	156,226✔
81	{
82	var genericArgument = genericInstanceTypeAnalysisContext.GenericArguments[i];	42,793✔
83	var instantiatedGenericArgument = Instantiate(genericArgument, genericTypeParameters, genericMethodParameters);	42,793✔
84	genericArguments[i] = instantiatedGenericArgument;	42,793✔
85	createNew \|= instantiatedGenericArgument != genericArgument;	42,793✔
86	}
87
88	return createNew	35,320✔
89	? new GenericInstanceTypeAnalysisContext(genericType, genericArguments, genericInstanceTypeAnalysisContext.DeclaringAssembly)	35,320✔
90	: genericInstanceTypeAnalysisContext;	35,320✔
91	}
92	default:
93	return type;	356,805✔
94	}
95	}
96
97	public static bool HasAnyGenericParameters(this TypeAnalysisContext type) => type switch	×
98	{	×
99	GenericParameterTypeAnalysisContext => true,	×
100	SzArrayTypeAnalysisContext szArrayTypeAnalysisContext => HasAnyGenericParameters(szArrayTypeAnalysisContext.ElementType),	×
101	ArrayTypeAnalysisContext arrayTypeAnalysisContext => HasAnyGenericParameters(arrayTypeAnalysisContext.ElementType),	×
102	ByRefTypeAnalysisContext byReferenceTypeAnalysisContext => HasAnyGenericParameters(byReferenceTypeAnalysisContext.ElementType),	×
103	PointerTypeAnalysisContext pointerTypeAnalysisContext => HasAnyGenericParameters(pointerTypeAnalysisContext.ElementType),	×
NEW 104	PinnedTypeAnalysisContext pinnedTypeAnalysisContext => HasAnyGenericParameters(pinnedTypeAnalysisContext.ElementType),	×
NEW 105	BoxedTypeAnalysisContext boxedTypeAnalysisContext => HasAnyGenericParameters(boxedTypeAnalysisContext.ElementType),	×
NEW 106	CustomModifierTypeAnalysisContext customModifierTypeAnalysisContext => HasAnyGenericParameters(customModifierTypeAnalysisContext.ElementType) \|\| HasAnyGenericParameters(customModifierTypeAnalysisContext.ModifierType),	×
107	GenericInstanceTypeAnalysisContext genericInstanceTypeAnalysisContext => genericInstanceTypeAnalysisContext.GenericArguments.Any(HasAnyGenericParameters),	×
108	_ => false,	×
109	};	×
110	}

SamboyCoding / Cpp2IL / 15014383252

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