15144219583

Committed 20 May 2025 05:38PM UTC coverage: 34.28% (+0.2%) from 34.047%

Build # 15144219583

Build Type

Pull #462

github

Committed by

web-flow

Commit Message

Merge f80b990bc into 5807d2b6c

Pull Request Pull Request #462: Support overriding member types

Run Details

1799 of 6646 branches covered (27.07%)

Branch coverage included in aggregate %.

115 of 202 new or added lines in 33 files covered. (56.93%)

22 existing lines in 6 files now uncovered.

4197 of 10845 relevant lines covered (38.7%)

186399.11 hits per line

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

82.35

/Cpp2IL.Core/Model/Contexts/ConcreteGenericMethodAnalysisContext.cs

using System;
using System.Reflection;
using Cpp2IL.Core.Utils;
using LibCpp2IL;
using LibCpp2IL.Reflection;

namespace Cpp2IL.Core.Model.Contexts;

public class ConcreteGenericMethodAnalysisContext : MethodAnalysisContext
{
    public readonly AssemblyAnalysisContext DeclaringAsm;
    public readonly Cpp2IlMethodRef? MethodRef;
    public readonly MethodAnalysisContext BaseMethodContext;

    /// <summary>
    /// The generic parameters for the <see cref="BaseMethodContext"/> declaring type.
    /// </summary>
    /// <remarks>
    /// If not empty, <see cref="MethodAnalysisContext.DeclaringType"/> is a <see cref="GenericInstanceTypeAnalysisContext"/>.
    /// </remarks>
    public TypeAnalysisContext[] TypeGenericParameters { get; }

    /// <summary>
    /// The generic parameters for the <see cref="BaseMethodContext"/>.
    /// </summary>
    /// <remarks>
    /// These may be empty if <see cref="BaseMethodContext"/> has no generic parameters or if <see cref="IsPartialInstantiation"/>.
    /// </remarks>
    public TypeAnalysisContext[] MethodGenericParameters { get; }

    /// <summary>
    /// If true, this is a generic method on a <see cref="GenericInstanceTypeAnalysisContext"/>, but it does not specify any <see cref="MethodGenericParameters"/>.
    /// </summary>
    public bool IsPartialInstantiation => MethodGenericParameters.Length == 0 && BaseMethodContext.GenericParameterCount > 0;

    public sealed override ulong UnderlyingPointer => MethodRef?.GenericVariantPtr ?? default;

    public override string DefaultName => BaseMethodContext.DefaultName;

    public override TypeAnalysisContext DefaultReturnType { get; }

    public override string? OverrideName { get => BaseMethodContext.OverrideName; set => BaseMethodContext.OverrideName = value; }

    public override MethodAttributes DefaultAttributes => BaseMethodContext.DefaultAttributes;

    public override MethodAttributes? OverrideAttributes { get => BaseMethodContext.OverrideAttributes; set => BaseMethodContext.OverrideAttributes = value; }

    public override AssemblyAnalysisContext CustomAttributeAssembly => BaseMethodContext.CustomAttributeAssembly;

