21104268457

Committed 18 Jan 2026 02:00AM UTC coverage: 34.371% (+0.01%) from 34.357%

Build # 21104268457

Build Type

push

github

Committed by

SamboyCoding

Commit Message

Change the meaning of MethodAnalysisContext::Overrides

It now specifically refers to methods that use `.override` in IL.

Run Details

1818 of 6636 branches covered (27.4%)

Branch coverage included in aggregate %.

33 of 38 new or added lines in 2 files covered. (86.84%)

3 existing lines in 1 file now uncovered.

4209 of 10899 relevant lines covered (38.62%)

201213.77 hits per line

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

58.33

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

using System;
using System.Collections.Generic;
using System.Diagnostics;
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. 

    private GenericInstanceTypeAnalysisContext(Il2CppType rawType, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)
    {
        // Cache this instance before resolving anything else, which might contain a reference to this instance.
        // https://github.com/SamboyCoding/Cpp2IL/issues/469
        referencedFrom.GenericInstanceTypesByIl2CppType.TryAdd(rawType, this);

        //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();
    }

    /// <summary>
    /// Get or create a <see cref="GenericInstanceTypeAnalysisContext"/> from an <see cref="Il2CppType"/>.
    /// </summary>
    /// <param name="rawType">The underlying <see cref="Il2CppType"/>.</param>
    /// <param name="referencedFrom">The assembly that is referencing this generic instance.</param>
    /// <returns>The context for the <paramref name="rawType"/>.</returns>
    public static GenericInstanceTypeAnalysisContext GetOrCreate(Il2CppType rawType, AssemblyAnalysisContext referencedFrom)
    {
        if (rawType.Type != Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)
            throw new ArgumentException($"Cannot create {nameof(GenericInstanceTypeAnalysisContext)} from type {rawType.Type}. Expected {Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST}.");

        if (!referencedFrom.GenericInstanceTypesByIl2CppType.TryGetValue(rawType, out var result))
        {
            result = new GenericInstanceTypeAnalysisContext(rawType, referencedFrom);
            Debug.Assert(referencedFrom.GenericInstanceTypesByIl2CppType.ContainsKey(rawType), $"The {nameof(GenericInstanceTypeAnalysisContext)} constructor should add itself to the dictionary.");
        }

        return result;
    }

    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;
2	using System.Collections.Generic;
3	using System.Diagnostics;
4	using System.Linq;
5	using System.Reflection;
6	using System.Text;
7	using Cpp2IL.Core.Utils;
8	using LibCpp2IL.BinaryStructures;
9
10	namespace Cpp2IL.Core.Model.Contexts;
11
12	public class GenericInstanceTypeAnalysisContext : ReferencedTypeAnalysisContext
13	{
14	public TypeAnalysisContext GenericType { get; }	641,148✔
15
16	public List<TypeAnalysisContext> GenericArguments { get; } = [];	1,362,487✔
17
UNCOV 18	public override TypeAttributes DefaultAttributes => GenericType.DefaultAttributes;	×
19
UNCOV 20	public override TypeAttributes? OverrideAttributes { get => GenericType.OverrideAttributes; set => GenericType.OverrideAttributes = value; }	×
21
22	public override string DefaultName => $"{GenericType.Name}<{string.Join(", ", GenericArguments.Select(a => a.Name))}>";	×
23
24	public override string DefaultNamespace => GenericType.Namespace;	×
25
UNCOV 26	public override TypeAnalysisContext? DefaultBaseType { get; }	×
27
28	public sealed override Il2CppTypeEnum Type => Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST;	×
29
30	public sealed override bool IsGenericInstance => true;	×
31
32	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✔
33
34	private GenericInstanceTypeAnalysisContext(Il2CppType rawType, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)	12,261✔
35	{
36	// Cache this instance before resolving anything else, which might contain a reference to this instance.
37	// https://github.com/SamboyCoding/Cpp2IL/issues/469
38	referencedFrom.GenericInstanceTypesByIl2CppType.TryAdd(rawType, this);	12,261✔
39
40	//Generic type has to be a type definition
41	var gClass = rawType.GetGenericClass();	12,261✔
42	GenericType = AppContext.ResolveContextForType(gClass.TypeDefinition) ?? throw new($"Could not resolve type {gClass.TypeDefinition.FullName} for generic instance base type");	12,261!
43
44	GenericArguments.AddRange(gClass.Context.ClassInst.Types.Select(referencedFrom.ResolveIl2CppType)!);	12,261✔
45
46	SetDeclaringType();	12,261✔
47	}	12,261✔
48
49	public GenericInstanceTypeAnalysisContext(TypeAnalysisContext genericType, IEnumerable<TypeAnalysisContext> genericArguments, AssemblyAnalysisContext referencedFrom) : base(referencedFrom)	501,258✔
50	{
51	GenericType = genericType;	501,258✔
52	GenericArguments.AddRange(genericArguments);	501,258✔
53	DefaultBaseType = genericType.BaseType;	501,258✔
54
55	SetDeclaringType();	501,258✔
56	}	501,258✔
57
58	/// <summary>
59	/// Get or create a <see cref="GenericInstanceTypeAnalysisContext"/> from an <see cref="Il2CppType"/>.
60	/// </summary>
61	/// <param name="rawType">The underlying <see cref="Il2CppType"/>.</param>
62	/// <param name="referencedFrom">The assembly that is referencing this generic instance.</param>
63	/// <returns>The context for the <paramref name="rawType"/>.</returns>
64	public static GenericInstanceTypeAnalysisContext GetOrCreate(Il2CppType rawType, AssemblyAnalysisContext referencedFrom)
65	{
66	if (rawType.Type != Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST)	127,450!
67	throw new ArgumentException($"Cannot create {nameof(GenericInstanceTypeAnalysisContext)} from type {rawType.Type}. Expected {Il2CppTypeEnum.IL2CPP_TYPE_GENERICINST}.");	×
68
69	if (!referencedFrom.GenericInstanceTypesByIl2CppType.TryGetValue(rawType, out var result))	127,450✔
70	{
71	result = new GenericInstanceTypeAnalysisContext(rawType, referencedFrom);	12,261✔
72	Debug.Assert(referencedFrom.GenericInstanceTypesByIl2CppType.ContainsKey(rawType), $"The {nameof(GenericInstanceTypeAnalysisContext)} constructor should add itself to the dictionary.");
73	}
74
75	return result;	127,450✔
76	}
77
78	public override string GetCSharpSourceString()
79	{
80	var sb = new StringBuilder();	×
81
82	sb.Append(GenericType.GetCSharpSourceString());	×
83	sb.Append('<');	×
84	var first = true;	×
85	foreach (var genericArgument in GenericArguments)	×
86	{
87	if (!first)	×
88	sb.Append(", ");	×
89	else
90	first = false;	×
91
92	sb.Append(genericArgument.GetCSharpSourceString());	×
93	}
94
95	sb.Append('>');	×
96
97	return sb.ToString();	×
98	}
99
100	private void SetDeclaringType()
101	{
102	var declaringType = GenericType.DeclaringType;	513,519✔
103	if (declaringType is null)	513,519✔
104	return;	379,584✔
105
106	DeclaringType = declaringType.GenericParameters.Count == 0	133,935✔
107	? declaringType	133,935✔
108	: declaringType.MakeGenericInstanceType(GenericArguments.Take(declaringType.GenericParameters.Count));	133,935✔
109	}	133,935✔
110	}

SamboyCoding / Cpp2IL / 21104268457

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