15172218253

Committed 21 May 2025 08:44PM UTC coverage: 34.282% (+0.2%) from 34.047%

Build # 15172218253

Build Type

Pull #462

github

Committed by

web-flow

Commit Message

Merge 9de1a7abb into 5807d2b6c

Pull Request Pull Request #462: Support overriding member types

Run Details

1801 of 6650 branches covered (27.08%)

Branch coverage included in aggregate %.

127 of 226 new or added lines in 35 files covered. (56.19%)

22 existing lines in 6 files now uncovered.

4199 of 10852 relevant lines covered (38.69%)

186271.78 hits per line

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

60.0

/Cpp2IL.Core/Model/Contexts/GenericInstanceTypeAnalysisContext.cs

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using Cpp2IL.Core.Utils;
using LibCpp2IL.BinaryStructures;

namespace Cpp2IL.Core.Model.Contexts;

public class GenericInstanceTypeAnalysisContext : ReferencedTypeAnalysisContext
{
    public TypeAnalysisContext GenericType { get; }

    public List<TypeAnalysisContext> GenericArguments { get; } = [];

    public override TypeAttributes DefaultAttributes => GenericType.DefaultAttributes;

    public override TypeAttributes? OverrideAttributes { get => GenericType.OverrideAttributes; set => GenericType.OverrideAttributes = value; }

    public override string DefaultName => $"{GenericType.Name}<{string.Join(", ", GenericArguments.Select(a => a.Name))}>";

    public override string DefaultNamespace => GenericType.Namespace;

    public override TypeAnalysisContext? DefaultBaseType { get; }

    public sealed override Il2CppTypeEnum Type => Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST;

    public sealed override bool IsGenericInstance => true;

    public sealed override bool IsValueType => GenericType.IsValueType; //We don't set a definition so the default implementation cannot determine if we're a value type or not. 

    public GenericInstanceTypeAnalysisContext(Il2CppType rawType, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)
    {
        //Generic type has to be a type definition
        var gClass = rawType.GetGenericClass();
        GenericType = AppContext.ResolveContextForType(gClass.TypeDefinition) ?? throw new($"Could not resolve type {gClass.TypeDefinition.FullName} for generic instance base type");

        GenericArguments.AddRange(gClass.Context.ClassInst.Types.Select(referencedFrom.ResolveIl2CppType)!);

        SetDeclaringType();
    }

    public GenericInstanceTypeAnalysisContext(TypeAnalysisContext genericType, IEnumerable<TypeAnalysisContext> genericArguments, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)
    {
        GenericType = genericType;
        GenericArguments.AddRange(genericArguments);
        DefaultBaseType = genericType.BaseType;

        SetDeclaringType();
    }

    public override string GetCSharpSourceString()
    {
        var sb = new StringBuilder();

        sb.Append(GenericType.GetCSharpSourceString());
        sb.Append('<');
        var first = true;
        foreach (var genericArgument in GenericArguments)
        {
            if (!first)
                sb.Append(", ");
            else
                first = false;

            sb.Append(genericArgument.GetCSharpSourceString());
        }

        sb.Append('>');

        return sb.ToString();
    }

    private void SetDeclaringType()
    {
        var declaringType = GenericType.DeclaringType;
        if (declaringType is null)
            return;

        DeclaringType = declaringType.GenericParameters.Count == 0
            ? declaringType
            : declaringType.MakeGenericInstanceType(GenericArguments.Take(declaringType.GenericParameters.Count));
    }
}

1	using System.Collections.Generic;
2	using System.Linq;
3	using System.Reflection;
4	using System.Text;
5	using Cpp2IL.Core.Utils;
6	using LibCpp2IL.BinaryStructures;
7
8	namespace Cpp2IL.Core.Model.Contexts;
9
10	public class GenericInstanceTypeAnalysisContext : ReferencedTypeAnalysisContext
11	{
12	public TypeAnalysisContext GenericType { get; }	648,214✔
13
14	public List<TypeAnalysisContext> GenericArguments { get; } = [];	1,362,010✔
15
16	public override TypeAttributes DefaultAttributes => GenericType.DefaultAttributes;	327✔
17
18	public override TypeAttributes? OverrideAttributes { get => GenericType.OverrideAttributes; set => GenericType.OverrideAttributes = value; }	327✔
19
20	public override string DefaultName => $"{GenericType.Name}<{string.Join(", ", GenericArguments.Select(a => a.Name))}>";	×
21
NEW 22	public override string DefaultNamespace => GenericType.Namespace;	×
23
24	public override TypeAnalysisContext? DefaultBaseType { get; }	65✔
25
26	public sealed override Il2CppTypeEnum Type => Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST;	×
27
28	public sealed override bool IsGenericInstance => true;	×
29
30	public sealed override bool IsValueType => GenericType.IsValueType; //We don't set a definition so the default implementation cannot determine if we're a value type or not.	8,920✔
31
32	public GenericInstanceTypeAnalysisContext(Il2CppType rawType, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)	109,571✔
33	{
34	//Generic type has to be a type definition
35	var gClass = rawType.GetGenericClass();	109,571✔
36	GenericType = AppContext.ResolveContextForType(gClass.TypeDefinition) ?? throw new($"Could not resolve type {gClass.TypeDefinition.FullName} for generic instance base type");	109,571!
37
38	GenericArguments.AddRange(gClass.Context.ClassInst.Types.Select(referencedFrom.ResolveIl2CppType)!);	109,571✔
39
40	SetDeclaringType();	109,571✔
41	}	109,571✔
42
43	public GenericInstanceTypeAnalysisContext(TypeAnalysisContext genericType, IEnumerable<TypeAnalysisContext> genericArguments, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)	426,917✔
44	{
45	GenericType = genericType;	426,917✔
46	GenericArguments.AddRange(genericArguments);	426,917✔
47	DefaultBaseType = genericType.BaseType;	426,917✔
48
49	SetDeclaringType();	426,917✔
50	}	426,917✔
51
52	public override string GetCSharpSourceString()
53	{
54	var sb = new StringBuilder();	×
55
56	sb.Append(GenericType.GetCSharpSourceString());	×
57	sb.Append('<');	×
58	var first = true;	×
59	foreach (var genericArgument in GenericArguments)	×
60	{
61	if (!first)	×
62	sb.Append(", ");	×
63	else
64	first = false;	×
65
66	sb.Append(genericArgument.GetCSharpSourceString());	×
67	}
68
69	sb.Append('>');	×
70
71	return sb.ToString();	×
72	}
73
74	private void SetDeclaringType()
75	{
76	var declaringType = GenericType.DeclaringType;	536,488✔
77	if (declaringType is null)	536,488✔
78	return;	418,701✔
79
80	DeclaringType = declaringType.GenericParameters.Count == 0	117,787✔
81	? declaringType	117,787✔
82	: declaringType.MakeGenericInstanceType(GenericArguments.Take(declaringType.GenericParameters.Count));	117,787✔
83	}	117,787✔
84	}

SamboyCoding / Cpp2IL / 15172218253

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