    public ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef methodRef, ApplicationAnalysisContext context)
        : this(methodRef, ResolveDeclaringAssembly(methodRef, context))
    {
    }

    private ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef methodRef, AssemblyAnalysisContext declaringAssembly)
        : this(
              methodRef,
              ResolveBaseMethod(methodRef, declaringAssembly.GetTypeByDefinition(methodRef.DeclaringType)!),
              ResolveDeclaringType(methodRef, declaringAssembly),
              ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly),
              ResolveTypeArray(methodRef.MethodGenericParams, declaringAssembly),
              declaringAssembly)
    {
    }

    /// <summary>
    /// Generically instantiate a method.
    /// </summary>
    /// <param name="baseMethod">The method definition on which this instantiation is based.</param>
    /// <param name="typeGenericParameters">The type parameters for the declaring type, if any. These must always be specified.</param>
    /// <param name="methodGenericParameters">
    /// The type parameters for the base method, if any.
    /// These may be omitted (<see cref="IsPartialInstantiation"/> == <see langword="true"/>).
    /// </param>
    public ConcreteGenericMethodAnalysisContext(MethodAnalysisContext baseMethod, TypeAnalysisContext[] typeGenericParameters, TypeAnalysisContext[] methodGenericParameters)
        : this(
              null,
              baseMethod,
              typeGenericParameters.Length > 0 ? baseMethod.DeclaringType!.MakeGenericInstanceType(typeGenericParameters) : baseMethod.DeclaringType!,
              typeGenericParameters,
              methodGenericParameters,
              baseMethod.CustomAttributeAssembly)
    {
        if (baseMethod.DeclaringType!.GenericParameters.Count != typeGenericParameters.Length)
            throw new ArgumentException("The number of type generic parameters must match the number of generic parameters on the declaring type.");

        if (methodGenericParameters.Length > 0 && baseMethod.GenericParameterCount != methodGenericParameters.Length)
            throw new ArgumentException("The number of method generic parameters must match the number of generic parameters on the base method.");
    }

    private ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef? methodRef, MethodAnalysisContext baseMethodContext, TypeAnalysisContext declaringType, TypeAnalysisContext[] typeGenericParameters, TypeAnalysisContext[] methodGenericParameters, AssemblyAnalysisContext declaringAssembly)
        : base(null, declaringType)
    {
        MethodRef = methodRef;
        DeclaringAsm = declaringAssembly;
        BaseMethodContext = baseMethodContext;

        TypeGenericParameters = typeGenericParameters;
        MethodGenericParameters = methodGenericParameters;

        // For the purpose of generic instantiation, we need an array of method generic parameters, even if none are provided.
        if (methodGenericParameters.Length == 0 && baseMethodContext.GenericParameterCount > 0)
            methodGenericParameters = baseMethodContext.GenericParameters.ToArray();

        for (var i = 0; i < BaseMethodContext.Parameters.Count; i++)
        {
            var parameter = BaseMethodContext.Parameters[i];
            var instantiatedType = GenericInstantiation.Instantiate(
                parameter.ParameterType,
                typeGenericParameters,
                methodGenericParameters);

            Parameters.Add(new ConcreteGenericParameterAnalysisContext(parameter, instantiatedType, this));
        }

        DefaultReturnType = GenericInstantiation.Instantiate(BaseMethodContext.ReturnType, typeGenericParameters, methodGenericParameters);

        if (UnderlyingPointer != 0)
            rawMethodBody = AppContext.InstructionSet.GetRawBytesForMethod(this, false);
    }

    private static AssemblyAnalysisContext ResolveDeclaringAssembly(Cpp2IlMethodRef methodRef, ApplicationAnalysisContext context)
    {
        return context.GetAssemblyByName(methodRef.DeclaringType.DeclaringAssembly!.Name!)
               ?? throw new($"Unable to resolve declaring assembly {methodRef.DeclaringType.DeclaringAssembly.Name} for generic method {methodRef}");
    }

    private static TypeAnalysisContext ResolveDeclaringType(Cpp2IlMethodRef methodRef, AssemblyAnalysisContext declaringAssembly)
    {
        var baseType = declaringAssembly.AppContext.ResolveContextForType(methodRef.DeclaringType)
                       ?? throw new($"Unable to resolve declaring type {methodRef.DeclaringType.FullName} for generic method {methodRef}");

        if (methodRef.TypeGenericParams.Length == 0)
            return baseType;

        var genericParams = ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly);

        return new GenericInstanceTypeAnalysisContext(baseType, genericParams, declaringAssembly);
    }

    private static TypeAnalysisContext[] ResolveTypeArray(Il2CppTypeReflectionData[] array, AssemblyAnalysisContext declaringAssembly)
    {
        if (array.Length == 0)
            return [];

        var ret = new TypeAnalysisContext[array.Length];
        for (var i = 0; i < array.Length; i++)
        {
            ret[i] = array[i].ToContext(declaringAssembly)
                     ?? throw new($"Unable to resolve generic parameter {array[i]} for generic method.");
        }

        return ret;
    }

    private static MethodAnalysisContext ResolveBaseMethod(Cpp2IlMethodRef methodRef, TypeAnalysisContext declaringType)
    {
        return declaringType.GetMethod(methodRef.BaseMethod)
               ?? throw new($"Unable to resolve base method {methodRef.BaseMethod} for generic method {methodRef}");
    }
}

1	using System;
2	using System.Reflection;
3	using Cpp2IL.Core.Utils;
4	using LibCpp2IL;
5	using LibCpp2IL.Reflection;
6
7	namespace Cpp2IL.Core.Model.Contexts;
8
9	public class ConcreteGenericMethodAnalysisContext : MethodAnalysisContext
10	{
11	public readonly AssemblyAnalysisContext DeclaringAsm;
12	public readonly Cpp2IlMethodRef? MethodRef;
13	public readonly MethodAnalysisContext BaseMethodContext;
14
15	/// <summary>
16	/// The generic parameters for the <see cref="BaseMethodContext"/> declaring type.
17	/// </summary>
18	/// <remarks>
19	/// If not empty, <see cref="MethodAnalysisContext.DeclaringType"/> is a <see cref="GenericInstanceTypeAnalysisContext"/>.
20	/// </remarks>
21	public TypeAnalysisContext[] TypeGenericParameters { get; }	×
22
23	/// <summary>
24	/// The generic parameters for the <see cref="BaseMethodContext"/>.
25	/// </summary>
26	/// <remarks>
27	/// These may be empty if <see cref="BaseMethodContext"/> has no generic parameters or if <see cref="IsPartialInstantiation"/>.
28	/// </remarks>
29	public TypeAnalysisContext[] MethodGenericParameters { get; }	325✔
30
31	/// <summary>
32	/// If true, this is a generic method on a <see cref="GenericInstanceTypeAnalysisContext"/>, but it does not specify any <see cref="MethodGenericParameters"/>.
33	/// </summary>
34	public bool IsPartialInstantiation => MethodGenericParameters.Length == 0 && BaseMethodContext.GenericParameterCount > 0;	×
35
36	public sealed override ulong UnderlyingPointer => MethodRef?.GenericVariantPtr ?? default;	894,204✔
37
38	public override string DefaultName => BaseMethodContext.DefaultName;	325✔
39
NEW 40	public override TypeAnalysisContext DefaultReturnType { get; }	×
41
42	public override string? OverrideName { get => BaseMethodContext.OverrideName; set => BaseMethodContext.OverrideName = value; }	325✔
43
NEW 44	public override MethodAttributes DefaultAttributes => BaseMethodContext.DefaultAttributes;	×
45
NEW 46	public override MethodAttributes? OverrideAttributes { get => BaseMethodContext.OverrideAttributes; set => BaseMethodContext.OverrideAttributes = value; }	×
47
48	public override AssemblyAnalysisContext CustomAttributeAssembly => BaseMethodContext.CustomAttributeAssembly;	×
49
50	public ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef methodRef, ApplicationAnalysisContext context)
51	: this(methodRef, ResolveDeclaringAssembly(methodRef, context))	298,308✔
52	{
53	}	298,308✔
54
55	private ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef methodRef, AssemblyAnalysisContext declaringAssembly)
56	: this(	298,308✔
57	methodRef,	298,308✔
58	ResolveBaseMethod(methodRef, declaringAssembly.GetTypeByDefinition(methodRef.DeclaringType)!),	298,308✔
59	ResolveDeclaringType(methodRef, declaringAssembly),	298,308✔
60	ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly),	298,308✔
61	ResolveTypeArray(methodRef.MethodGenericParams, declaringAssembly),	298,308✔
62	declaringAssembly)	298,308✔
63	{
64	}	298,308✔
65
66	/// <summary>
67	/// Generically instantiate a method.
68	/// </summary>
69	/// <param name="baseMethod">The method definition on which this instantiation is based.</param>
70	/// <param name="typeGenericParameters">The type parameters for the declaring type, if any. These must always be specified.</param>
71	/// <param name="methodGenericParameters">
72	/// The type parameters for the base method, if any.
73	/// These may be omitted (<see cref="IsPartialInstantiation"/> == <see langword="true"/>).
74	/// </param>
75	public ConcreteGenericMethodAnalysisContext(MethodAnalysisContext baseMethod, TypeAnalysisContext[] typeGenericParameters, TypeAnalysisContext[] methodGenericParameters)
76	: this(	330!
77	null,	330✔
78	baseMethod,	330✔
79	typeGenericParameters.Length > 0 ? baseMethod.DeclaringType!.MakeGenericInstanceType(typeGenericParameters) : baseMethod.DeclaringType!,	330✔
80	typeGenericParameters,	330✔
81	methodGenericParameters,	330✔
82	baseMethod.CustomAttributeAssembly)	330✔
83	{
84	if (baseMethod.DeclaringType!.GenericParameters.Count != typeGenericParameters.Length)	330!
85	throw new ArgumentException("The number of type generic parameters must match the number of generic parameters on the declaring type.");	×
86
87	if (methodGenericParameters.Length > 0 && baseMethod.GenericParameterCount != methodGenericParameters.Length)	330!
88	throw new ArgumentException("The number of method generic parameters must match the number of generic parameters on the base method.");	×
89	}	330✔
90
91	private ConcreteGenericMethodAnalysisContext(Cpp2IlMethodRef? methodRef, MethodAnalysisContext baseMethodContext, TypeAnalysisContext declaringType, TypeAnalysisContext[] typeGenericParameters, TypeAnalysisContext[] methodGenericParameters, AssemblyAnalysisContext declaringAssembly)
92	: base(null, declaringType)	298,638✔
93	{
94	MethodRef = methodRef;	298,638✔
95	DeclaringAsm = declaringAssembly;	298,638✔
96	BaseMethodContext = baseMethodContext;	298,638✔
97
98	TypeGenericParameters = typeGenericParameters;	298,638✔
99	MethodGenericParameters = methodGenericParameters;	298,638✔
100
101	// For the purpose of generic instantiation, we need an array of method generic parameters, even if none are provided.
102	if (methodGenericParameters.Length == 0 && baseMethodContext.GenericParameterCount > 0)	298,638✔
103	methodGenericParameters = baseMethodContext.GenericParameters.ToArray();	5✔
104
105	for (var i = 0; i < BaseMethodContext.Parameters.Count; i++)	1,228,522✔
106	{
107	var parameter = BaseMethodContext.Parameters[i];	315,623✔
108	var instantiatedType = GenericInstantiation.Instantiate(	315,623✔
109	parameter.ParameterType,	315,623✔
110	typeGenericParameters,	315,623✔
111	methodGenericParameters);	315,623✔
112
113	Parameters.Add(new ConcreteGenericParameterAnalysisContext(parameter, instantiatedType, this));	315,623✔
114	}
115
116	DefaultReturnType = GenericInstantiation.Instantiate(BaseMethodContext.ReturnType, typeGenericParameters, methodGenericParameters);	298,638✔
117
118	if (UnderlyingPointer != 0)	298,638✔
119	rawMethodBody = AppContext.InstructionSet.GetRawBytesForMethod(this, false);	297,258✔
120	}	298,638✔
121
122	private static AssemblyAnalysisContext ResolveDeclaringAssembly(Cpp2IlMethodRef methodRef, ApplicationAnalysisContext context)
123	{
124	return context.GetAssemblyByName(methodRef.DeclaringType.DeclaringAssembly!.Name!)	298,308!
125	?? throw new($"Unable to resolve declaring assembly {methodRef.DeclaringType.DeclaringAssembly.Name} for generic method {methodRef}");	298,308✔
126	}
127
128	private static TypeAnalysisContext ResolveDeclaringType(Cpp2IlMethodRef methodRef, AssemblyAnalysisContext declaringAssembly)
129	{
130	var baseType = declaringAssembly.AppContext.ResolveContextForType(methodRef.DeclaringType)	298,308!
131	?? throw new($"Unable to resolve declaring type {methodRef.DeclaringType.FullName} for generic method {methodRef}");	298,308✔
132
133	if (methodRef.TypeGenericParams.Length == 0)	298,308✔
134	return baseType;	43,716✔
135
136	var genericParams = ResolveTypeArray(methodRef.TypeGenericParams, declaringAssembly);	254,592✔
137
138	return new GenericInstanceTypeAnalysisContext(baseType, genericParams, declaringAssembly);	254,592✔
139	}
140
141	private static TypeAnalysisContext[] ResolveTypeArray(Il2CppTypeReflectionData[] array, AssemblyAnalysisContext declaringAssembly)
142	{
143	if (array.Length == 0)	851,208✔
144	return [];	294,366✔
145
146	var ret = new TypeAnalysisContext[array.Length];	556,842✔
147	for (var i = 0; i < array.Length; i++)	2,552,904✔
148	{
149	ret[i] = array[i].ToContext(declaringAssembly)	719,610!
150	?? throw new($"Unable to resolve generic parameter {array[i]} for generic method.");	719,610✔
151	}
152
153	return ret;	556,842✔
154	}
155
156	private static MethodAnalysisContext ResolveBaseMethod(Cpp2IlMethodRef methodRef, TypeAnalysisContext declaringType)
157	{
158	return declaringType.GetMethod(methodRef.BaseMethod)	298,308!
159	?? throw new($"Unable to resolve base method {methodRef.BaseMethod} for generic method {methodRef}");	298,308✔
160	}
161	}

SamboyCoding / Cpp2IL / 15144219583

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